rekursive Version von 'Reload'

Question

Wenn ich Python-Code bin entwickeln, ich teste es in der Regel in einer Ad-hoc-Weise im Interpreter. Ich werde import some_module, testen, einen Fehler finden, beheben den Fehler und speichern, und verwenden Sie dann die eingebaute in reload Funktion reload(some_module) und erneut testen.

jedoch annehmen, dass in some_module Ich habe import some_other_module, und während some_module Testen entdecke ich einen Fehler in some_other_module und beheben. Jetzt ruft reload(some_module) nicht rekursiv some_other_module erneut importieren. Ich muss die Abhängigkeit entweder manuell neu importieren (indem ich etwas wie reload(some_module.some_other_module) oder import some_other_module; reload(some_other_module) mache, oder, wenn ich eine ganze Reihe von Abhängigkeiten geändert habe und nicht mehr nachgespielt habe, was ich neu laden muss, muss ich den gesamten Interpreter neu starten.

Was hat sein bequemer ist, wenn es einige recursive_reload Funktion waren und ich konnte nur tun recursive_reload(some_module) und haben Python nicht nur some_module neu zu laden, sondern auch neu zu laden rekursiv jedes Moduls, some_module Importe (und jedes Modul, dass jedes dieser Module Importe, und so weiter), so dass ich konnte sicher sein, dass ich nicht eine alte Version von einem der anderen Module verwendet, auf denen some_module abhängt.

Ich glaube nicht, dass Python etwas eingebaut hat, das sich wie die recursive_reload-Funktion verhält, die ich hier beschreibe, aber gibt es eine einfache Möglichkeit, so etwas zusammen zu hacken?

Answer 1

Ich habe gegen das gleiche Problem läuft, und du mich inspiriert, um tatsächlich das Problem zu lösen.

from types import ModuleType 

def rreload(module): 
    """Recursively reload modules.""" 
    reload(module) 
    for attribute_name in dir(module): 
     attribute = getattr(module, attribute_name) 
     if type(attribute) is ModuleType: 
      rreload(attribute) 

Oder, wenn Sie IPython arbeiten, verwenden Sie nur dreload oder --deep-reload beim Start übergeben.

Answer 2

Wäre es nicht einfacher sein, tatsächlich einige Testfälle zu schreiben und jedes Mal, wenn Sie fertig sind mit modifizierenden Ihr Modul laufen?

Was Sie tun, ist cool (Sie sind im Wesentlichen TDD (Test Driven Development mit), aber sie tun es falsch.

Bedenken Sie, dass mit schriftlicher Unit-Tests (der Standard-Python unittest Modul verwenden, oder besser noch nose) Sie haben Tests erhalten, die wiederverwendbar, stabil und helfen Sie sind inconsitencies in Ihrem Code viel viel schneller und besser als mit Prüfung des Moduls in der interaktiven Umgebung erkennen.

Answer 3

Es ist eine heikle Sache zu tun - ich habe ein funktionierendes Beispiel in dieser Antwort: how to find list of modules which depend upon a specific module in python

Answer 4

Technisch in jeder Sie Datei, einen Reload-Befehl setzen könnte, um sicherzustellen, dass sie jedes Mal neu geladen es importiert

a.py:

def testa(): 
    print 'hi!' 

b.py:

import a 
reload(a) 
def testb(): 
    a.testa() 

nun interaktiv:

import b 
b.testb() 
#hi! 

#<modify a.py> 

reload(b) 
b.testb() 
#hello again! 

Answer 5

Ich habe gegen das gleiche Problem gelaufen und ich habe auf @Mattew und @osa Antwort aufgebaut.

from types import ModuleType 
import os, sys 
def rreload(module, paths=None, mdict=None): 
    """Recursively reload modules.""" 
    if paths is None: 
     paths = [''] 
    if mdict is None: 
     mdict = {} 
    if module not in mdict: 
     # modules reloaded from this module 
     mdict[module] = [] 
    reload(module) 
    for attribute_name in dir(module): 
     attribute = getattr(module, attribute_name) 
     if type(attribute) is ModuleType: 
      if attribute not in mdict[module]: 
       if attribute.__name__ not in sys.builtin_module_names: 
        if os.path.dirname(attribute.__file__) in paths: 
         mdict[module].append(attribute) 
         rreload(attribute, paths, mdict) 
    reload(module) 
    #return mdict 

Es gibt drei Unterschiede:

1. Im allgemeinen Fall, reload (Modul) hat am Ende der Funktion als auch genannt werden, wie @osa hingewiesen.
2. Mit zirkulären Importabhängigkeiten würde der Code, der früher veröffentlicht wurde, für immer loopen, also habe ich ein Wörterbuch von Listen hinzugefügt, um den Satz von Modulen zu verfolgen, die von anderen Modulen geladen werden. Während zirkuläre Abhängigkeiten nicht cool sind, erlaubt Python sie, so dass diese Reload-Funktion auch mit ihnen umgeht.
3. Ich habe eine Liste von Pfaden hinzugefügt (Standard ist ['']), von denen das Neuladen erlaubt ist. Einige Module wurden nicht wie üblich neu geladen (wie gezeigt here).

Answer 6

Ich fand die Antwort von redsk sehr nützlich. Ich schlage eine vereinfachte (für den Benutzer, nicht als Code) Version vor, wo der Pfad zum Modul automatisch gesammelt wird und die Rekursion für eine beliebige Anzahl von Ebenen funktioniert. Alles ist in sich in einer einzigen Funktion enthalten. Getestet auf Python 3.4. Ich denke, für Python 3.3 muss man reload() von imp anstelle von importlib importieren. Es überprüft auch, ob die Datei Datei vorhanden ist, die falsch sein kann, wenn der Coder vergisst, eine init.py Datei im Submodul zu definieren. In diesem Fall wird eine Ausnahme ausgelöst.

def rreload(module): 
    """ 
    Recursive reload of the specified module and (recursively) the used ones. 
    Mandatory! Every submodule must have an __init__.py file 
    Usage: 
     import mymodule 
     rreload(mymodule) 

    :param module: the module to load (the module itself, not a string) 
    :return: nothing 
    """ 

    import os.path 
    import sys 

    def rreload_deep_scan(module, rootpath, mdict=None): 
     from types import ModuleType 
     from importlib import reload 

     if mdict is None: 
      mdict = {} 

     if module not in mdict: 
      # modules reloaded from this module 
      mdict[module] = [] 
     # print("RReloading " + str(module)) 
     reload(module) 
     for attribute_name in dir(module): 
      attribute = getattr(module, attribute_name) 
      # print ("for attr "+attribute_name) 
      if type(attribute) is ModuleType: 
       # print ("typeok") 
       if attribute not in mdict[module]: 
        # print ("not int mdict") 
        if attribute.__name__ not in sys.builtin_module_names: 
         # print ("not a builtin") 
         # If the submodule is a python file, it will have a __file__ attribute 
         if not hasattr(attribute, '__file__'): 
          raise BaseException("Could not find attribute __file__ for module '"+str(attribute)+"'. Maybe a missing __init__.py file?") 

         attribute_path = os.path.dirname(attribute.__file__) 

         if attribute_path.startswith(rootpath): 
          # print ("in path") 
          mdict[module].append(attribute) 
          rreload_deep_scan(attribute, rootpath, mdict) 

    rreload_deep_scan(module, rootpath=os.path.dirname(module.__file__))