FM / python3.9

/usr/lib64/python3.9

Name	Size	Mode	Actions
asyncio/	-	0755	rm
collections/	-	0755	rm
concurrent/	-	0755	rm
config-3.9-x86_64-linux-gnu/	-	0755	rm
ctypes/	-	0755	rm
curses/	-	0755	rm
dbm/	-	0755	rm
distutils/	-	0755	rm
email/	-	0755	rm
encodings/	-	0755	rm
ensurepip/	-	0755	rm
html/	-	0755	rm
http/	-	0755	rm
importlib/	-	0755	rm
json/	-	0755	rm
lib-dynload/	-	0755	rm
lib2to3/	-	0755	rm
logging/	-	0755	rm
multiprocessing/	-	0755	rm
pydoc_data/	-	0755	rm
site-packages/	-	0755	rm
sqlite3/	-	0755	rm
unittest/	-	0755	rm
urllib/	-	0755	rm
venv/	-	0755	rm
wsgiref/	-	0755	rm
xml/	-	0755	rm
xmlrpc/	-	0755	rm
zoneinfo/	-	0755	rm
__pycache__/	-	0755	rm
abc.py	4920	0644	edit dl rm
aifc.py	32605	0644	edit dl rm
antigravity.py	500	0644	edit dl rm
argparse.py	98119	0644	edit dl rm
ast.py	56256	0644	edit dl rm
asynchat.py	11321	0644	edit dl rm
asyncore.py	20102	0644	edit dl rm
base64.py	19859	0755	edit dl rm
bdb.py	31389	0644	edit dl rm
binhex.py	14784	0644	edit dl rm
bisect.py	2350	0644	edit dl rm
bz2.py	12447	0644	edit dl rm
calendar.py	24832	0644	edit dl rm
cgi.py	33932	0755	edit dl rm
cgitb.py	12096	0644	edit dl rm
chunk.py	5435	0644	edit dl rm
cmd.py	14860	0644	edit dl rm
code.py	10622	0644	edit dl rm
codecs.py	36673	0644	edit dl rm
codeop.py	6326	0644	edit dl rm
colorsys.py	4064	0644	edit dl rm
compileall.py	20105	0644	edit dl rm
configparser.py	54584	0644	edit dl rm
contextlib.py	24624	0644	edit dl rm
contextvars.py	129	0644	edit dl rm
copy.py	8650	0644	edit dl rm
copyreg.py	7274	0644	edit dl rm
cProfile.py	6345	0755	edit dl rm
crypt.py	3819	0644	edit dl rm
csv.py	16144	0644	edit dl rm
dataclasses.py	49586	0644	edit dl rm
datetime.py	89177	0644	edit dl rm
decimal.py	320	0644	edit dl rm
difflib.py	83307	0644	edit dl rm
dis.py	20570	0644	edit dl rm
doctest.py	104568	0644	edit dl rm
enum.py	39440	0644	edit dl rm
filecmp.py	10024	0644	edit dl rm
fileinput.py	14791	0644	edit dl rm
fnmatch.py	6004	0644	edit dl rm
formatter.py	15143	0644	edit dl rm
fractions.py	24323	0644	edit dl rm
ftplib.py	35496	0644	edit dl rm
functools.py	38881	0644	edit dl rm
genericpath.py	5246	0644	edit dl rm
getopt.py	7489	0644	edit dl rm
getpass.py	5990	0644	edit dl rm
gettext.py	27266	0644	edit dl rm
glob.py	5823	0644	edit dl rm
graphlib.py	9573	0644	edit dl rm
gzip.py	21772	0644	edit dl rm
hashlib.py	8069	0644	edit dl rm
heapq.py	22877	0644	edit dl rm
hmac.py	8043	0644	edit dl rm
imaplib.py	55256	0644	edit dl rm
imghdr.py	3808	0644	edit dl rm
imp.py	10536	0644	edit dl rm
inspect.py	118235	0644	edit dl rm
io.py	3541	0644	edit dl rm
ipaddress.py	80924	0644	edit dl rm
keyword.py	1047	0644	edit dl rm
LICENSE.txt	13937	0644	edit dl rm
linecache.py	5461	0644	edit dl rm
locale.py	78271	0644	edit dl rm
lzma.py	13231	0644	edit dl rm
mailbox.py	78794	0644	edit dl rm
mailcap.py	9116	0644	edit dl rm
mimetypes.py	21564	0644	edit dl rm
modulefinder.py	24401	0644	edit dl rm
netrc.py	5566	0644	edit dl rm
nntplib.py	41023	0644	edit dl rm
ntpath.py	26460	0644	edit dl rm
nturl2path.py	2887	0644	edit dl rm
numbers.py	10338	0644	edit dl rm
opcode.py	5660	0644	edit dl rm
operator.py	10751	0644	edit dl rm
optparse.py	60369	0644	edit dl rm
os.py	39065	0644	edit dl rm
pathlib.py	51134	0644	edit dl rm
pdb.py	63237	0755	edit dl rm
pickle.py	64920	0644	edit dl rm
pickletools.py	93486	0644	edit dl rm
pipes.py	8916	0644	edit dl rm
pkgutil.py	24276	0644	edit dl rm
platform.py	40601	0755	edit dl rm
plistlib.py	28248	0644	edit dl rm
poplib.py	15198	0644	edit dl rm
posixpath.py	16146	0644	edit dl rm
pprint.py	22527	0644	edit dl rm
profile.py	22881	0755	edit dl rm
pstats.py	29326	0644	edit dl rm
pty.py	4807	0644	edit dl rm
pyclbr.py	15255	0644	edit dl rm
pydoc.py	109599	0755	edit dl rm
py_compile.py	8203	0644	edit dl rm
queue.py	11496	0644	edit dl rm
quopri.py	7266	0755	edit dl rm
random.py	31484	0644	edit dl rm
re.py	15861	0644	edit dl rm
reprlib.py	5267	0644	edit dl rm
rlcompleter.py	7648	0644	edit dl rm
runpy.py	13084	0644	edit dl rm
sched.py	6442	0644	edit dl rm
secrets.py	2036	0644	edit dl rm
selectors.py	19536	0644	edit dl rm
shelve.py	8527	0644	edit dl rm
shlex.py	13501	0644	edit dl rm
shutil.py	53030	0644	edit dl rm
signal.py	2438	0644	edit dl rm
site.py	22085	0644	edit dl rm
smtpd.py	34821	0755	edit dl rm
smtplib.py	45405	0755	edit dl rm
sndhdr.py	7099	0644	edit dl rm
socket.py	36915	0644	edit dl rm
socketserver.py	27296	0644	edit dl rm
sre_compile.py	27973	0644	edit dl rm
sre_constants.py	7177	0644	edit dl rm
sre_parse.py	40779	0644	edit dl rm
ssl.py	52622	0644	edit dl rm
stat.py	5485	0644	edit dl rm
statistics.py	38067	0644	edit dl rm
string.py	10566	0644	edit dl rm
stringprep.py	12917	0644	edit dl rm
struct.py	257	0644	edit dl rm
subprocess.py	83564	0644	edit dl rm
sunau.py	18158	0644	edit dl rm
symbol.py	2281	0644	edit dl rm
symtable.py	7905	0644	edit dl rm
sysconfig.py	25557	0644	edit dl rm
tabnanny.py	11406	0755	edit dl rm
tarfile.py	112939	0755	edit dl rm
telnetlib.py	23254	0644	edit dl rm
tempfile.py	27963	0644	edit dl rm
textwrap.py	19407	0644	edit dl rm
this.py	1003	0644	edit dl rm
threading.py	54176	0644	edit dl rm
timeit.py	13480	0755	edit dl rm
token.py	2368	0644	edit dl rm
tokenize.py	25883	0644	edit dl rm
trace.py	29207	0755	edit dl rm
traceback.py	24660	0644	edit dl rm
tracemalloc.py	18047	0644	edit dl rm
tty.py	879	0644	edit dl rm
types.py	9785	0644	edit dl rm
typing.py	77044	0644	edit dl rm
uu.py	7277	0644	edit dl rm
uuid.py	27324	0644	edit dl rm
warnings.py	19688	0644	edit dl rm
wave.py	18004	0644	edit dl rm
weakref.py	21560	0644	edit dl rm
webbrowser.py	24083	0755	edit dl rm
xdrlib.py	5913	0644	edit dl rm
zipapp.py	7535	0644	edit dl rm
zipfile.py	88899	0644	edit dl rm
zipimport.py	30765	0644	edit dl rm
_aix_support.py	3389	0644	edit dl rm
_bootlocale.py	1801	0644	edit dl rm
_bootsubprocess.py	2675	0644	edit dl rm
_collections_abc.py	29374	0644	edit dl rm
_compat_pickle.py	8749	0644	edit dl rm
_compression.py	5340	0644	edit dl rm
_markupbase.py	14623	0644	edit dl rm
_osx_support.py	21773	0644	edit dl rm
_pydecimal.py	228666	0644	edit dl rm
_pyio.py	93316	0644	edit dl rm
_py_abc.py	6189	0644	edit dl rm
_sitebuiltins.py	3115	0644	edit dl rm
_strptime.py	25277	0644	edit dl rm
_sysconfigdata__linux_x86_64-linux-gnu.py	41236	0644	edit dl rm
_threading_local.py	7220	0644	edit dl rm
_weakrefset.py	5923	0644	edit dl rm
__future__.py	5147	0644	edit dl rm
__phello__.foo.py	64	0644	edit dl rm

Edit: /usr/lib64/python3.9/modulefinder.py (24401B)

"""Find modules used by a script, using introspection."""

import dis
import importlib._bootstrap_external
import importlib.machinery
import marshal
import os
import io
import sys

LOAD_CONST = dis.opmap['LOAD_CONST']
IMPORT_NAME = dis.opmap['IMPORT_NAME']
STORE_NAME = dis.opmap['STORE_NAME']
STORE_GLOBAL = dis.opmap['STORE_GLOBAL']
STORE_OPS = STORE_NAME, STORE_GLOBAL
EXTENDED_ARG = dis.EXTENDED_ARG

# Old imp constants:

_SEARCH_ERROR = 0
_PY_SOURCE = 1
_PY_COMPILED = 2
_C_EXTENSION = 3
_PKG_DIRECTORY = 5
_C_BUILTIN = 6
_PY_FROZEN = 7

# Modulefinder does a good job at simulating Python's, but it can not
# handle __path__ modifications packages make at runtime.  Therefore there
# is a mechanism whereby you can register extra paths in this map for a
# package, and it will be honored.

# Note this is a mapping is lists of paths.
packagePathMap = {}

# A Public interface
def AddPackagePath(packagename, path):
    packagePathMap.setdefault(packagename, []).append(path)

replacePackageMap = {}

# This ReplacePackage mechanism allows modulefinder to work around
# situations in which a package injects itself under the name
# of another package into sys.modules at runtime by calling
# ReplacePackage("real_package_name", "faked_package_name")
# before running ModuleFinder.

def ReplacePackage(oldname, newname):
    replacePackageMap[oldname] = newname

def _find_module(name, path=None):
    """An importlib reimplementation of imp.find_module (for our purposes)."""

# It's necessary to clear the caches for our Finder first, in case any
    # modules are being added/deleted/modified at runtime. In particular,
    # test_modulefinder.py changes file tree contents in a cache-breaking way:

importlib.machinery.PathFinder.invalidate_caches()

spec = importlib.machinery.PathFinder.find_spec(name, path)

if spec is None:
        raise ImportError("No module named {name!r}".format(name=name), name=name)

# Some special cases:

if spec.loader is importlib.machinery.BuiltinImporter:
        return None, None, ("", "", _C_BUILTIN)

if spec.loader is importlib.machinery.FrozenImporter:
        return None, None, ("", "", _PY_FROZEN)

file_path = spec.origin

if spec.loader.is_package(name):
        return None, os.path.dirname(file_path), ("", "", _PKG_DIRECTORY)

if isinstance(spec.loader, importlib.machinery.SourceFileLoader):
        kind = _PY_SOURCE

elif isinstance(spec.loader, importlib.machinery.ExtensionFileLoader):
        kind = _C_EXTENSION

elif isinstance(spec.loader, importlib.machinery.SourcelessFileLoader):
        kind = _PY_COMPILED

else:  # Should never happen.
        return None, None, ("", "", _SEARCH_ERROR)

file = io.open_code(file_path)
    suffix = os.path.splitext(file_path)[-1]

return file, file_path, (suffix, "rb", kind)

class Module:

def __init__(self, name, file=None, path=None):
        self.__name__ = name
        self.__file__ = file
        self.__path__ = path
        self.__code__ = None
        # The set of global names that are assigned to in the module.
        # This includes those names imported through starimports of
        # Python modules.
        self.globalnames = {}
        # The set of starimports this module did that could not be
        # resolved, ie. a starimport from a non-Python module.
        self.starimports = {}

def __repr__(self):
        s = "Module(%r" % (self.__name__,)
        if self.__file__ is not None:
            s = s + ", %r" % (self.__file__,)
        if self.__path__ is not None:
            s = s + ", %r" % (self.__path__,)
        s = s + ")"
        return s

class ModuleFinder:

def __init__(self, path=None, debug=0, excludes=None, replace_paths=None):
        if path is None:
            path = sys.path
        self.path = path
        self.modules = {}
        self.badmodules = {}
        self.debug = debug
        self.indent = 0
        self.excludes = excludes if excludes is not None else []
        self.replace_paths = replace_paths if replace_paths is not None else []
        self.processed_paths = []   # Used in debugging only

def msg(self, level, str, *args):
        if level <= self.debug:
            for i in range(self.indent):
                print("   ", end=' ')
            print(str, end=' ')
            for arg in args:
                print(repr(arg), end=' ')
            print()

def msgin(self, *args):
        level = args[0]
        if level <= self.debug:
            self.indent = self.indent + 1
            self.msg(*args)

def msgout(self, *args):
        level = args[0]
        if level <= self.debug:
            self.indent = self.indent - 1
            self.msg(*args)

def run_script(self, pathname):
        self.msg(2, "run_script", pathname)
        with io.open_code(pathname) as fp:
            stuff = ("", "rb", _PY_SOURCE)
            self.load_module('__main__', fp, pathname, stuff)

def load_file(self, pathname):
        dir, name = os.path.split(pathname)
        name, ext = os.path.splitext(name)
        with io.open_code(pathname) as fp:
            stuff = (ext, "rb", _PY_SOURCE)
            self.load_module(name, fp, pathname, stuff)

def import_hook(self, name, caller=None, fromlist=None, level=-1):
        self.msg(3, "import_hook", name, caller, fromlist, level)
        parent = self.determine_parent(caller, level=level)
        q, tail = self.find_head_package(parent, name)
        m = self.load_tail(q, tail)
        if not fromlist:
            return q
        if m.__path__:
            self.ensure_fromlist(m, fromlist)
        return None

def determine_parent(self, caller, level=-1):
        self.msgin(4, "determine_parent", caller, level)
        if not caller or level == 0:
            self.msgout(4, "determine_parent -> None")
            return None
        pname = caller.__name__
        if level >= 1: # relative import
            if caller.__path__:
                level -= 1
            if level == 0:
                parent = self.modules[pname]
                assert parent is caller
                self.msgout(4, "determine_parent ->", parent)
                return parent
            if pname.count(".") < level:
                raise ImportError("relative importpath too deep")
            pname = ".".join(pname.split(".")[:-level])
            parent = self.modules[pname]
            self.msgout(4, "determine_parent ->", parent)
            return parent
        if caller.__path__:
            parent = self.modules[pname]
            assert caller is parent
            self.msgout(4, "determine_parent ->", parent)
            return parent
        if '.' in pname:
            i = pname.rfind('.')
            pname = pname[:i]
            parent = self.modules[pname]
            assert parent.__name__ == pname
            self.msgout(4, "determine_parent ->", parent)
            return parent
        self.msgout(4, "determine_parent -> None")
        return None

def find_head_package(self, parent, name):
        self.msgin(4, "find_head_package", parent, name)
        if '.' in name:
            i = name.find('.')
            head = name[:i]
            tail = name[i+1:]
        else:
            head = name
            tail = ""
        if parent:
            qname = "%s.%s" % (parent.__name__, head)
        else:
            qname = head
        q = self.import_module(head, qname, parent)
        if q:
            self.msgout(4, "find_head_package ->", (q, tail))
            return q, tail
        if parent:
            qname = head
            parent = None
            q = self.import_module(head, qname, parent)
            if q:
                self.msgout(4, "find_head_package ->", (q, tail))
                return q, tail
        self.msgout(4, "raise ImportError: No module named", qname)
        raise ImportError("No module named " + qname)

def load_tail(self, q, tail):
        self.msgin(4, "load_tail", q, tail)
        m = q
        while tail:
            i = tail.find('.')
            if i < 0: i = len(tail)
            head, tail = tail[:i], tail[i+1:]
            mname = "%s.%s" % (m.__name__, head)
            m = self.import_module(head, mname, m)
            if not m:
                self.msgout(4, "raise ImportError: No module named", mname)
                raise ImportError("No module named " + mname)
        self.msgout(4, "load_tail ->", m)
        return m

def ensure_fromlist(self, m, fromlist, recursive=0):
        self.msg(4, "ensure_fromlist", m, fromlist, recursive)
        for sub in fromlist:
            if sub == "*":
                if not recursive:
                    all = self.find_all_submodules(m)
                    if all:
                        self.ensure_fromlist(m, all, 1)
            elif not hasattr(m, sub):
                subname = "%s.%s" % (m.__name__, sub)
                submod = self.import_module(sub, subname, m)
                if not submod:
                    raise ImportError("No module named " + subname)

def find_all_submodules(self, m):
        if not m.__path__:
            return
        modules = {}
        # 'suffixes' used to be a list hardcoded to [".py", ".pyc"].
        # But we must also collect Python extension modules - although
        # we cannot separate normal dlls from Python extensions.
        suffixes = []
        suffixes += importlib.machinery.EXTENSION_SUFFIXES[:]
        suffixes += importlib.machinery.SOURCE_SUFFIXES[:]
        suffixes += importlib.machinery.BYTECODE_SUFFIXES[:]
        for dir in m.__path__:
            try:
                names = os.listdir(dir)
            except OSError:
                self.msg(2, "can't list directory", dir)
                continue
            for name in names:
                mod = None
                for suff in suffixes:
                    n = len(suff)
                    if name[-n:] == suff:
                        mod = name[:-n]
                        break
                if mod and mod != "__init__":
                    modules[mod] = mod
        return modules.keys()

def import_module(self, partname, fqname, parent):
        self.msgin(3, "import_module", partname, fqname, parent)
        try:
            m = self.modules[fqname]
        except KeyError:
            pass
        else:
            self.msgout(3, "import_module ->", m)
            return m
        if fqname in self.badmodules:
            self.msgout(3, "import_module -> None")
            return None
        if parent and parent.__path__ is None:
            self.msgout(3, "import_module -> None")
            return None
        try:
            fp, pathname, stuff = self.find_module(partname,
                                                   parent and parent.__path__, parent)
        except ImportError:
            self.msgout(3, "import_module ->", None)
            return None

try:
            m = self.load_module(fqname, fp, pathname, stuff)
        finally:
            if fp:
                fp.close()
        if parent:
            setattr(parent, partname, m)
        self.msgout(3, "import_module ->", m)
        return m

def load_module(self, fqname, fp, pathname, file_info):
        suffix, mode, type = file_info
        self.msgin(2, "load_module", fqname, fp and "fp", pathname)
        if type == _PKG_DIRECTORY:
            m = self.load_package(fqname, pathname)
            self.msgout(2, "load_module ->", m)
            return m
        if type == _PY_SOURCE:
            co = compile(fp.read(), pathname, 'exec')
        elif type == _PY_COMPILED:
            try:
                data = fp.read()
                importlib._bootstrap_external._classify_pyc(data, fqname, {})
            except ImportError as exc:
                self.msgout(2, "raise ImportError: " + str(exc), pathname)
                raise
            co = marshal.loads(memoryview(data)[16:])
        else:
            co = None
        m = self.add_module(fqname)
        m.__file__ = pathname
        if co:
            if self.replace_paths:
                co = self.replace_paths_in_code(co)
            m.__code__ = co
            self.scan_code(co, m)
        self.msgout(2, "load_module ->", m)
        return m

def _add_badmodule(self, name, caller):
        if name not in self.badmodules:
            self.badmodules[name] = {}
        if caller:
            self.badmodules[name][caller.__name__] = 1
        else:
            self.badmodules[name]["-"] = 1

def _safe_import_hook(self, name, caller, fromlist, level=-1):
        # wrapper for self.import_hook() that won't raise ImportError
        if name in self.badmodules:
            self._add_badmodule(name, caller)
            return
        try:
            self.import_hook(name, caller, level=level)
        except ImportError as msg:
            self.msg(2, "ImportError:", str(msg))
            self._add_badmodule(name, caller)
        except SyntaxError as msg:
            self.msg(2, "SyntaxError:", str(msg))
            self._add_badmodule(name, caller)
        else:
            if fromlist:
                for sub in fromlist:
                    fullname = name + "." + sub
                    if fullname in self.badmodules:
                        self._add_badmodule(fullname, caller)
                        continue
                    try:
                        self.import_hook(name, caller, [sub], level=level)
                    except ImportError as msg:
                        self.msg(2, "ImportError:", str(msg))
                        self._add_badmodule(fullname, caller)

def scan_opcodes(self, co):
        # Scan the code, and yield 'interesting' opcode combinations
        code = co.co_code
        names = co.co_names
        consts = co.co_consts
        opargs = [(op, arg) for _, op, arg in dis._unpack_opargs(code)
                  if op != EXTENDED_ARG]
        for i, (op, oparg) in enumerate(opargs):
            if op in STORE_OPS:
                yield "store", (names[oparg],)
                continue
            if (op == IMPORT_NAME and i >= 2
                    and opargs[i-1][0] == opargs[i-2][0] == LOAD_CONST):
                level = consts[opargs[i-2][1]]
                fromlist = consts[opargs[i-1][1]]
                if level == 0: # absolute import
                    yield "absolute_import", (fromlist, names[oparg])
                else: # relative import
                    yield "relative_import", (level, fromlist, names[oparg])
                continue

def scan_code(self, co, m):
        code = co.co_code
        scanner = self.scan_opcodes
        for what, args in scanner(co):
            if what == "store":
                name, = args
                m.globalnames[name] = 1
            elif what == "absolute_import":
                fromlist, name = args
                have_star = 0
                if fromlist is not None:
                    if "*" in fromlist:
                        have_star = 1
                    fromlist = [f for f in fromlist if f != "*"]
                self._safe_import_hook(name, m, fromlist, level=0)
                if have_star:
                    # We've encountered an "import *". If it is a Python module,
                    # the code has already been parsed and we can suck out the
                    # global names.
                    mm = None
                    if m.__path__:
                        # At this point we don't know whether 'name' is a
                        # submodule of 'm' or a global module. Let's just try
                        # the full name first.
                        mm = self.modules.get(m.__name__ + "." + name)
                    if mm is None:
                        mm = self.modules.get(name)
                    if mm is not None:
                        m.globalnames.update(mm.globalnames)
                        m.starimports.update(mm.starimports)
                        if mm.__code__ is None:
                            m.starimports[name] = 1
                    else:
                        m.starimports[name] = 1
            elif what == "relative_import":
                level, fromlist, name = args
                if name:
                    self._safe_import_hook(name, m, fromlist, level=level)
                else:
                    parent = self.determine_parent(m, level=level)
                    self._safe_import_hook(parent.__name__, None, fromlist, level=0)
            else:
                # We don't expect anything else from the generator.
                raise RuntimeError(what)

for c in co.co_consts:
            if isinstance(c, type(co)):
                self.scan_code(c, m)

def load_package(self, fqname, pathname):
        self.msgin(2, "load_package", fqname, pathname)
        newname = replacePackageMap.get(fqname)
        if newname:
            fqname = newname
        m = self.add_module(fqname)
        m.__file__ = pathname
        m.__path__ = [pathname]

# As per comment at top of file, simulate runtime __path__ additions.
        m.__path__ = m.__path__ + packagePathMap.get(fqname, [])

fp, buf, stuff = self.find_module("__init__", m.__path__)
        try:
            self.load_module(fqname, fp, buf, stuff)
            self.msgout(2, "load_package ->", m)
            return m
        finally:
            if fp:
                fp.close()

def add_module(self, fqname):
        if fqname in self.modules:
            return self.modules[fqname]
        self.modules[fqname] = m = Module(fqname)
        return m

def find_module(self, name, path, parent=None):
        if parent is not None:
            # assert path is not None
            fullname = parent.__name__+'.'+name
        else:
            fullname = name
        if fullname in self.excludes:
            self.msgout(3, "find_module -> Excluded", fullname)
            raise ImportError(name)

if path is None:
            if name in sys.builtin_module_names:
                return (None, None, ("", "", _C_BUILTIN))

path = self.path

return _find_module(name, path)

def report(self):
        """Print a report to stdout, listing the found modules with their
        paths, as well as modules that are missing, or seem to be missing.
        """
        print()
        print("  %-25s %s" % ("Name", "File"))
        print("  %-25s %s" % ("----", "----"))
        # Print modules found
        keys = sorted(self.modules.keys())
        for key in keys:
            m = self.modules[key]
            if m.__path__:
                print("P", end=' ')
            else:
                print("m", end=' ')
            print("%-25s" % key, m.__file__ or "")

# Print missing modules
        missing, maybe = self.any_missing_maybe()
        if missing:
            print()
            print("Missing modules:")
            for name in missing:
                mods = sorted(self.badmodules[name].keys())
                print("?", name, "imported from", ', '.join(mods))
        # Print modules that may be missing, but then again, maybe not...
        if maybe:
            print()
            print("Submodules that appear to be missing, but could also be", end=' ')
            print("global names in the parent package:")
            for name in maybe:
                mods = sorted(self.badmodules[name].keys())
                print("?", name, "imported from", ', '.join(mods))

def any_missing(self):
        """Return a list of modules that appear to be missing. Use
        any_missing_maybe() if you want to know which modules are
        certain to be missing, and which *may* be missing.
        """
        missing, maybe = self.any_missing_maybe()
        return missing + maybe

def any_missing_maybe(self):
        """Return two lists, one with modules that are certainly missing
        and one with modules that *may* be missing. The latter names could
        either be submodules *or* just global names in the package.

The reason it can't always be determined is that it's impossible to
        tell which names are imported when "from module import *" is done
        with an extension module, short of actually importing it.
        """
        missing = []
        maybe = []
        for name in self.badmodules:
            if name in self.excludes:
                continue
            i = name.rfind(".")
            if i < 0:
                missing.append(name)
                continue
            subname = name[i+1:]
            pkgname = name[:i]
            pkg = self.modules.get(pkgname)
            if pkg is not None:
                if pkgname in self.badmodules[name]:
                    # The package tried to import this module itself and
                    # failed. It's definitely missing.
                    missing.append(name)
                elif subname in pkg.globalnames:
                    # It's a global in the package: definitely not missing.
                    pass
                elif pkg.starimports:
                    # It could be missing, but the package did an "import *"
                    # from a non-Python module, so we simply can't be sure.
                    maybe.append(name)
                else:
                    # It's not a global in the package, the package didn't
                    # do funny star imports, it's very likely to be missing.
                    # The symbol could be inserted into the package from the
                    # outside, but since that's not good style we simply list
                    # it missing.
                    missing.append(name)
            else:
                missing.append(name)
        missing.sort()
        maybe.sort()
        return missing, maybe

def replace_paths_in_code(self, co):
        new_filename = original_filename = os.path.normpath(co.co_filename)
        for f, r in self.replace_paths:
            if original_filename.startswith(f):
                new_filename = r + original_filename[len(f):]
                break

if self.debug and original_filename not in self.processed_paths:
            if new_filename != original_filename:
                self.msgout(2, "co_filename %r changed to %r" \
                                    % (original_filename,new_filename,))
            else:
                self.msgout(2, "co_filename %r remains unchanged" \
                                    % (original_filename,))
            self.processed_paths.append(original_filename)

consts = list(co.co_consts)
        for i in range(len(consts)):
            if isinstance(consts[i], type(co)):
                consts[i] = self.replace_paths_in_code(consts[i])

return co.replace(co_consts=tuple(consts), co_filename=new_filename)

def test():
    # Parse command line
    import getopt
    try:
        opts, args = getopt.getopt(sys.argv[1:], "dmp:qx:")
    except getopt.error as msg:
        print(msg)
        return

# Process options
    debug = 1
    domods = 0
    addpath = []
    exclude = []
    for o, a in opts:
        if o == '-d':
            debug = debug + 1
        if o == '-m':
            domods = 1
        if o == '-p':
            addpath = addpath + a.split(os.pathsep)
        if o == '-q':
            debug = 0
        if o == '-x':
            exclude.append(a)

# Provide default arguments
    if not args:
        script = "hello.py"
    else:
        script = args[0]

# Set the path based on sys.path and the script directory
    path = sys.path[:]
    path[0] = os.path.dirname(script)
    path = addpath + path
    if debug > 1:
        print("path:")
        for item in path:
            print("   ", repr(item))

# Create the module finder and turn its crank
    mf = ModuleFinder(path, debug, exclude)
    for arg in args[1:]:
        if arg == '-m':
            domods = 1
            continue
        if domods:
            if arg[-2:] == '.*':
                mf.import_hook(arg[:-2], None, ["*"])
            else:
                mf.import_hook(arg)
        else:
            mf.load_file(arg)
    mf.run_script(script)
    mf.report()
    return mf  # for -i debugging

if __name__ == '__main__':
    try:
        mf = test()
    except KeyboardInterrupt:
        print("\n[interrupted]")

cmd: