def module_exists(module_name, comment):
    try:
        imp.find_module(module_name)
    except ImportError:
        print "You have to install "+module_name
        print comment
        exit()
Beispiel #2
0
def import_pyv8():
	# Importing non-existing modules is a bit tricky in Python:
	# if we simply call `import PyV8` and module doesn't exists,
	# Python will cache this failed import and will always
	# throw exception even if this module appear in PYTHONPATH.
	# To prevent this, we have to manually test if
	# PyV8.py(c) exists in PYTHONPATH before importing PyV8
	if 'PyV8' in sys.modules and 'PyV8' not in globals():
		# PyV8 was loaded by ST2, create global alias
		globals()['PyV8'] = __import__('PyV8')
		return

	loaded = False
	f, pathname, description = imp.find_module('PyV8')
	bin_f, bin_pathname, bin_description = imp.find_module('_PyV8')
	if f:
		try:
			imp.acquire_lock()
			globals()['_PyV8'] = imp.load_module('_PyV8', bin_f, bin_pathname, bin_description)
			globals()['PyV8'] = imp.load_module('PyV8', f, pathname, description)
			imp.release_lock()
			loaded = True
		finally:
			# Since we may exit via an exception, close fp explicitly.
			if f:
				f.close()
			if bin_f:
				bin_f.close()

	if not loaded:
		raise ImportError('No PyV8 module found')
Beispiel #3
0
def readfile(name):
    tokens = name.split(".")
    f = None

    token = tokens[0]
    token_name = [token]
    token_str = ".".join(token_name)

    try:
        f, pathname, description = imp.find_module(token_str)

        for token in tokens[1:]:
            module = imp.load_module(token_str, f, pathname, description)
            if f is not None:
                f.close()

            token_name.append(token)
            token_str = ".".join(token_name)

            f, pathname, description = imp.find_module(
                token, module.__path__)

        if f is not None:
            contents = f.read()
        else:
            contents = ""

    finally:
        if f is not None:
            f.close()

    return contents.encode("UTF8")
Beispiel #4
0
def find_management_module(app_name):
    """
    Determines the path to the management module for the given app_name,
    without actually importing the application or the management module.

    Raises ImportError if the management module cannot be found for any reason.
    """
    parts = app_name.split(".")
    parts.append("management")
    parts.reverse()
    part = parts.pop()
    path = None

    # When using manage.py, the project module is added to the path,
    # loaded, then removed from the path. This means that
    # testproject.testapp.models can be loaded in future, even if
    # testproject isn't in the path. When looking for the management
    # module, we need look for the case where the project name is part
    # of the app_name but the project directory itself isn't on the path.
    try:
        f, path, descr = imp.find_module(part, path)
    except ImportError as e:
        if os.path.basename(os.getcwd()) != part:
            raise e

    while parts:
        part = parts.pop()
        f, path, descr = imp.find_module(part, path and [path] or None)
    return path
Beispiel #5
0
def import_module(module_name):
    """
    Imports a module. A single point of truth for importing modules to
    be documented by `pdoc`. In particular, it makes sure that the top
    module in `module_name` can be imported by using only the paths in
    `pdoc.import_path`.

    If a module has already been imported, then its corresponding entry
    in `sys.modules` is returned. This means that modules that have
    changed on disk cannot be re-imported in the same process and have
    its documentation updated.
    """
    if import_path != sys.path:
        # Such a kludge. Only restrict imports if the `import_path` has
        # been changed. We don't want to always restrict imports, since
        # providing a path to `imp.find_module` stops it from searching
        # in special locations for built ins or frozen modules.
        #
        # The problem here is that this relies on the `sys.path` not being
        # independently changed since the initialization of this module.
        # If it is changed, then some packages may fail.
        #
        # Any other options available?

        # Raises an exception if the parent module cannot be imported.
        # This hopefully ensures that we only explicitly import modules
        # contained in `pdoc.import_path`.
        imp.find_module(module_name.split('.')[0], import_path)

    if module_name in sys.modules:
        return sys.modules[module_name]
    else:
        __import__(module_name)
        return sys.modules[module_name]
Beispiel #6
0
    def load_module(self, module_path):
        """
        uses imp to load a module
        """
        loaded_module = None

        module_name = os.path.basename(module_path)
        package_path = os.path.dirname(module_path)

        pkg_name = os.path.basename(package_path)
        root_path = os.path.dirname(package_path)

        if module_name.find(".py") != -1:
            module_name = module_name.split(".")[0]

        f, p_path, description = find_module(pkg_name, [root_path])
        loaded_pkg = load_module(pkg_name, f, p_path, description)

        f, m_path, description = find_module(
            module_name,
            loaded_pkg.__path__)
        try:
            mod = "{0}.{1}".format(loaded_pkg.__name__, module_name)
            loaded_module = load_module(mod, f, m_path, description)
        except ImportError:
            raise

        return loaded_module
Beispiel #7
0
def find_commands_module(app_name):
    """
    Find the commands module in each app (if it exists) and return the path
    app_name : The name of an app in the INSTALLED_APPS setting
    return - path to the app
    """
    parts = app_name.split('.')
    parts.append('commands')
    parts.reverse()
    part = parts.pop()
    path = None

    #Load the module if needed
    try:
        f, path, descr = imp.find_module(part, path)
    except ImportError as e:
        if os.path.basename(os.getcwd()) != part:
            raise e
        else:
            try:
                if f:
                    f.close()
            except UnboundLocalError:
                log.error("Could not import module {0} at path {1}.  Sys.path is {2}".format(part, path, sys.path))

    #Go down level by and level and try to load the module at each level
    while parts:
        part = parts.pop()
        f, path, descr = imp.find_module(part, [path] if path else None)
        if f:
            f.close()
    return path
Beispiel #8
0
    def clean_tool(self):
        """
        Checks the SCMTool used for this repository for dependencies.

        If one or more dependencies aren't found, they will be presented
        as validation errors.
        """
        tool = self.cleaned_data['tool']
        scmtool_class = tool.get_scmtool_class()

        errors = []

        for dep in scmtool_class.dependencies.get('modules', []):
            try:
                imp.find_module(dep)
            except ImportError:
                errors.append('The Python module "%s" is not installed.'
                              'You may need to restart the server '
                              'after installing it.' % dep)

        for dep in scmtool_class.dependencies.get('executables', []):
            if not is_exe_in_path(dep):
                if sys.platform == 'win32':
                    exe_name = '%s.exe' % dep
                else:
                    exe_name = dep

                errors.append('The executable "%s" is not in the path.' %
                              exe_name)

        if errors:
            raise forms.ValidationError(errors)

        return tool
Beispiel #9
0
 def is_module_for_sure(mod, search_path=sys.path):
     mod = mod.replace('(', '')  # Ignore parentheses
     try:
         mod_name = mod
         while '.' in mod_name:
             pack_name, _sep, mod_name = mod.partition('.')
             f, p, d = imp.find_module(pack_name, search_path)
             search_path = [p]
         imp.find_module(mod_name, search_path)
     except ImportError:
         try:
             # NOTE(vish): handle namespace modules
             __import__(mod)
         except ImportError as exc:
             # NOTE(vish): the import error might be due
             #             to a missing dependency
             missing = str(exc).split()[-1]
             if (missing != mod.split('.')[-1] or
                     "cannot import" in str(exc)):
                 return True
             return False
         except Exception:
             # NOTE(jogo) don't stack trace if unexpected import error,
             # log and continue.
             traceback.print_exc()
             return False
     return True
def mod_exists(mod):
    """Check whether module is known to exist."""
    try:
        imp.find_module(mod)
        return True
    except ImportError:
        return False
Beispiel #11
0
 def pluginImport(self, name, path=None):
     """Import a single plugin"""
     if path is not None:
         try:
             self.info('loading plugin from specified path : %s', path)
             fp, pathname, description = imp.find_module(name, [path])
             try:
                 return imp.load_module(name, fp, pathname, description)
             finally:
                 if fp:
                     fp.close()
         except ImportError:
             pass
     try:
         module = 'b3.plugins.%s' % name
         mod = __import__(module)
         components = module.split('.')
         for comp in components[1:]:
             mod = getattr(mod, comp)
         return mod
     except ImportError, m:
         self.info('Could not load built in plugin %s (%s)', name, m)
         self.info('trying external plugin directory : %s', self.config.getpath('plugins', 'external_dir'))
         fp, pathname, description = imp.find_module(name, [self.config.getpath('plugins', 'external_dir')])
         try:
             return imp.load_module(name, fp, pathname, description)
         finally:
             if fp:
                 fp.close()
Beispiel #12
0
def autodiscover():
    """
    Automatically register all bbcode tags. This searches the 'bbtags' modules
    of all INSTALLED_APPS if available.
    """
    global AUTODISCOVERED
    if AUTODISCOVERED:
        return
    import imp
    from django.conf import settings
    import os

    for app in settings.INSTALLED_APPS:
        try:
            module = __import__(app, {}, {}, [app.split('.')[-1]])
            app_path = module.__path__
        except AttributeError:
            continue
        try:
            imp.find_module('bbtags', app_path)
        except ImportError:
            continue
        for f in os.listdir(os.path.join(os.path.dirname(os.path.abspath(module.__file__)), 'bbtags')):
            mod_name, ext = os.path.splitext(f)
            if ext == '.py':
                __import__("%s.bbtags.%s" % (app, mod_name))
    AUTODISCOVERED = True
Beispiel #13
0
def testModuleExists(mod):
    try:
        imp.find_module(mod)
    except ImportError:
        print "!!! Module " + mod + " doesn't exist"
        print "No fancy particle names for you!"
        args.rawNames = True
Beispiel #14
0
    def _tool_module(self):
        oldpythonpath = sys.path
        sys.path = self.toolpath + sys.path

        try:
            try:
                file, path, desc = imp.find_module(self.name, self.toolpath)
                try:
                    return imp.load_module(self.name, file, path, desc)
                finally:
                    if file:
                        file.close()
            except ImportError, e:
                pass
        finally:
            sys.path = oldpythonpath

        full_name = "SCons.Tool." + self.name
        try:
            return sys.modules[full_name]
        except KeyError:
            try:
                smpath = sys.modules["SCons.Tool"].__path__
                file, path, desc = imp.find_module(self.name, smpath)
                try:
                    module = imp.load_module(full_name, file, path, desc)
                    setattr(SCons.Tool, self.name, module)
                    return module
                finally:
                    if file:
                        file.close()
            except ImportError, e:
                m = "No tool named '%s': %s" % (self.name, e)
                raise SCons.Errors.UserError, m
Beispiel #15
0
def _find_module(module_name):
    name = _get_name(module_name)
    package = get_package(module_name)
    if package:
        try:
            found = find_module(name, package.__path__)
        except ImportError:
            # It appears that we are expeted to load either:
            #
            #   sample.sample.factorial
            # or
            #   sample.factorial
            #
            # Both expect us to load the same module. For now basically catch
            # InportError in find_module, then try again stripping off the
            # first module. I'm not sure yet how this is supposed to be done.
            package = get_package(module_name, depth=2)
            if package:
                found = find_module(name, package.__path__)
            else:
                # With the six test this causes things to break
                #found = find_module(name)
                found = None
    else:
        found = find_module(module_name)
    return found
Beispiel #16
0
def autodiscover():
    import imp
    from django.conf import settings
    
    for app in settings.CONFIGURED_APPS:
        # For each app, we need to look for an search_indexes.py inside that app's
        # package. We can't use os.path here -- recall that modules may be
        # imported different ways (think zip files) -- so we need to get
        # the app's __path__ and look for search_indexes.py on that path.
        
        # Step 1: find out the app's __path__ Import errors here will (and
        # should) bubble up, but a missing __path__ (which is legal, but weird)
        # fails silently -- apps that do weird things with __path__ might
        # need to roll their own index registration.
        try:
            app_path = __import__(app, {}, {}, [app.split('.')[-1]]).__path__
        except AttributeError:
            continue
        
        # Step 2: use imp.find_module to find the app's search_indexes.py. For some
        # reason imp.find_module raises ImportError if the app can't be found
        # but doesn't actually try to import the module. So skip this app if
        # its search_indexes.py doesn't exist
        try:
            imp.find_module('config_definitions', app_path)
        except ImportError:
            continue
        
        # Step 3: import the app's search_index file. If this has errors we want them
        # to bubble up.
        __import__("%s.config_definitions" % app)
Beispiel #17
0
def Use(name):
    # print(dir(sys.modules['solidpy'])); exit()
    if name.endswith(".solid.py"):
        with open(name) as f:
            code = compile(f.read(), name, "exec")
            exec(code, script_globals)  # , script_locals)
    elif name.endswith(".scad"):
        Defaults.includeFiles.append(name)
    else:
        import imp

        try:
            fname = imp.find_module(name)[1]
        except:
            try:
                fname = imp.find_module(name + ".solid")[1]
            except:
                fname = imp.find_module(name + "/" + name + ".solid")[1]
        if fname is None:
            code = "from " + name + " import *"
            exec(code, script_globals)  # , script_locals)
        else:
            with open(fname) as f:
                code = compile(f.read(), fname, "exec")
                exec(code, script_globals)  # , script_locals)
Beispiel #18
0
def build(buildargs=['-y', '-windowed', '--onedir', '--clean', '--icon="icons/desuratools.ico"', '--noupx',
                     '--version-file=versioninfo.txt'], package=True):
    pyinstaller = os.path.join(site.getsitepackages()[0], "Scripts", "pyinstaller-script.py")
    dependencies = ['PySide', 'PIL', 'win32api', 'win32gui', 'win32ui', 'win32con', 'requests']
    imageformats = os.path.join(site.getsitepackages()[1], "PySide", "plugins", "imageformats")
    buildargs.insert(0, 'desuratools.py')
    buildargs.insert(0, pyinstaller)
    buildargs.insert(0, "python")
    dist_folder = os.path.join(os.getcwd(), "dist")
    output_folder = os.path.join(os.getcwd(), "dist", "desuratools")

    if not os.path.exists(pyinstaller):
        raise IOError("PyInstaller is required to build for windows")
    print "PyInstaller check passed"
    for module in dependencies:
        try:
            imp.find_module(module)
        except ImportError:
           raise ImportError("Dependency {0} is required".format(module))
    print "Dependency check passed"
    print "Building DesuraTools"
    subprocess.call(' '.join(buildargs))

    print "Copying imageformat plugins"
    imageformats_dist = os.path.join(output_folder, "imageformats")
    distutils.dir_util.copy_tree(imageformats, imageformats_dist, verbose=1)

    print "Copying icon"
    images_dist = os.path.join(output_folder, "desuratools_256.png")
    shutil.copyfile("desuratools_256.png", images_dist)

    if package:
        package_app(dist_folder, output_folder)
Beispiel #19
0
def autodiscover():
    """
    Goes and imports the permissions submodule of every app in INSTALLED_APPS
    to make sure the templates classes/fns are registered correctly.
    """
    global LOADING
    if LOADING:
        return
    LOADING = True

    import imp
    from django.conf import settings

    for app in settings.INSTALLED_APPS:
        try:
            __import__(app)
            app_path = sys.modules[app].__path__
        except AttributeError:
            continue
        try:
            imp.find_module('enlivetmpl', app_path)
        except ImportError:
            continue
        __import__("%s.enlivetmpl" % app)
        app_path = sys.modules["%s.enlivetmpl" % app]

    LOADING = False
    def __init__(self, method, test=None, arg=tuple(), descriptor=None):
        """Initialize the MethodTestCase.
        """
        self.method = method
        self.test = test
        self.arg = arg
        self.descriptor = descriptor
        self.cls = method.im_class
        self.inst = self.cls()
        if self.test is None:
            method_name = self.method.__name__
            self.test = getattr(self.inst, method_name)
        TestBase.__init__(self)

        self.suite = TestBase.Suite()
        self.suite.__module__, self.suite.__name__ = self.__get_module()

        has_module = True
        try:
            imp.find_module(self.suite.__module__)[1]
        except ImportError:
            has_module = False
        if sys.version.find("IronPython") != -1 or not has_module:
            # Iron Python doesn't fully support imp
            self.suite.abs_location = ""
        else:
            self.suite.abs_location = "file://" + imp.find_module(self.suite.__module__)[1]
        self.suite.location = "python_uttestid://" + self.suite.__module__ + "." + self.suite.__name__
Beispiel #21
0
 def is_module_for_sure(mod, search_path=sys.path):
     mod = mod.replace('(', '')  # Ignore parentheses
     try:
         mod_name = mod
         while '.' in mod_name:
             pack_name, _sep, mod_name = mod.partition('.')
             f, p, d = imp.find_module(pack_name, search_path)
             search_path = [p]
         imp.find_module(mod_name, search_path)
     except ImportError:
         try:
             # NOTE(vish): handle namespace modules
             if '.' in mod:
                 pack_name, mod_name = mod.rsplit('.', 1)
                 __import__(pack_name, fromlist=[mod_name])
             else:
                 __import__(mod)
         except ImportError:
             # NOTE(imelnikov): import error here means the thing is
             # not importable in current environment, either because
             # of missing dependency, typo in code being checked, or
             # any other reason. Anyway, we have no means to know if
             # it is module or not, so we return True to avoid
             # false positives.
             return True
         except Exception:
             # NOTE(jogo) don't stack trace if unexpected import error,
             # log and continue.
             traceback.print_exc()
             return False
         else:
             # NOTE(imelnikov): we imported the thing; if it was module,
             # it must be there:
             return mod in sys.modules
     return True
def dajaxice_autodiscover():
    """
    Auto-discover INSTALLED_APPS ajax.py modules and fail silently when
    not present. NOTE: dajaxice_autodiscover was inspired/copied from
    django.contrib.admin autodiscover
    """
    global LOADING_DAJAXICE
    if LOADING_DAJAXICE:
        return
    LOADING_DAJAXICE = True

    import imp
    from django.conf import settings

    for app in settings.INSTALLED_APPS:

        try:
            app_path = import_module(app).__path__
        except AttributeError:
            continue

        try:
            imp.find_module('ajax', app_path)
        except ImportError:
            continue

        import_module("%s.ajax" % app)

    LOADING_DAJAXICE = False
Beispiel #23
0
    def validate(cls, value):
        if not value:
            return value

        if value == '<PATHS>':
            caffe = cls.find_executable('caffe')
            if not caffe:
                raise ValueError('caffe binary not found in PATH')
            cls.validate_version(caffe)
            try:
                imp.find_module('caffe')
            except ImportError:
                raise ValueError('caffe python package not found in PYTHONPATH')
            return value
        else:
            value = os.path.abspath(value)
            if not os.path.isdir(value):
                raise ValueError('"%s" is not a directory' % value)
            #expected_path = os.path.join(value, 'bin', 'caffe.bin')
            expected_path = os.path.join(value, 'build', 'tools', 'caffe.bin')
            if not os.path.exists(expected_path):
                raise ValueError('caffe binary not found at "%s"' % value)
            cls.validate_version(expected_path)

            pythonpath = os.path.join(value, 'python')
            sys.path.insert(0, pythonpath)
            try:
                imp.find_module('caffe')
            except ImportError as e:
                raise ValueError('Error while importing caffe from "%s": %s' % (pythonpath, e.message))
            finally:
                # Don't actually add this until apply() is called
                sys.path.pop(0)

            return value
def np_comparison_check(h2o_data, np_data, num_elements):
    """
    Check values achieved by h2o against values achieved by numpy

    :param h2o_data: an H2OFrame or H2OVec
    :param np_data: a numpy array
    :param num_elements: number of elements to compare
    :return: None
    """
    # Check for numpy
    try:
        imp.find_module('numpy')
    except ImportError:
        assert False, "failed comparison check because unable to import numpy"

    import numpy as np
    rows, cols = h2o_data.dim
    for i in range(num_elements):
        r = random.randint(0,rows-1)
        c = random.randint(0,cols-1)
        h2o_val = h2o_data[r,c] if isinstance(h2o_data,H2OFrame) else h2o_data[r]
        np_val = np_data[r,c] if len(np_data.shape) > 1 else np_data[r]
        if isinstance(np_val, np.bool_): np_val = bool(np_val)  # numpy haz special bool type :(
        assert np.absolute(h2o_val - np_val) < 1e-6, \
            "failed comparison check! h2o computed {0} and numpy computed {1}".format(h2o_val, np_val)
Beispiel #25
0
def _read_credentials():
    bpy.rffi_creds_found = False
    bpy.rffi_user = ""
    bpy.rffi_hash = ""

    pwfile = bpy.utils.user_resource("CONFIG", "rffi", True)
    try:
        pwmod = imp.find_module("rffi_credentials", [pwfile])
    except ImportError:
        _write_credentials("", "")
        pwmod = imp.find_module("rffi_credentials", [pwfile])
    try:
        user_creds = imp.load_module("rffi_credentials", pwmod[0], pwmod[1], pwmod[2])
        bpy.rffi_user = user_creds.user
        bpy.rffi_hash = user_creds.hash
        bpy.rffi_creds_found = True
    except ImportError:
        # doesn't exist yet, write template
        _write_credentials("", "")
        pwfile = bpy.utils.user_resource("CONFIG", "rffi", True)
        pwmod = imp.find_module("rffi_credentials", [pwfile])
        try:
            user_creds = imp.load_module("rffi_credentials", pwmod[0], pwmod[1], pwmod[2])
            bpy.rffi_user = user_creds.user
            bpy.rffi_hash = user_creds.hash
            bpy.rffi_creds_found = True
        except Exception as e2:
            print("Couldn't write rffi_credentials.py", e2)
    finally:
        if pwmod and pwmod[0]:
            pwmod[0].close()

    return bpy.rffi_creds_found
Beispiel #26
0
        def follow_str(ns, string):
            debug.dbg('follow_module', ns, string)
            path = None
            if ns:
                path = ns[1]
            elif self.import_stmt.relative_count:
                module = self.import_stmt.get_parent_until()
                path = os.path.abspath(module.path)
                for i in range(self.import_stmt.relative_count):
                    path = os.path.dirname(path)

            global imports_processed
            imports_processed += 1
            if path is not None:
                return imp.find_module(string, [path])
            else:
                debug.dbg('search_module', string, self.file_path)
                # Override the sys.path. It works only good that way.
                # Injecting the path directly into `find_module` did not work.
                sys.path, temp = sys_path_mod, sys.path
                try:
                    i = imp.find_module(string)
                except ImportError:
                    sys.path = temp
                    raise
                sys.path = temp
                return i
    def setUp(self):
        B3TestCase.setUp(self)
        when(self.console.config).get_external_plugins_dir().thenReturn(external_plugins_dir)
        self.conf = CfgConfigParser(testplugin_config_file)

        self.plugin_list = [
            {'name': 'admin', 'conf': '@b3/conf/plugin_admin.ini', 'path': None, 'disabled': False},
        ]

        fp, pathname, description = imp.find_module('testplugin1', [os.path.join(b3.getB3Path(True), '..', 'tests', 'plugins', 'fakeplugins')])
        pluginModule1 = imp.load_module('testplugin1', fp, pathname, description)
        if fp:
            fp.close()

        fp, pathname, description = imp.find_module('testplugin3', [os.path.join(b3.getB3Path(True), '..', 'tests', 'plugins', 'fakeplugins')])
        pluginModule3 = imp.load_module('testplugin3', fp, pathname, description)
        if fp:
            fp.close()

        fp, pathname, description = imp.find_module('admin', [os.path.join(b3.getB3Path(True), 'plugins')])
        adminModule = imp.load_module('admin', fp, pathname, description)
        if fp:
            fp.close()

        when(self.console.config).get_plugins().thenReturn(self.plugin_list)
        when(self.console).pluginImport('admin', ANY).thenReturn(adminModule)
        when(self.console).pluginImport('testplugin1', ANY).thenReturn(pluginModule1)
        when(self.console).pluginImport('testplugin3', ANY).thenReturn(pluginModule3)
Beispiel #28
0
def import_project():
    '''
    Import moderator from project root and register all models it contains with
    moderation. The project root file allows you to add moderation for models
    that are in libraries outside the project.
    '''
    from django.conf import settings
    from django.utils.importlib import import_module
    import imp
    import sys
    
    project_root = settings.ROOT_URLCONF.split(".")[0]
    
    try:
        app_path = import_module(project_root).__path__
    except AttributeError:
        return None

    try:
        imp.find_module('moderator', app_path)
    except ImportError:
        return None
    
    module = import_module("%s.moderator" % project_root)
    
    return module    
Beispiel #29
0
  def __init__(self, **kwargs):
    """Keyword arguments to the constructor become attributes of this
    object, which is passed to all functions in the device-specific
    module."""
    for k, v in kwargs.iteritems():
      setattr(self, k, v)
    self.extras = OPTIONS.extras

    if self.module is None:
      path = OPTIONS.device_specific
      if not path:
        return
      try:
        if os.path.isdir(path):
          info = imp.find_module("releasetools", [path])
        else:
          d, f = os.path.split(path)
          b, x = os.path.splitext(f)
          if x == ".py":
            f = b
          info = imp.find_module(f, [d])
        print "loaded device-specific extensions from", path
        self.module = imp.load_module("device_specific", *info)
      except ImportError:
        print "unable to load device-specific module; assuming none"
Beispiel #30
0
 def import_module(self, path):
     if os.path.isfile(path):
         sys.path.insert(0, os.path.dirname(path))
         name = os.path.split(path)[-1].split('.')[0]
         filename, pathname, description = imp.find_module(name, [os.path.dirname(path)])
         module = imp.load_module(name, filename, pathname, description)
         module.functest_module_path = path
         module.__file__ = os.path.abspath(path)
         sys.path.pop(0)
     elif os.path.isdir(path):
         if os.path.isfile(os.path.join(path, '__init__.py')):
             sys.path.insert(0, os.path.abspath(os.path.join(path, os.path.pardir)))
             name = os.path.split(path)[-1]
             filename, pathname, description = imp.find_module(
                 name, [os.path.abspath(os.path.join(path, os.path.pardir))])
             module = imp.load_module(name, filename, pathname, description)
             module.functest_module_path = path
             module.__file__ = os.path.abspath(os.path.join(path, '__init__.py'))
             sys.path.pop(0)
         else:
             module = new.module(os.path.split(path)[-1])
             module.functest_module_path = path
     else:
         raise ImportError('path is not file or directory')
     return module
Beispiel #31
0
    'openassessment.xblock',

    # edxval
    'edxval',

    # Organizations App (http://github.com/edx/edx-organizations)
    'organizations',
)


for app_name in OPTIONAL_APPS:
    # First attempt to only find the module rather than actually importing it,
    # to avoid circular references - only try to import if it can't be found
    # by find_module, which doesn't work with import hooks
    try:
        imp.find_module(app_name)
    except ImportError:
        try:
            __import__(app_name)
        except ImportError:
            continue
    INSTALLED_APPS += (app_name,)

### ADVANCED_SECURITY_CONFIG
# Empty by default
ADVANCED_SECURITY_CONFIG = {}

### External auth usage -- prefixes for ENROLLMENT_DOMAIN
SHIBBOLETH_DOMAIN_PREFIX = 'shib:'
OPENID_DOMAIN_PREFIX = 'openid:'
Beispiel #32
0
    prev_path = os.path.dirname(opsbro_test_import.__file__)
    del opsbro_test_import
    # But to be sure future opsbro import will load the new one, we need to
    # first hard unload the opsbro modules from python
    # NOTE: this is only ok because we are in the setup.py, don't do this outside this scope!
    all_modules = list(sys.modules.keys())
    for modname in all_modules:
        if modname == 'opsbro' or modname.startswith('opsbro.'):
            del sys.modules[modname]
except ImportError as exp:  # great, first install so
    pass

# Now look at loading the local opsbro lib for version and banner
my_dir = os.path.dirname(os.path.abspath(__file__))
opsbro = imp.load_module(
    'opsbro', *imp.find_module('opsbro', [os.path.realpath(my_dir)]))
from opsbro.info import VERSION, BANNER, TXT_BANNER
from opsbro.log import cprint, is_tty, sprintf, core_logger
from opsbro.misc.bro_quotes import get_quote
from opsbro.systempacketmanager import get_systepacketmgr
from opsbro.cli_display import print_h1
from opsbro.characters import CHARACTERS

systepacketmgr = get_systepacketmgr()

##################################       Only root as it's a global system tool.
if os.name != 'nt' and os.getuid() != 0:
    cprint('Setup must be launched as root.', color='red')
    sys.exit(2)

# By default logger should not print anything
Beispiel #33
0
import imp
from password import passwd
table_functions = imp.load_module('reformat',
                                  *imp.find_module('reformat', ['data']))
DATABASE_CONFIG = {'user': '******', 'db': 'bip3', 'pw': passwd}
ERSATZPG_CONFIG = {'debug': True}
ERSATZPG_CONFIG.update(DATABASE_CONFIG)
 def test_imp_find_module_builtins(self):
     self.assertEqual(imp.find_module('sys'), (None, 'sys', ('', '', 6)))
     self.assertEqual(imp.find_module('__builtin__'),
                      (None, '__builtin__', ('', '', 6)))
Beispiel #35
0
 async def render(self, path):
     name = os.path.basename(path)
     find = imp.find_module(name, [os.path.dirname(path)])
     mod = imp.load_module(name, *find)
     return await mod.render(self.service, self.service.middleware)
Beispiel #36
0
def _import_module_from_library(module_name, path):
    # https://stackoverflow.com/questions/67631/how-to-import-a-module-given-the-full-path
    file, path, description = imp.find_module(module_name, [path])
    # Close the .so file after load.
    with file:
        return imp.load_module(module_name, file, path, description)
    def load( self, data ):
        '''
        Walk though a directory and load all the *py* and *pyc* modules
        '''
        # use a set to insure that no two files are loaded twice
        names = Set()

        for directory in self.directories:
            for root, dirs, files in os.walk( directory ):
                for filename in files:
                    # Get just the file name - no extension
                    name, ext = os.path.splitext( filename )
                    if ( ext.lower() == ".py" and
                        not name.lower().endswith( "_test" ) ):
                        # and to names which will prevent doubles
                        names.add( name )
                        self.logger.error( "name = {} ext = {}".format( name, ext ) )
                for name in names:
                    f = None
                    filename = None
                    description = None
                    package = None
                    continue_processing = True
                    try:
                        f, filename, description = imp.find_module( name, \
                                                            self.directories )
                    except ImportError as er:
                        self.logger.error( "error finding {}: error is {}"  \
                                                            .format( name, er ) )
                        continue_processing = False

                    # Check if we failed.  If so then jump to the beginning
                    # and start next file
                    if ( not continue_processing ):
                        continue

                    try:
                        package = imp.load_module( name, f, filename, description )
                    except ImportError as ex:
                        self.logger.error( "error importing {}: error is {}".\
                                                            format( name, ex ) )
                        continue_processing = False
                    finally:
                        if f:
                            self.close_file( f )

                    # Check if we failed.  If so then jump to the beginning
                    # and start next file
                    if ( not continue_processing ):
                        continue

                    try:
#                        pprint(inspect.getmembers(package))
#                        pprint(inspect.getsourcelines(package.instantuate_me))
                        instance = package.instantuate_me( data )
                        if ( None != instance ):
                            self.instances.append( instance )
                            self.logger.info( "Class {} instantiated".format( name ) )
                    except AttributeError as err:
                        self.logger.error( \
                        "The function \"instantiate_me\" was not found in {}: {}"\
                        .format( name, err ) )
Beispiel #38
0
 def import_module(self, mod_name, mod_path):
     ''' 动态调用第三方模块'''
     fn_, path, desc = imp.find_module(mod_name, [mod_path])
     mod = imp.load_module(mod_name, fn_, path, desc)
     return mod
for arg in sys.argv:
    if arg == "-h" or arg == "--help":
        helpOpt = 1
        print("\n####################################################### ")
        print("##################  KOLKO I KRZYZYK ################### ")
        print("#######################################################\n")
        print(
            " Gracz rozpoczyna gre klikajac na jedno z dziewieciu\n pol na planszy.\n\n Gracz -> kolko, \n komputer -> krzyzyk.\n"
        )
        print(
            "\n Program wymaga\n srodowiska graficznego oraz biblioteki PYGAME.\n"
        )
        sys.exit(0)

try:
    imp.find_module('pygame')
    import pygame
    from pygame.locals import *

    from pygame import gfxdraw

except ImportError:
    print(
        ' # BLAD - brak biblioteki PyGame #\n Zainstaluj \'PyGame\' w celu poprawnego dzialania skryptu.\n'
    )
    sys.exit(1)

checkDisplay = os.popen("echo $DISPLAY")
isGraphicalEnvExist = 1 if checkDisplay.read().strip() else 0
if not isGraphicalEnvExist:
    print(
Beispiel #40
0
# -*- coding: utf-8 -*-
from . import qt
from . import lang
import os
import json
import imp
from maya.app.general.mayaMixin import MayaQWidgetBaseMixin
try:
    imp.find_module('PySide2')
    from PySide2.QtWidgets import *
    from PySide2.QtGui import *
    from PySide2.QtCore import *
except ImportError:
    from PySide.QtGui import *
    from PySide.QtCore import *


class Option():
    def __init__(self):
        global WINDOW
        try:
            WINDOW.closeEvent(None)
            WINDOW.close()
        except Exception as e:
            print(e)
        WINDOW = SubWindow()
        #WINDOW.init_flag=False
        WINDOW.resize(800, 500)
        #WINDOW.move(WINDOW.pw-8, WINDOW.ph-31)
        WINDOW.show()
Beispiel #41
0
#!/usr/bin/python
# coding=utf-8
from __future__ import print_function, unicode_literals

import datetime, re, os, imp
from bgmi.config import SCRIPT_PATH
from bgmi.lib.fetch import DATA_SOURCE_MAP
file, pathname, desc = imp.find_module('script_extend',
                                       [os.path.join(SCRIPT_PATH)])
imp.load_module('script_extend', file, pathname, desc)
from script_extend.script import SearchScriptBase


class Script(SearchScriptBase):
    class Model(SearchScriptBase.Model):
        bangumi_name = '普通攻擊是全體二連擊,這樣的媽媽你喜歡嗎?'
        cover = 'http://lain.bgm.tv/pic/cover/l/10/19/264355_PBB4E.jpg'
        update_time = 'Fri'
        # due_date = datetime.datetime(2019, 10, 1)
        source = 'dmhy'
        keyword = '普通攻击 喜欢吗'

        include_regex_filters = [
            r'(BIG5|繁体|繁體|\[繁\])',
        ]

        exclude_regex_filters = [
            r'(HEVC|MKV|H265)',
        ]

"""Unit tests for cloudformation.py"""
import imp
import os
import sys

module_name = 'provisioner'

here_dir = os.path.dirname(os.path.abspath(__file__))
module_path = os.path.join(here_dir, '../../')
sys.path.append(module_path)
fp, pathname, description = imp.find_module(module_name)
provisioner = imp.load_module(module_name, fp, pathname, description)


class TestCloudFormation:
    def test_unit_cloudformation_get_stack_status(self):
        stack_id = "abc123"
        response = {
            "Stacks": [{
                "StackName": "MyStack",
                "StackStatus": "There"
            }, {
                "StackName": "abc123",
                "StackStatus": "Here"
            }]
        }
        exists, status = provisioner.CloudFormation.get_stack_status(
            stack_id, response)
        assert exists is True
        assert status == "Here"
def __boot():
    import sys
    import os
    PYTHONPATH = os.environ.get('PYTHONPATH')
    if PYTHONPATH is None or (sys.platform == 'win32' and not PYTHONPATH):
        PYTHONPATH = []
    else:
        PYTHONPATH = PYTHONPATH.split(os.pathsep)

    pic = getattr(sys, 'path_importer_cache', {})
    stdpath = sys.path[len(PYTHONPATH):]
    mydir = os.path.dirname(__file__)

    for item in stdpath:
        if item == mydir or not item:
            continue    # skip if current dir. on Windows, or my own directory
        importer = pic.get(item)
        if importer is not None:
            loader = importer.find_module('site')
            if loader is not None:
                # This should actually reload the current module
                loader.load_module('site')
                break
        else:
            try:
                import imp  # Avoid import loop in Python >= 3.3
                stream, path, descr = imp.find_module('site', [item])
            except ImportError:
                continue
            if stream is None:
                continue
            try:
                # This should actually reload the current module
                imp.load_module('site', stream, path, descr)
            finally:
                stream.close()
            break
    else:
        raise ImportError("Couldn't find the real 'site' module")

    known_paths = dict([(makepath(item)[1], 1) for item in sys.path])  # 2.2 comp

    oldpos = getattr(sys, '__egginsert', 0)   # save old insertion position
    sys.__egginsert = 0                     # and reset the current one

    for item in PYTHONPATH:
        addsitedir(item)

    sys.__egginsert += oldpos           # restore effective old position

    d, nd = makepath(stdpath[0])
    insert_at = None
    new_path = []

    for item in sys.path:
        p, np = makepath(item)

        if np == nd and insert_at is None:
            # We've hit the first 'system' path entry, so added entries go here
            insert_at = len(new_path)

        if np in known_paths or insert_at is None:
            new_path.append(item)
        else:
            # new path after the insert point, back-insert it
            new_path.insert(insert_at, item)
            insert_at += 1

    sys.path[:] = new_path
Beispiel #44
0
def readmodule_ex(module, path=[], inpackage=0):
    '''Read a module file and return a dictionary of classes.

	Search for MODULE in PATH and sys.path, read and parse the
	module and return a dictionary with one entry for each class
	found in the module.'''

    dict = {}

    i = string.rfind(module, '.')
    if i >= 0:
        # Dotted module name
        package = string.strip(module[:i])
        submodule = string.strip(module[i + 1:])
        parent = readmodule(package, path, inpackage)
        child = readmodule(submodule, parent['__path__'], 1)
        return child

    if _modules.has_key(module):
        # we've seen this module before...
        return _modules[module]
    if module in sys.builtin_module_names:
        # this is a built-in module
        _modules[module] = dict
        return dict

    # search the path for the module
    f = None
    if inpackage:
        try:
            f, file, (suff, mode, type) = \
             imp.find_module(module, path)
        except ImportError:
            f = None
    if f is None:
        fullpath = list(path) + sys.path
        f, file, (suff, mode, type) = imp.find_module(module, fullpath)
    if type == imp.PKG_DIRECTORY:
        dict['__path__'] = [file]
        _modules[module] = dict
        path = [file] + path
        f, file, (suff, mode, type) = \
          imp.find_module('__init__', [file])
    if type != imp.PY_SOURCE:
        # not Python source, can't do anything with this module
        f.close()
        _modules[module] = dict
        return dict

    _modules[module] = dict
    imports = []
    classstack = []  # stack of (class, indent) pairs
    src = f.read()
    f.close()

    # To avoid having to stop the regexp at each newline, instead
    # when we need a line number we simply string.count the number of
    # newlines in the string since the last time we did this; i.e.,
    #    lineno = lineno + \
    #             string.count(src, '\n', last_lineno_pos, here)
    #    last_lineno_pos = here
    countnl = string.count
    lineno, last_lineno_pos = 1, 0
    i = 0
    while 1:
        m = _getnext(src, i)
        if not m:
            break
        start, i = m.span()

        if m.start("Method") >= 0:
            # found a method definition or function
            thisindent = _indent(m.group("MethodIndent"))
            meth_name = m.group("MethodName")
            lineno = lineno + \
              countnl(src, '\n',
               last_lineno_pos, start)
            last_lineno_pos = start
            # close all classes indented at least as much
            while classstack and \
                  classstack[-1][1] >= thisindent:
                del classstack[-1]
            if classstack:
                # it's a class method
                cur_class = classstack[-1][0]
                cur_class._addmethod(meth_name, lineno)
            else:
                # it's a function
                f = Function(module, meth_name, file, lineno)
                dict[meth_name] = f

        elif m.start("String") >= 0:
            pass

        elif m.start("Class") >= 0:
            # we found a class definition
            thisindent = _indent(m.group("ClassIndent"))
            # close all classes indented at least as much
            while classstack and \
                  classstack[-1][1] >= thisindent:
                del classstack[-1]
            lineno = lineno + \
              countnl(src, '\n', last_lineno_pos, start)
            last_lineno_pos = start
            class_name = m.group("ClassName")
            inherit = m.group("ClassSupers")
            if inherit:
                # the class inherits from other classes
                inherit = string.strip(inherit[1:-1])
                names = []
                for n in string.splitfields(inherit, ','):
                    n = string.strip(n)
                    if dict.has_key(n):
                        # we know this super class
                        n = dict[n]
                    else:
                        c = string.splitfields(n, '.')
                        if len(c) > 1:
                            # super class
                            # is of the
                            # form module.class:
                            # look in
                            # module for class
                            m = c[-2]
                            c = c[-1]
                            if _modules.has_key(m):
                                d = _modules[m]
                                if d.has_key(c):
                                    n = d[c]
                    names.append(n)
                inherit = names
            # remember this class
            cur_class = Class(module, class_name, inherit, file, lineno)
            dict[class_name] = cur_class
            classstack.append((cur_class, thisindent))

        elif m.start("Import") >= 0:
            # import module
            for n in string.split(m.group("ImportList"), ','):
                n = string.strip(n)
                try:
                    # recursively read the imported module
                    d = readmodule(n, path, inpackage)
                except:
                    ##print 'module', n, 'not found'
                    pass

        elif m.start("ImportFrom") >= 0:
            # from module import stuff
            mod = m.group("ImportFromPath")
            names = string.split(m.group("ImportFromList"), ',')
            try:
                # recursively read the imported module
                d = readmodule(mod, path, inpackage)
            except:
                ##print 'module', mod, 'not found'
                continue
            # add any classes that were defined in the
            # imported module to our name space if they
            # were mentioned in the list
            for n in names:
                n = string.strip(n)
                if d.has_key(n):
                    dict[n] = d[n]
                elif n == '*':
                    # only add a name if not
                    # already there (to mimic what
                    # Python does internally)
                    # also don't add names that
                    # start with _
                    for n in d.keys():
                        if n[0] != '_' and \
                           not dict.has_key(n):
                            dict[n] = d[n]
        else:
            assert 0, "regexp _getnext found something unexpected"

    return dict
Beispiel #45
0
from numpy import sum as numpysum
from scipy.stats import norm
from snippets.localfolder import get_path
from src.parallelSIRs import ParallelSIRs
import subprocess

random.seed(17)
MODEL = "locallevel"

THISPATH = get_path()

xmodulename = MODEL + "x"
thetamodulename = MODEL + "theta"
modelfolder = os.path.join(THISPATH, "models")
sys.path.append(modelfolder)
f, filename, description = imp.find_module(xmodulename)
xmodule = imp.load_module("xmodule", f, filename, description)
f, filename, description = imp.find_module(thetamodulename)
thetamodule = imp.load_module("thetamodule", f, filename, description)

print "Creating data set..."
#xmodule.modelx.generateData(5000, xmodule.modelx.parameters, savefilename = "/tmp/txt.txt")
syntheticdatasetpath = os.path.join(THISPATH,
                                    "data/%s-syntheticdata.R" % MODEL)
if os.path.isfile(syntheticdatasetpath):
    xmodule.modelx.loadData(syntheticdatasetpath)
xmodule.modelx.model_states = xmodule.modelx.model_states[:, newaxis]
print xmodule.modelx.model_obs.shape
nbparameters = thetamodule.modeltheta.parameterdimension
Nx = 100
Ntheta = 1000
Beispiel #46
0
                      action="store",
                      type="string",
                      dest="dsFile",
                      help="override dsFile")
    (options, args) = parser.parse_args()

    if not options.date:
        print "Date missing"
        sys.exit()

    if len(args) == 0:
        print "You should give the template file name"
        sys.exit()
    mod_dir, filename = os.path.split(args[0])
    mod, ext = os.path.splitext(filename)
    f, filename, desc = imp.find_module(mod, [mod_dir])
    mod = imp.load_module(mod, f, filename, desc)

    todo = [
        "preamble", "dsFile", "anaType", "rootPath", "onTheFlyCustomization",
        "fun"
    ]
    for t in todo:
        globals()[t] = getattr(mod, t)

    if options.dsFile:
        print "Overriding dsFile to ", options.dsFile
        globals()["dsFile"] = options.dsFile

    dateTT = options.date  #"20140411" ## TODO fixme!
    anaVersion = anaType + "_" + dateTT
Beispiel #47
0
	def loadModules(self, path, base):
		modules = {}

		if not os.path.exists(path):
			log.debug("[SP Modules]: Error: Path doesn't exist: " + path)
			return

		# Import all subfolders to allow relative imports
		for root, dirs, files in os.walk(path):
			if root not in sys.path:
				sys.path.append(root)

		# List files
		files = [fname[:-3] for fname in os.listdir(path) if fname.endswith(".py") and not fname.startswith("__")]
		log.debug(files)
		if not files:
			files = [fname[:-4] for fname in os.listdir(path) if fname.endswith(".pyo") or fname.endswith(".pyc")]
			log.debug(files)

		# Import modules
		for name in files:
			module = None

			if name == "__init__":
				continue

			try:
				fp, pathname, description = imp.find_module(name, [path])
			except Exception as e:
				log.debug("[SP Modules] Find module exception: " + str(e))
				fp = None

			if not fp:
				log.debug("[SP Modules] No module found: " + str(name))
				continue

			try:
				module = imp.load_module(name, fp, pathname, description)
			except Exception as e:
				log.debug("[SP Modules] Load exception: " + str(e))
			finally:
				# Since we may exit via an exception, close fp explicitly.
				if fp:
					fp.close()

			if not module:
				log.debug("[SP Modules] No module available: " + str(name))
				continue

			# Continue only if the attribute is available
			if not hasattr(module, name):
				log.debug("[SP Modules] Warning attribute not available: " + str(name))
				continue

			# Continue only if attr is a class
			attr = getattr(module, name)
			if not inspect.isclass(attr):
				log.debug("[SeriesService] Warning no class definition: " + str(name))
				continue

			# Continue only if the class is a subclass of the corresponding base class
			if not issubclass(attr, base):
				log.debug("[SP Modules] Warning no subclass of base: " + str(name))
				continue

			# Add module to the module list
			modules[name] = attr
		return modules
Beispiel #48
0
from rucio.common.types import InternalAccount, InternalScope
# delay import until function to avoid circular dependancy (note here for reference)
# from rucio.core.rse import get_rse_name

# Extra modules: Only imported if available
EXTRA_MODULES = {'web': False, 'paramiko': False, 'flask': False}

try:
    from rucio.db.sqla.enum import EnumSymbol
    EXTRA_MODULES['rucio.db.sqla.enum'] = True
except ImportError:
    EXTRA_MODULES['rucio.db.sqla.enum'] = False

for extra_module in EXTRA_MODULES:
    try:
        imp.find_module(extra_module)
        EXTRA_MODULES[extra_module] = True
    except ImportError:
        EXTRA_MODULES[extra_module] = False

if EXTRA_MODULES['web']:
    from web import HTTPError

if EXTRA_MODULES['paramiko']:
    try:
        from paramiko import RSAKey
    except Exception:
        EXTRA_MODULES['paramiko'] = False

if EXTRA_MODULES['flask']:
    from flask import Response
Beispiel #49
0
 def GetModule(self, ModuleName, ModuleFile, ModulePath):
     # Python fiddling to load a module from a file, there is probably a better way...
     f, Filename, desc = imp.find_module(
         ModuleFile.split('.')[0],
         [ModulePath])  # ModulePath = os.path.abspath(ModuleFile)
     return imp.load_module(ModuleName, f, Filename, desc)
Beispiel #50
0
    def run(self, tmp=None, task_vars=None):
        play_context = copy.deepcopy(self._play_context)
        play_context.network_os = self._get_network_os(task_vars)

        # we should be able to stream line this a bit by creating a common
        # provider argument spec in module_utils/network_common.py or another
        # option is that there isn't a need to push provider into the module
        # since the connection is started in the action handler.
        f, p, d = find_module('ansible')
        f2, p2, d2 = find_module('module_utils', [p])
        f3, p3, d3 = find_module(play_context.network_os, [p2])
        module = load_module('ansible.module_utils.' + play_context.network_os,
                             f3, p3, d3)

        self.provider = load_provider(module.get_provider_argspec(),
                                      self._task.args)

        if play_context.network_os == 'junos':
            play_context.connection = 'netconf'
            play_context.port = int(self.provider['port']
                                    or self._play_context.port or 830)
        else:
            play_context.connection = 'network_cli'
            play_context.port = int(self.provider['port']
                                    or self._play_context.port or 22)

        play_context.remote_addr = self.provider[
            'host'] or self._play_context.remote_addr
        play_context.remote_user = self.provider[
            'username'] or self._play_context.connection_user
        play_context.password = self.provider[
            'password'] or self._play_context.password
        play_context.private_key_file = self.provider[
            'ssh_keyfile'] or self._play_context.private_key_file
        play_context.timeout = int(self.provider['timeout']
                                   or C.PERSISTENT_COMMAND_TIMEOUT)
        if 'authorize' in self.provider.keys():
            play_context.become = self.provider['authorize'] or False
            play_context.become_pass = self.provider['auth_pass']

        if self._play_context.connection == 'local':
            socket_path = self._start_connection(play_context)
            task_vars['ansible_socket'] = socket_path

        if 'fail_on_missing_module' not in self._task.args:
            self._task.args['fail_on_missing_module'] = False

        result = super(ActionModule, self).run(tmp, task_vars)

        module = self._get_implementation_module(play_context.network_os,
                                                 self._task.action)

        if not module:
            if self._task.args['fail_on_missing_module']:
                result['failed'] = True
            else:
                result['failed'] = False

            result['msg'] = ('Could not find implementation module %s for %s' %
                             (self._task.action, play_context.network_os))
        else:
            new_module_args = self._task.args.copy()
            # perhaps delete the provider argument here as well since the
            # module code doesn't need the information, the connection is
            # already started
            if 'network_os' in new_module_args:
                del new_module_args['network_os']

            del new_module_args['fail_on_missing_module']

            display.vvvv('Running implementation module %s' % module)
            result.update(
                self._execute_module(module_name=module,
                                     module_args=new_module_args,
                                     task_vars=task_vars,
                                     wrap_async=self._task. async))

            display.vvvv('Caching network OS %s in facts' %
                         play_context.network_os)
            result['ansible_facts'] = {'network_os': play_context.network_os}

        return result
Beispiel #51
0
import imp
from imp_get_suffixes import module_types

print 'Package:'
f, filename, description = imp.find_module('example')
print module_types[description[2]], filename
print

 def is_module_installed(module_name):
     try:
         imp.find_module(module_name)
         return True
     except ImportError:
         return False
Beispiel #53
0
 def spy_imp_find_module(name, path):
     self.find_module_calls.append(name)
     return imp.find_module(name, path)
Beispiel #54
0
# Get the version
try:
    __version__ = get_distribution("arm_pyart").version
except DistributionNotFound:
    # package is not installed
    __version__ = '0.0.0'

try:
    if _sys.version_info[:2] >= (3, 4):
        import importlib as _importlib
        specs = _importlib.util.find_spec('pytest')
        specs.loader.load_module()
    else:
        import imp as _imp
        _imp.find_module('pytest')
except (AttributeError, ImportError) as error:

    def _test(verbose=False):
        """
        This would invoke the Py-ART test suite, but pytest couldn't
        be imported so the test suite can not run.
        """
        raise ImportError("Could not load pytest. Unit tests not available."
                          " To run unit tests, please install pytest.")
else:

    def _test(verbose=False):
        """
        Invoke the Py-ART test suite.
        """
Beispiel #55
0
# Copyright 2015 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Tests for the Chromium Performance Dashboard data format implementation."""

import imp
import os.path
import sys
import unittest

try:
    imp.find_module("devtoolslib")
except ImportError:
    sys.path.append(os.path.dirname(os.path.dirname(
        os.path.abspath(__file__))))

from devtoolslib.perf_dashboard import ChartDataRecorder


class ChartDataRecorderTest(unittest.TestCase):
    """Tests the chart data recorder."""
    def test_empty(self):
        """Tests chart data with no charts."""
        recorder = ChartDataRecorder('benchmark')
        result = recorder.get_chart_data()
        self.assertEquals(
            {
                'format_version': '1.0',
                'benchmark_name': 'benchmark',
                'charts': {}
            }, result)
Beispiel #56
0
 def get_numpy_incpath(self):
     from imp import find_module
     # avoid actually importing numpy, it screws up distutils
     file, pathname, descr = find_module("numpy")
     from os.path import join
     return join(pathname, "core", "include")
Beispiel #57
0
    }
    url = "https://chart.googleapis.com/chart?" + urlencode({
        "chs":"200x200",
        "chld":"M|0",
        "cht":"qr",
        "chl":data
    })
    return url

########NEW FILE########
__FILENAME__ = manage
#!/usr/bin/env python
from django.core.management import execute_manager
import imp
try:
    imp.find_module('settings') # Assumed to be in the same directory.
except ImportError:
    import sys
    sys.stderr.write("Error: Can't find the file 'settings.py' in the directory containing %r. It appears you've customized things.\nYou'll have to run django-admin.py, passing it your settings module.\n" % __file__)
    sys.exit(1)

import settings

if __name__ == "__main__":
    execute_manager(settings)

########NEW FILE########
__FILENAME__ = settings
import os
ROOT = os.path.dirname(os.path.realpath(__file__))
Beispiel #58
0
from main import app as application

#
#  main():
#
if __name__ == '__main__':
    application = imp.load_source('app', 'main.py')
    port = application.app.config['PORT']
    ip = application.app.config['IP']
    app_name = application.app.config['APP_NAME']
    host_name = application.app.config['HOST_NAME']

    fwtype = "wsgiref"
    for fw in ("gevent", "cherrypy", "flask"):
        try:
            imp.find_module(fw)
            fwtype = fw
        except ImportError:
            pass

    print('Starting WSGIServer type %s on %s:%d ... ' % (fwtype, ip, port))
    if fwtype == "gevent":
        from gevent.pywsgi import WSGIServer

        WSGIServer((ip, port), application.app).serve_forever()

    elif fwtype == "cherrypy":
        from cherrypy import wsgiserver

        server = wsgiserver.CherryPyWSGIServer(
            (ip, port), application.app, server_name=host_name)
Beispiel #59
0
import re
import shutil
import sys

try:
    import PyInstaller
except ImportError:
    # if importing PyInstaller fails, try to load from parent
    # directory to support running without installation.
    import imp
    # Prevent running as superuser (root).
    if not hasattr(os, "getuid") or os.getuid() != 0:
        imp.load_module(
            'PyInstaller',
            *imp.find_module(
                'PyInstaller',
                [os.path.dirname(os.path.dirname(os.path.abspath(__file__)))]))

from PyInstaller import HOMEPATH
from PyInstaller import compat, configure
from PyInstaller import main as pyi_main
from PyInstaller.compat import is_py25, is_py26, is_win, is_darwin
from PyInstaller.lib import unittest2 as unittest
from PyInstaller.lib import junitxml
from PyInstaller.utils import misc

VERBOSE = False
REPORT = False
PYI_CONFIG = {}
# Directory with this script (runtests.py).
BASEDIR = os.path.dirname(os.path.abspath(__file__))
Beispiel #60
0
        def __init__(self):
            #
            ## I have to do this in order to explicitly use ipv4 in instances where ipv6 is used but does not work.
            logging.info(
                'HAVE TO DO THIS IN ORDER TO USE IPV4 WHEN IPV6 DOES NOT WORK')
            _old_getaddrinfo = socket.getaddrinfo

            def _new_getaddrinfo(*args, **kwargs):
                responses = _old_getaddrinfo(*args, **kwargs)
                return [
                    response for response in responses
                    if response[0] == socket.AF_INET
                ]

            socket.getaddrinfo = _new_getaddrinfo

            if not os.environ.get(
                    'READTHEDOCS'
            ):  # more and more contortions to get read the docs to work...
                #
                ## first see if we have PyQt4
                try:
                    val = imp.find_module('PyQt4')
                    from PyQt4.QtGui import QFontDatabase
                except ImportError:
                    print('ERROR, YOU NEED TO INSTALL PyQt4 ON YOUR MACHINE.')
                    sys.exit(0)
                #
                ## now see if we have sshpass
                sshpass = find_executable('sshpass')
                if sshpass is None:
                    print(
                        'ERROR, YOU NEED TO INSTALL sshpass ON YOUR MACHINE.')
                    sys.exit(0)
                #
                ## now see if we have pandoc
                pandoc = find_executable('pandoc')
                if pandoc is None:
                    print('ERROR, YOU NEED TO INSTALL pandoc ON YOUR MACHINE.')
                    sys.exit(0)

            #
            ## first see if we have pip on this machine
            try:
                val = imp.find_module('pip')
            except ImportError:
                _choose_install_pip()

            #
            ## now go through all the dependencies in the requirements packages
            mainDir = os.path.dirname(
                os.path.dirname(os.path.abspath(__file__)))
            reqs = sorted(
                set(
                    map(
                        lambda line: line.replace('\n', '').strip(),
                        open(
                            os.path.join(mainDir, 'resources',
                                         'requirements.txt'),
                            'r').readlines())))
            reqs_remain = []
            for req in reqs:
                try:
                    val = imp.find_module(req)
                except ImportError:
                    try:
                        val = pkg_resources.require([req])
                    except pkg_resources.DistributionNotFound:
                        reqs_remain.append(req)
            #
            if len(reqs_remain) != 0:
                _choose_install_local(reqs_remain)