Cercando di stampare ogni sottomodulo all'interno di un modulo in python

Question

scusate se ho sbagliato alcuni dati durante questo, ma ho solo programmato per circa un anno, da quando ho iniziato un corso di informatica nella mia scuola, e mi dispiace se questa domanda è stata ho risposto prima di aver cercato ovunque ma non so cosa cercare. Recentemente ho trovato un gioco in cui è possibile utilizzare un iniettore per iniettare codice Python in esso, ma l'unico modo di trovare i codici è quello di utilizzare:

import modulename 
    print dir(modulename) 

e poi stampa dir (modulename.submodulename)

Quale stampa tutti i sottomoduli all'interno di quel modulo nel file di registro del gioco. Usando questa tecnica ho sviluppato uno script che, una volta eseguito, troverà tutti i sottomoduli in quella directory e li scriverà in un file.

import modulename 

myfile=open("name.txt","w") 
myfile.write("modulename\n") 

for a in dir(modulename): 
    a="modulename"+"."+a 
    for b in dir(a): 
     b=a+"."+b 
     for c in dir(b): 
      c=b+"."+c 
      if ".__" in c: 
       pass 
      elif "._" in c: 
       pass 
      else: 
       myfile.write(c+"\n") 
     if ".__" in b: 
      pass 
     if "._" in b: 
      pass 
     else: 
      myfile.write(b+"\n") 
    if ".__" in a: 
     pass 
    if "._" in a: 
     pass 
    else: 
     myfile.write(a+"\n") 

print "Done" 
myfile.close() 

Sfortunatamente quando si esegue "something.qualcosa" passato i moduli non esistono. Ecco un esempio per il modulo "Random" in cui "random.weibullvariate" è un modulo reale ma qualcosa oltre il secondo "." non è nei sottomoduli casuali.

random.weibullvariate.title.translate 
random.weibullvariate.title.upper 
random.weibullvariate.title.zfill 
random.weibullvariate.title 
random.weibullvariate.translate.capitalize 
random.weibullvariate.translate.center 
random.weibullvariate.translate.count 
random.weibullvariate.translate.decode 
random.weibullvariate.translate.encode 
random.weibullvariate.translate.endswith 
random.weibullvariate.translate.expandtabs 
random.weibullvariate.translate.find 
random.weibullvariate.translate.format 
random.weibullvariate.translate.index 
random.weibullvariate.translate.isalnum 
random.weibullvariate.translate.isalpha 
random.weibullvariate.translate.isdigit 
random.weibullvariate.translate.islower 
random.weibullvariate.translate.isspace 
random.weibullvariate.translate.istitle 
random.weibullvariate.translate.isupper 
random.weibullvariate.translate.join 
random.weibullvariate.translate.ljust 
random.weibullvariate.translate.lower 
random.weibullvariate.translate.lstrip 
random.weibullvariate.translate.partition 
random.weibullvariate.translate.replace 
random.weibullvariate.translate.rfind 
random.weibullvariate.translate.rindex 
random.weibullvariate.translate.rjust 
random.weibullvariate.translate.rpartition 
random.weibullvariate.translate.rsplit 
random.weibullvariate.translate.rstrip 
random.weibullvariate.translate.split 
random.weibullvariate.translate.splitlines 
random.weibullvariate.translate.startswith 
random.weibullvariate.translate 

Come si può vedere ci sono dei sottomoduli inseriti che non esistono in "random". Ho finito per capire qual è il problema, ma non ho esperienza sufficiente per risolvere il problema.

Il problema è che utilizzando le prime 2 linee come esempio

for a in dir(modulename): 
    a="module name"+"."+a 

se ho fatto un "modulename.submodule" Come si può vedere "a" è una stringa, e se poi metti "a" in una "dir()" quindi la stessa cosa verrebbe restituita indipendentemente dal nome del sottomodulo.

Devo trovare un modo per aggiungere il sottomodulo al nome dei moduli precedenti con un "." in mezzo senza trasformarlo in una stringa.

Ci scusiamo per il post lungo, qualcuno ha qualche idea?

Answer 1

import types 

def list_modules(module_name): 
    try: 
     module = __import__(module_name, globals(), locals(), [module_name.split('.')[-1]]) 
    except ImportError: 
     return 
    print(module_name) 
    for name in dir(module): 
     if type(getattr(module, name)) == types.ModuleType: 
      list_modules('.'.join([module_name, name])) 

Non è possibile affermare che funzionerà in tutti i casi, ma vale la pena provare?