-

cool-RR · cool-RR · commit 3adccbd43299 · 2019-07-19T15:57:05.000+03:00
diff --git a/python_toolbox/import_tools.py b/python_toolbox/import_tools.py
@@ -124,158 +124,7 @@ def exists(module_name, path=None):
     '''
     if '.' in module_name:
         raise NotImplementedError
-    module_file = None
-    try:
-        module_file, _, _ = find_module(module_name, path=path,
-                                        legacy_output=True)
-    except ImportError:
-        return False
-    else:
-        return True
-    finally:
-        if hasattr(module_file, 'close'):
-            module_file.close()
-
-
-def _import_by_path_from_zip(path):
-    '''Import a module from a path inside a zip file.'''
-    assert '.zip' in path
-
-    parent_path, child_name = path.rsplit(os.path.sep, 1)
-    zip_importer = zipimport.zipimporter(parent_path)
-    module = zip_importer.load_module(child_name)
-
-    return module
-
-
-def import_by_path(path, name=None, keep_in_sys_modules=True):
-    '''
-    Import module/package by path.
-
-    You may specify a name: This is helpful only if it's an hierarchical name,
-    i.e. a name with dots like "orange.claw.hammer". This will become the
-    imported module's __name__ attribute. Otherwise only the short name,
-    "hammer", will be used, which might cause problems in some cases. (Like
-    when using multiprocessing.)
-    '''
-    path = pathlib.Path(path)
-    if '.zip' in path:
-        if name is not None:
-            raise NotImplementedError
-        module = _import_by_path_from_zip(path)
-
-    else: # '.zip' not in path
-        short_name = path.stem
-
-        if name is None: name = short_name
-        my_file = None
-        try:
-            (my_file, pathname, description) = \
-                imp.find_module(short_name, [path.parent])
-            module = imp.load_module(name, my_file, pathname, description)
-        finally:
-            if my_file is not None:
-                my_file.close()
-
-    if not keep_in_sys_modules:
-        del sys.modules[module.__name__]
-
-    return module
-
-
-def find_module(module_name, path=None, look_in_zip=True, legacy_output=False):
-    '''
-    Search for a module by name and return its filename.
-
-    When `path=None`, search for a built-in, frozen or special module and
-    continue search in `sys.path`.
-
-    When `legacy_output=True`, instead of returning the module's filename,
-    returns a tuple `(file, filename, (suffix, mode, type))`.
-
-    When `look_in_zip=True`, also looks in zipmodules.
-
-    todo: Gives funky output when `legacy_output=True and look_in_zip=True`.
-    '''
-    # todo: test
-    if look_in_zip:
-        try:
-            result = _find_module_in_some_zip_path(module_name, path)
-        except ImportError:
-            pass
-        else:
-            return (None, result, None) if legacy_output else result
-
-
-    if '.' in module_name:
-        parent_name, child_name = module_name.rsplit('.', 1)
-        parent_path = find_module(parent_name, path)
-        result = imp.find_module(child_name, [parent_path])
-    else:
-        result = imp.find_module(module_name, path)
-
-    if legacy_output:
-        return result
-    else: # legacy_output is False
-        file_, path_, description_ = result
-        if file_ is not None:
-            file_.close()
-        return path_
-
-
-def _find_module_in_some_zip_path(module_name, path=None):
-    '''
-    If a module called `module_name` exists in a zip archive, get its path.
-
-    If the module is not found, raises `ImportError`.
-    '''
-    original_path_argument = path
-
-    if path is not None:
-        zip_paths = path
-    else:
-        zip_paths = [path for path in sys.path if '.zip' in path]
-        # todo: Find better way to filter zip paths.
-
-    for zip_path in zip_paths:
-
-        # Trying to create a zip importer:
-        try:
-            zip_importer = zipimport.zipimporter(zip_path)
-        except zipimport.ZipImportError:
-            continue
-            # Excepted `ZipImportError` because we may have zip paths in
-            # `sys.path` that don't really exist, which causes `zipimport` to
-            # raise `ZipImportError`.
-            #
-            # todo: should find smarter way of catching this, excepting
-            # `ZipImportError` is not a good idea.
-
-        result = zip_importer.find_module(
-            # Python's zip importer stupidly needs us to replace dots with path
-            # separators:
-            _module_address_to_partial_path(module_name)
-        )
-        if result is None:
-            continue
-        else:
-            assert result is zip_importer
-
-            #if '.' in module_name:
-                #parent_package_name, child_module_name = \
-                    #module_name.rsplit('.')
-                #leading_path = \
-                    #_module_address_to_partial_path(parent_package_name)
-            #else:
-                #leading_path = ''
-
-            return pathlib.Path(str(zip_path)) / \
-                                   _module_address_to_partial_path(module_name)
-
-    if original_path_argument is not None:
-        raise ImportError('Module not found in the given zip path.')
-    else:
-        raise ImportError('Module not found in any of the zip paths.')
+    return bool(importlib.util.find_spec(module_name))
 
 
 def _module_address_to_partial_path(module_address):
