Re: Recommendation on PyCharm config when working with SCons

'''
for use with pylint.

to avoid "Undefined variable 'Builder' (undefined-variable)"

usage: put in SConscript* file:

if 'SCons' not in sys.modules:
  from scons_dummy import Builder, Environment, Export

'''

# pylint: disable = bad-indentation
# pylint: disable = invalid-name
# pylint: disable = exec-used
# pylint: disable = too-many-instance-attributes
# pylint: disable = too-many-arguments
# pylint: disable = too-many-boolean-expressions

from __future__ import print_function

import os
import sys

sys.stderr.write('scons_dummy.py  should only used for pylint!\n')

def Builder(**kwargs):
  '''dummy for pylint'''
  if kwargs:
    pass

class Environment(object):
  '''dummy for pylint'''
  def __init__(self, **kwargs):
    '''dummy for pylint'''
    self.dict = kwargs
    self['DEVENV_EXE'] = '-'
    self['CL_EXE'] = '-'
    self['BINPATH'] = '-'

    self.vc_version = self.dummy_builder
    self.genVcxProj = self.dummy_builder
    self.member = self.dummy_builder
    self.gmemfile = self.dummy_builder
    self.AddChecksumAndVersionHeaders = self.dummy_builder
    self.lines_of_code = self.dummy_builder
    self.sevenZip = self.dummy_builder
    self.FillChecksumHeader = self.dummy_builder
    self.bin2mot = self.dummy_builder
    self.FillChecksumHeader = self.dummy_builder
    self.genSizeRep = self.dummy_builder
    self.cc = self.dummy_builder
    self.asm = self.dummy_builder
    self.ar = self.dummy_builder
    self.lnk = self.dummy_builder
    self.vc = self.dummy_builder
    self.CompressECL = self.dummy_builder
    self.aes_128_cbc = self.dummy_builder
    self.GBuild = self.dummy_builder
    self.GBuildIntegrity = self.dummy_builder
    self.gmemfile_map_add_ROM2RAM = self.dummy_builder
    self.binMerge = self.dummy_builder
    self.mfc = self.dummy_builder
    self.binMergeReport = self.dummy_builder
    self.copy_file = self.dummy_builder
    self.crc32 = self.dummy_builder
    self.socwizard_batch = self.dummy_builder
    self.jflasharm_batch = self.dummy_builder
    self.jlink_batch = self.dummy_builder
    self.multiflash_batch = self.dummy_builder
    self.emerald_jl_batch = self.dummy_builder
    self.emerald_jl_shell = self.dummy_builder
    self.titan_jl_batch = self.dummy_builder
    self.titan_jl_shell = self.dummy_builder
    self.atlasl_jl_batch = self.dummy_builder
    self.atlasl_jl_shell = self.dummy_builder
    self.jlink_batch_eeprom = self.dummy_builder
    self.OdxCreate = self.dummy_builder
    self.CommandFlasherBatch = self.dummy_builder
    self.CommandFlasherIni = self.dummy_builder
    self.CommandFlasherBatchSeq = self.dummy_builder
    self.mostContainer = self.dummy_builder
    self.zip = self.dummy_builder
    self.report_products = self.dummy_builder
    self.flash_kombi = self.dummy_builder

  @staticmethod
  def dummy_builder(target, source, **env):
    '''dummy for pylint'''
    if target or source or env:
      pass
    return target

  #if kwargs is not None:
  #  pass
  #return kwargs

  def __getitem__(self, key):
    '''dummy for pylint'''
    return self.dict[key]

  def __setitem__(self, key, value):
    '''dummy for pylint'''
    self.dict[key] = value

  def AddMethod(self, function, name=None):
    '''dummy for pylint'''
    pass

  def AppendUnique(self, **kwargs):
    '''iarARM.AppendUnique(CPPSUFFIXES = ['.dat'])'''
    for d in kwargs:
      print('.{} := {}'.format(d, kwargs[d]))
      if d not in self.dict:
        self.dict[d] = []
      self.dict[d].extend(kwargs[d])
  def Clone(self, **kwargs):
    '''dummy for pylint'''
    for key in kwargs:
      self[key] = kwargs[key]
    return self

  def clearReadOnly(self, arg):
    '''dummy for pylint'''
    if self or arg:
      pass

  def Precious(self, arg):
    '''dummy for pylint'''
    if self or arg:
      pass

  def Command(self, target, source, action, **kw):
    '''dummy for pylint'''
    if self or target or source or action or kw:
      pass

  def multiFileCompileLink(self, out_elf, out_map, out_dnm, out_dla, in_sources, in_headers):
    '''dummy for pylint'''
    if self or out_elf or out_map or out_dnm or out_dla or in_sources or in_headers:
      pass

  def version(self, target):
    '''dummy for pylint'''
    if self or target:
      pass


def Export(what):
  '''dummy for pylint'''
  assert what

def Delete(dest, must_exist=0):
  '''dummy for pylint'''
  if dest:
    if must_exist:
      pass

class ARGUMENTS_(object):
  '''dummy for pylint'''
  def __init__(self):
    self.defaults = {}

  def get(self, name, default):
    '''ARGUMENTS.get('extver', ...)'''
    if self or name:
      pass
    if name in self.defaults:
      print('{} -> {}'.format(name, self.defaults[name]))
      return self.defaults[name]

    print('{} -> {}'.format(name, default))
    return default

  def set(self, name, value):
    '''dummy for pylint'''
    print('{} := {}'.format(name, value))
    self.defaults[name] = value

ARGUMENTS = ARGUMENTS_()

def SetOption(name, value):
  '''dummy for pylint'''
  ARGUMENTS.set(name, value)

def GetOption(optionname):
  '''dummy for pylint'''
  return ARGUMENTS.get(optionname, None)

def Help(str_):
  '''dummy for pylint'''
  if str_:
    pass

def EnsurePythonVersion(ma, mi):
  '''dummy for pylint'''
  if ma and mi:
    pass

def EnsureSConsVersion(ma, mi):
  '''dummy for pylint'''
  if ma and mi:
    pass

def AddOption(args, **kwargs):
  '''dummy for pylint'''
  # AddOption('--define', action = 'append', dest = 'compiler_defines', default = [])
  if args:
    pass
  if 'default' in kwargs:
    ARGUMENTS.set(kwargs['dest'], kwargs['default'])

def SConscript(name):
  '''dummy for pylint'''
  # maybe lambda x:
  #name = os.path.splitext(name)[0]
  #name = name.replace('\\', '.').replace('/', '.')
  print('SConscript({})'.format(name))
  #exec('import ' + name)
  p = os.path.dirname(name)
  if p != '':
    sys.path.insert(0, p)
    print(sys.path)
  if name.endswith('.py'):
    exec('import {}'.format(os.path.splitext(name)[0]))
  else:
    execfile(name)

def CScan():
  '''dummy for pylint'''
  return None

def Decider(arg):
  '''dummy for pylint'''
  if arg:
    pass

def Progress(arg):
  '''Progress('Evaluating $TARGET\n')'''
  if arg:
    pass

def SideEffect(side, main):
  '''SideEffect(list_files + side_effects, output_elf)'''
  if side or main:
    pass

def Depends(main, dep):
  '''Depends(output_elf, headers_other_dependencies)'''
  if main or dep:
    pass

def Alias(arg1, arg2):
  '''dummy for pylint'''
  if arg1 or arg2:
    pass

def Default(arg):
  '''dummy for pylint'''
  if arg:
    pass

def Dir(arg):
  '''dummy for pylint'''
  if arg:
    pass
  return arg

def Import(arg):
  '''dummy for pylint'''
  if arg == 'top_level':
    raise UserError('is expected in this case.')
  if arg:
    pass
  exec('global {}'.format(arg))

def Clean(main, to_clean):
  '''dummy for pylint'''
  if main or to_clean:
    pass
  return main

class UserError(Exception):
  '''dummy for pylint'''
  pass

def Exit(exitcode):
  '''dummy for pylint'''
  sys.exit(exitcode)

def AddPostAction(arg1, arg2):
  '''dummy for pylint'''
  if arg1 or arg2:
    pass