コード例 #1
0
ファイル: test_api.py プロジェクト: joar/cpython
 def test_sys_modules_loader_is_None(self):
     # If sys.modules[name].__loader__ is None, raise ValueError.
     name = 'some_mod'
     with util.uncache(name):
         module = imp.new_module(name)
         module.__loader__ = None
         sys.modules[name] = module
         with self.assertRaises(ValueError):
             importlib.find_loader(name)
コード例 #2
0
ファイル: test_api.py プロジェクト: luw630/ddzserver
 def test_sys_modules_loader_is_None(self):
     # If sys.modules[name].__loader__ is None, raise ValueError.
     name = 'some_mod'
     with util.uncache(name):
         module = imp.new_module(name)
         module.__loader__ = None
         sys.modules[name] = module
         with self.assertRaises(ValueError):
             importlib.find_loader(name)
コード例 #3
0
ファイル: test_api.py プロジェクト: GuardianRG/static-python
 def test_sys_modules_loader_is_not_set(self):
     # Should raise ValueError
     # Issue #17099
     name = 'some_mod'
     with util.uncache(name):
         module = types.ModuleType(name)
         try:
             del module.__loader__
         except AttributeError:
             pass
         sys.modules[name] = module
         with self.assertRaises(ValueError):
             importlib.find_loader(name)
コード例 #4
0
 def test_sys_modules_loader_is_not_set(self):
     # Should raise ValueError
     # Issue #17099
     name = 'some_mod'
     with util.uncache(name):
         module = types.ModuleType(name)
         try:
             del module.__loader__
         except AttributeError:
             pass
         sys.modules[name] = module
         with self.assertRaises(ValueError):
             importlib.find_loader(name)
コード例 #5
0
 def check_modules(self, module_name, module_fqn, module_path):
     with warnings.catch_warnings(record=True) as w:
         warnings.simplefilter('always')
         # imp.load_module will load even if it has already been loaded.
         # We need to ensure that happens in order to trigger the
         # deprecation warnings
         importlib.find_loader(module_fqn, module_path).load_module()
         warning_raised = False
         for warning in (e.message for e in w):
             if isinstance(warning, PendingDeprecationWarning) and \
                     ('%s is deprecated' % module_name) in warning.args[0]:
                 warning_raised = True
                 break
         tools.assert_true(warning_raised, msg='%s did not raise a PendingDeprecationWarning' % module_fqn)
コード例 #6
0
ファイル: validate.py プロジェクト: thePortus/arakhne
 def modules(self):
     # Returns True if all Python modules are downloaded
     # Returns a list of missing modules otherwise
     needed = []
     for module in self._modules:
         try:
             importlib.find_loader(module)
         except:
             needed.append(module)
     # Return needed packages
     if len(needed) > 0:
         return needed
     else:
         return False
コード例 #7
0
ファイル: test_api.py プロジェクト: juleskt/ek128_work
 def test_success_path(self):
     # Searching on a path should work.
     name = "some_mod"
     path = "path to some place"
     with util.uncache(name):
         with util.import_state(meta_path=[self.FakeMetaFinder]):
             self.assertEqual((name, path), importlib.find_loader(name, path))
コード例 #8
0
    def __init__(self):
        self.session = requests.Session()
        self.session.headers.update(
            {
                'Accept': 'application/json, application/xml',
                'Accept-Language': 'en-US',
                'User-Agent': 'Mozilla/5.0 GelbooruViewer/1.0 (+https://github.com/ArchieMeng/GelbooruViewer)'
            }
        )
        # only cache for get_all with tags while pid is 0!!!

        if importlib.find_loader('lru'):
            from lru import LRU
            self.cache = LRU(GelbooruViewer.MAX_CACHE_SIZE)
        else:
            self.cache = dict()

        self.cache_lock = Lock()
        # occasionally update cache
        self.last_cache_used = time()
        self.update_cache_thread = Thread(target=self._update_cache_loop, daemon=True)
        self.update_cache_thread.start()

        # get latest image to update MAX_ID
        self.get(limit=0)
コード例 #9
0
def create_app():
    app = Flask(__name__, static_url_path="")

    app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://*****:*****@postgresql:5432/site'
    app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
    app.config['ALEMBIC'] = {
        'script_location': 'migrations',
        'version_locations': []
    }

    database = SQLAlchemy(app)

    # подключение модулей
    skip = ['__pycache__']

    for folder in os.listdir('./modules'):
        if os.path.isdir(os.path.join('./modules', folder)) and folder not in skip:
            # importing api
            api_path = os.path.join('./modules', folder, 'api')
            api_module = 'modules.' + folder + '.api'
            api = None
            if os.path.isdir(api_path):
                if find_loader(api_module):
                    api = import_module(api_module)
            elif os.path.isfile(api_path + '.py'):
                api = import_module(api_module)
            if api is not None and hasattr(api, 'blueprint'):
                app.register_blueprint(api.blueprint)
            # importing migrations    
            app.config['ALEMBIC']['version_locations'] = (
                    folder, 'modules/{}/migrations'.format(folder)
            )

    return app
コード例 #10
0
def _decode_base64_data(
    data_text: str, layer_width: int, compression: Optional[str] = None
) -> List[List[int]]:
    """Decode base64 data.

    Args:
        data_text (str): Data to be decoded.
        layer_width (int): Width of each layer in tiles.
        compression (Optional[str]): The type of compression for the data.

    Raises:
        ValueError: If compression type is unsupported.

    Returns:
        :List[List[int]]: Tile grid.
    """
    tile_grid: List[List[int]] = [[]]

    unencoded_data = base64.b64decode(data_text)
    if compression == "zlib":
        unzipped_data = zlib.decompress(unencoded_data)
    elif compression == "gzip":
        unzipped_data = gzip.decompress(unencoded_data)
    elif compression == "zstd":
        modulename = 'zstandard'
        my_loader = importlib.find_loader(modulename)
        found = my_loader is not None
        if not found:
            raise ValueError("Can't load 'zstd' compressed map without the 'zstandard' "
                             "library available. Either install 'zstandard' or go to "
                             "Map Properties and change Tile Layer Format to "
                             "Base64, Base64 gzip, or Base64.")
        else:
            import zstandard
            dctx = zstandard.ZstdDecompressor()
            unzipped_data = dctx.decompress(unencoded_data)
    elif compression is None:
        unzipped_data = unencoded_data
    else:
        raise ValueError(f"Unsupported compression type '{compression}'.")

    # Turn bytes into 4-byte integers
    byte_count = 0
    int_count = 0
    int_value = 0
    row_count = 0
    for byte in unzipped_data:
        int_value += byte << (byte_count * 8)
        byte_count += 1
        if not byte_count % 4:
            byte_count = 0
            int_count += 1
            tile_grid[row_count].append(int_value)
            int_value = 0
            if not int_count % layer_width:
                row_count += 1
                tile_grid.append([])

    tile_grid.pop()
    return tile_grid
コード例 #11
0
def import_file(name, path):
    '''
        Import source file with debugging

        <<< module = import_file(__file__, '/usr/local/lib/python3.7/dist-packages/denova/os/user.py')
        <<< print(str(module))
        <module 'python.py' from '/usr/local/lib/python3.7/dist-packages/denova/os/user.py'>
    '''

    import importlib

    try:
        log(f'import_file({path})')  #DEBUG
        # deprecated in python 3.3
        # the 'right' way to do this varies greatly with the specific python version
        # see http://stackoverflow.com/questions/19009932/import-arbitrary-python-source-file-python-3-3
        #     http://bugs.python.org/issue21436
        # the following is undocumented in python 3, and may not work in all versions
        module = importlib.find_loader(name, path)
        log(f'import_file() result: {module}')  #DEBUG
    except ImportError as imp_error:
        log(f'unable to import {path}')
        log('ImportError: ' + str(imp_error))
        msg = f'could not import {path}'
        log(msg)
        raise ImportError(msg)

    return module
コード例 #12
0
 def copy(self, modname, target):
     loader = importlib.find_loader(modname, self.path)
     pkg = loader.is_package(modname)
     file = loader.get_filename(modname)
     if isinstance(loader, importlib.abc.FileLoader):
         if pkg:
             pkgdir, basename = os.path.split(file)
             assert basename.startswith('__init__')
             dest = os.path.join(target, modname)
             shutil.copytree(pkgdir, dest, ignore=shutil.ignore_patterns('*.pyc'))
         else:                
             shutil.copy2(file, target)
     
     elif isinstance(loader, zipimport.zipimporter):
         prefix = loader.archive + '/' + loader.prefix
         assert file.startswith(prefix)
         path_in_zip = file[len(prefix):]
         zf = zipfile.ZipFile(loader.archive)
         if pkg:
             pkgdir, basename = path_in_zip.rsplit('/', 1)
             assert basename.startswith('__init__')
             pkgfiles = [f for f in zf.namelist() if f.startswith(pkgdir)]
             zf.extractall(target, pkgfiles)
         else:
             zf.extract(path_in_zip, target)
コード例 #13
0
def _check_is_dataframe(obj):
    import importlib
    pandas_loader = importlib.find_loader('pandas')
    found = pandas_loader is not None
    if not found: return False
    import pandas as pd
    return isinstance(obj, pd.DataFrame)
コード例 #14
0
def check_module_conditional_import(module_name):
    """ Test to see if we can import a module

        See: https://stackoverflow.com/questions/14050281/how-to-check-if-a-python-module-exists-without-importing-it

        Args:
            module_name (str): Module to be imported

        Returns:
            True if module is loadable
    """
    if PY2:
        import imp
        try:
            imp.find_module(module_name)
            return True
        except ImportError:
            return False
    else:
        import importlib
        import importlib.util
        if not PY3_4_Plus:
            avail = importlib.find_loader(module_name)
            return avail is not None
        else:
            avail = importlib.util.find_spec(module_name)
            return avail is not None
コード例 #15
0
def find_module_py33(string, path=None):
    loader = importlib.machinery.PathFinder.find_module(string, path)

    if loader is None and path is None:  # Fallback to find builtins
        try:
            loader = importlib.find_loader(string)
        except ValueError as e:
            # See #491. Importlib might raise a ValueError, to avoid this, we
            # just raise an ImportError to fix the issue.
            raise ImportError("Originally ValueError: " + e.message)

    if loader is None:
        raise ImportError("Couldn't find a loader for {0}".format(string))

    try:
        is_package = loader.is_package(string)
        if is_package:
            module_path = os.path.dirname(loader.path)
            module_file = None
        else:
            module_path = loader.get_filename(string)
            module_file = open(module_path, 'rb')
    except AttributeError:
        # ExtensionLoader has not attribute get_filename, instead it has a
        # path attribute that we can use to retrieve the module path
        try:
            module_path = loader.path
            module_file = open(loader.path, 'rb')
        except AttributeError:
            module_path = string
            module_file = None
        finally:
            is_package = False

    return module_file, module_path, is_package
コード例 #16
0
 def load_plugin_from_module(self, path):
     name = os.path.basename(path)
     module_loader = importlib.find_loader(name)
     module_spec = importlib.util.spec_from_loader(name, module_loader)
     module = importlib.util.module_from_spec(module_spec)
     module_spec.loader.exec_module(module)
     self.load_plugin_module(module)
コード例 #17
0
ファイル: pkgutil.py プロジェクト: luw630/ddzserver
def find_loader(fullname):
    """Find a PEP 302 "loader" object for fullname

    This is s convenience wrapper around :func:`importlib.find_loader` that
    sets the *path* argument correctly when searching for submodules, and
    also ensures parent packages (if any) are imported before searching for
    submodules.
    """
    if fullname.startswith('.'):
        msg = "Relative module name {!r} not supported".format(fullname)
        raise ImportError(msg)
    path = None
    pkg_name = fullname.rpartition(".")[0]
    if pkg_name:
        pkg = importlib.import_module(pkg_name)
        path = getattr(pkg, "__path__", None)
        if path is None:
            return None
    try:
        return importlib.find_loader(fullname, path)
    except (ImportError, AttributeError, TypeError, ValueError) as ex:
        # This hack fixes an impedance mismatch between pkgutil and
        # importlib, where the latter throws other errors for cases where
        # pkgutil previously threw ImportError
        msg = "Error while finding loader for {!r} ({}: {})"
        raise ImportError(msg.format(fullname, type(ex), ex)) from ex
コード例 #18
0
def find_module_py33(string, path=None):
    loader = importlib.machinery.PathFinder.find_module(string, path)

    if loader is None and path is None:  # Fallback to find builtins
        loader = importlib.find_loader(string)

    if loader is None:
        raise ImportError("Couldn't find a loader for {0}".format(string))

    try:
        is_package = loader.is_package(string)
        if is_package:
            module_path = os.path.dirname(loader.path)
            module_file = None
        else:
            module_path = loader.get_filename(string)
            mode = 'rb' if module_path.endswith(".pyc") else 'r'
            module_file = open(module_path, mode)
    except AttributeError:
        # ExtensionLoader has not attribute get_filename, instead it has a
        # path attribute that we can use to retrieve the module path
        try:
            module_path = loader.path
            module_file = open(loader.path, 'rb')
        except AttributeError:
            module_path = string
            module_file = None
        finally:
            is_package = False

    return module_file, module_path, is_package
コード例 #19
0
ファイル: cltk.py プロジェクト: thePortus/dhelp
    def setup(self):
        """Download CLTK packages and trainer corpora.

        Launches the CLTK package download interface. Overridden by the CLTK
        child classes to launch the automated CLTK downloader. Convenience
        method if user has not already downloaded CLTK packages and trainer
        sets.

        Example:
            >>> LatinText('').setup()
        """
        # check if cltk is already installed, if not, install it
        if not importlib.find_loader('cltk'):
            pip.main(['install', 'cltk'])
        # include cltk inline
        from cltk.corpus.utils.importer import CorpusImporter
        setup_language = self.options['language']
        # for ancient greek, change to 'greek' for purposes of cltk setup
        if setup_language == 'ancient greek':
            setup_language = 'greek'
        corpus_importer = CorpusImporter(setup_language)
        # loop through, check if extant, attempt to download, skip any errors
        for cltk_corpus in corpus_importer.list_corpora:
            print('Downloading', cltk_corpus)
            try:
                corpus_importer.import_corpus(cltk_corpus)
            except:
                print('Problem downloading', cltk_corpus, '(skipping)')
        return True
コード例 #20
0
ファイル: importhelper.py プロジェクト: slackmage/quodlibet
def load_module(name, package, path):
    """Load a module/package. Returns the module or None.
       Doesn't catch any exceptions during the actual import.
    """

    fullname = package + "." + name
    try:
        return sys.modules[fullname]
    except KeyError:
        pass

    loader = importlib.find_loader(fullname, [path])
    if loader is None:
        return

    # modules need a parent package
    if package not in sys.modules:
        spec = importlib.machinery.ModuleSpec(package, None, is_package=True)
        sys.modules[package] = importlib.util.module_from_spec(spec)

    mod = loader.load_module(fullname)

    # make it accessible from the parent, like __import__ does
    vars(sys.modules[package])[name] = mod

    return mod
コード例 #21
0
ファイル: _compatibility.py プロジェクト: Axure/jedi
def find_module_py33(string, path=None):
    loader = importlib.machinery.PathFinder.find_module(string, path)

    if loader is None and path is None:  # Fallback to find builtins
        loader = importlib.find_loader(string)

    if loader is None:
        raise ImportError("Couldn't find a loader for {0}".format(string))

    try:
        is_package = loader.is_package(string)
        if is_package:
            module_path = os.path.dirname(loader.path)
            module_file = None
        else:
            module_path = loader.get_filename(string)
            module_file = open(module_path, 'rb')
    except AttributeError:
        # ExtensionLoader has not attribute get_filename, instead it has a
        # path attribute that we can use to retrieve the module path
        try:
            module_path = loader.path
            module_file = open(loader.path, 'rb')
        except AttributeError:
            module_path = string
            module_file = None
        finally:
            is_package = False

    return module_file, module_path, is_package
コード例 #22
0
ファイル: entap_graphing.py プロジェクト: spficklin/EnTAP
def verify_package():
    is_2 = 2 <= gVersion < 3
    has_matplot = False
    if is_2:
        import imp
        try:
            imp.find_module("matplotlib")
            has_matplot = True
        except ImportError:
            has_matplot = False
    elif gVersion >= 3.4:
        import importlib.util
        check = importlib.util.find_spec("matplotlib")
        has_matplot = check is not None
    elif not is_2 and gVersion < 3.4:
        import importlib
        spam_loader = importlib.find_loader("matplotlib")
        has_matplot = spam_loader is not None
    else:
        print("Python version not compatable.")
        exit(ENTAP_EXIT_UNSUPPORTED_SOFTWARE)
    if has_matplot:
        global gPlot
        import matplotlib
        import matplotlib.pyplot as gPlot
        gPlot.switch_backend('agg')
    else:
        print("Matplotlib module not found. Not able to graph data.")
        exit(ENTAP_EXIT_UNSUPPORTED_SOFTWARE)
コード例 #23
0
ファイル: jet.py プロジェクト: criexe/jet
def install_jet():

    import importlib
    if importlib.find_loader('pycurl') == None:
        print(color_red("Not Found : ") + "pycurl")
        print(color_yellow("Installing : ") + "pycurl")
        os.system("pip3 install pycurl")
コード例 #24
0
        def copy(self, modname, target):
            """Copy the importable module 'modname' to the directory 'target'.

            modname should be a top-level import, i.e. without any dots.
            Packages are always copied whole.

            This can currently copy regular filesystem files and directories,
            and extract modules and packages from appropriately structured zip
            files.
            """
            loader = importlib.find_loader(modname, self.path)
            if loader is None:
                raise ImportError('Could not find %s' % modname)
            pkg = loader.is_package(modname)

            if isinstance(loader, importlib.machinery.ExtensionFileLoader):
                check_ext_mod(loader.path, self.py_version)
                shutil.copy2(loader.path, target)

            elif isinstance(loader, importlib.abc.FileLoader):
                file = loader.get_filename(modname)
                if pkg:
                    pkgdir, basename = os.path.split(file)
                    assert basename.startswith('__init__')
                    check_package_for_ext_mods(pkgdir, self.py_version)
                    dest = os.path.join(target, modname)
                    shutil.copytree(pkgdir,
                                    dest,
                                    ignore=shutil.ignore_patterns('*.pyc'))
                else:
                    shutil.copy2(file, target)

            elif isinstance(loader, zipimport.zipimporter):
                copy_zipmodule(loader, modname, target)
コード例 #25
0
ファイル: _compatibility.py プロジェクト: Airead/airemacs.d
def find_module_py33(string, path=None):
    mod_info = (None, None, None)
    loader = None
    if path is not None:
        # Check for the module in the specidied path
        loader = importlib.machinery.PathFinder.find_module(string, path)
    else:
        # Check for the module in sys.path
        loader = importlib.machinery.PathFinder.find_module(string, sys.path)
        if loader is None:
            # Fallback to find builtins
            loader = importlib.find_loader(string)

    if loader is None:
        raise ImportError

    try:
        if (loader.is_package(string)):
            mod_info = (None, os.path.dirname(loader.path), True)
        else:
            filename = loader.get_filename(string)
            if filename and os.path.exists(filename):
                mod_info = (open(filename, 'U'), filename, False)
            else:
                mod_info = (None, filename, False)
    except AttributeError:
        mod_info = (None, loader.load_module(string).__name__, False)

    return mod_info
コード例 #26
0
def find_module_py33(string,
                     path=None,
                     loader=None,
                     full_name=None,
                     is_global_search=True):
    loader = loader or importlib.machinery.PathFinder.find_module(string, path)

    if loader is None and path is None:  # Fallback to find builtins
        try:
            with warnings.catch_warnings(record=True):
                # Mute "DeprecationWarning: Use importlib.util.find_spec()
                # instead." While we should replace that in the future, it's
                # probably good to wait until we deprecate Python 3.3, since
                # it was added in Python 3.4 and find_loader hasn't been
                # removed in 3.6.
                loader = importlib.find_loader(string)
        except ValueError as e:
            # See #491. Importlib might raise a ValueError, to avoid this, we
            # just raise an ImportError to fix the issue.
            raise ImportError("Originally  " + repr(e))

    if loader is None:
        raise ImportError("Couldn't find a loader for {}".format(string))

    return _from_loader(loader, string)
コード例 #27
0
ファイル: pkgutil.py プロジェクト: GuardianRG/static-python
def find_loader(fullname):
    """Find a PEP 302 "loader" object for fullname

    This is s convenience wrapper around :func:`importlib.find_loader` that
    sets the *path* argument correctly when searching for submodules, and
    also ensures parent packages (if any) are imported before searching for
    submodules.
    """
    if fullname.startswith('.'):
        msg = "Relative module name {!r} not supported".format(fullname)
        raise ImportError(msg)
    path = None
    pkg_name = fullname.rpartition(".")[0]
    if pkg_name:
        pkg = importlib.import_module(pkg_name)
        path = getattr(pkg, "__path__", None)
        if path is None:
            return None
    try:
        return importlib.find_loader(fullname, path)
    except (ImportError, AttributeError, TypeError, ValueError) as ex:
        # This hack fixes an impedance mismatch between pkgutil and
        # importlib, where the latter raises other errors for cases where
        # pkgutil previously raised ImportError
        msg = "Error while finding loader for {!r} ({}: {})"
        raise ImportError(msg.format(fullname, type(ex), ex)) from ex
コード例 #28
0
ファイル: allPythonContent.py プロジェクト: Mondego/pyreco
        def copy(self, modname, target):
            """Copy the importable module 'modname' to the directory 'target'.

            modname should be a top-level import, i.e. without any dots.
            Packages are always copied whole.

            This can currently copy regular filesystem files and directories,
            and extract modules and packages from appropriately structured zip
            files.
            """
            loader = importlib.find_loader(modname, self.path)
            if loader is None:
                raise ImportError('Could not find %s' % modname)
            pkg = loader.is_package(modname)

            if isinstance(loader, importlib.machinery.ExtensionFileLoader):
                check_ext_mod(loader.path, self.py_version)
                shutil.copy2(loader.path, target)

            elif isinstance(loader, importlib.abc.FileLoader):
                file = loader.get_filename(modname)
                if pkg:
                    pkgdir, basename = os.path.split(file)
                    assert basename.startswith('__init__')
                    check_package_for_ext_mods(pkgdir, self.py_version)
                    dest = os.path.join(target, modname)
                    shutil.copytree(pkgdir, dest,
                                    ignore=shutil.ignore_patterns('*.pyc'))
                else:
                    shutil.copy2(file, target)

            elif isinstance(loader, zipimport.zipimporter):
                copy_zipmodule(loader, modname, target)
コード例 #29
0
ファイル: _utils.py プロジェクト: GarbageColl/swapy
def ssl(module, host='127.0.0.1', path=None):
    """
    Adds SSL support for development

    :param module: str
        Name of the module
    :param host: str
        Domain or IP of the server
        Default = '127.0.0.1'
    :param path: str
        Path to cert files (without .crt and .key ending)
        If empty you have to install python OpenSSL lib
        Default = None
    """
    state_ = state(module)
    if path:
        state_.ssl = make_ssl_devcert(path, host=host)
    else:
        import importlib
        # noinspection PyDeprecation
        open_ssl = importlib.find_loader('OpenSSL')
        if open_ssl:
            state_.ssl = 'adhoc'
        else:
            raise ModuleNotFoundError(
                'SSL generation requires the PyOpenSSl module. Please install it or pass the path\
             to your self generated certificate')
コード例 #30
0
ファイル: geo_trace_dialog.py プロジェクト: vrosnet/GeoTrace
    def setup_cost_calculator(self):
        cost_calc_widget = QWidget()
        self.cost_calc_layout = QFormLayout()
        self.raster_layer_combo_box = QgsMapLayerComboBox()
        self.raster_layer_combo_box.setCurrentIndex(-1)
        self.raster_layer_combo_box.setFilters(
            QgsMapLayerProxyModel.RasterLayer)
        self.raster_layer_combo_box.currentIndexChanged.connect(
            self.updateCostName)
        self.costs = []
        self.cost_calc_layout.addRow("Reference Raster: ",
                                     self.raster_layer_combo_box)

        #self.addCost('_lightness','Lightness')
        self.addCost('_darkness', 'Darkness')
        self.addCost('_sobel', 'Sobel')
        self.addCost('_sobv', 'Sobel Vertical Transform')
        self.addCost('_sobh', 'Sobel Horizontal Transform')
        self.addCost('_roberts', 'Roberts\' cross opperator')
        self.addCost('_prewitt', 'Prewitt Transform')
        self.addCost('_scharr', 'Scharr transform')
        self.addCost('_phase', 'Phase Congruency')
        if importlib.find_loader('phasepack') is None:
            self.costs[-1][1].setEnabled(False)
        self.cost_name = QLineEdit()
        self.cost_calc_layout.addRow("Cost Layer Name", self.cost_name)
        cost_calculator_run = QPushButton("Run")
        self.cost_calc_layout.addRow(cost_calculator_run)
        cost_calc_widget.setLayout(self.cost_calc_layout)
        cost_calculator_run.clicked.connect(self.run_costcalculator)

        return cost_calc_widget
コード例 #31
0
def module_exists(name):
    if sys.version_info[0] == 3:
        if sys.version_info[1] <= 4:
            return importlib.find_loader(name) is not None
        else:
            return importlib.util.find_spec(name) is not None
    return False
コード例 #32
0
ファイル: utils.py プロジェクト: andreymal/tabun_api
def is_module_available(name):
    """Проверяет доступность модуля для импорта, при этом не импортируя его.

    :param str name: имя модуля
    :rtype: bool
    """

    if PY2 and isinstance(name, text):
        name = name.encode('utf-8')
    elif not isinstance(name, text):
        name = name.decode('utf-8')

    if PY2:
        import imp
        path = None
        try:
            for x in name.split('.'):
                if path is not None:
                    path = [path]
                path = imp.find_module(x, path)[1]
            return True
        except ImportError:
            return False

    elif sys.version_info < (3, 4):
        import importlib
        return importlib.find_loader(name) is not None

    else:
        # >= 3.4
        import importlib.util
        return importlib.util.find_spec(name) is not None
コード例 #33
0
def find_module_py33(string, path=None):
    mod_info = (None, None, None)
    loader = None
    if path is not None:
        # Check for the module in the specidied path
        loader = importlib.machinery.PathFinder.find_module(string, path)
    else:
        # Check for the module in sys.path
        loader = importlib.machinery.PathFinder.find_module(string, sys.path)
        if loader is None:
            # Fallback to find builtins
            loader = importlib.find_loader(string)

    if loader is None:
        raise ImportError

    try:
        if (loader.is_package(string)):
            mod_info = (None, os.path.dirname(loader.path), True)
        else:
            filename = loader.get_filename(string)
            if filename and os.path.exists(filename):
                mod_info = (open(filename, 'U'), filename, False)
            else:
                mod_info = (None, filename, False)
    except AttributeError:
        mod_info = (None, loader.load_module(string).__name__, False)

    return mod_info
コード例 #34
0
ファイル: __init__.py プロジェクト: codebasic/bigpython
def setup_webdriver(test=False):
    # selenium package 설치
    if not importlib.find_loader('selenium'):
        pip.main(['install', 'selenium'])

    print('chromedriver 다운로드')
    downloaded_file = download_chromedriver()
    print(downloaded_file)

    # 압축 해제
    print('다운로드 받은 파일 압축 해제 ...')
    driverzip = zipfile.ZipFile(downloaded_file)
    driverzip.extractall()
    driverfile = driverzip.namelist()[0]
    driverzip.close()

    # 실행권한 설정
    st = os.stat(driverfile)
    os.chmod(driverfile, st.st_mode | stat.S_IEXEC)

    if test:
        print('설정 테스트 ...', end=' ')
        test_webdriver(driverfile)
        print('완료')

    return driverfile
コード例 #35
0
def detect(name):
    assert name in names
    d = {'name': name}

    if name in builtins:
        d['type'] = 'builtin'
        return d

    if name in python_modules:
        loader = importlib.find_loader(python_modules[name])
        if loader is not None:
            d['type'] = 'python'
            d['module'] = python_modules[name]
            d['path'] = loader.get_filename()
            return d

    envvar = get_executable_env_var(name)
    if envvar in os.environ:
        d['command'] = os.environ[envvar]
        d['envvar'] = envvar
        d['type'] = 'environment'
        return d

    if name in default_executables:
        commands = default_executables[name]
        for command in commands:
            fullpath = shutil.which(command)
            if fullpath:
                d['command'] = command
                d['fullpath'] = fullpath
                d['type'] = 'which'
                return d
コード例 #36
0
    def plugin_item_changed(self, index):
        """
        This function is called when the user selects another plugin in the plugin tree on the left side.
        Every change of plugin updates the displayed plugin information on the right side.

        :param index:
        :return:
        """
        plugin_info = self.pluginTree.model().data(index, Qt.UserRole)

        self.clear()

        self.scrollArea.setDisabled(True)

        if plugin_info is None:
            return

        self.scrollArea.setDisabled(False)

        self.nameEdit.setText(plugin_info.name)
        self.authorEdit.setText(plugin_info.author)
        self.descriptionText.setText(plugin_info.description)
        self.pathEdit.setText(plugin_info.path)

        self.createButton.setEnabled(plugin_info.loadable)

        lines = None
        with open(plugin_info.path + '.py') as f:
            lines = f.readlines()

        found_imports = []

        for line in lines:
            if line.startswith('import'):

                m = re.search('(import)\s+([\w.]*)(\s+as){0,1}', str.strip(line))
                if m is not None:
                    if len(m.groups()) > 2:
                        found_imports.append(m.group(2))

            if line.startswith('from'):
                m = re.search('(from)\s+([\w.]*)(\s+import)', str.strip(line))
                if m is not None:
                    if len(m.groups()) > 2:
                        found_imports.append(m.group(2))
        found_imports.sort()

        for imp in found_imports:
            item = QListWidgetItem(imp)

            spam_loader = importlib.find_loader(imp)
            found = spam_loader is not None
            if not found:
                self.modulesList.addItem(item)
                item.setBackground(QColor(255, 0, 0, 50))

        if not plugin_info.loadable:
            self.modulesList.setEnabled(True)
            self.modulesLabel.setEnabled(True)
コード例 #37
0
ファイル: __main__.py プロジェクト: naggie/home-assistant
def ensure_pip():
    """ Validate pip is installed so we can install packages on demand. """
    if importlib.find_loader('pip') is None:
        print("Your Python installation did not bundle 'pip'")
        print("Home Assistant requires 'pip' to be installed.")
        print("Please install pip: "
              "https://pip.pypa.io/en/latest/installing.html")
        sys.exit()
 def check_modules(self, module_name, module_fqn, module_path):
     with warnings.catch_warnings(record=True) as w:
         warnings.simplefilter('always')
         # imp.load_module will load even if it has already been loaded.
         # We need to ensure that happens in order to trigger the
         # deprecation warnings
         importlib.find_loader(module_fqn, module_path).load_module()
         warning_raised = False
         for warning in (e.message for e in w):
             if isinstance(warning, PendingDeprecationWarning) and \
                     ('%s is deprecated' % module_name) in warning.args[0]:
                 warning_raised = True
                 break
         tools.assert_true(
             warning_raised,
             msg='%s did not raise a PendingDeprecationWarning' %
             module_fqn)
コード例 #39
0
ファイル: monitor.py プロジェクト: Bakkes/csgod
 def load_handlers(self):
     modules = [
         entry.split('.')[0]
         for entry in os.listdir("handlers")
         if os.path.isfile(os.path.join("handlers", entry))
     ]
     loaders = {module: importlib.find_loader(module, ["handlers"]) for module in modules}
     self.handlers = [loader.load_module(name) for name, loader in loaders.items() if loader]
コード例 #40
0
ファイル: vespiddeps.py プロジェクト: zorbathut/vespid
def install_package(package):
  if not importlib.find_loader(package):
    import pip
    pip.main(["install", package])
    
    # reload site paths so we can later import the package
    import site
    importlib.reload(site)
コード例 #41
0
ファイル: test_api.py プロジェクト: luw630/ddzserver
 def test_success_path(self):
     # Searching on a path should work.
     name = 'some_mod'
     path = 'path to some place'
     with util.uncache(name):
         with util.import_state(meta_path=[self.FakeMetaFinder]):
             self.assertEqual((name, path),
                              importlib.find_loader(name, path))
コード例 #42
0
ファイル: oanda.py プロジェクト: einaru/curry
 def __init__(self, **kwargs):
     APIProvider.__init__(self, **kwargs)
     self.cache_file = get_cache_file(self.id_)
     # Use lxml as the BeautifulSoup parser if it's installed.
     if importlib.find_loader('lxml'):
         self._parser = 'lxml'
     else:
         self._parser = 'html.parser'
コード例 #43
0
ファイル: worker_impl.py プロジェクト: yuyichao/artiq
def import_in_folder(path, name):
    try:
        del sys.modules[name]  # force path search
    except KeyError:
        pass
    loader = importlib.find_loader(name, [path])
    if loader is None:
        raise ImportError("Could not find loader")
    return loader.load_module()
コード例 #44
0
ファイル: auxiliary.py プロジェクト: miktoki/swarmtoolkit
def _importable(module_str):
    """check whether module can be imported"""
    try:
        l = importlib.find_loader(module_str)
        found = l is not None

    except Exception:
        logger.error("Could not import module: '{}'".format(module_str))
        raise ImportError
    return found
コード例 #45
0
ファイル: test_api.py プロジェクト: joar/cpython
 def test_sys_modules(self):
     # If a module with __loader__ is in sys.modules, then return it.
     name = 'some_mod'
     with util.uncache(name):
         module = imp.new_module(name)
         loader = 'a loader!'
         module.__loader__ = loader
         sys.modules[name] = module
         found = importlib.find_loader(name)
         self.assertEqual(loader, found)
コード例 #46
0
ファイル: importer.py プロジェクト: GrahamDumpleton/wrapt
    def find_module(self, fullname, path=None):
        # If the module being imported is not one we have registered
        # post import hooks for, we can return immediately. We will
        # take no further part in the importing of this module.

        if not fullname in _post_import_hooks:
            return None

        # When we are interested in a specific module, we will call back
        # into the import system a second time to defer to the import
        # finder that is supposed to handle the importing of the module.
        # We set an in progress flag for the target module so that on
        # the second time through we don't trigger another call back
        # into the import system and cause a infinite loop.

        if fullname in self.in_progress:
            return None

        self.in_progress[fullname] = True

        # Now call back into the import system again.

        try:
            if PY3:
                # For Python 3 we need to use find_spec().loader
                # from the importlib.util module. It doesn't actually
                # import the target module and only finds the
                # loader. If a loader is found, we need to return
                # our own loader which will then in turn call the
                # real loader to import the module and invoke the
                # post import hooks.
                try:
                    import importlib.util
                    loader = importlib.util.find_spec(fullname).loader
                except (ImportError, AttributeError):
                    loader = importlib.find_loader(fullname, path)
                if loader:
                    return _ImportHookChainedLoader(loader)

            else:
                # For Python 2 we don't have much choice but to
                # call back in to __import__(). This will
                # actually cause the module to be imported. If no
                # module could be found then ImportError will be
                # raised. Otherwise we return a loader which
                # returns the already loaded module and invokes
                # the post import hooks.

                __import__(fullname)

                return _ImportHookLoader()

        finally:
            del self.in_progress[fullname]
コード例 #47
0
ファイル: plan.py プロジェクト: van-Kalsing/UGV-Control
	def check_module_presence(module_name):
		is_module_present = True
		
		try:
			if importlib.find_loader(module_name) is None:
				is_module_present = False
		except ValueError:
			is_module_present = False
			
			
		return is_module_present
コード例 #48
0
ファイル: model.py プロジェクト: nesanders/pystan
def load_module(module_name, module_path):
    """Load the module named `module_name` from  `module_path`
    independently of the Python version."""
    if hasattr(importlib, 'find_loader'):
        # Python 3
        loader = importlib.find_loader(module_name, [module_path])
        return loader.load_module()
    else:
        # Python 2.7
        module_info = imp.find_module(module_name, [module_path])
        return imp.load_module(module_name, *module_info)
コード例 #49
0
ファイル: mf3.py プロジェクト: Anhsirk-455/ctypes-stuff
    def _find_and_load(self, name):
        """Find and load the module.

        Inserts the module into self.modules and returns it.
        If the module is not found or could not be imported,
        it is inserted in self.badmodules.
        """
        path = self.path
        parent = name.rpartition('.')[0]
        if parent:
            if parent not in self.modules:
                self._gcd_import(parent)
            # Crazy side-effects!
            if name in self.modules:
                return self.modules[name]
            # Backwards-compatibility; be nicer to skip the dict lookup.
            parent_module = self.modules[parent]
            try:
                path = parent_module.__path__
            except AttributeError:
                # this fixes 'import os.path'. Does it create other problems?
                child = name.rpartition('.')[2]
                if child in parent_module.__globalnames__:
                    return parent_module
                msg = ('No module named {!r}; {} is not a package').format(name, parent)
                self._add_badmodule(name)
                raise ImportError(msg, name=name)
        loader = importlib.find_loader(name, path)
        if loader is None:
            self._add_badmodule(name)
            raise ImportError(name)
        elif name not in self.modules:
            # The parent import may have already imported this module.
            try:
                self._load_module(loader, name)
            except ImportError:
                self._add_badmodule(name)
                raise

        # Backwards-compatibility; be nicer to skip the dict lookup.
        module = self.modules[name]

        if parent:
            # Set the module as an attribute on its parent.
            parent_module = self.modules[parent]
            setattr(parent_module, name.rpartition('.')[2], module)

        # It is important that all the required __...__ attributes at
        # the module are set before the code is scanned.
        if module.__code__:
            self._scan_code(module.__code__, module)

        return module
コード例 #50
0
ファイル: make.py プロジェクト: shuckc/misoc
def _misoc_import(default, external, name):
	if external:
		try:
			del sys.modules[name] # force external path search
		except KeyError:
			pass
		loader = importlib.find_loader(name, [external])
		if loader is None:
			raise ImportError("Module not found: "+name)
		return loader.load_module()
	else:
		return importlib.import_module(default + "." + name)
コード例 #51
0
 def is_installed(self, module):
     if hasattr(importlib, 'find_loader'):
         found = importlib.find_loader(module)
     else:
         try:
             found = imp.find_module(module)
         except ImportError:
             found = False
     # Coerce result to boolean
     if found:
         return True
     else:
         return False
コード例 #52
0
ファイル: util.py プロジェクト: ghisvail/imageio
def has_module(module_name):
    """Check to see if a python module is available.
    """
    if sys.version_info > (3, ):
        import importlib
        return importlib.find_loader(module_name) is not None
    else:  # pragma: no cover
        import imp
        try:
            imp.find_module(module_name)
        except ImportError:
            return False
        return True
コード例 #53
0
ファイル: _compatibility.py プロジェクト: andrewgu12/config
def find_module_py33(string, path=None, loader=None, full_name=None):
    loader = loader or importlib.machinery.PathFinder.find_module(string, path)

    if loader is None and path is None:  # Fallback to find builtins
        try:
            with warnings.catch_warnings(record=True):
                # Mute "DeprecationWarning: Use importlib.util.find_spec()
                # instead." While we should replace that in the future, it's
                # probably good to wait until we deprecate Python 3.3, since
                # it was added in Python 3.4 and find_loader hasn't been
                # removed in 3.6.
                loader = importlib.find_loader(string)
        except ValueError as e:
            # See #491. Importlib might raise a ValueError, to avoid this, we
            # just raise an ImportError to fix the issue.
            raise ImportError("Originally  " + repr(e))

    if loader is None:
        raise ImportError("Couldn't find a loader for {}".format(string))

    try:
        is_package = loader.is_package(string)
        if is_package:
            if hasattr(loader, 'path'):
                module_path = os.path.dirname(loader.path)
            else:
                # At least zipimporter does not have path attribute
                module_path = os.path.dirname(loader.get_filename(string))
            if hasattr(loader, 'archive'):
                module_file = DummyFile(loader, string)
            else:
                module_file = None
        else:
            module_path = loader.get_filename(string)
            module_file = DummyFile(loader, string)
    except AttributeError:
        # ExtensionLoader has not attribute get_filename, instead it has a
        # path attribute that we can use to retrieve the module path
        try:
            module_path = loader.path
            module_file = DummyFile(loader, string)
        except AttributeError:
            module_path = string
            module_file = None
        finally:
            is_package = False

    if hasattr(loader, 'archive'):
        module_path = loader.archive

    return module_file, module_path, is_package
コード例 #54
0
ファイル: copy_modules.py プロジェクト: Jon0/openage
def copy_module(name, destination):
    """Copy the importable module 'name' to the 'destination' directory"""
    loader = importlib.find_loader(name)
    if not isinstance(loader, importlib.abc.FileLoader):
        print('Loader for module %s is not handled', name)
        sys.exit(1)

    print('Copying "%s" to "%s"' % (name, destination))
    filename = loader.get_filename(name)
    if loader.is_package(name):
        pkgdir, _ = os.path.split(filename)
        shutil.copytree(pkgdir, os.path.join(destination, name))
    else:
        shutil.copy2(filename, destination)
コード例 #55
0
ファイル: package.py プロジェクト: KGerring/RevealMe
def stats(path):
	stats = dict()
	from importlib import find_loader
	if os.path.isfile(path):
		stat_result = os.stat(path)
		stats['birth'] = dt.fromtimestamp(stat_result.st_birthtime).timetuple()
		stats['mtime'] = dt.fromtimestamp(stat_result.st_mtime).timetuple()
		stats['ctime'] = dt.fromtimestamp(stat_result.st_ctime).timetuple()
		stats['atime'] = dt.fromtimestamp(stat_result.st_atime).timetuple()
	else:
		stat_result = os.stat(find_loader(name).path)
		stats['birth'] = dt.fromtimestamp(stat_result.st_birthtime).timetuple()
		stats['mtime'] = dt.fromtimestamp(stat_result.st_mtime).timetuple()
		stats['ctime'] = dt.fromtimestamp(stat_result.st_ctime).timetuple()
		stats['atime'] = dt.fromtimestamp(stat_result.st_atime).timetuple()
	return stats
コード例 #56
0
ファイル: pkgutil.py プロジェクト: johndpope/sims4-ai-engine
def find_loader(fullname):
    if fullname.startswith('.'):
        msg = 'Relative module name {!r} not supported'.format(fullname)
        raise ImportError(msg)
    path = None
    pkg_name = fullname.rpartition('.')[0]
    if pkg_name:
        pkg = importlib.import_module(pkg_name)
        path = getattr(pkg, '__path__', None)
        if path is None:
            return
    try:
        return importlib.find_loader(fullname, path)
    except (ImportError, AttributeError, TypeError, ValueError) as ex:
        msg = 'Error while finding loader for {!r} ({}: {})'
        raise ImportError(msg.format(fullname, type(ex), ex)) from ex
コード例 #57
0
ファイル: Searchlime.py プロジェクト: aflc/Searchlime
def plugin_loaded():
    global wsh
    import importlib
    whoosh_libdir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'whoosh_2_5_4')
    wsh_loader = importlib.find_loader('whoosh', [whoosh_libdir])
    wsh = wsh_loader.load_module('whoosh')
    import whoosh.index
    import whoosh.fields
    import whoosh.qparser
    import whoosh.query
    global SCHEMA
    SCHEMA = wsh.fields.Schema(path=wsh.fields.ID(stored=True), mtime=wsh.fields.STORED, fsize=wsh.fields.STORED,
                               data=wsh.fields.NGRAM(stored=False, phrase=True, minsize=2, maxsize=2))
    Const.cache_ix = open_ix(load_index_dir(), '__Searchlime_cache__', create=True,
                             schema=wsh.fields.Schema(name=wsh.fields.ID(stored=True), tree=wsh.fields.STORED)
                             )