Python Introspektion

Question

Ist es möglich, Code aus importiertem Modul auf Modul anzuwenden, die es importieren? Zum Beispiel habe ich Modul Debug wo einige Dekorateur für das Debuggen definiert, zum Beispiel:

def debug_func(f): 
    def wrapper(*func_args, **func_kwargs): 
     print(f(*func_args, **func_kwargs)) 
    return wrapper 

Was ist die Idee: Es wäre wenn ist nützlich sein, ich kann nur

import Debug 

und alle Funktionen von aktuellen Modul wird mit Dekorateur eingewickelt. Ist es möglich?

Answer 1

Innerhalb Debug.py:

import functools 
from types import FunctionType 

def wrap_functions(module_dict): 
    for k, f in module_dict.items(): 
     if not isinstance(f, FunctionType): 
      continue 
     def get_wrapper(f): 
      def wrapper(*func_args, **func_kwargs): 
       print(f(*func_args, **func_kwargs)) 
      return functools.wraps(f)(wrapper) 
     module_dict[k] = get_wrapper(f) 

Am unten des Moduls Sie debuggen wollen, sind:

import Debug 
Debug.wrap_functions(globals()) 

Dank (+1) an alle Kommentatoren, die Vorschläge zur Verfügung gestellt.

Answer 2

Ich denke, die pythonic Art und Weise tun Sie Ihre Debug rufen Sie das debuggt Modul zu haben wäre, wie die Standard-Tools (pdb, unittest, ...) mit einem Aufruf wie:

$ python -m Debug mymodule.py 

Mit Ihrer Debuggen Importieren/Ausführen des Moduls mit beliebigen Dekoratoren. Anderenfalls (Importieren Debug) wird die Reihenfolge, in der die Module ausgewertet werden, falsch, da Sie versuchen, Ihr Modul Debug davon abhängig zu machen, dass das Modul es importiert, was bestenfalls knifflig ist.

Neben Ihre Funktionen explizit von vorbei (via globals(), eine Liste von Funktionen ...), um einige Debug.mark_as_debug als Jim Garrison vorgeschlagen, ich glaube, es würde mehr Sinn machen, Ihren Code zu organisieren, so dass Sie Ihre Debug anrufen können Ihre Module statt umgekehrt.

Answer 3

Wie würde Debug wissen, aus welchem ​​Modul es importiert wird? Antwort: Es kann nicht. Wie kann Debug mehr als einmal ausgeführt werden, wenn es in mehr als ein Modul importiert wird? Antwort: Es würde nicht; Module werden nur einmal ausgeführt und dann zwischengespeichert. Was Sie also tun möchten, kann nicht ganz so einfach gemacht werden, wie Sie möchten.

Sie könnten dies jedoch tun, indem Sie nach dem Importieren eine Funktion in Ihrem debug Modul aufrufen. Sie können __name__ vom aufrufenden Modul übergeben, um seinen Namen anzugeben, nach dem es möglich ist, einen Verweis auf das Modul selbst und dann die darin definierten Variablen der obersten Ebene zu erhalten, von denen einige Funktionen sein können. Diese können dann dekoriert werden.

# debug.py 
import types, sys, functools 

# decorator to be applied to all top-level functions in a module 
def debug(fn): 
    @functools.wraps(fn) 
    def wrapper(*args, **kwargs): 
     print "calling", fn.__name__, "with args", *args, **kwargs 
     result = fn(*args, **kwargs) 
     print "returning from", fn.__name__, "with return value", result 
     return result 

# decorate all top-level functions in named module with a given decorator 
# (by default it is the above decorator but it could be a different one) 
# This makes these functions behave as though they had been written with 
# @debug above them. 
def set_debug(modname, debug=debug): 
    module = sys.modules[modname] 
    for name in dir(module): 
     if not name.startswith("_"): 
      thing = getattr(module, name) 
      if isinstance(thing, types.FunctionType): 
       setattr(module, name, debug(thing)) 

nun in dem rufenden Modul:

# main.py 
import debug 

def main(): 
    print "in main module" 

debug.set_debug(__name__) # install debugging decorator 

main() 

Jim Garrison Ansatz den Namespace explizit der Weitergabe (statt dem Modulnamen) ist auch gut und tatsächlich vereinfacht die Dinge ein wenig; Sie könnten damit andere Dinge als Module dekorieren. Ich habe meine kaputt gemacht, so dass du einen anderen Dekorateur einreichen kannst, wenn du willst.