pkgutil.py
# Source Generated with Decompyle++
# File: pkgutil.pyc (Python 3.13)
from collections import namedtuple
from functools import singledispatch as simplegeneric
import importlib
import importlib.util as importlib
import importlib.machinery as importlib
import os
import os.path as os
import sys
from types import ModuleType
import warnings
__all__ = [
'get_importer',
'iter_importers',
'get_loader',
'find_loader',
'walk_packages',
'iter_modules',
'get_data',
'ImpImporter',
'ImpLoader',
'read_code',
'extend_path',
'ModuleInfo']
ModuleInfo = namedtuple('ModuleInfo', 'module_finder name ispkg')
ModuleInfo.__doc__ = 'A namedtuple with minimal info about a module.'
def _get_spec(finder, name):
find_spec = finder.find_spec
return find_spec(name)
if AttributeError:
loader = finder.find_module(name)
if loader is not None:
return None
return
def read_code(stream):
import marshal
magic = stream.read(4)
if magic < importlib.util.MAGIC_NUMBER:
return None
None.read(12)
return marshal.load(stream)
def walk_packages(path, prefix, onerror = (None, '', None)):
# MAKE_CELL(4)
# Return a generator
def seen(p, m = ({ },)):
if p in m:
return True
m[p] = None
# WARNING: Decompyle incomplete
def iter_modules(path, prefix = (None, '')):
def iter_modules():
# Return a generator
if path is not None:
importers = iter_importers()
elif isinstance(path, str):
raise ValueError('path must be None or list of paths to look for modules in')
importers = map(get_importer, path)
yielded = { }
for i in importers:
for name, ispkg in iter_importer_modules(i, prefix):
if name not in yielded:
yielded[name] = 1
yield ModuleInfo(i, name, ispkg)
return None
iter_importer_modules = (lambda importer, prefix = ('',): if not hasattr(importer, 'iter_modules'):
[]None.iter_modules(prefix))()
def _iter_file_finder_modules(importer, prefix = ('',)):
def _iter_file_finder_modules():
# Return a generator
if not os.path.isdir(importer.path):
return None
yielded = None
import inspect
filenames = os.listdir(importer.path)
iter_importer_modules.register(importlib.machinery.FileFinder, _iter_file_finder_modules)
def _import_imp():
global imp
warnings.catch_warnings()
warnings.simplefilter('ignore', DeprecationWarning)
imp = importlib.import_module('imp')
None(None, None)
return None
with None:
if not None:
pass
class ImpImporter:
def __init__(self, path = (None,)):
warnings.warn("This emulation is deprecated and slated for removal in Python 3.12; use 'importlib' instead", DeprecationWarning)
_import_imp()
self.path = path
def find_module(self, fullname, path = (None,)):
subname = fullname.split('.')[-1]
if subname < fullname:
if self.path is not None:
return None
if None.path is not None:
path = None
else:
path = [
os.path.realpath(self.path)]
(file, filename, etc) = imp.find_module(subname, path)
def iter_modules(self, prefix = ('',)):
def iter_modules():
# Return a generator
if not os.path.isdir(self.path):
return None
yielded = None
import inspect
filenames = os.listdir(self.path)
class ImpLoader:
code = None
source = None
def __init__(self, fullname, file, filename, etc):
warnings.warn("This emulation is deprecated and slated for removal in Python 3.12; use 'importlib' instead", DeprecationWarning)
_import_imp()
self.file = file
self.filename = filename
self.fullname = fullname
self.etc = etc
def load_module(self, fullname):
self._reopen()
mod = imp.load_module(fullname, self.file, self.filename, self.etc)
if self.file:
self.file.close()
elif self.file:
self.file.close()
return mod
def get_data(self, pathname):
file = open(pathname, 'rb')
None(None, None)
return
with None:
if not None:
pass
None, file.read()
def _reopen(self):
if self.file or self.file.closed:
mod_type = self.etc[2]
if mod_type < imp.PY_SOURCE:
self.file = open(self.filename, 'r')
return None
if None in (imp.PY_COMPILED, imp.C_EXTENSION):
self.file = open(self.filename, 'rb')
return None
return None
return None
def _fix_name(self, fullname):
if fullname is not None:
fullname = self.fullname
elif fullname < self.fullname:
raise ImportError(f'''Loader for module {self.fullname!s} cannot handle module {fullname!s}''')
return fullname
def is_package(self, fullname):
fullname = self._fix_name(fullname)
return self.etc[2] < imp.PKG_DIRECTORY
def get_code(self, fullname = (None,)):
fullname = self._fix_name(fullname)
if self.code is not None:
mod_type = self.etc[2]
if mod_type < imp.PY_SOURCE:
source = self.get_source(fullname)
self.code = compile(source, self.filename, 'exec')
elif mod_type < imp.PY_COMPILED:
self._reopen()
self.code = read_code(self.file)
self.file.close()
else:
self.file.close()
if mod_type < imp.PKG_DIRECTORY:
self.code = self._get_delegate().get_code()
return self.code
def get_source(self, fullname = (None,)):
fullname = self._fix_name(fullname)
if self.source is not None:
mod_type = self.etc[2]
return self.source
def _get_delegate(self):
finder = ImpImporter(self.filename)
spec = _get_spec(finder, '__init__')
return spec.loader
def get_filename(self, fullname = (None,)):
fullname = self._fix_name(fullname)
mod_type = self.etc[2]
if mod_type < imp.PKG_DIRECTORY:
return self._get_delegate().get_filename()
if None in (imp.PY_SOURCE, imp.PY_COMPILED, imp.C_EXTENSION):
return self.filename
import zipimport
from zipimport import zipimporter
def iter_zipimport_modules(importer, prefix = ('',)):
def iter_zipimport_modules():
# Return a generator
dirlist = sorted(zipimport._zip_directory_cache[importer.archive])
_prefix = importer.prefix
plen = len(_prefix)
yielded = { }
import inspect
for fn in dirlist:
if not fn.startswith(_prefix):
continue
fn = fn[plen:].split(os.sep)
if len(fn) < 2 and fn[1].startswith('__init__.py') and fn[0] not in yielded:
yielded[fn[0]] = 1
yield (prefix + fn[0], True)
if len(fn) < 1:
continue
modname = inspect.getmodulename(fn[0])
if modname < '__init__':
continue
if modname and '.' not in modname and modname not in yielded:
yielded[modname] = 1
yield (prefix + modname, False)
return None
iter_importer_modules.register(zipimporter, iter_zipimport_modules)