Ejemplo n.º 1
0
def nexec(statement, globals=None, locals=None, **kwargs):
    """Execute *statement* using *globals* and *locals* dictionaries as
    *global* and *local* namespace.  *statement* is transformed using
    :class:`.NapiTransformer`."""

    try:
        import __builtin__ as builtins
    except ImportError:
        import builtins

    from ast import parse
    from napi.transformers import NapiTransformer
    from ast import fix_missing_locations as fml
    try:
        node = parse(statement, '<string>', 'exec')
    except ImportError:#KeyError:
        exec(statement)
    else:
        if globals is None:
            globals = builtins.globals()
        if locals is None:
            locals = {}
        trans = NapiTransformer(globals=globals, locals=locals, **kwargs)
        trans.visit(node)
        code = compile(fml(node), '<string>', 'exec')
        return builtins.eval(code, globals, locals)
Ejemplo n.º 2
0
  def createInstance(self, module, type, **kargs):
    for package in reversed(self.packages.keys()):
      try:
        imported = __import__(self.packages[package].module+"."+module,
          __builtin__.globals(), __builtin__.locals(), [type])
        instance = getattr(imported, type)
      except ImportError as importError:
        self.spam("Importing type "+type+" from "+
          self.packages[package].module+"."+module+" failed: "+
          str(importError))
        self.spam(traceback.format_exc())
      except AttributeError as attributeError:
        self.spam("Importing type "+type+" from "+
          self.packages[package].module+"."+module+" failed: "+
          str(attributeError))
        self.spam(traceback.format_exc())
      else:
        self.spam("Importing type "+type+" from "+
          self.packages[package].module+"."+module+" succeeded")
        return instance(**kargs)

    error = "Failed to import "+type+" from module "+module+"."
    if self.debug:
      error = error+" See debugging output for details."
    else:
      error = error+" Enable debugging output for details."
    self.error(error)
Ejemplo n.º 3
0
def neval(expression, globals=None, locals=None, **kwargs):
    """Evaluate *expression* using *globals* and *locals* dictionaries as
    *global* and *local* namespace.  *expression* is transformed using
    :class:`.NapiTransformer`."""

    try:
        import __builtin__ as builtins
    except ImportError:
        import builtins

    from ast import parse
    from ast import fix_missing_locations as fml

    try:
        transformer = kwargs['transformer']
    except KeyError:
        from napi.transformers import NapiTransformer as transformer

    #try:
    node = parse(expression, '<string>', 'eval')
    #except ImportError:
    #    builtins.eval(expression)
    #else:
    if globals is None:
        globals = builtins.globals()
    if locals is None:
        locals = {}
    trans = transformer(globals=globals, locals=locals, **kwargs)
    trans.visit(node)
    code = compile(fml(node), '<string>', 'eval')
    return builtins.eval(code, globals, locals)
Ejemplo n.º 4
0
def clone_function(func, globals=None):
    """
    Clone a function object by creating a new FunctionType with a cloned
    code object.
    """

    from types import CodeType, FunctionType
    co = func.func_code
    code = CodeType(
        co.co_argcount,
        co.co_nlocals,
        co.co_stacksize,
        co.co_flags,
        co.co_code,
        co.co_consts,
        co.co_names,
        co.co_varnames,
        co.co_filename,
        co.co_name,
        co.co_firstlineno,
        co.co_lnotab
    )

    import __builtin__
    if globals is None:
        globals = __builtin__.globals()
    return FunctionType(code, globals, func.func_name, func.func_defaults)
Ejemplo n.º 5
0
  def include(self, package, **kargs):
    package = package.replace("-", "_")
    if package in self.packages.keys():
      return
    
    self.info("Including package: "+package)
    try:
      self.packages[package] = Package(package, **kargs)
    except Exception as includeError:
      self.error("Failed to include package "+package+": "+str(includeError))
      
    if self.packages[package].requires:
      for required in self.packages[package].requires:
        self.include(required)
      
    packageModule = __import__(self.packages[package].module)
    packagePath = os.path.dirname(packageModule.__file__)
    modules = [name for _, name, _ in pkgutil.iter_modules([packagePath])]

    if "facade" in modules:      
      facade = __import__(self.packages[package].module+".facade",
        __builtin__.globals(), __builtin__.locals(), ["*"])
      for expression in dir(facade):
        if not __builtin__.__dict__.has_key(expression):
          __builtin__.__dict__[expression] = getattr(facade, expression)
Ejemplo n.º 6
0
  def __init__(self, locals = __builtin__.globals()):
    InteractiveConsole.__init__(self, locals)

    self.stdout = sys.stdout
    self.stderr = sys.stderr
    
    self.pipe = Pipe()
    self.completer = Completer(locals)
Ejemplo n.º 7
0
def import_all_but_wx(name,
                      globals=__builtin__.globals(),
                      locals=__builtin__.locals(),
                      fromlist=[], level=-1,
                      default_import=__builtin__.__import__):
    if name == "wx" or name.startswith("wx."):
        raise ImportError("Not allowed to import wx!")
    return default_import(name, globals, locals, fromlist, level)
Ejemplo n.º 8
0
    def get_available_gui_toolkits(cls):
# #
        '''
            Determines available gui toolkits.

            Examples:

            >>> __test_globals__['qt'] = __test_globals__['gtk'] = None

            >>> Browser('google.de').available_gui_toolkits
            ('default',)
        '''
        toolkits = []
        for toolkit in builtins.globals():
            if(builtins.globals()[toolkit] is not None and
               '_initialize_%s_browser' % toolkit in cls.__dict__):
                toolkits.append(toolkit)
        toolkits.append('default')
        return builtins.tuple(toolkits)
Ejemplo n.º 9
0
def do_complete(text):
    """Does code completion"""
    import __main__
    import __builtin__
    import readline
    import rlcompleter
    matchDict=__main__.__dict__.copy()
    matchDict.update(__builtin__.globals())
    rlc=rlcompleter.Completer(matchDict)
    rlc.complete(text,0)
    return list(set(rlc.matches)) #just to get rid of duplicates
Ejemplo n.º 10
0
def do_complete(text):
    """Does code completion"""
    import __main__
    import __builtin__
    import readline
    import rlcompleter
    matchDict = __main__.__dict__.copy()
    matchDict.update(__builtin__.globals())
    rlc = rlcompleter.Completer(matchDict)
    rlc.complete(text, 0)
    return list(set(rlc.matches))  #just to get rid of duplicates
Ejemplo n.º 11
0
 def config_files(self, site, context, dir = None, release = True):
     ctx = self.get_context(context)
     dns = [ctx['dns']] + ctx['redirects']
     ndns = [r.replace('.','\.') for r in dns]
     ser.all_redirects = '|'.join(ndns)
     ser.apps = application_map(site.settings.INSTALLED_APPS,
                                 safe=False).values()
     environ['nginx'] = config_file(self, self.nginx, ctx, dir=dir)
     if not release:
         from __builtin__ import globals
         g = globals()
         g['script_result'] = environ
Ejemplo n.º 12
0
 def config_files(self, site, context, dir=None, release=True):
     ctx = self.get_context(context)
     dns = [ctx['dns']] + ctx['redirects']
     ndns = [r.replace('.', '\.') for r in dns]
     ser.all_redirects = '|'.join(ndns)
     ser.apps = application_map(site.settings.INSTALLED_APPS,
                                safe=False).values()
     environ['nginx'] = config_file(self, self.nginx, ctx, dir=dir)
     if not release:
         from __builtin__ import globals
         g = globals()
         g['script_result'] = environ
Ejemplo n.º 13
0
 def config_files(self, environ, dir = None, release = True):
     rs = [environ['domain_name']] + environ['redirects']
     v  = []
     for r in rs:
         v.append(r.replace('.','\.'))
     environ['nginx_redirects'] = '|'.join(v)
     environ['apps']  = application_map().values()
     if dir is None:
         dir = None if not release else environ['confdir']
     environ['nginx']  = config_file(self.nginx,environ=environ,dir=dir)
     if not release:
         from __builtin__ import globals
         g = globals()
         g['script_result'] = environ
Ejemplo n.º 14
0
def clone_function(func, globals=None):
    """
    Clone a function object by creating a new FunctionType with a cloned
    code object.
    """

    from types import CodeType, FunctionType
    co = func.func_code
    code = CodeType(co.co_argcount, co.co_nlocals, co.co_stacksize,
                    co.co_flags, co.co_code, co.co_consts, co.co_names,
                    co.co_varnames, co.co_filename, co.co_name,
                    co.co_firstlineno, co.co_lnotab)

    import __builtin__
    if globals is None:
        globals = __builtin__.globals()
    return FunctionType(code, globals, func.func_name, func.func_defaults)
Ejemplo n.º 15
0
  def __init__(self, name, homeVar = None, configDir = None, systemDir = None,
      userDir = None, module = None, requires = None, options = None,
      arguments = None, **kargs):
    super(Package, self).__init__()

    self.name = name
    self.module = module
    self.requires = requires
    self.options = options
    self.arguments = arguments
    
    self.homeVar = homeVar
    self.configDir = configDir
    self.systemDir = systemDir
    self.userDir = userDir

    if not self.module:
      self.module = self.name.replace("-", "_")

    imported = __import__(self.module+".config", __builtin__.globals(),
      __builtin__.locals(), ["config"])
    self.configuration = getattr(imported, "Configuration")()
      
    if not self.homeVar:
      self.homeVar = (self.name.replace("-", "_")+"_HOME").upper()
    if not self.configDir:
      self.configDir = self.configuration.configurationPath
    if not self.systemDir:
      self.systemDir = self.configuration.filePath
    if not self.userDir:
      self.userDir = os.path.join(os.environ["HOME"], "."+self.name)
    
    if not self.requires:
      if hasattr(self.configuration, "requires"):
        self.requires = self.configuration.requires
    if not self.options:
      if hasattr(self.configuration, "options"):
        self.options = self.configuration.options
    if not self.arguments:
      if hasattr(self.configuration, "arguments"):
        self.arguments = self.configuration.arguments
Ejemplo n.º 16
0
import myhacks

ctx
# Error: NameError: file <maya console> line 1: name 'ctx' is not defined

import __builtin__

__builtin__.globals()['ctx']
# Error: KeyError: file <maya console> line 1: ctx #

__builtin__.globals()['ctx'] = myhacks.ctx

ctx

ctx.scriptEditor.comment()
ctx.scriptEditor.uncomment()

del ctx

ctx
# Error: NameError: file <maya console> line 1: name 'ctx' is not defined

myhacks.ctx
# Result: <myhacks.Context object at 0x0000000748150FD0>

del myhacks.ctx

myhacks.ctx
# Error: AttributeError: file <maya console> line 1: 'module' object has no attribute 'ctx'

reload(myhacks)
Ejemplo n.º 17
0
        return __import__('sys').modules.setdefault(self.name, self.module)

# add import hook for internal api
sys.meta_path.append(__base__)

# add custom subdirs to the search path
for p in (_ for _ in os.listdir(root) if os.path.isdir(os.path.join(root,_)) and not _.startswith('.')):
    path = os.path.join(root, p)
    if path == __base__.base:
        continue
    #sys.meta_path.append(__submodule__(path))
    sys.path.append(path)

# empty out idapython's namespace
import __builtin__
[__builtin__.globals().pop(_) for _ in __builtin__.globals().copy() if not _.startswith('_')]

# re-populate with a default namespace
from __root__ import *

# try and execute our user's idapythonrc.py
try:
    if os.getenv('HOME'):
        execfile(os.path.join(os.getenv('HOME'), 'idapythonrc.py'))
    elif os.getenv('USERPROFILE'):
        execfile(os.path.join(os.getenv('USERPROFILE'), 'idapythonrc.py'))
    else:
        raise OSError('Unable to figure out home directory')
    pass
except IOError:
    logging.warn('No idapythonrc.py file found in home directory')
Ejemplo n.º 18
0
def Confirmation(f, action, **kwargs):
    function = globals()[f]
    oc = ObjectContainer(title2=action)
    oc.add(DirectoryObject(title=unicode('{} {}'.format(L('confirm'), action)), thumb=R('icon-default.png'),
                           key=Callback(function, **kwargs)))
    return oc
Ejemplo n.º 19
0
def declare(member, value):
	attr = 'a_%s' % member
	globals()[attr] = value
	print attr, value