Come sovrascrivere un'importazione Python?

Question

Sto lavorando su pypreprocessor che è un preprocessore che prende le direttive in stile c e sono riuscito a farlo funzionare come un preprocessore tradizionale (è auto-consumante ed esegue il codice postelaborato al volo) eccetto che rompe le importazioni della biblioteca.

Il problema è: il preprocessore esegue il file, lo elabora, restituisce un file temporaneo ed exec() il file temporaneo. Le librerie importate devono essere gestite in modo un po 'diverso, perché non vengono eseguite, ma vengono caricate e rese accessibili al modulo chiamante.

Quello che devo essere in grado di fare è: Interrompere l'importazione (dal momento che il preprocessore viene eseguito nel mezzo dell'importazione), caricare il codice postelaborato come tempModule e sostituire l'importazione originale con tempModule per ingannare lo script chiamante con l'importazione a credere che tempModule sia il modulo originale.

Ho cercato dappertutto e finora e non ho soluzione.

Questo Stack Overflow domanda è la più vicina che ho visto finora a fornire una risposta: Override namespace in Python

Ecco quello che ho.

# Remove the bytecode file created by the first import 
os.remove(moduleName + '.pyc') 

# Remove the first import 
del sys.modules[moduleName] 

# Import the postprocessed module 
tmpModule = __import__(tmpModuleName) 

# Set first module's reference to point to the preprocessed module 
sys.modules[moduleName] = tmpModule 

moduleName è il nome del modulo originale e tmpModuleName è il nome del file di codice postelaborato.

La parte strana è che questa soluzione è ancora completamente normale come se il primo modulo fosse stato completato correttamente; a meno che non si rimuova l'ultima riga, si ottiene un errore non trovato nel modulo.

Speriamo che qualcuno su Stack   Overflow conosca molto di più sulle importazioni di me, perché questo mi ha bloccato.

Nota: assegnerò solo una soluzione o, se ciò non è possibile in Python; la spiegazione migliore e più dettagliata del perché questo non è impossibile.

Aggiornamento: per chiunque sia interessato, ecco il codice di lavoro.

if imp.lock_held() is True: 
    del sys.modules[moduleName] 
    sys.modules[tmpModuleName] = __import__(tmpModuleName) 
    sys.modules[moduleName] = __import__(tmpModuleName) 

La parte 'imp.lock_held' rileva se il modulo viene caricato come libreria. Le seguenti linee fanno il resto.

Answer 1

Questo risponde alla tua domanda? La seconda importazione fa il trucco.

Mod_1.py

def test_function(): 
    print "Test Function -- Mod 1" 

Mod_2.py

def test_function(): 
    print "Test Function -- Mod 2" 

test.py

#!/usr/bin/python 

import sys 

import Mod_1 

Mod_1.test_function() 

del sys.modules['Mod_1'] 

sys.modules['Mod_1'] = __import__('Mod_2') 

import Mod_1 

Mod_1.test_function() 

Answer 2

Approccio molto strano - per emulare il linguaggio di basso livello con quello di alto livello. Se il primo modo semplice non funziona, potrebbe essere un obiettivo sbagliato?

BTW, il preprocessore C funziona semplicemente con file di testo e un set di variabili del preprocessore, non moduli caricati/scaricati di alto livello.

Answer 3

Per definire un comportamento di importazione diverso o per sovvertire completamente il processo di importazione, è necessario scrivere ganci di importazione. Vedi PEP 302.

Ad esempio,

import sys 

class MyImporter(object): 

    def find_module(self, module_name, package_path): 
     # Return a loader 
     return self 

    def load_module(self, module_name): 
     # Return a module 
     return self 

sys.meta_path.append(MyImporter()) 

import now_you_can_import_any_name 
print now_you_can_import_any_name 

Produce:

<__main__.MyImporter object at 0x009F85F0> 

Quindi sostanzialmente restituisce un nuovo modulo (che può essere qualsiasi oggetto), in questo caso per sé. È possibile utilizzarlo per modificare il comportamento di importazione restituendo processe_xxx all'importazione di xxx.

IMO: Python non ha bisogno di un preprocessore. Qualunque cosa si sta realizzando può essere realizzato in Python per sé a causa di essa la natura molto dinamica, per esempio, prendendo il caso dell'esempio di debug, ciò che è sbagliato con avere in cima alla lima

debug = 1 

e successivamente

if debug: 
    print "wow" 

?

Answer 4

In Python 2 c'è il modulo imputil che sembra fornire la funzionalità che si sta cercando, ma è stato rimosso in python 3. Non è molto ben documentato ma contiene una sezione di esempio che mostra come è possibile sostituire l'importazione standard funzioni.

Per Python 3 è disponibile il modulo importlib (introdotto in Python 3.1) che contiene funzioni e classi per modificare la funzionalità di importazione in tutti i modi. Dovrebbe essere adatto per collegare il preprocessore al sistema di importazione.