示例#1
0
文件: test_imp.py 项目: mdavid/dlr
def test_load_package():
    import testpkg1
    pkg = imp.load_package('libcopy', testpkg1.__path__[0])
    AreEqual(sys.modules['libcopy'], pkg)

    pkg = imp.load_package('some_new_pkg', 'some_path_that_does_not_and_never_will_exist')
    AreEqual(sys.modules['some_new_pkg'], pkg)
示例#2
0
    def test_load_package(self):
        import testpkg1
        pkg = imp.load_package('libcopy', testpkg1.__path__[0])
        self.assertEqual(sys.modules['libcopy'], pkg)

        with self.assertRaises(AttributeError): # AttributeError: 'NoneType' object has no attribute 'name'
            imp.load_package('some_new_pkg', 'some_path_that_does_not_and_never_will_exist')
示例#3
0
    def _load_plugins(self, plugin_dir, namespace):
        """
            Load all modules in plugin_dir
        """
        if not os.path.exists(os.path.join(plugin_dir, "__init__.py")):
            raise Exception(
                "The plugin directory %s should be a valid python package with a __init__.py file"
                % plugin_dir)

        mod_name = ".".join(namespace.to_path())
        imp.load_package(mod_name, plugin_dir)

        for py_file in glob.glob(os.path.join(plugin_dir, "*.py")):
            if not py_file.endswith("__init__.py"):
                # name of the python module
                sub_mod = mod_name + "." + os.path.basename(py_file).split(
                    ".")[0]

                # create a namespace for the submodule
                new_ns = Namespace(sub_mod.split(".")[-1])
                new_ns.parent = namespace
                self.graph.add_namespace(new_ns, namespace)

                # load the python file
                imp.load_source(sub_mod, py_file)
示例#4
0
def test_load_package():
    import testpkg1
    pkg = imp.load_package('libcopy', testpkg1.__path__[0])
    AreEqual(sys.modules['libcopy'], pkg)

    pkg = imp.load_package('some_new_pkg', 'some_path_that_does_not_and_never_will_exist')
    AreEqual(sys.modules['some_new_pkg'], pkg)
示例#5
0
def load_plugin(plugin_path):
    if not os.path.exists(plugin_path):
        raise IOError('Plugin path not found: {}'.format(plugin_path))
    config_path = os.path.join(plugin_path, 'config.json')
    if not os.path.exists(config_path):
        raise ImportError('No config found in {}'.format(plugin_path))
    config = json.load(open(config_path))
    imp.load_package(config['name'], plugin_path)
    importlib.import_module('taas.strategies.builtin')
    def open(self, tracker_home, optimize=0):
        """Open the tracker.

        Parameters:
            tracker_home:
                tracker home directory
            optimize:
                if set, precompile html templates

        Raise ValueError if the tracker home doesn't exist.

        """
        import imp
        # sanity check existence of tracker home
        if not os.path.exists(tracker_home):
            raise ValueError, 'no such directory: "%s"'%tracker_home

        # sanity check tracker home contents
        for reqd in 'config dbinit select_db interfaces'.split():
            if not os.path.exists(os.path.join(tracker_home, '%s.py'%reqd)):
                raise TrackerError, 'File "%s.py" missing from tracker '\
                    'home "%s"'%(reqd, tracker_home)

        if self.trackers.has_key(tracker_home):
            return imp.load_package(self.trackers[tracker_home],
                tracker_home)
        # register all available backend modules
        backends.list_backends()
        self.number = self.number + 1
        modname = '_roundup_tracker_%s'%self.number
        self.trackers[tracker_home] = modname

        # load the tracker
        tracker = imp.load_package(modname, tracker_home)

        # ensure the tracker has all the required bits
        for required in 'open init Client MailGW'.split():
            if not hasattr(tracker, required):
                raise TrackerError, \
                    'Required tracker attribute "%s" missing'%required

        # load and apply the config
        tracker.config = configuration.CoreConfig(tracker_home)
        tracker.dbinit.config = tracker.config

        tracker.optimize = optimize
        tracker.templates = templating.Templates(tracker.config["TEMPLATES"])
        if optimize:
            tracker.templates.precompileTemplates()

        return tracker
示例#7
0
文件: lptenv.py 项目: Scemoon/lpts
def setup(base_path, root_module_name="lpt"):
        
    if sys.modules.has_key(root_module_name):
    # already set up
        return

    _create_module_and_parents(root_module_name)
    imp.load_package(root_module_name, base_path)

    # Allow locally installed third party packages to be found.
    # This is primarily for the benefit of frontend and tko so that they
    # may use libraries other than those available as system packages.
    
    sys.path.insert(0, os.path.join(base_path, "site-packages"))
示例#8
0
    def open(self, tracker_home, optimize=0):
        """Open the tracker.

        Parameters:
            tracker_home:
                tracker home directory
            optimize:
                if set, precompile html templates

        Raise ValueError if the tracker home doesn't exist.

        """
        import imp
        # sanity check existence of tracker home
        if not os.path.exists(tracker_home):
            raise ValueError('no such directory: "%s"' % tracker_home)

        # sanity check tracker home contents
        for reqd in 'config dbinit select_db interfaces'.split():
            if not os.path.exists(os.path.join(tracker_home, '%s.py' % reqd)):
                raise TrackerError('File "%s.py" missing from tracker '\
                    'home "%s"'%(reqd, tracker_home))

        if tracker_home in self.trackers:
            return imp.load_package(self.trackers[tracker_home], tracker_home)
        # register all available backend modules
        backends.list_backends()
        self.number = self.number + 1
        modname = '_roundup_tracker_%s' % self.number
        self.trackers[tracker_home] = modname

        # load the tracker
        tracker = imp.load_package(modname, tracker_home)

        # ensure the tracker has all the required bits
        for required in 'open init Client MailGW'.split():
            if not hasattr(tracker, required):
                raise TrackerError('Required tracker attribute "%s" missing' %
                                   required)

        # load and apply the config
        tracker.config = configuration.CoreConfig(tracker_home)
        tracker.dbinit.config = tracker.config

        tracker.optimize = optimize
        tracker.templates = templating.get_loader(tracker.config["TEMPLATES"])
        if optimize:
            tracker.templates.precompile()

        return tracker
示例#9
0
文件: main.py 项目: hdeweirdt/imp
    def _load_plugins(self, plugin_dir, namespace):
        """
            Load all modules in plugin_dir
        """
        if not os.path.exists(os.path.join(plugin_dir, "__init__.py")):
            raise Exception("The plugin directory %s should be a valid python package with a __init__.py file" % plugin_dir)

        mod_name = ".".join(namespace.to_path())
        imp.load_package(mod_name, plugin_dir)
        
        for py_file in glob.glob(os.path.join(plugin_dir, "*.py")):
            if not py_file.endswith("__init__.py"):
                sub_mod = mod_name + "." + os.path.basename(py_file).split(".")[0]
                imp.load_source(sub_mod, py_file)
示例#10
0
文件: init_env.py 项目: zhyh329/lpts
def setup(base_path, root_module_name="lpt"):

    if sys.modules.has_key(root_module_name):
        # already set up
        return

    _create_module_and_parents(root_module_name)
    imp.load_package(root_module_name, base_path)

    # Allow locally installed third party packages to be found.
    # This is primarily for the benefit of frontend and tko so that they
    # may use libraries other than those available as system packages.

    sys.path.insert(0, os.path.join(base_path, "site-packages"))
示例#11
0
def load_ais(base_folder="AIs"):
    '''
    Finds packages containing AIs from the root->AIs folder and returns
    a list of the AI objects they contain.
    '''
    from ..game import PlayerAIBase

    # We find the AI package folders, which live in the "AIs" folder...
    ai_folders = [item for item in os.listdir(base_folder)]

    # We loop through the packages...
    ais = []
    for ai_folder in ai_folders:
        if not ai_folder.startswith("."):
            # We load each package...
            package_folder = os.path.join(base_folder,ai_folder)
            print(package_folder)
            ai_package = imp.load_package(ai_folder, package_folder)

            # We find the classes they expose that are derived from the
            # base AI class...
            ais_in_package = _find_derived_classes(ai_package, PlayerAIBase)
            ais.extend(ais_in_package)

    return ais
示例#12
0
def setup(base_path, root_module_name="caliper"):
    """
    Setup a library namespace, with the appropriate top root module name.

    Perform all the necessary setup so that all the packages at 'base_path' can
    be imported via 'import root_module_name,package'
    :param base_path: Base path for the module
    :parma root_module_name: Top level name for the module
    """
    if sys.modules.has_key(root_module_name):
        return
    _create_module_and_parents(root_module_name)
    imp.load_package(root_module_name, base_path)

    # allow locally installed third party packages to be found.
    sys.path.insert(0, os.path.join(base_path, "site_packages"))
示例#13
0
def setup(base_path, root_module_name="caliper"):
    """
    Setup a library namespace, with the appropriate top root module name.

    Perform all the necessary setup so that all the packages at 'base_path' can
    be imported via 'import root_module_name,package'
    :param base_path: Base path for the module
    :parma root_module_name: Top level name for the module
    """
    if sys.modules.has_key(root_module_name):
        return
    _create_module_and_parents(root_module_name)
    imp.load_package(root_module_name, base_path)

    # allow locally installed third party packages to be found.
    sys.path.insert(0, os.path.join(base_path, "site_packages"))
示例#14
0
def loader_lp(uri, name=None):
    mountpoint = get_mount_point()
    name = name or __new_submod_name()
    modname = mountpoint + '.' + name
    mod = imp.load_package(modname, uri)
    setattr(sys.modules[mountpoint], name, mod)    
    exec 'import %s' %modname ## sanity check    
    return Plugin(mod.__plgname__, mod.__entries__, mod.__extensions__)
示例#15
0
 def reRaiseECO(self, eco):
     import json
     if eco.exceptionmodule:
         mod = imp.load_package(eco.exceptionmodule, eco.exceptionmodule)
     else:
         import __builtin__ as mod
     Klass = getattr(mod, eco.exceptionclassname, RuntimeError)
     exc = Klass(eco.errormessage)
     for key, value in json.loads(eco.exceptioninfo).iteritems():
         setattr(exc, key, value)
     raise exc
示例#16
0
 def reRaiseECO(self, eco):
     if eco.exceptionmodule:
         mod = imp.load_package(eco.exceptionmodule, eco.exceptionmodule)
     else:
         import builtins as mod
     Klass = getattr(mod, eco.exceptionclassname, RuntimeError)
     exc = Klass(eco.errormessage)
     for key, value in list(
             j.data.serializer.json.loads(eco.exceptioninfo).items()):
         setattr(exc, key, value)
     raise exc
示例#17
0
 def _load_plugins(self):
     module_dir, _ = get_module_info()
     plugin_dir = os.path.join(module_dir, "plugins")
     if not os.path.exists(plugin_dir):
         return
     if not os.path.exists(os.path.join(plugin_dir, "__init__.py")):
         raise Exception(
             "Plugins directory doesn't have a __init__.py file.")
     result = {}
     mod_name = os.path.basename(module_dir)
     imp.load_package("inmanta_plugins." + mod_name, plugin_dir)
     for py_file in glob.glob(os.path.join(plugin_dir, "*.py")):
         sub_mod_path = "inmanta_plugins." + mod_name + "." + os.path.basename(
             py_file).split(".")[0]
         imp.load_source(sub_mod_path, py_file)
         sub_mod = importlib.import_module(sub_mod_path)
         for k, v in sub_mod.__dict__.items():
             if isinstance(v, types.FunctionType):
                 result[k] = v
     return result
 def reRaiseECO(self, eco):
     import json
     if eco.exceptionmodule:
         mod = imp.load_package(eco.exceptionmodule, eco.exceptionmodule)
     else:
         import builtins as mod
     Klass = getattr(mod, eco.exceptionclassname, RuntimeError)
     exc = Klass(eco.errormessage)
     for key, value in list(json.loads(eco.exceptioninfo).items()):
         setattr(exc, key, value)
     raise exc
示例#19
0
def setup(base_path, root_module_name=""):
    """
    Perform all the necessary setup so that all the packages at
    'base_path' can be imported via "import root_module_name.package".
    If root_module_name is empty, then all the packages at base_path
    are inserted as top-level packages.

    Also, setup all the common.* aliases for modules in the common
    library.

    The setup must be different if you are running on an Autotest server
    or on a test machine that just has the client directories installed.
    """
    setup_client_only = False
    try:
        sys.modules[root_module_name]
    except KeyError:
        # Hack... Any better ideas?
        if root_module_name == 'autotest.client':
            serverdir = os.path.join(os.path.dirname(__file__), '..', 'server')
            full_source = os.path.exists(serverdir)
            if full_source:
                root_module_name = 'autotest'
                base_path = os.path.abspath(os.path.join(base_path, '..'))
            else:
                setup_client_only = True

        if setup_client_only:
            _create_module_and_parents(root_module_name)
            imp.load_package(root_module_name, base_path)
        else:
            _create_module_and_parents(root_module_name)
            _import_children_into_module(root_module_name, base_path)
            # Allow locally installed third party packages to be found
            # before any that are installed on the system itself when not.
            # running as a client.
            # This is primarily for the benefit of frontend and tko so that they
            # may use libraries other than those available as system packages.
            sys.path.insert(0, os.path.join(base_path, "site-packages"))

        _monkeypatch_logging_handle_error()
示例#20
0
def setup(base_path, root_module_name=""):
    """
    Perform all the necessary setup so that all the packages at
    'base_path' can be imported via "import root_module_name.package".
    If root_module_name is empty, then all the packages at base_path
    are inserted as top-level packages.

    Also, setup all the common.* aliases for modules in the common
    library.

    The setup must be different if you are running on an Autotest server
    or on a test machine that just has the client directories installed.
    """
    setup_client_only = False
    try:
        sys.modules[root_module_name]
    except KeyError:
        # Hack... Any better ideas?
        if root_module_name == 'autotest.client':
            serverdir = os.path.join(os.path.dirname(__file__), '..', 'server')
            full_source = os.path.exists(serverdir)
            if full_source:
                root_module_name = 'autotest'
                base_path = os.path.abspath(os.path.join(base_path, '..'))
            else:
                setup_client_only = True

        if setup_client_only:
            _create_module_and_parents(root_module_name)
            imp.load_package(root_module_name, base_path)
        else:
            _create_module_and_parents(root_module_name)
            _import_children_into_module(root_module_name, base_path)
            # Allow locally installed third party packages to be found
            # before any that are installed on the system itself when not.
            # running as a client.
            # This is primarily for the benefit of frontend and tko so that they
            # may use libraries other than those available as system packages.
            sys.path.insert(0, os.path.join(base_path, "site-packages"))

        _monkeypatch_logging_handle_error()
示例#21
0
def setup(base_path, root_module_name="autotest"):
    """
    Setup a library namespace, with the appropriate top root module name.

    Perform all the necessary setup so that all the packages at
    'base_path' can be imported via "import root_module_name.package".

    :param base_path: Base path for the module.
    :param root_module_name: Top level name for the module.
    """
    if sys.modules.has_key(root_module_name):
        # already set up
        return

    _create_module_and_parents(root_module_name)
    imp.load_package(root_module_name, base_path)

    # Allow locally installed third party packages to be found.
    # This is primarily for the benefit of frontend and tko so that they
    # may use libraries other than those available as system packages.
    sys.path.insert(0, os.path.join(base_path, "site-packages"))
示例#22
0
def load_from_path(plugin_path):
    packages = setuptools.find_packages(plugin_path)
    for pkg in packages:
        manifest_file = Path(plugin_path)/pkg/'manifest.py'
        if not manifest_file.exists():
            continue
        imp.load_package(pkg, Path(plugin_path)/pkg)
        __import__(pkg+'.manifest')

    # There can only one manifest in each plugin
    if len(manifest_cache) > 1:
        raise ManifestError('More than one manifest in this plugin')
    if len(manifest_cache) == 0:
        raise ManifestError(f'Not found any manifest in {plugin_path}')

    # TODO
    manifest = manifest_cache[0][0]
    caller_info = manifest_cache[0][1]
    plugin = Plugin(manifest['id'], **manifest)
    plugin.location = str(Path(caller_info.filename).parent)
    return plugin
示例#23
0
def setup(base_path, root_module_name="autotest"):
    """
    Setup a library namespace, with the appropriate top root module name.

    Perform all the necessary setup so that all the packages at
    'base_path' can be imported via "import root_module_name.package".

    :param base_path: Base path for the module.
    :param root_module_name: Top level name for the module.
    """
    if root_module_name in sys.modules:
        # already set up
        return

    _create_module_and_parents(root_module_name)
    imp.load_package(root_module_name, base_path)

    # Allow locally installed third party packages to be found.
    # This is primarily for the benefit of frontend and tko so that they
    # may use libraries other than those available as system packages.
    sys.path.insert(0, os.path.join(base_path, "site-packages"))
示例#24
0
    def _load_codec_module(self, path, expected_class):
        """
        Return and load expected_class from path file.
        """
        if os.path.isfile(path):
            mod_name, file_ext = os.path.splitext(os.path.basename(path))
            if file_ext.lower() == '.py':
                py_mod = imp.load_source(mod_name, path)
            elif file_ext.lower() == '.pyc':
                py_mod = imp.load_compiled(mod_name, path)
        else:
            mod_name = os.path.basename(path)
            py_mod = imp.load_package(mod_name, path)

        if hasattr(py_mod, expected_class):
            return getattr(py_mod, expected_class)()
        return None
示例#25
0
    def modules(self):
        """ Return a dict of module names and module info.

        Each value of the dict is a list of functions and classes as returned by
        get_functions() and get_classes().

        """

        modules = {}
        for node in self._tree.body:
            for subnode in ast.walk(node):
                if isinstance(subnode, ast.Import):
                    module_name = subnode.names[0].name
                elif isinstance(subnode, ast.ImportFrom):
                    module_name = subnode.module
                    imported_name = subnode.names[0].name
                else:
                    continue

                try:
                    module_tree = _parse_module(module_name)
                except TypeError:  # .so files
                    loaded_module = imp.load_dynamic(
                        module_name, imp.find_module(module_name)[1])
                    module_info = dir(loaded_module)
                except IOError:  # directories
                    loaded_module = imp.load_package(
                        module_name, imp.find_module(module_name)[1])
                    module_info = dir(loaded_module)
                else:
                    module_info = self._functions() + self._classes()
                finally:
                    if isinstance(subnode, ast.ImportFrom):
                        if imported_name in module_info:
                            modules[imported_name] = module_info[imported_name]
                    else:
                        modules[module_name] = module_info
        return modules
示例#26
0
def load_ais():
    '''
    Finds packages containing AIs from the root->AIs folder and returns
    a list of the AI objects they contain.
    '''
    from ..game import PlayerAIBase

    # We find the AI package folders, which live in the "AIs" folder...
    ai_folders = [item for item in os.listdir("AIs")]

    # We loop through the packages...
    ais = []
    for ai_folder in ai_folders:
        # We load each package...
        package_folder = "AIs/" + ai_folder
        ai_package = imp.load_package(ai_folder, package_folder)

        # We find the classes they expose that are derived from the
        # base AI class...
        ais_in_package = _find_derived_classes(ai_package, PlayerAIBase)
        ais.extend(ais_in_package)

    return ais
示例#27
0
def getPrjPackage():
    """
    Так как папка проекта является пакетом Python,
    то можно получить объект пакета.
    @return: Объект пакета прикладного проекта.
    """
    prj_dir = getPrjDir()
    prj_name = getPrjName()

    if not prj_dir:
        log.warning(
            u'Не определена папка проекта для получения объекта пакета Python')
        return None
    if not prj_name:
        log.warning(
            u'Не определено имя проекта для получения объекта пакета Python')
        return None

    try:
        return imp.load_package(prj_name, prj_dir)
    except:
        log.fatal(u'Ошибка создания объекта пакета Python <%s> : <%s>' %
                  (prj_name, prj_dir))
    return None
import imp
import os.path as osp


abs_path = osp.dirname(osp.abspath(__file__))


deep_sort = imp.load_package(
    'deep_sort', osp.join(abs_path, 'deep_sort/deep_sort'))

application_util = imp.load_package(
    'application_util', osp.join(abs_path, 'deep_sort/application_util'))

deep_sort_app = imp.load_source(
    'deep_sort_app', osp.join(abs_path, 'deep_sort/deep_sort_app.py'))
示例#29
0
    def _get_subclasses(self, parent=None, parent_class=None, recursive=True):
        """
        Import all submodules of the package containing the present class.
        Includes subpackages recursively, if specified.

        :param parent: package/class.
            If package looks for the classes in submodules.
            If class, first looks for the package where it is contained
        :param parent_class: class of which to look for subclasses
        :param recursive: True/False (go recursively into submodules)
        """

        import pkgutil
        import imp
        import inspect
        import os

        # If no parent class is specified set it to self.__class
        parent = self.__class__ if parent is None else parent

        # Suppose parent is class
        if inspect.isclass(parent):

            # Set the package where the class is contained
            classfile = inspect.getfile(parent)
            package_path = os.path.dirname(classfile)

            # If parent class is not specified, assume it is the parent
            if parent_class is None:
                parent_class = parent

        # Suppose parent is a package (directory containing __init__.py).
        # Check if it contains attribute __path__
        elif inspect.ismodule(parent) and hasattr(parent, '__path__'):

            # Assume path is one element list
            package_path = parent.__path__[0]

            # if parent is a package, parent_class cannot be None
            if parent_class is None:
                raise TypeError('argument parent_class cannot be None')

                # Recursively check the subpackages
        results = {}

        for _, name, is_pkg in pkgutil.walk_packages([package_path]):
            # N.B. pkgutil.walk_package requires a LIST of paths.

            full_path_base = os.path.join(package_path, name)

            if is_pkg:
                app_module = imp.load_package(full_path_base, full_path_base)
            else:
                full_path = full_path_base + '.py'
                # I could use load_module but it takes lots of arguments,
                # then I use load_source
                app_module = imp.load_source('rst' + name, full_path)

            # Go through the content of the module
            if not is_pkg:
                for fname, obj in inspect.getmembers(app_module):
                    if inspect.isclass(obj) and issubclass(obj, parent_class):
                        results[fname] = obj
            # Look in submodules
            elif is_pkg and recursive:
                results.update(
                    self._get_subclasses(parent=app_module,
                                         parent_class=parent_class))
        return results
from setuptools import setup, find_packages
import os
import imp

def find_package_data(module, path):
    """Find all data files to include in the package"""
    files = []
    for dirpath, dirnames, filenames in os.walk(os.path.join(module,path)):
        for filename in filenames:
            files.append(os.path.relpath(os.path.join(dirpath,filename),module))
    return {module:files}

#Setup the application using meta information from
#the plugin's own __dist__ object:
plugin = imp.load_package(module_name,module_name)
setup(name=module_name,
      description=plugin.__dist__['pypi_description'],
      version=plugin.__version__,
      author=plugin.__dist__["author"],
      url=plugin.__dist__["url"],
      packages=[module_name],
      package_data = find_package_data(module_name,"site_src"),
      include_package_data = True,
      install_requires =['blogofile'],
      entry_points = {
        "blogofile.plugins":
            ["{module_name} = {module_name}".format(**locals())]
        }
      )
示例#31
0
    def test_issue5604(self):
        # Test cannot cover imp.load_compiled function.
        # Martin von Loewis note what shared library cannot have non-ascii
        # character because init_xxx function cannot be compiled
        # and issue never happens for dynamic modules.
        # But sources modified to follow generic way for processing pathes.

        locale_encoding = locale.getpreferredencoding()

        # covers utf-8 and Windows ANSI code pages
        # one non-space symbol from every page
        # (http://en.wikipedia.org/wiki/Code_page)
        known_locales = {
            'utf-8' : b'\xe4',
            'cp1250' : b'\x8C',
            'cp1251' : b'\xc0',
            'cp1252' : b'\xc0',
            'cp1253' : b'\xc1',
            'cp1254' : b'\xc0',
            'cp1255' : b'\xe0',
            'cp1256' : b'\xe0',
            'cp1257' : b'\xc0',
            'cp1258' : b'\xc0',
            }

        special_char = known_locales.get(locale_encoding)
        if special_char:
            encoded_char = special_char.decode(locale_encoding)
            temp_mod_name = 'test_imp_helper_' + encoded_char
            test_package_name = 'test_imp_helper_package_' + encoded_char
            init_file_name = os.path.join(test_package_name, '__init__.py')
            try:
                with open(temp_mod_name + '.py', 'w') as file:
                    file.write('a = 1\n')
                file, filename, info = imp.find_module(temp_mod_name)
                self.assertNotEquals(None, file)
                self.assertTrue(filename[:-3].endswith(temp_mod_name))
                self.assertEquals('.py', info[0])
                self.assertEquals('U', info[1])
                self.assertEquals(imp.PY_SOURCE, info[2])

                mod = imp.load_module(temp_mod_name, file, filename, info)
                self.assertEquals(1, mod.a)
                file.close()

                mod = imp.load_source(temp_mod_name, temp_mod_name + '.py')
                self.assertEquals(1, mod.a)

                mod = imp.load_compiled(temp_mod_name, temp_mod_name + '.pyc')
                self.assertEquals(1, mod.a)

                if not os.path.exists(test_package_name):
                    os.mkdir(test_package_name)
                with open(init_file_name, 'w') as file:
                    file.write('b = 2\n')
                package = imp.load_package(test_package_name, test_package_name)
                self.assertEquals(2, package.b)
            finally:
                support.unlink(temp_mod_name + '.py')
                support.unlink(temp_mod_name + '.pyc')
                support.unlink(temp_mod_name + '.pyo')

                support.unlink(init_file_name + '.py')
                support.unlink(init_file_name + '.pyc')
                support.unlink(init_file_name + '.pyo')
                support.rmtree(test_package_name)
示例#32
0
    def test_issue5604(self):
        # Test cannot cover imp.load_compiled function.
        # Martin von Loewis note what shared library cannot have non-ascii
        # character because init_xxx function cannot be compiled
        # and issue never happens for dynamic modules.
        # But sources modified to follow generic way for processing pathes.

        # the return encoding could be uppercase or None
        fs_encoding = sys.getfilesystemencoding()

        # covers utf-8 and Windows ANSI code pages
        # one non-space symbol from every page
        # (http://en.wikipedia.org/wiki/Code_page)
        known_locales = {
            'utf-8' : b'\xc3\xa4',
            'cp1250' : b'\x8C',
            'cp1251' : b'\xc0',
            'cp1252' : b'\xc0',
            'cp1253' : b'\xc1',
            'cp1254' : b'\xc0',
            'cp1255' : b'\xe0',
            'cp1256' : b'\xe0',
            'cp1257' : b'\xc0',
            'cp1258' : b'\xc0',
            }

        if sys.platform == 'darwin':
            self.assertEqual(fs_encoding, 'utf-8')
            # Mac OS X uses the Normal Form D decomposition
            # http://developer.apple.com/mac/library/qa/qa2001/qa1173.html
            special_char = b'a\xcc\x88'
        else:
            special_char = known_locales.get(fs_encoding)

        if not special_char:
            self.skipTest("can't run this test with %s as filesystem encoding"
                          % fs_encoding)
        decoded_char = special_char.decode(fs_encoding)
        temp_mod_name = 'test_imp_helper_' + decoded_char
        test_package_name = 'test_imp_helper_package_' + decoded_char
        init_file_name = os.path.join(test_package_name, '__init__.py')
        try:
            # if the curdir is not in sys.path the test fails when run with
            # ./python ./Lib/test/regrtest.py test_imp
            sys.path.insert(0, os.curdir)
            with open(temp_mod_name + '.py', 'w') as file:
                file.write('a = 1\n')
            file, filename, info = imp.find_module(temp_mod_name)
            with file:
                self.assertIsNotNone(file)
                self.assertTrue(filename[:-3].endswith(temp_mod_name))
                self.assertEqual(info[0], '.py')
                self.assertEqual(info[1], 'r')
                self.assertEqual(info[2], imp.PY_SOURCE)

                mod = imp.load_module(temp_mod_name, file, filename, info)
                self.assertEqual(mod.a, 1)

            with warnings.catch_warnings():
                warnings.simplefilter('ignore')
                mod = imp.load_source(temp_mod_name, temp_mod_name + '.py')
            self.assertEqual(mod.a, 1)

            with warnings.catch_warnings():
                warnings.simplefilter('ignore')
                if not sys.dont_write_bytecode:
                    mod = imp.load_compiled(
                        temp_mod_name,
                        imp.cache_from_source(temp_mod_name + '.py'))
            self.assertEqual(mod.a, 1)

            if not os.path.exists(test_package_name):
                os.mkdir(test_package_name)
            with open(init_file_name, 'w') as file:
                file.write('b = 2\n')
            with warnings.catch_warnings():
                warnings.simplefilter('ignore')
                package = imp.load_package(test_package_name, test_package_name)
            self.assertEqual(package.b, 2)
        finally:
            del sys.path[0]
            for ext in ('.py', '.pyc', '.pyo'):
                support.unlink(temp_mod_name + ext)
                support.unlink(init_file_name + ext)
            support.rmtree(test_package_name)
            support.rmtree('__pycache__')
示例#33
0
 def _do_load_module(self, name):
     real_name = 'canivett_' + name
     _, path, *_ = imp.find_module(real_name)  # NOQA
     module = imp.load_package(real_name, path)
     self.modules[name] = module
     return module
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
#import catboost

import imp
import sys

# Manually load the model incase it does now work with import
imp.load_package('catboost', 'C:\python\Lib\site-packages\catboost')
import catboost as cb
print(sys.path)
sys.path.append('C:\python\Lib\site-packages\mypackages')

from catboost import CatBoostRegressor
import pandas as pd
import sys
import numpy as np
import scipy as sp
import matplotlib
import matplotlib.pyplot as plt
import seaborn as sns
import sklearn as sk
from sklearn.model_selection import train_test_split
from sklearn.ensemble import GradientBoostingClassifier

ds = pd.read_csv(r'file_name.csv')

cols = ds.columns.tolist()
n = int(cols.index('Y_Col'))
cols = cols[:n] + cols[n + 1:] + [cols[n]]
示例#35
0
import imp

import numpy as np
import pandas as pd
# import rampwf as rw


local_workflow = imp.load_package('workflow', './workflow')


problem_title = 'Mars craters detection and classification'

# A type (class) which will be used to create wrapper objects for y_pred
Predictions = local_workflow.predictions.Predictions

# An object implementing the workflow
workflow = local_workflow.workflow.ObjectDetector()

score_types = [
    local_workflow.scores.SCP(precision=4),
    local_workflow.scores.OSPA(precision=4),
    local_workflow.scores.AveragePrecision(precision=4),
    local_workflow.scores.Precision(precision=4),
    local_workflow.scores.Recall(precision=4),
]


def get_cv(folder_X, y):
    # _, X = folder_X
    # cv = StratifiedShuffleSplit(n_splits=1, test_size=0.2, random_state=57)
    # return cv.split(X, y)
示例#36
0
"""
from ._version import __version__

# mokeypatch cclib/chemlab classes improved for this implementation
# TODO don't think this is working, use mock?

import os, sys, platform

##TODO a weird thing sometimes happens if docx installed,
#whereby 'import enum' installs docx/enum instead of enum (req for numba)!?
if platform.system() == 'Windows':
    import imp
    init = os.path.abspath(__file__)
    pkg = os.path.dirname(init)
    sites = os.path.dirname(pkg)
    imp.load_package('enum', os.path.join(sites, 'enum'))

from .cclib_patch.parser import data

sys.modules['cclib.parser.data'] = data

import cclib  # version 1.3
import chemlab  # version 0.4

from .molecule import Molecule
from .analysis import Analysis
from .file_io import Folder
from .docs import MSDocument
from .utils import df_to_img, set_imagik_exe

import cPickle as pkl
示例#37
0
    def test_issue5604(self):
        # Test cannot cover imp.load_compiled function.
        # Martin von Loewis note what shared library cannot have non-ascii
        # character because init_xxx function cannot be compiled
        # and issue never happens for dynamic modules.
        # But sources modified to follow generic way for processing pathes.

        # the return encoding could be uppercase or None
        fs_encoding = sys.getfilesystemencoding()

        # covers utf-8 and Windows ANSI code pages
        # one non-space symbol from every page
        # (http://en.wikipedia.org/wiki/Code_page)
        known_locales = {
            "utf-8": b"\xc3\xa4",
            "cp1250": b"\x8C",
            "cp1251": b"\xc0",
            "cp1252": b"\xc0",
            "cp1253": b"\xc1",
            "cp1254": b"\xc0",
            "cp1255": b"\xe0",
            "cp1256": b"\xe0",
            "cp1257": b"\xc0",
            "cp1258": b"\xc0",
        }

        if sys.platform == "darwin":
            self.assertEqual(fs_encoding, "utf-8")
            # Mac OS X uses the Normal Form D decomposition
            # http://developer.apple.com/mac/library/qa/qa2001/qa1173.html
            special_char = b"a\xcc\x88"
        else:
            special_char = known_locales.get(fs_encoding)

        if not special_char:
            self.skipTest("can't run this test with %s as filesystem encoding" % fs_encoding)
        decoded_char = special_char.decode(fs_encoding)
        temp_mod_name = "test_imp_helper_" + decoded_char
        test_package_name = "test_imp_helper_package_" + decoded_char
        init_file_name = os.path.join(test_package_name, "__init__.py")
        try:
            # if the curdir is not in sys.path the test fails when run with
            # ./python ./Lib/test/regrtest.py test_imp
            sys.path.insert(0, os.curdir)
            with open(temp_mod_name + ".py", "w") as file:
                file.write("a = 1\n")
            file, filename, info = imp.find_module(temp_mod_name)
            with file:
                self.assertIsNotNone(file)
                self.assertTrue(filename[:-3].endswith(temp_mod_name))
                self.assertEqual(info[0], ".py")
                self.assertEqual(info[1], "U")
                self.assertEqual(info[2], imp.PY_SOURCE)

                mod = imp.load_module(temp_mod_name, file, filename, info)
                self.assertEqual(mod.a, 1)

            mod = imp.load_source(temp_mod_name, temp_mod_name + ".py")
            self.assertEqual(mod.a, 1)

            mod = imp.load_compiled(temp_mod_name, imp.cache_from_source(temp_mod_name + ".py"))
            self.assertEqual(mod.a, 1)

            if not os.path.exists(test_package_name):
                os.mkdir(test_package_name)
            with open(init_file_name, "w") as file:
                file.write("b = 2\n")
            package = imp.load_package(test_package_name, test_package_name)
            self.assertEqual(package.b, 2)
        finally:
            del sys.path[0]
            for ext in (".py", ".pyc", ".pyo"):
                support.unlink(temp_mod_name + ext)
                support.unlink(init_file_name + ext)
            support.rmtree(test_package_name)
示例#38
0
文件: setup.py 项目: meikuam/adolpy
#
# $Id$
# ---------------------------------------------------------------------------

from distutils.core import setup
import re
import os
import sys
import imp

# Load the data.

here = os.path.dirname(os.path.abspath(sys.argv[0]))
sys.path = [here] + sys.path
mf = os.path.join(here, 'adolpy')
adolpy = imp.load_package('adolpy', mf)
long_description = adolpy.__doc__
version = str(adolpy.__version__)
author = adolpy.__author__
email = adolpy.__email__

url = adolpy.__url__
license = adolpy.__license__

setup(name="adolpy",
      version=version,
      description="Automatic differentiation using the forward model",
      long_description=long_description,
      url=url,
      license=license,
      author=author,
示例#39
0
文件: loader.py 项目: damantou/moon
def load_pkg(name, location, parent):
    pname = modname(parent) + '.' + name
    module = imp.load_package(pname, location)
    setattr(sysmod(parent), pname, module)
    return (pname, module)
示例#40
0
def get_module(path):
    module = imp.load_package('module',path)
    return module
示例#41
0
#!/usr/bin/env python

# Standard Python Imports
import os
import numpy as np
import time
import imp
import sys
from argparse import ArgumentParser

# OpenRAVE
from openravepy import *
#RaveInitialize(True, DebugLevel.Debug)

# Import Dfab Python, Watch out for hard coded directory
dfab_pack = imp.load_package('dfab', './dfab-master/python/dfab/')
from dfab.mocap import extract_trajectory, datafiles
from dfab.geometry.quaternion import to_threexform
from dfab.rapid.joint_sequence import single_trajectory_program

curr_path = os.getcwd()
relative_ordata = '/models'
ordata_path_thispack = curr_path + relative_ordata

#this sets up the OPENRAVE_DATA environment variable to include the files we're using
openrave_data_path = os.getenv('OPENRAVE_DATA', '')
openrave_data_paths = openrave_data_path.split(':')
if ordata_path_thispack not in openrave_data_paths:
  if openrave_data_path == '':
      os.putenv('OPENRAVE_DATA', ordata_path_thispack)
  else:
示例#42
0
#!/usr/bin/env python

# Standard Python Imports
import os
import numpy as np
import time
import imp
import sys
from argparse import ArgumentParser

# OpenRAVE
from openravepy import *
#RaveInitialize(True, DebugLevel.Debug)

# Import Dfab Python, Watch out for hard coded directory
dfab_pack = imp.load_package('dfab', '../dfab/python/dfab/')
from dfab.mocap import extract_trajectory, datafiles
from dfab.geometry.quaternion import to_threexform
from dfab.rapid.joint_sequence import single_trajectory_program

from scipy.optimize import fmin
from math import sqrt, cos, sin, radians

curr_path = os.getcwd()
relative_ordata = '/models'
ordata_path_thispack = curr_path + relative_ordata

#this sets up the OPENRAVE_DATA environment variable to include the files we're using
openrave_data_path = os.getenv('OPENRAVE_DATA', '')
openrave_data_paths = openrave_data_path.split(':')
if ordata_path_thispack not in openrave_data_paths:
示例#43
0
import imp
import os
import sys

from pathlib import Path

project_dir = Path(Path.cwd(), __file__).parent

# Remove the distribution directory from sys.path
if os.path.abspath(sys.path[0]) == str(project_dir):
    del sys.path[0]

try:
    import sgfmill
except ImportError:
    sys.exit("test_installed_sgfmill: can't find the sgfmill package")

PACKAGE_NAME = "sgfmill_tests"

# Make sgfmill_tests importable without the sibling sgfmill
packagepath = Path(project_dir, PACKAGE_NAME)
mdl = imp.load_package(PACKAGE_NAME, str(packagepath))
sys.modules[PACKAGE_NAME] = mdl

found = Path(Path.cwd(), sgfmill.__file__).parent
print("testing sgfmill package in %s" % found, file=sys.stderr)
from sgfmill_tests import run_sgfmill_testsuite

run_sgfmill_testsuite.run(sys.argv[1:])
示例#44
0
def get_module(path):
    module = imp.load_package('module', path)
    return module
示例#45
0
    def test_issue5604(self):
        # Test cannot cover imp.load_compiled function.
        # Martin von Loewis note what shared library cannot have non-ascii
        # character because init_xxx function cannot be compiled
        # and issue never happens for dynamic modules.
        # But sources modified to follow generic way for processing pathes.

        locale_encoding = locale.getpreferredencoding()

        # covers utf-8 and Windows ANSI code pages
        # one non-space symbol from every page
        # (http://en.wikipedia.org/wiki/Code_page)
        known_locales = {
            'utf-8': b'\xe4',
            'cp1250': b'\x8C',
            'cp1251': b'\xc0',
            'cp1252': b'\xc0',
            'cp1253': b'\xc1',
            'cp1254': b'\xc0',
            'cp1255': b'\xe0',
            'cp1256': b'\xe0',
            'cp1257': b'\xc0',
            'cp1258': b'\xc0',
        }

        special_char = known_locales.get(locale_encoding)
        if special_char:
            encoded_char = special_char.decode(locale_encoding)
            temp_mod_name = 'test_imp_helper_' + encoded_char
            test_package_name = 'test_imp_helper_package_' + encoded_char
            init_file_name = os.path.join(test_package_name, '__init__.py')
            try:
                with open(temp_mod_name + '.py', 'w') as file:
                    file.write('a = 1\n')
                file, filename, info = imp.find_module(temp_mod_name)
                self.assertNotEquals(None, file)
                self.assertTrue(filename[:-3].endswith(temp_mod_name))
                self.assertEquals('.py', info[0])
                self.assertEquals('U', info[1])
                self.assertEquals(imp.PY_SOURCE, info[2])

                mod = imp.load_module(temp_mod_name, file, filename, info)
                self.assertEquals(1, mod.a)
                file.close()

                mod = imp.load_source(temp_mod_name, temp_mod_name + '.py')
                self.assertEquals(1, mod.a)

                mod = imp.load_compiled(temp_mod_name, temp_mod_name + '.pyc')
                self.assertEquals(1, mod.a)

                if not os.path.exists(test_package_name):
                    os.mkdir(test_package_name)
                with open(init_file_name, 'w') as file:
                    file.write('b = 2\n')
                package = imp.load_package(test_package_name,
                                           test_package_name)
                self.assertEquals(2, package.b)
            finally:
                support.unlink(temp_mod_name + '.py')
                support.unlink(temp_mod_name + '.pyc')
                support.unlink(temp_mod_name + '.pyo')

                support.unlink(init_file_name + '.py')
                support.unlink(init_file_name + '.pyc')
                support.unlink(init_file_name + '.pyo')
                support.rmtree(test_package_name)
示例#46
0
    def test_issue5604(self):
        # Test cannot cover imp.load_compiled function.
        # Martin von Loewis note what shared library cannot have non-ascii
        # character because init_xxx function cannot be compiled
        # and issue never happens for dynamic modules.
        # But sources modified to follow generic way for processing pathes.

        # the return encoding could be uppercase or None
        fs_encoding = sys.getfilesystemencoding()

        # covers utf-8 and Windows ANSI code pages
        # one non-space symbol from every page
        # (http://en.wikipedia.org/wiki/Code_page)
        known_locales = {
            'utf-8': b'\xc3\xa4',
            'cp1250': b'\x8C',
            'cp1251': b'\xc0',
            'cp1252': b'\xc0',
            'cp1253': b'\xc1',
            'cp1254': b'\xc0',
            'cp1255': b'\xe0',
            'cp1256': b'\xe0',
            'cp1257': b'\xc0',
            'cp1258': b'\xc0',
        }

        if sys.platform == 'darwin':
            self.assertEqual(fs_encoding, 'utf-8')
            # Mac OS X uses the Normal Form D decomposition
            # http://developer.apple.com/mac/library/qa/qa2001/qa1173.html
            special_char = b'a\xcc\x88'
        else:
            special_char = known_locales.get(fs_encoding)

        if not special_char:
            self.skipTest(
                "can't run this test with %s as filesystem encoding" %
                fs_encoding)
        decoded_char = special_char.decode(fs_encoding)
        temp_mod_name = 'test_imp_helper_' + decoded_char
        test_package_name = 'test_imp_helper_package_' + decoded_char
        init_file_name = os.path.join(test_package_name, '__init__.py')
        try:
            # if the curdir is not in sys.path the test fails when run with
            # ./python ./Lib/test/regrtest.py test_imp
            sys.path.insert(0, os.curdir)
            with open(temp_mod_name + '.py', 'w') as file:
                file.write('a = 1\n')
            file, filename, info = imp.find_module(temp_mod_name)
            with file:
                self.assertIsNotNone(file)
                self.assertTrue(filename[:-3].endswith(temp_mod_name))
                self.assertEqual(info[0], '.py')
                self.assertEqual(info[1], 'r')
                self.assertEqual(info[2], imp.PY_SOURCE)

                mod = imp.load_module(temp_mod_name, file, filename, info)
                self.assertEqual(mod.a, 1)

            with warnings.catch_warnings():
                warnings.simplefilter('ignore')
                mod = imp.load_source(temp_mod_name, temp_mod_name + '.py')
            self.assertEqual(mod.a, 1)

            with warnings.catch_warnings():
                warnings.simplefilter('ignore')
                if not sys.dont_write_bytecode:
                    mod = imp.load_compiled(
                        temp_mod_name,
                        imp.cache_from_source(temp_mod_name + '.py'))
            self.assertEqual(mod.a, 1)

            if not os.path.exists(test_package_name):
                os.mkdir(test_package_name)
            with open(init_file_name, 'w') as file:
                file.write('b = 2\n')
            with warnings.catch_warnings():
                warnings.simplefilter('ignore')
                package = imp.load_package(test_package_name,
                                           test_package_name)
            self.assertEqual(package.b, 2)
        finally:
            del sys.path[0]
            for ext in ('.py', '.pyc'):
                support.unlink(temp_mod_name + ext)
                support.unlink(init_file_name + ext)
            support.rmtree(test_package_name)
            support.rmtree('__pycache__')
示例#47
0
文件: nodes.py 项目: xxoolm/Ryven
 def update_event(self, inp=-1):
     self.set_output_val(0, imp.load_package(self.input(0), self.input(1)))
示例#48
0
 def test_issue5604(self):
     fs_encoding = sys.getfilesystemencoding()
     known_locales = {
         'utf-8': b'\xc3\xa4',
         'cp1250': b'\x8c',
         'cp1251': b'\xc0',
         'cp1252': b'\xc0',
         'cp1253': b'\xc1',
         'cp1254': b'\xc0',
         'cp1255': b'\xe0',
         'cp1256': b'\xe0',
         'cp1257': b'\xc0',
         'cp1258': b'\xc0'
     }
     if sys.platform == 'darwin':
         self.assertEqual(fs_encoding, 'utf-8')
         special_char = b'a\xcc\x88'
     else:
         special_char = known_locales.get(fs_encoding)
     if not special_char:
         self.skipTest(
             "can't run this test with %s as filesystem encoding" %
             fs_encoding)
     decoded_char = special_char.decode(fs_encoding)
     temp_mod_name = 'test_imp_helper_' + decoded_char
     test_package_name = 'test_imp_helper_package_' + decoded_char
     init_file_name = os.path.join(test_package_name, '__init__.py')
     try:
         sys.path.insert(0, os.curdir)
         with open(temp_mod_name + '.py', 'w') as file:
             file.write('a = 1\n')
         file, filename, info = imp.find_module(temp_mod_name)
         with file:
             self.assertIsNotNone(file)
             self.assertTrue(filename[:-3].endswith(temp_mod_name))
             self.assertEqual(info[0], '.py')
             self.assertEqual(info[1], 'r')
             self.assertEqual(info[2], imp.PY_SOURCE)
             mod = imp.load_module(temp_mod_name, file, filename, info)
             self.assertEqual(mod.a, 1)
         with warnings.catch_warnings():
             warnings.simplefilter('ignore')
             mod = imp.load_source(temp_mod_name, temp_mod_name + '.py')
         self.assertEqual(mod.a, 1)
         with warnings.catch_warnings():
             warnings.simplefilter('ignore')
             if not sys.dont_write_bytecode:
                 mod = imp.load_compiled(
                     temp_mod_name,
                     imp.cache_from_source(temp_mod_name + '.py'))
         self.assertEqual(mod.a, 1)
         if not os.path.exists(test_package_name):
             os.mkdir(test_package_name)
         with open(init_file_name, 'w') as file:
             file.write('b = 2\n')
         with warnings.catch_warnings():
             warnings.simplefilter('ignore')
             package = imp.load_package(test_package_name,
                                        test_package_name)
         self.assertEqual(package.b, 2)
     finally:
         del sys.path[0]
         for ext in ('.py', '.pyc'):
             support.unlink(temp_mod_name + ext)
             support.unlink(init_file_name + ext)
         support.rmtree(test_package_name)
         support.rmtree('__pycache__')
示例#49
0
#
# $Id$
# ---------------------------------------------------------------------------

from distutils.core import setup
import re
import os
import sys
import imp

# Load the data.

here = os.path.dirname(os.path.abspath(sys.argv[0]))
sys.path = [here] + sys.path
mf = os.path.join(here, 'adolpy')
adolpy = imp.load_package('adolpy', mf) 
long_description = adolpy.__doc__
version = str(adolpy.__version__)
author = adolpy.__author__
email = adolpy.__email__

url = adolpy.__url__
license = adolpy.__license__

setup(
    name="adolpy",
    version=version,
    description="Automatic differentiation using the forward model",
    long_description=long_description,
    url=url,
    license=license,