¿Cómo puedo acceder al módulo de ejecución actual o al nombre de la clase en Python?

Me gustaría poder recuperar dinámicamente el módulo de ejecución actual o el nombre de clase desde dentro de un módulo importado. Aquí hay algo de código:

foo.py:

def f():
    print __name__

bar.py:

from foo import f

def b(): f()

Esto obviamente no funciona como __name__ es el nombre del módulo que contiene la función. Lo que me gustaría tener acceso dentro del foo módulo es el nombre del módulo de ejecución actual que está utilizando foo. Así que en el caso anterior sería bar pero si cualquier otro módulo importado foo Me gustaría foo para tener acceso dinámicamente al nombre de ese módulo.

Editar: los inspect El módulo parece bastante prometedor, pero no es exactamente lo que estaba buscando. Lo que esperaba era algún tipo de variable global o de nivel de entorno a la que pudiera acceder y que contuviera el nombre del módulo de ejecución actual. No es que no esté dispuesto a recorrer la pila para encontrar esa información, solo pensé que Python ya podría haber expuesto esos datos.

Editar: Así es como estoy tratando de usar esto. Tengo dos aplicaciones Django diferentes que necesitan registrar errores en el archivo. Digamos que se llaman “AppOne” y “AppTwo”. También tengo un lugar en el que me gustaría registrar estos archivos: “/home/hare/app_logs“. En cada aplicación, en un momento dado, me gustaría poder importar mi módulo de registro y llamar a la función de registro que escribe la cadena de registro en el archivo. Sin embargo, lo que me gustaría hacer es crear un directorio en app_logs ese es el nombre de la aplicación actual (“AppOne” o “AppTwo”) para que los archivos de registro de cada aplicación vayan a sus respectivos directorios de registro.

Para hacer esto, pensé que la mejor manera sería que el módulo de registro tuviera acceso a algún tipo de variable global que indique el nombre de la aplicación actual, ya que es responsable de conocer la ubicación del directorio de registro principal y crear el registro de la aplicación. directorio si aún no existe.

Del comentario, no de la pregunta.

Simplemente tengo curiosidad por ver si lo que estoy tratando de hacer es posible.

La respuesta a “es posible” siempre es “sí”. Siempre. A menos que su pregunta involucre viajes en el tiempo, antigravedad o movimiento perpetuo.

Dado que la respuesta siempre es “sí”, su pregunta está mal formulada. La verdadera pregunta es “¿cuál es una buena manera de que mi módulo de registro sepa el nombre del cliente?” o algo así.

La respuesta es “Acéptalo como un parámetro”. No pierda el tiempo inspeccionando o buscando globales misteriosos u otros trucos.

Simplemente siga el patrón de diseño de logging.getLogger() y use registradores con nombres explícitos. Un modismo común es el siguiente

logger= logging.getLogger( __name__ )

Eso maneja casi todos los nombres de registros a la perfección.

Esto debería funcionar para hacer referencia al módulo actual:

import sys
sys.modules[__name__]

El “módulo actualmente en ejecución” claramente es foo, ya que eso es lo que contiene la función que se está ejecutando actualmente. Creo que una mejor descripción de lo que desea es el módulo de la persona que llama inmediatamente a foo (que puede ser foo si está llamando af() de una función en foo llamada por una función en bar. Qué tan lejos quieras subir depende de para qué quieras esto.

En cualquier caso, suponiendo que desea la llamada inmediata, puede obtenerla recorriendo la pila de llamadas. Esto se puede lograr llamando sys._getframecon el número de niveles adecuado para caminar.

def f():
    caller = sys._getframe(1)  # Obtain calling frame
    print "Called from module", caller.f_globals['__name__']

[Edit]: En realidad, usando el inspeccionar El módulo como se sugirió anteriormente es probablemente una forma más limpia de obtener el marco de la pila. El código equivalente es:

def f():
    caller = inspect.currentframe().f_back
    print "Called from module", caller.f_globals['__name__']

(sys._getframe está documentado como para uso interno; el módulo de inspección es una API más confiable)

Para obtener una referencia al “_principal_” módulo cuando en otro:

import sys
sys.modules['__main__']

Para luego obtener la ruta del archivo del módulo, que incluye su nombre:

sys.modules['__main__'].__file__  # type: str

Si está dentro del módulo “__main__”, simplemente use: __file__

Para obtener solo el nombre del archivo de la ruta del archivo:

import os
os.path.basename(file_path)

Para separar el nombre del archivo de su extensión:

file_name.split(".")[0]

Para obtener el nombre de una instancia de clase:

instance.__class__.__name__

Para obtener el nombre de una clase:

class.__name__

__file__ es la ruta del módulo actual en el que se realiza la llamada.

Creo que lo que quieres usar es el inspeccionar módulo, para inspeccionar la pila de tiempo de ejecución de python. Mira esto tutorial. Creo que proporciona un ejemplo casi exacto de lo que quieres hacer.

Usando __file__ solo le brinda una ruta relativa para el módulo principal y una ruta absoluta para los módulos importados. Siendo conscientes de esto, podemos obtener el archivo del módulo constantemente de cualquier manera con un poco de ayuda de nuestro os.path instrumentos.

Para el uso de nombre de archivo solamente __file__.split(os.path.sep)[-1].

Para uso de ruta completa os.path.abspath(__file__).

Manifestación:

/tmp $ cat f.py
from pprint import pprint
import os
import sys

pprint({
    'sys.modules[__name__]': sys.modules[__name__],
    '__file__': __file__,
    '__file__.split(os.path.sep)[-1]': __file__.split(os.path.sep)[-1],
    'os.path.abspath(__file__)': os.path.abspath(__file__),
})

/tmp $ cat i.py
import f

Resultados:

## on *Nix ##

/tmp $ python3 f.py
{'sys.modules[__name__]': <module '__main__' from 'f.py'>,
 '__file__': 'f.py',
 '__file__.split(os.path.sep)[-1]': 'f.py',
 'os.path.abspath(__file__)': '/tmp/f.py'}

/tmp $ python3 i.py
{'sys.modules[__name__]': <module 'f' from '/tmp/f.pyc'>,
 '__file__': '/tmp/f.pyc',
 '__file__.split(os.path.sep)[-1]': 'f.pyc',
 'os.path.abspath(__file__)': '/tmp/f.pyc'}

## on Windows ##

PS C:\tmp> python3.exe f.py
{'sys.modules[__name__]': <module '__main__' from 'f.py'>,
 '__file__': 'f.py',
 '__file__.split(os.path.sep)[-1]': 'f.py',
 'os.path.abspath(__file__)': 'C:\\tools\\cygwin\\tmp\\f.py'}

PS C:\tmp> python3.exe i.py
{'sys.modules[__name__]': <module 'f' from 'C:\\tools\\cygwin\\tmp\\f.py'>,
 '__file__': 'C:\\tools\\cygwin\\tmp\\f.py',
 '__file__.split(os.path.sep)[-1]': 'f.py',
 'os.path.abspath(__file__)': 'C:\\tools\\cygwin\\tmp\\f.py'}

Si desea eliminar el ‘.py’ del final, puede hacerlo fácilmente. (Pero no olvide que puede ejecutar un ‘.pyc’ en su lugar).