コード例 #1
0
def run_tests_from_names(names, buffer_test_output, xml_output):
    loader = unittest.TestLoader()
    for name in names:
        package_path = name.split('.')
        for i in range(0, len(package_path)):
            package = '.'.join(
                itertools.chain(['irods', 'test'], package_path[0:i]))
            module = ''.join(['.', package_path[i]])
            try:
                if 'importlib' in globals():
                    importlib.import_module(module, package=package)
                else:
                    __import__(''.join([package, module]))
            except ImportError:
                break
    suites = [
        loader.loadTestsFromName(name, module=irods.test) for name in names
    ]
    super_suite = unittest.TestSuite(suites)
    if xml_output:
        import xmlrunner
        runner = xmlrunner.XMLTestRunner(output='test-reports', verbosity=2)
    else:
        runner = unittest.TextTestRunner(verbosity=2,
                                         failfast=True,
                                         buffer=buffer_test_output,
                                         resultclass=RegisteredTestResult)
    results = runner.run(super_suite)
    return results
コード例 #2
0
ファイル: ctx_pickle.py プロジェクト: jamesmunro/mdf
def _unpickle_node(node_name, modulename, is_bound, vardata=None):
    """returns an MDFNode object from the pickled results of _pickle_node"""
    # make sure all the required module is imported
    _log.debug("Unpickling node %s from module %s" % (node_name, modulename))
    if modulename:
        if modulename not in sys.modules:

            # TODO: we have to reference __builtin__ for now due to the way the import hook works
            # in the cluster. Get rid of it once a more stable import hook is implemented.
            __builtin__.__import__(modulename)

    # get the node and return it (there's no state to recover)
    try:
        return _get_node(node_name, is_bound)
    except MissingNodeError:
        if not vardata:
            raise

    # if the above block didn't return or raise then it must be a varnode
    # that hasn't been created (possibly one that was originally dynamically
    # created) so re-create it now.
    _log.debug("Creating new varnode node %s" % node_name)
    return MDFVarNode(name=node_name,
                      fqname=node_name,
                      default=vardata["default"],
                      category=vardata["categories"],
                      modulename=modulename)
コード例 #3
0
ファイル: PMGApp.py プロジェクト: Almad/pymol
 def initializePlugins(self):
     startup_pattern = re.sub(r"[\/\\][^\/\\]*$","/startup/*.py*",__file__)
     # startup_pattern = os.environ['PYMOL_PATH']+"/modules/pmg_tk/startup/*.py*"
     raw_list = glob(startup_pattern)
     unique = {}
     for a in raw_list:
         unique[re.sub(r".*[\/\\]|\.py.*$","",a)] = 1
     for name in unique.keys():
         try:
             if name != "__init__":
                 module_context = string.join(string.split(__name__,'.')[0:-1])
                 mod_name = module_context+".startup."+name
                 __builtin__.__import__(mod_name)
                 mod = sys.modules[mod_name]
                 if hasattr(mod,'__init_plugin__'):
                     mod.__init_plugin__(self)
                 elif hasattr(mod,'__init__'):
                     mod.__init__(self)
         except:
             suppress = 0
             # suppress error reporting when using old versions of Python
             if float(sys.version[0:3])<2.3:
                 if( name in ['apbs_tools' ]):
                     suppress = 1
             if not suppress:
                 print "Exception in plugin '%s' -- Traceback follows..."%name
                 traceback.print_exc()
                 print "Error: unable to initialize plugin '%s'."%name
コード例 #4
0
ファイル: mapSnippet.py プロジェクト: raosvikram/Shellom
 def validateInputs( self, inputs ) :
     from __builtin__ import __import__
     try :
         __import__( 'snippets.%s'%( inputs[2] ) )
     except ImportError :
         return False
     return True
コード例 #5
0
ファイル: __init__.py プロジェクト: BlaisProteomics/mzDesktop
 def __init__(self, name):
     """
     Creates an instance. Stores the name of the module (for lookup) and a
     reference to the module itself (for reloading)
     """
     self.name = name[3:] # strip off the 'RC_' prefix
     __builtin__.__import__(name) # import the module
     self.mod = sys.modules[name] # keep reference to this module
コード例 #6
0
    def test_module_utils_basic_imports(self):
        realimport = __builtin__.__import__

        def _mock_import(name, *args, **kwargs):
            if name == 'json':
                raise ImportError()
            realimport(name, *args, **kwargs)

        with patch.object(__builtin__, '__import__', _mock_import, create=True) as m:
            m('ansible.module_utils.basic')
            __builtin__.__import__('ansible.module_utils.basic')
コード例 #7
0
ファイル: test_basic.py プロジェクト: ferhaty/ansible
    def test_module_utils_basic_imports(self):
        realimport = __builtin__.__import__

        def _mock_import(name, *args, **kwargs):
            if name == 'json':
                raise ImportError()
            realimport(name, *args, **kwargs)

        with patch.object(__builtin__, '__import__', _mock_import, create=True) as m:
            m('ansible.module_utils.basic')
            __builtin__.__import__('ansible.module_utils.basic')
コード例 #8
0
ファイル: marshal_files.py プロジェクト: mmikolajczyk95/depyc
def import_(module=None,version=None,magic=None):
    if module:    pass
    elif version: module = by_version[version]
    elif magic:   module = by_magic[magic]
    else:
        raise 'at least one argument is required'
    from __builtin__ import __import__
    if module == 'marshal':
        # use current version's 'marshal' module
        return __import__('marshal', globals(), locals())
    else:
        return __import__('decompyle.%s' % module, globals(),
                          locals(), 'decompyle')
コード例 #9
0
ファイル: util.py プロジェクト: idobarkan/my-code
def simple_import(name):
    mod = __builtin__.__import__(name)
    # in case of dotted name, return last module, not first as __import__ does
    components = name.split('.')   
    for c in components[1:]:
        mod = getattr(mod, c)
    return mod
コード例 #10
0
ファイル: liblist_original.py プロジェクト: blaka90/liblist
def library_list():
	print "--------------------------------------------------"
	print "Here are the available library's:"
	print "--------------------------------------------------"
	table = PrettyTable(["Index", "Package"])
	count = 0
	for mod in path_mod:
		table.add_row(["%d" % count, "%s" % mod])
		count += 1
	print table
	print "--------------------------------------------------"
	ans = raw_input("what library would you like to look at?: ")
	print "--------------------------------------------------"
	print "You have chosen to look at %s" % ans
	print "--------------------------------------------------"
	sleep(1)
	try:
		global module
		module = __builtin__.__import__(ans)
	except ImportError:
		print "no such file(try changing lower/uppercase)"
		sleep(3)
		library_list()
	contents = dir(module)
	for c in contents:
		print c
コード例 #11
0
ファイル: support.py プロジェクト: sahilbadyal/sagenb
def cython_import(filename,
                  verbose=False,
                  compile_message=False,
                  use_cache=False,
                  create_local_c_file=True):
    """
    Compile a file containing Cython code, then import and return the
    module.  Raises an ``ImportError`` if anything goes wrong.

    INPUT:
    
    - ``filename`` - a string; name of a file that contains Cython
      code
    
    OUTPUT:
    
    - the module that contains the compiled Cython code.
    """
    name, build_dir = cython(filename,
                             verbose=verbose,
                             compile_message=compile_message,
                             use_cache=use_cache,
                             create_local_c_file=create_local_c_file)
    sys.path.append(build_dir)
    return __builtin__.__import__(name)
コード例 #12
0
 def test__apply_patches(self):
     redis = self.mox.CreateMockAnything()
     redis.smembers('key').AndReturn(['a'])
     self.mox.StubOutWithMock(patch.glob, 'glob')
     patch.glob.glob(mox.IgnoreArg()).AndReturn(['c', 'a', 'b'])
     self.mox.StubOutWithMock(__builtin__, '__import__')
     b = self.mox.CreateMockAnything()
     __builtin__.__import__('mod.b', fromlist=['mod.b']).AndReturn(b)
     b.main()
     redis.sadd('key', 'b')
     c = self.mox.CreateMockAnything()
     __builtin__.__import__('mod.c', fromlist=['mod.c']).AndReturn(c)
     c.main()
     redis.sadd('key', 'c')
     self.mox.ReplayAll()
     patch._apply_patches(redis, 'key', 'dir', 'mod')
コード例 #13
0
def cython_import(filename, verbose=False, compile_message=False,
                 use_cache=False, create_local_c_file=True):
    """
    INPUT:
    
    
    -  ``filename`` - name of a file that contains cython
       code
    
    
    OUTPUT:
    
    
    -  ``module`` - the module that contains the compiled
       cython code.
    
    
    Raises an ``ImportError`` exception if anything goes
    wrong.
    """
    name, build_dir = sage.misc.cython.cython(filename, verbose=verbose,
                                            compile_message=compile_message,
                                            use_cache=use_cache,
                                            create_local_c_file=create_local_c_file)
    sys.path.append(build_dir)
    return __builtin__.__import__(name)
コード例 #14
0
ファイル: shellom.py プロジェクト: raosvikram/Shellom
    def importSnippet( self ) :
        '''Imports a valid snippet from a tar.gz file of the same name as the snippet.'''

        snippetFile = str( QtGui.QFileDialog.getOpenFileName( parent = self, caption = "Select the snippet to import ... ", filter = '*.tar.gz' ) )

        if snippetFile == '' :
            QtGui.QMessageBox.warning( self, "Error !", 'Please select a \'tar\' file to import a snippet from ... ' )
            return

        os.system( "tar -xvf \"%s\" -C /tmp > /dev/null"%snippetFile )
        snippetFile = snippetFile.split('/')[-1].split('.')[0]
        
        from __builtin__ import __import__ as im
        import snippetValidator as val
        sys.path.append( '/tmp' )

        try :
            s = getattr( __import__(snippetFile), snippetFile )
        except BaseException :
            QtGui.QMessageBox.warning( self, "Error !", 'The file you selected does not contain a snippet at all. Please recheck.' )
            return

        if( val.snippetValidator(s).validate() == 'OK' ) :
            os.system ( "cat /tmp/%s.py > /home/vikrams/Shellom/snippets/%s.py"%( snippetFile, snippetFile ) )
        else :
            QtGui.QMessageBox.warning( self, "Error !", 'The file you selected contains an invalid snippet. Please recheck.' )
            return
コード例 #15
0
  def loadPluginInstances(self, plugins, manager):
    """
    plugins := {name: spec, name: spec, ...}
    spec := {class: class, args: args}
    """
    self.plugins = []

    #for (instance_name, instance_spec) in plugins.items():
    plugin_keys = plugins.keys()
    plugin_keys.sort()
    for instance_name in plugin_keys:
      instance_spec = plugins[instance_name]
      instance_class = instance_spec["class"]
      instance_args = instance_spec["args"]
      if not self.plugin_defs.has_key(instance_class):
        rospy.logerr('cannot find %s in plugins for %s' % (instance_class,
                                                           self.package_name))
      else:
        try:
          module_path = self.plugin_defs[instance_class]
          module_name, class_from_class_type = module_path.rsplit('.', 1)
          module = __builtin__.__import__(module_name, 
                                          fromlist=[class_from_class_type],
                                          level=0)
          class_ref = getattr(module, class_from_class_type, None)
          if class_ref is None:
            rospy.logfatal('cannot find %s' % (class_from_class_type))
          else:
            self.plugins.append(class_ref(instance_name, instance_args))
            self.plugins[-1].registerManager(manager)
        except:
          rospy.logerr('failed to load %s' % (instance_class))
          traceback.print_exc(file=sys.stdout)
    return self.plugins
コード例 #16
0
def cython_import(filename, verbose=False, compile_message=False,
                 use_cache=False, create_local_c_file=True, **kwds):
    """
    Compile a file containing Cython code, then import and return the
    module.  Raises an ``ImportError`` if anything goes wrong.

    INPUT:

    - ``filename`` - a string; name of a file that contains Cython
      code

    See the function :func:`sage.misc.cython.cython` for documentation
    for the other inputs.

    OUTPUT:

    - the module that contains the compiled Cython code.
    """
    name, build_dir = cython(filename, verbose=verbose,
                             compile_message=compile_message,
                             use_cache=use_cache,
                             create_local_c_file=create_local_c_file,
                             **kwds)
    sys.path.append(build_dir)
    return __builtin__.__import__(name)
コード例 #17
0
def param_objhook(obj):
    '''
    A custom JSON "decoder" which can recognize certain types of serialized python objects 
    (django models, function calls, object constructors) and re-create the objects

    Parameters
    ----------
    obj : dict
        The deserialized JSON data in python dictionary form (after calling json.loads)

    Returns
    -------
    object
        If possible, a python object based on the JSON data is created. If not, the original dictionary
        is simply returned.

    '''
    if '__django_model__' in obj:
        model = getattr(models, obj['__django_model__'])
        return model(pk = obj['pk'])
    elif '__builtin__' in obj:
        func = getattr(__builtin__, obj['__builtin__'])
        return func(*obj['args'])
    elif '__class__' in obj:
        # look up the module
        mod = __builtin__.__import__(obj['__module__'], fromlist=[obj['__class__']])

        # get the class with the 'getattr' and then run the class constructor on the class data
        return getattr(mod, obj['__class__'])(obj['__dict__'])
    else: # the type of object is unknown, just return the original dictionary
        return obj
コード例 #18
0
    def load(self, plugin_id, plugin_context):
        # get class reference from plugin descriptor
        attributes = self._plugin_descriptors[plugin_id].attributes()
        sys.path.append(os.path.join(attributes['plugin_path'], attributes['library_path']))

        try:
            module = __builtin__.__import__(
                attributes['module_name'], fromlist=[attributes['class_from_class_type']], level=0)
        except NotImplementedError as e:
            qCritical('RosPluginProvider.load(%s): raised an exception:\n%s' % (plugin_id, e))
            return None
        except Exception as e:
            qCritical('RosPluginProvider.load(%s) exception raised in '
                      '__builtin__.__import__(%s, [%s]):\n%s' % (
                          plugin_id, attributes['module_name'],
                          attributes['class_from_class_type'],
                          traceback.format_exc()))
            raise e

        class_ref = getattr(module, attributes['class_from_class_type'], None)
        if class_ref is None:
            qCritical('RosPluginProvider.load(%s): could not find class "%s" in module "%s"' %
                      (plugin_id, attributes['class_from_class_type'], module))
            return None

        # create plugin provider instance without context
        try:
            code = class_ref.__init__.func_code
        except AttributeError:
            code = class_ref.__init__.__code__
        if code.co_argcount == 1 and plugin_context is None:
            return class_ref()
        # create plugin instance
        return class_ref(plugin_context)
コード例 #19
0
ファイル: _compat.py プロジェクト: 4grim/hackbright-django
    def __import__(name, globals={}, locals={}, fromlist=[], level=-1):
        """Compatibility definition for Python 2.4.

        Silently ignore the `level` argument missing in Python < 2.5.
        """
        # we need the level arg because the default changed in Python 3.3
        return __builtin__.__import__(name, globals, locals, fromlist)
コード例 #20
0
    def __import__(name, globals={}, locals={}, fromlist=[], level=-1):
        """Compatibility definition for Python 2.4.

        Silently ignore the `level` argument missing in Python < 2.5.
        """
        # we need the level arg because the default changed in Python 3.3
        return __builtin__.__import__(name, globals, locals, fromlist)
コード例 #21
0
ファイル: liblist_original.py プロジェクト: blaka90/liblist
def library_list():
    print "--------------------------------------------------"
    print "Here are the available library's:"
    print "--------------------------------------------------"
    table = PrettyTable(["Index", "Package"])
    count = 0
    for mod in path_mod:
        table.add_row(["%d" % count, "%s" % mod])
        count += 1
    print table
    print "--------------------------------------------------"
    ans = raw_input("what library would you like to look at?: ")
    print "--------------------------------------------------"
    print "You have chosen to look at %s" % ans
    print "--------------------------------------------------"
    sleep(1)
    try:
        global module
        module = __builtin__.__import__(ans)
    except ImportError:
        print "no such file(try changing lower/uppercase)"
        sleep(3)
        library_list()
    contents = dir(module)
    for c in contents:
        print c
コード例 #22
0
ファイル: portage.py プロジェクト: KDE/emerge-history
def __import__(module):  # pylint: disable=W0622
    utils.debug("module to import: %s" % module, 2)
    if not os.path.isfile(module):
        try:
            return __builtin__.__import__(module)
        except ImportError as e:
            utils.warning("import failed for module %s: %s" % (module, e.message))
            return None
    else:
        sys.path.append(os.path.dirname(module))
        modulename = os.path.basename(module).replace(".py", "")

        suff_index = None
        for suff in imp.get_suffixes():
            if suff[0] == ".py":
                suff_index = suff
                break

        if suff_index is None:
            utils.die("no .py suffix found")

        with open(module) as fileHdl:
            try:
                return imp.load_module(modulename.replace(".", "_"), fileHdl, module, suff_index)
            except ImportError as e:
                utils.warning("import failed for file %s: %s" % (module, e.message))
                return None
コード例 #23
0
ファイル: binding_helper.py プロジェクト: Basildcruz/ecg-1
def _named_import(name):
    parts = name.split('.')
    assert(len(parts) >= 2)
    module = __builtin__.__import__(name)
    for m in parts[1:]:
        module = module.__dict__[m]
    module_name = parts[-1]
    _register_binding_module(module_name, module)
コード例 #24
0
def _named_import(name):
    parts = name.split('.')
    assert (len(parts) >= 2)
    module = builtins.__import__(name)
    for m in parts[1:]:
        module = module.__dict__[m]
    module_name = parts[-1]
    _register_binding_module(module_name, module)
コード例 #25
0
def r_import(name, globals={}, locals={}, fromlist=[]):
    '''Restricted __import__ only allows importing of specific modules'''

    ok_modules = ("mud", "obj", "char", "room", "exit", "account", "mudsock",
                  "event", "action", "random", "traceback", "utils",
                  "__restricted_builtin__")
    if name not in ok_modules:
        raise ImportError, "Untrusted module, %s" % name
    return __builtin__.__import__(name, globals, locals, fromlist)
コード例 #26
0
ファイル: QtBindingHelper.py プロジェクト: imclab/echo_tree
def _named_import(name):
    import __builtin__
    parts = name.split('.')
    assert(len(parts) >= 2)
    module = __builtin__.__import__(name)
    for m in parts[1:]:
        module = module.__dict__[m]
    sys.modules[parts[-1]] = module
    QT_BINDING_MODULES.append(parts[-1])
コード例 #27
0
def _named_import(name):
    import __builtin__
    parts = name.split('.')
    assert (len(parts) >= 2)
    module = __builtin__.__import__(name)
    for m in parts[1:]:
        module = module.__dict__[m]
    sys.modules[parts[-1]] = module
    QT_BINDING_MODULES.append(parts[-1])
コード例 #28
0
def r_import(name, globals = {}, locals = {}, fromlist = [], level = -1):
    '''Restricted __import__ only allows importing of specific modules'''

    ok_modules = ("mud", "obj", "char", "room", "exit", "account", "mudsock",
                  "event", "action", "random", "traceback", "utils",
                  "__restricted_builtin__")
    if name not in ok_modules:
        raise ImportError, "Untrusted module, %s" % name
    return __builtin__.__import__(name, globals, locals, fromlist)
コード例 #29
0
ファイル: utils.py プロジェクト: troiganto/root
 def __init__(self,kernel):        
      magics_path = os.path.dirname(__file__)+"/magics/*.py"
      for file in glob(magics_path):
           if file != magics_path.replace("*.py","__init__.py"):
               module_path="JupyROOT.kernel.magics."+file.split("/")[-1].replace(".py","")
               try:
                   module= __builtin__.__import__(module_path, globals(), locals(), ['register_magics'], -1)
                   module.register_magics(kernel)
               except ImportError:
                   raise Exception("Error importing Magic: %s"%module_path)
コード例 #30
0
ファイル: shellom.py プロジェクト: raosvikram/Shellom
    def addSnippet( self, selection ) :
        '''Displays the snippet selected'''

        #snippet = self.dictOfSnippets[ str( selection.text() ) ]
        snippet = self.dictOfSnippets[ selection ]
        

        if snippet == snippets.mapSnippet.mapSnippet :
            temp = QtGui.QInputDialog.getItem( self, 'Select the snippet to map into ...', 'Snippet', self.dictOfSnippets.keys(), editable = False )
            
            if temp[1] == False :
                return
            
            snippetToMap = self.dictOfSnippets[ str( temp[0] ) ]
            self.maps.append( snippetToMap )
            x = [ snippet, len( snippetToMap.details ) *[''] ]
        else :
            x = [ snippet, len( snippet.details )*[''] ]
            self.maps.append( None )


        self.snippetChanged = True
        
        #--------------------------------------------------------------------------------
        
        for i in snippet.packages :
            if( os.system( "dpkg -l | awk '{ print $2 }' | tail -n +6 | grep %s > /dev/null"%i ) != 0 ) :
                try :
                    from __builtin__ import __import__
                    __import__( i )
                except ImportError :
                    QtGui.QMessageBox.warning( self, "Error !", '%s missing. Install the package before using this snippet.'%i )
                    return -1
        
        #--------------------------------------------------------------------------------

        self.workflow.append( x )
        #print 'appended'
        snip = QtGui.QTableWidgetItem( snippet.name )
        self.snippetsTable.insertRow( self.snippetsTable.rowCount() )
        self.snippetsTable.setItem( self.snippetsTable.rowCount() - 1, 0, snip )
        self.showInputs( self.snippetsTable.rowCount() - 1 )
        self.snippetChanged = False
コード例 #31
0
ファイル: utils.py プロジェクト: youmehsid/root
 def __init__(self,kernel):
      magics_path = os.path.dirname(__file__)+"/magics/*.py"
      for file in glob(magics_path):
           if file != magics_path.replace("*.py","__init__.py"):
               module_path="JupyROOT.kernel.magics."+file.split("/")[-1].replace(".py","")
               try:
                   module= __builtin__.__import__(module_path, globals(), locals(), ['register_magics'], -1)
                   module.register_magics(kernel)
               except ImportError:
                   raise Exception("Error importing Magic: %s"%module_path)
コード例 #32
0
def listImportables(modName, returnModDict=False, modulesOnly=False):
    """! @brief list all available importables of a modules
    @param modName name of module to inspect
    @param returnModDict boolean to return a dict with module-names (k) and modules (v)
    @param modulesOnly only list other modules
    @return default return a list() of module names, if returnModDict true returns a dict { module-name (str) : module }
    """
    emptyReturn = {} if returnModDict else []
    # check if we are a sub moduel
    baseMod = modName
    if modName.find(".") != -1:
        baseMod, modName = modName.rsplit(".", 1)
        modName = [modName]
    else:
        modName = []
    
    # try to import base module
    try:
        mod = __builtin__.__import__(baseMod, globals(), locals(), modName, -1)
    except:
        return __errorMsg("No module found named: '%s'\n" % baseMod, emptyReturn)
    
    # if is submodule get correct module
    if modName:
        mod = getattr(mod, modName[0], None)
        if not mod: __errorMsg("No submodule found named: '%s'\n" % modName[0], emptyReturn)
         
    # check if module is init file
    modIsInit = hasattr(mod, '__file__') and '__init__' in mod.__file__
    modDir = os.path.dirname(mod.__file__) if modIsInit else None
        
    # check modules __all__ list
    foundModules = []
    foundModules.extend(getattr(mod, '__all__', []))
    
    # look for importable modules (simple dir on module)
    if modIsInit or (not hasattr(mod, '__file__')) or (not modulesOnly):
        if modulesOnly:
            foundModules.extend([ret for ret in dir(mod) if inspect.ismodule(getattr(mod, ret))])
        else:
            foundModules.extend([ret for ret in dir(mod) if not(ret[-2:] == '__' and ret[:2] == '__')])
    
    # append from file system  
    if modDir:    
        foundModules.extend(listModules(modDir))
    
    # remove all __init__ 
    foundModules = set(foundModules)
    if '__init__' in foundModules:
        foundModules.remove('__init__')
    
    if returnModDict:
        return (mod, list(foundModules) )
    
    return list(foundModules)
コード例 #33
0
ファイル: pluginsManager.py プロジェクト: b01u/autoscan
 def run(self, dreq):
     plugins = [p.split(".")[0] for p in self.loadPlugins()]
     for plugin in plugins:
         try:
             cplugin = __import__(self.pack + "."+plugin, fromlist = [plugin, ])   
             vulc = cplugin.getPluginClass()
             self.dlog.debug("[Audit Plugin]Loading Plugin --> %s"%str(vulc))
             c = vulc(dreq)
             c.audit()
         except Exception,e:
             elog.exception(e)
コード例 #34
0
def import_(module=None, version=None, magic=None):
    if module: pass
    elif version: module = by_version[version]
    elif magic: module = by_magic[magic]
    else:
        raise 'at least one argument is required'
    from __builtin__ import __import__
    if module == 'marshal':
        return __import__('marshal', globals(), locals())
    else:
        raise 'marshal_20 not found'
コード例 #35
0
ファイル: base_object.py プロジェクト: benjdezi/mongo-orm
def _get_class_from_name(cls_name):
    ''' Get the class for the given name '''
    g = globals()
    if g.has_key(cls_name):
        return g[cls_name]
    else:
        mod_name = camel_to_py_case(cls_name)
        m = __import__("model.classes.%s" % mod_name)
        cls = getattr(m.classes, mod_name)
        cls = getattr(cls, cls_name)
        g[cls_name] = cls
        return cls
コード例 #36
0
ファイル: liblist.py プロジェクト: blaka90/liblist
def check_import(lib):
    try:
        global module
        module = __builtin__.__import__(lib) or importlib.import_module(lib)

        # try importing module
    except ImportError:
        print "Library does not exist: check your spelling or make sure library is installed"
        # module not in library or mispelled/ out of range
        sleep(4)
        library_list()
    print_output()
コード例 #37
0
def __import__(name, glob=globals(), loc=locals(), path=""):
    """Runtime reloading importer.

    Import a module multiple times, when code has changed on disk between each import, updating the code getting executed."""
    if debug:
        print "###IMPORTER###"
    leaf = name
    if path:
        name = path + "." + name
    if name in sys.modules:
        if hasattr(sys.modules[name],'__file__'):
            if debug:
                print "###LOADING:" + sys.modules[name].__file__
            module_path = sys.modules[name].__file__
            if module_path[-13:] == '/__init__.pyc':
                module_path = module_path[0:-13]
            if module_path[-4:] == '.pyc':
                module_path = module_path[0:-1]
            if os.path.exists(module_path):
                if (os.path.isdir(module_path) and os.stat(module_path).st_mtime > os.stat(module_path + "/__init__.pyc").st_mtime) or not os.path.isdir(module_path) and os.stat(module_path).st_mtime > os.stat(module_path + 'c').st_mtime:
                    # The module has been modified, reimport it
                    del(sys.modules[name])
                    if debug:
                        print "###REIMPORTED###"
                    return __builtin__.__import__(name, fromlist=path)
            else:
                # The module no longer exists, remove it
                del(sys.modules[name])
                if debug:
                    print "###REMOVED###"
                return None
        # Do not reimport, simply return the unmodified module
        if debug:
            print "###RETURNED###"
        return sys.modules[name]
    else:
        # Initial import
        if debug:
            print "###INITIALLY IMPORTED###"
        return __builtin__.__import__(name, fromlist=path)
コード例 #38
0
ファイル: gui.py プロジェクト: arunchaganty/Shellom
    def displaySnippet( self ) :
        '''Displays the snippet selected'''
        if self.firstTime == False :
            x = self.submitInputs()
            if x == -2 :
                return -1
        else :
            self.firstTime = False

        #--------------------------------------------------------------------------------

        selection = str( self.snippetsList.currentItem().text() )
        snippet = getattr( getattr( snippets, selection ), selection )
        
        #--------------------------------------------------------------------------------
        
        for i in snippet.packages :
            if( os.system( "dpkg -l | awk '{ print $2 }' | tail -n +6 | grep %s > /dev/null"%i ) != 0 ) :
                try :
                    from __builtin__ import __import__
                    __import__( i )
                except ImportError :
                    QtGui.QMessageBox.warning( self, "Error !", '%s missing. Install the package before using this snippet.'%i )
                    curSnip = ''
                    return -1
        
        #--------------------------------------------------------------------------------

        node = QtGui.QTreeWidgetItem( self.inputsList )
        node.setFlags( QtCore.Qt.ItemIsEnabled )
        node.setText( 0, snippet.sname )

        for i in snippet.details :
            item = QtGui.QTreeWidgetItem( node )
            item.setFlags( QtCore.Qt.ItemIsSelectable|QtCore.Qt.ItemIsEditable|QtCore.Qt.ItemIsDragEnabled|QtCore.Qt.ItemIsUserCheckable|QtCore.Qt.ItemIsEnabled )
            item.setText( 1, i )

        self.curSnip = snippet.sname
        self.inputsList.expandItem( node )
コード例 #39
0
def check_import(clib):
    try:
        global module
        module = __builtin__.__import__(clib) or importlib.import_module(clib)

    # try importing module
    except ImportError:
        print(
            "Library does not exist: check your spelling or make sure library is installed"
        )
        # module not in library or mispelled/ out of range
        sleep(4)
        library_list()
    print_output()
コード例 #40
0
ファイル: run_tests.py プロジェクト: 0x414A/irods
def run_tests_from_names(names, buffer_test_output, xml_output):
    loader = unittest.TestLoader()
    for name in names:
        package_path = name.split('.')
        for i in range(0, len(package_path)):
            package = '.'.join(itertools.chain(['irods', 'test'], package_path[0:i]))
            module = ''.join(['.', package_path[i]])
            try:
                if 'importlib' in globals():
                    importlib.import_module(module, package=package)
                else:
                    __import__(''.join([package, module]))
            except ImportError:
                break
    suites = [loader.loadTestsFromName(name, module=irods.test) for name in names]
    super_suite = unittest.TestSuite(suites)
    if xml_output:
        import xmlrunner
        runner = xmlrunner.XMLTestRunner(output='test-reports', verbosity=2)
    else:
        runner = unittest.TextTestRunner(verbosity=2, failfast=True, buffer=buffer_test_output, resultclass=RegisteredTestResult)
    results = runner.run(super_suite)
    return results
コード例 #41
0
ファイル: InvTS.py プロジェクト: mickg10/DARLAB
def init_invts(lm,ruledb,rulefile,infile,driverfile,outfile,flags,lm_object):
    """Processes the ruleset. Return values:
        0  :  Ok
        1  :  General Error
        2  :  Could not initialize Language Module 
    """
    global log
    log.Warning("lm_object: %s"%lm_object)
    try:
        langmodule=__builtin__.__import__(lm.split(":")[0],None,None,['LanguageModule'])
    except Exception, inst:
        log.ERROR("Cannot load Language Module: %s"%lm.split(":")[0])
        log.ERROR(str(inst))
        return 2
コード例 #42
0
ファイル: num_version_tester.py プロジェクト: blaka90/liblist
def check_import(lib):
	try:
		global module
		module = __builtin__.__import__(lib) or importlib.import_module(lib)

	# try importing module
	except ImportError:
		print "Library does not exit: check your spelling or make sure library is installed"
		# module not in library or mispelled/ out of range
		sleep(4)
		library_list()
	contents = dir(module)  # handle for the module contents
	for c in contents:
		print c  # iterate over contents of module showing whats inside
コード例 #43
0
ファイル: num_version_tester.py プロジェクト: blaka90/liblist
def check_import(lib):
    try:
        global module
        module = __builtin__.__import__(lib) or importlib.import_module(lib)

    # try importing module
    except ImportError:
        print "Library does not exit: check your spelling or make sure library is installed"
        # module not in library or mispelled/ out of range
        sleep(4)
        library_list()
    contents = dir(module)  # handle for the module contents
    for c in contents:
        print c  # iterate over contents of module showing whats inside
コード例 #44
0
 def run(self, dreq):
     plugins = [p.split(".")[0] for p in self.loadPlugins()]
     for plugin in plugins:
         try:
             cplugin = __import__(self.pack + "." + plugin,
                                  fromlist=[
                                      plugin,
                                  ])
             vulc = cplugin.getPluginClass()
             self.dlog.debug("[Audit Plugin]Loading Plugin --> %s" %
                             str(vulc))
             c = vulc(dreq)
             c.audit()
         except Exception, e:
             elog.exception(e)
コード例 #45
0
ファイル: __init__.py プロジェクト: phe-bioinformatics/PHEnix
def dynamic_filter_loader():
    """Fancy way of dynamically importing existing filters.
    
    Returns
    -------
    dict:
        Available filters dictionary. Keys are parameters that
        can be supplied to the filters.
    """

    # We assume the filters are in the same directory as THIS file.
    filter_dir = os.path.dirname(__file__)
    filter_dir = os.path.abspath(filter_dir)

    # This is populated when the module is first imported.
    avail_filters = {}

    # Add this directory to the syspath.
    sys.path.insert(0, filter_dir)

    # Find all "py" files.
    for filter_mod in glob.glob(os.path.join(filter_dir, "*.py")):

        # Derive name of the module where filter is.
        filter_mod_file = os.path.basename(filter_mod)

        # Ignore this file, obviously.
        if filter_mod_file.startswith("__init__"):
            continue

        # Import the module with a filter.
        mod = __import__(filter_mod_file.replace(".pyc", "").replace(".py", ""))

        # Find all the classes contained in this module.
        classes = inspect.getmembers(mod, inspect.isclass)
        for cls_name, cls in classes:
            # For each class, if it is a sublass of PHEFilterBase, add it.
            if cls_name != "PHEFilterBase" and issubclass(cls, PHEFilterBase):
                # The parameters are inherited and defined within each filter.
                avail_filters[cls.parameter] = cls

    sys.path.remove(filter_dir)

    return avail_filters
コード例 #46
0
def tryDoc(object_name, doesclass=None):
    try:
        import __builtin__
        #Magic.
        module = __builtin__.__import__(module_name)

        #You suppose `module.__getattribute__(object_name)' works?! Ain't it. :D
        if doesclass:
            classobject = module.__getattribute__(doesclass)
            object = getattr(classobject, object_name)
        else:
            object = module.__getattribute__(object_name)
        #object.__doc__
        docstring = getattr(object, '__doc__')
        #Exists?
        if docstring:
            print docstring
    except:
        pass
コード例 #47
0
def library_list():
	global lib
	print "--------------------------------------------------"
	print "Here are the available library's:"
	print "--------------------------------------------------"
	table = PrettyTable(["Index", "Package"])  # initiate prettytable
	count = 0
	for mod in path_mod:  # adds numbers and modules to prettytable
		table.add_row(["%d" % count, "%s" % mod])
		count += 1
	print table
	print "--------------------------------------------------"
	ans = raw_input("what library would you like to look at?: ")
	print "--------------------------------------------------"
	try:
		lib = mod_dict[ans]  # check if input is in module dictionary
	except KeyError:
		print "Please choose a valid number associating to a library"
		sleep(3)  # ^ error checking for invalid input
		library_list()
	# print repr(lib)   - shows raw string literal
	lib = lib.replace("\n", "")
	# ^get rid of all newlines so only actual module name is checked
	print "You have chosen to look at %s" % lib
	print "--------------------------------------------------"
	sleep(1)
	try:
		global module
		module = __builtin__.__import__(lib) or importlib.import_module(lib)
	# try importing module
	except ImportError:
		print "Please choose a valid number associating to a library"
		# module not in library or mispelled/ out of range
		sleep(3)
		library_list()
	contents = dir(module)  # handle for the module contents
	for c in contents:
		print c  # iterate over contents of module showing whats inside
コード例 #48
0
 def loadPluginInstances(self, plugins):
     self.plugins = []
     for plugin in plugins:
         if not self.plugin_defs.has_key(plugin):
             rospy.logerr('cannot find %s in plugins for %s' %
                          (plugin, self.package_name))
         else:
             try:
                 module_path = self.plugin_defs[plugin]
                 module_name, class_from_class_type = module_path.rsplit(
                     '.', 1)
                 module = __builtin__.__import__(
                     module_name, fromlist=[class_from_class_type], level=0)
                 class_ref = getattr(module, class_from_class_type, None)
                 if class_ref is None:
                     rospy.logfatal('cannot find %s' %
                                    (class_from_class_type))
                 else:
                     self.plugins.append(class_ref())
             except:
                 rospy.logerr('failed to load %s' % (plugin))
                 traceback.print_exc(file=sys.stdout)
     return self.plugins
コード例 #49
0
    def loadPluginInstances(self, plugins, manager):
        """
    plugins := {name: spec, name: spec, ...}
    spec := {class: class, args: args}
    """
        self.plugins = []

        #for (instance_name, instance_spec) in plugins.items():
        plugin_keys = plugins.keys()
        plugin_keys.sort()
        for instance_name in plugin_keys:
            instance_spec = plugins[instance_name]
            instance_class = instance_spec["class"]
            instance_args = instance_spec["args"]
            if not self.plugin_defs.has_key(instance_class):
                rospy.logerr('cannot find %s in plugins for %s' %
                             (instance_class, self.package_name))
            else:
                try:
                    module_path = self.plugin_defs[instance_class]
                    module_name, class_from_class_type = module_path.rsplit(
                        '.', 1)
                    module = __builtin__.__import__(
                        module_name, fromlist=[class_from_class_type], level=0)
                    class_ref = getattr(module, class_from_class_type, None)
                    if class_ref is None:
                        rospy.logfatal('cannot find %s' %
                                       (class_from_class_type))
                    else:
                        self.plugins.append(
                            class_ref(instance_name, instance_args))
                        self.plugins[-1].registerManager(manager)
                except:
                    rospy.logerr('failed to load %s' % (instance_class))
                    traceback.print_exc(file=sys.stdout)
        return self.plugins
コード例 #50
0
    def getInstance(self, dashboard_name, dashboard_node=None):
        """! Load Python package.
        @param descriptor: package descriptor xml node.
        @type descriptor: Element.
        
        @param uuid: dashboard id.
        @type uuid: string.
        
        @return dashboard_instance: dashboard instance.
        @type dashboard_instance: Dashboard.
        """

        dashboard_pkg_name = self.getPkgByName(dashboard_name)

        dashboard_dir = get_pkg_dir(dashboard_pkg_name)

        dashboard_descriptor_file = os.path.join(dashboard_dir,
                                                 "dashboard_descriptor.xml")

        if not os.path.isfile(dashboard_descriptor_file):
            self._context.getLogger().err(
                'Cannot found dashboard_descriptor.xml into plugin %s' %
                dashboard_name)
            return None

        dashboard_descriptor_root = ElementTree.parse(
            dashboard_descriptor_file).getroot()

        dashboard_import = dashboard_descriptor_root.find('import')

        dashboard_module_path = dashboard_import.attrib['module']
        dashboard_class_name = dashboard_import.attrib['class']

        sys.path.append(
            os.path.join(dashboard_dir, self.DASHBOARD_SOURCES_LOCATION))

        dashboard_class_ref = None
        #Import package module
        #Raise exception
        try:
            module = __builtin__.__import__(dashboard_module_path,
                                            fromlist=[dashboard_class_name],
                                            level=0)

        except Exception as ex:
            self._context.getLogger().err("Cannot import plugin '%s' !\n%s" %
                                          (dashboard_name, str(ex)))
            return None

        #Get referance to plugin class
        dashboard_class_ref = getattr(module, dashboard_class_name)

        if dashboard_class_ref is None:
            self._context.getLogger().err("Cannot found plugin class '%s' !" %
                                          dashboard_class_name)
            return None

        dashboard_instance = dashboard_class_ref(self._context)

        dashboard_params = DashboardProvider.getParameters(
            dashboard_descriptor_root, dashboard_node)

        dashboard_instance.setup(dashboard_descriptor_root, dashboard_params)

        return dashboard_instance
コード例 #51
0
def safe_import(name, globals=None, locals=None, fromlist=None, level=-1):
    mod = __builtin__.__import__(name, globals, locals, fromlist, level)
    if mod:
        mod.open = dummyOpen
        mod.urllib2 = dummyUrllib2
    return mod
コード例 #52
0
    def eval(self, x, globals=None, locals=None):
        """
        EXAMPLES::

            sage: from sage.misc.inline_fortran import InlineFortran, _example
            sage: fortran = InlineFortran(globals())
            sage: fortran(_example)
            sage: import numpy
            sage: n = numpy.array(range(10),dtype=float)
            sage: fib(n,int(10))
            sage: n
            array([  0.,   1.,   1.,   2.,   3.,   5.,   8.,  13.,  21.,  34.])

        TESTS::

            sage: os.chdir(SAGE_ROOT)
            sage: fortran.eval("SYNTAX ERROR !@#$")
            Traceback (most recent call last):
            ...
            RuntimeError: failed to compile Fortran code:...
            sage: os.getcwd() == SAGE_ROOT
            True
        """
        if len(x.splitlines()) == 1 and os.path.exists(x):
            filename = x
            x = open(x).read()
            if filename.lower().endswith('.f90'):
                x = '!f90\n' + x

        from numpy import f2py

        # Create everything in a temporary directory
        mytmpdir = tmp_dir()

        try:
            old_cwd = os.getcwd()
            os.chdir(mytmpdir)

            old_import_path = os.sys.path
            os.sys.path.append(mytmpdir)

            name = "fortran_module"  # Python module name
            # if the first line has !f90 as a comment, gfortran will
            # treat it as Fortran 90 code
            if x.startswith('!f90'):
                fortran_file = name + '.f90'
            else:
                fortran_file = name + '.f'

            s_lib_path = ""
            s_lib = ""
            for s in self.library_paths:
                s_lib_path = s_lib_path + "-L%s "

            for s in self.libraries:
                s_lib = s_lib + "-l%s " % s

            log = name + ".log"
            extra_args = '--quiet --f77exec=sage-inline-fortran --f90exec=sage-inline-fortran %s %s >"%s" 2>&1' % (
                s_lib_path, s_lib, log)

            f2py.compile(x,
                         name,
                         extra_args=extra_args,
                         source_fn=fortran_file)
            log_string = open(log).read()

            # f2py.compile() doesn't raise any exception if it fails.
            # So we manually check whether the compiled file exists.
            # NOTE: the .so extension is used expect on Cygwin,
            # that is even on OS X where .dylib might be expected.
            soname = name
            uname = os.uname()[0].lower()
            if uname[:6] == "cygwin":
                soname += '.dll'
            else:
                soname += '.so'
            if not os.path.isfile(soname):
                raise RuntimeError("failed to compile Fortran code:\n" +
                                   log_string)

            if self.verbose:
                print(log_string)

            m = __builtin__.__import__(name)
        finally:
            os.sys.path = old_import_path
            os.chdir(old_cwd)
            try:
                import shutil
                shutil.rmtree(mytmpdir)
            except OSError:
                # This can fail for example over NFS
                pass

        for k, x in m.__dict__.iteritems():
            if k[0] != '_':
                self.globals[k] = x
コード例 #53
0
    def eval(self,x,globals=None, locals=None):
        """
        EXAMPLES::
        
            sage: from sage.misc.inline_fortran import InlineFortran, _example
            sage: test_fortran = InlineFortran(globals())   # optional -- fortran
            sage: test_fortran(_example)                    # optional -- fortran
            sage: import numpy
            sage: n = numpy.array(range(10),dtype=float)
            sage: fib(n,int(10))                            # optional -- fortran
            sage: n                                         # optional -- fortran
            array([  0.,   1.,   1.,   2.,   3.,   5.,   8.,  13.,  21.,  34.])
        """
        if len(x.splitlines()) == 1 and os.path.exists(x):
            filename = x
            x = open(x).read()
            if filename.lower().endswith('.f90'):
                x = '!f90\n' + x
        global count
        # On linux g77_shared should be a script that runs sage_fortran -shared
        # On OS X it should be a script that runs gfortran -bundle -undefined dynamic_lookup
        path = os.environ['SAGE_LOCAL']+'/bin/sage-g77_shared'
        from numpy import f2py
        old_import_path=os.sys.path
        cwd=os.getcwd()
        os.sys.path.append(cwd)

        #name = tmp_dir() + '/fortran_module_%d'%count
        name = 'fortran_module_%d'%count
        if os.path.exists(name):
            os.unlink(name)
        s_lib_path=""
        s_lib=""
        for s in self.library_paths:
            s_lib_path=s_lib_path+"-L"+s+" "

        for s in self.libraries:
            s_lib=s_lib +"-l"+s + " "

        # if the first line has !f90 as a comment gfortran will treat it as
        # fortran 90 code
        if x.startswith('!f90'):        
            fname = os.path.join(tmp_filename() +'.f90')
        else:
            fname = os.path.join(tmp_filename() +'.f')

        log = tmp_filename()
        extra_args = '--quiet --f77exec=%s --f90exec=%s %s %s  1>&2 >"%s"'%(
                    path, path, s_lib_path, s_lib, log)

        f2py.compile(x, name, extra_args = extra_args, source_fn=fname)

        log_string = open(log).read()

        os.unlink(log)
        os.unlink(fname)

        if self.verbose:
            print log_string
        
        count += 1
        try:
            m=__builtin__.__import__(name)
        except ImportError:
            if not self.verbose:
                print log_string
            return
        finally:
            os.sys.path=old_import_path
            os.unlink(name + '.so')
        
        for k, x in m.__dict__.iteritems():
            if k[0] != '_':
                self.globals[k] = x
コード例 #54
0
ファイル: remoteproxy.py プロジェクト: scseeman/acq4
    def handleRequest(self):
        """Handle a single request from the remote process. 
        Blocks until a request is available."""
        result = None
        while True:
            try:
                ## args, kwds are double-pickled to ensure this recv() call never fails
                cmd, reqId, nByteMsgs, optStr = self.conn.recv()
                break
            except EOFError:
                self.debugMsg(
                    '  handleRequest: got EOFError from recv; raise ClosedError.'
                )
                ## remote process has shut down; end event loop
                raise ClosedError()
            except IOError as err:
                if err.errno == 4:  ## interrupted system call; try again
                    self.debugMsg(
                        '  handleRequest: got IOError 4 from recv; try again.')
                    continue
                else:
                    self.debugMsg(
                        '  handleRequest: got IOError %d from recv (%s); raise ClosedError.'
                        % (err.errno, err.strerror))
                    raise ClosedError()

        self.debugMsg("  handleRequest: received %s %s" %
                      (str(cmd), str(reqId)))

        ## read byte messages following the main request
        byteData = []
        if nByteMsgs > 0:
            self.debugMsg("    handleRequest: reading %d byte messages" %
                          nByteMsgs)
        for i in range(nByteMsgs):
            while True:
                try:
                    byteData.append(self.conn.recv_bytes())
                    break
                except EOFError:
                    self.debugMsg(
                        "    handleRequest: got EOF while reading byte messages; raise ClosedError."
                    )
                    raise ClosedError()
                except IOError as err:
                    if err.errno == 4:
                        self.debugMsg(
                            "    handleRequest: got IOError 4 while reading byte messages; try again."
                        )
                        continue
                    else:
                        self.debugMsg(
                            "    handleRequest: got IOError while reading byte messages; raise ClosedError."
                        )
                        raise ClosedError()

        try:
            if cmd == 'result' or cmd == 'error':
                resultId = reqId
                reqId = None  ## prevents attempt to return information from this request
                ## (this is already a return from a previous request)

            opts = pickle.loads(optStr)
            self.debugMsg("    handleRequest: id=%s opts=%s" %
                          (str(reqId), str(opts)))
            #print os.getpid(), "received request:", cmd, reqId, opts
            returnType = opts.get('returnType', 'auto')

            if cmd == 'result':
                with self.resultLock:
                    self.results[resultId] = ('result', opts['result'])
            elif cmd == 'error':
                with self.resultLock:
                    self.results[resultId] = ('error', (opts['exception'],
                                                        opts['excString']))
            elif cmd == 'getObjAttr':
                result = getattr(opts['obj'], opts['attr'])
            elif cmd == 'callObj':
                obj = opts['obj']
                fnargs = opts['args']
                fnkwds = opts['kwds']

                ## If arrays were sent as byte messages, they must be re-inserted into the
                ## arguments
                if len(byteData) > 0:
                    for i, arg in enumerate(fnargs):
                        if isinstance(arg, tuple) and len(
                                arg) > 0 and arg[0] == '__byte_message__':
                            ind = arg[1]
                            dtype, shape = arg[2]
                            fnargs[i] = np.fromstring(
                                byteData[ind], dtype=dtype).reshape(shape)
                    for k, arg in fnkwds.items():
                        if isinstance(arg, tuple) and len(
                                arg) > 0 and arg[0] == '__byte_message__':
                            ind = arg[1]
                            dtype, shape = arg[2]
                            fnkwds[k] = np.fromstring(
                                byteData[ind], dtype=dtype).reshape(shape)

                if len(
                        fnkwds
                ) == 0:  ## need to do this because some functions do not allow keyword arguments.
                    try:
                        result = obj(*fnargs)
                    except:
                        print("Failed to call object %s: %d, %s" %
                              (obj, len(fnargs), fnargs[1:]))
                        raise
                else:
                    result = obj(*fnargs, **fnkwds)

            elif cmd == 'getObjValue':
                result = opts[
                    'obj']  ## has already been unpickled into its local value
                returnType = 'value'
            elif cmd == 'transfer':
                result = opts['obj']
                returnType = 'proxy'
            elif cmd == 'transferArray':
                ## read array data from next message:
                result = np.fromstring(
                    byteData[0], dtype=opts['dtype']).reshape(opts['shape'])
                returnType = 'proxy'
            elif cmd == 'import':
                name = opts['module']
                fromlist = opts.get('fromlist', [])
                mod = builtins.__import__(name, fromlist=fromlist)

                if len(fromlist) == 0:
                    parts = name.lstrip('.').split('.')
                    result = mod
                    for part in parts[1:]:
                        result = getattr(result, part)
                else:
                    result = map(mod.__getattr__, fromlist)

            elif cmd == 'del':
                LocalObjectProxy.releaseProxyId(opts['proxyId'])
                #del self.proxiedObjects[opts['objId']]

            elif cmd == 'close':
                if reqId is not None:
                    result = True
                    returnType = 'value'

            exc = None
        except:
            exc = sys.exc_info()

        if reqId is not None:
            if exc is None:
                self.debugMsg(
                    "    handleRequest: sending return value for %d: %s" %
                    (reqId, str(result)))
                #print "returnValue:", returnValue, result
                if returnType == 'auto':
                    with self.optsLock:
                        noProxyTypes = self.proxyOptions['noProxyTypes']
                    result = self.autoProxy(result, noProxyTypes)
                elif returnType == 'proxy':
                    result = LocalObjectProxy(result)

                try:
                    self.replyResult(reqId, result)
                except:
                    sys.excepthook(*sys.exc_info())
                    self.replyError(reqId, *sys.exc_info())
            else:
                self.debugMsg("    handleRequest: returning exception for %d" %
                              reqId)
                self.replyError(reqId, *exc)

        elif exc is not None:
            sys.excepthook(*exc)

        if cmd == 'close':
            if opts.get('noCleanup', False) is True:
                os._exit(
                    0
                )  ## exit immediately, do not pass GO, do not collect $200.
                ## (more importantly, do not call any code that would
                ## normally be invoked at exit)
            else:
                raise ClosedError()
コード例 #55
0
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# 2012.07.31

import sys
import __builtin__

names = sys.builtin_module_names

for name in names:
    module = __builtin__.__import__(name)
    print name
    print '-' * name.__len__()
    print
    print module.__doc__
    print
    print '#' * 83
    del module