在 Python 中，如何找出哪个模块导入了特定模块

Question

For example, I have a module called "Abc". Inside Abc, I need to find out which other module imports 'Abc'. If another module called "Egf" import "Abc", is it possible to print out "Egf" inside of 'Abc'? If so how?

I know a lib called https://github.com/thebjorn/pydeps/blob/master/pydeps/depgraph.py . It can build a graph by reading pyc file, but this is not what I am looking for.

Answer 1

Disclaimer: This might not be a good idea and I don't know much about the internals, so I cannot guarantee that it does not break anything or works in all cases.

1. Imports happen only once, so if the modules Def and Ghi both include import Abc , the code in Abc will be executed just once.
   • Thus we need to globally modify how imports are performed.
   • import Abc evaluated to builtins.__import__("Abc", ...) , so we can override that function to check if the module to import is Abc and act accordingly.
2. We can see the import statements in inspect.stack() , but are only provided with the filename of the import statement, not the module. So if Def.py calls import Abc , we get the absolute path to Def.py , but do not know if it really is the submodule Jkl.Def .
   • My answer ignores that case and just reports Def in that case.
   • You could try this approach to get the actual module if Def is just a submodule.
     1. Assuming the absolute path to be /home/testuser/modules/module1/Def.py and the actual module is module1.Def
     2. Try __import__("Def") . If it works, Def is likely to be the importing module (or there exists another module Def in the search path...)
     3. In our case that should fail, so we now call __import__("module1.Def") . This should succeed, so we can assume that the importing module was module1.Def .

Abc.py

import builtins
from builtins import __import__ as builtin_import
import inspect
import os


def my_import(*args):
    """This function is intended to globally override builtins.__import__"""

    module_to_import = args[0]
    if module_to_import == "Abc":
        # for indirect imports we need to find the actual import statement in the stack
        for stackframe in inspect.stack():
            if stackframe.code_context is None:
                continue
            code = stackframe.code_context[0]
            if code.startswith(("import Abc", "from Abc")):
                # name of importing file
                importing_file = stackframe.filename  # absolute path
                importing_module = os.path.basename(importing_file).split(".")[0]
                print("Imported Abc from module", importing_module)
                break
        else:
            # This should not happen...
            print("Abc was imported but I didn't find the import statement in the stack")

    # perform the actual import
    builtin_import(*args)


# globally replace __import__
builtins.__import__ = my_import

# the first import does not use the patched __import__, so we need to do it manually
__import__("Abc")

print("I am Abc")

Def.py

import Abc
print("I am Def")

Ghi.py

import Abc
print("I am Ghi")

main.py

import Abc
import Def
import Ghi

Result

$ python3 main.py
Imported Abc from module main
I am Abc
Imported Abc from module Def
I am Def
Imported Abc from module Ghi
I am Ghi