Get __name__ of calling function's module in Python

Question

Suppose myapp/foo.py contains:

def info(msg):
    caller_name = ????
    print '[%s] %s' % (caller_name, msg)

And myapp/bar.py contains:

import foo
foo.info('Hello') # => [myapp.bar] Hello

I want caller_name to be set to the __name__ attribute of the calling functions' module (which is 'myapp.foo') in this case. How can this be done?

Answer 1

Check out the inspect module:

inspect.stack() will return the stack information.

Inside a function, inspect.stack()[1] will return your caller's stack. From there, you can get more information about the caller's function name, module, etc.

See the docs for details:

http://docs.python.org/library/inspect.html

Also, Doug Hellmann has a nice writeup of the inspect module in his PyMOTW series:

http://pymotw.com/2/inspect/index.html#module-inspect

EDIT: Here's some code which does what you want, I think:

import inspect 

def info(msg):
    frm = inspect.stack()[1]
    mod = inspect.getmodule(frm[0])
    print '[%s] %s' % (mod.__name__, msg)

Answer 2

Confronted with a similar problem, I have found that sys._current_frames() from the sys module contains interesting information that can help you, without the need to import inspect, at least in specific use cases.

>>> sys._current_frames()
{4052: <frame object at 0x03200C98>}

You can then "move up" using f_back :

>>> f = sys._current_frames().values()[0]
>>> # for python3: f = list(sys._current_frames().values())[0]

>>> print f.f_back.f_globals['__file__']
'/base/data/home/apps/apricot/1.6456165165151/caller.py'

>>> print f.f_back.f_globals['__name__']
'__main__'

For the filename you can also use f.f_back.f_code.co_filename, as suggested by Mark Roddy above. I am not sure of the limits and caveats of this method (multiple threads will most likely be a problem) but I intend to use it in my case.

Answer 3

I don't recommend do this, but you can accomplish your goal with the following method:

def caller_name():
    frame=inspect.currentframe()
    frame=frame.f_back.f_back
    code=frame.f_code
    return code.co_filename

Then update your existing method as follows:

def info(msg):
    caller = caller_name()
    print '[%s] %s' % (caller, msg)

Answer 4

As for me, following line was enough to get callers'name.

import inspect
frame = inspect.stack()[-1]
print(frame.filename)

Answer 5

Calling inspect.getmodule() for a frame object enumerates the module objects in the sys.modules and compares the file path of the code object corresponding to the frame object with the file paths of module objects(module.__file__ for each module).

The following solution avoids such overheads.

import sys

def info(msg):
    caller_name = sys._getframe(1).f_globals['__name__']
    ...

Answer 6

Here is a version using inspect, similar to answers above, but instead of getting the whole stack, only traversing the frames we are interested in (by default the previous 2), and handling the cases that things might be None so you don't get AttributeError but rather the default value returned. You can also configure the depth (if depth is 1 it means go back the immediate caller -- equivalent to inspect.stack[1] -- and so on).

import inspect

def caller_module_name(depth: int = 1, default: str | None = '__main__') -> str | None:
    frame = inspect.currentframe()
    if not frame:
        return default

    # Go back up the stack to the caller (or caller's caller, etc.)
    # (add 1 to depth to account for this function itself)
    for _ in range(depth + 1):
        if not (frame := frame.f_back):
            return default

    if module := inspect.getmodule(frame):
        return module.__name__

    return default

I'm not sure what the best choice of default value would be, either "__main__", __name__ or just None could be appropriate. The internal function in typing module mentioned below uses the hard-coded string "__main__" as the default, so I have done the same, but what makes sense as a default will probably depend on the application and where/how it is supposed to run.

It might be interesting to see how its done internally in the CPython source code, e.g. here in typing module. However, this is using internal APIs and is only guaranteed to work on CPython, and with no backwards-compatible guarantees. So it would be better to write it using public APIs (in inspect module). (Obviously, it still won't work on Python interpreters without stack frame support, as cautioned in the inspect module docs, but by using inspect module and handling Nones, at least you won't get an exception and can still get a sensible value returned).