C'è un modo semplice per decapare una funzione python (o altrimenti serializzare il suo codice)?

Sto provando a trasferire una funzione attraverso una connessione di rete (usando asyncore). C'è un modo semplice per serializzare una funzione python (una che, almeno in questo caso, non avrà effetti collaterali) per un trasferimento come questo?

Idealmente mi piacerebbe avere un paio di funzioni simili a queste:

def transmit(func):
    obj = pickle.dumps(func)
    [send obj across the network]

def receive():
    [receive obj from the network]
    func = pickle.loads(s)
    func()

È possibile serializzare il bytecode della funzione e quindi ricostruirlo sul chiamante. Il modulo marshal può essere utilizzato per serializzare oggetti di codice, che possono quindi essere riassemblati in una funzione. cioè:

import marshal
def foo(x): return x*x
code_string = marshal.dumps(foo.func_code)

Quindi nel processo remoto (dopo aver trasferito code_string):

import marshal, types

code = marshal.loads(code_string)
func = types.FunctionType(code, globals(), "some_func_name")

func(10)  # gives 100

Alcuni avvertimenti:

• Il formato di marshal (qualsiasi bytecode python per quella materia) potrebbe non essere compatibile tra le principali versioni di python.

• Funzionerà solo per l'implementazione di cpython.

• Se la funzione fa riferimento a variabili globali (inclusi moduli importati, altre funzioni, ecc.) Che è necessario raccogliere, sarà necessario serializzare anche queste o ricrearle sul lato remoto. Il mio esempio fornisce solo lo spazio dei nomi globale del processo remoto.

• Probabilmente dovrai fare un po 'di più per supportare casi più complessi, come chiusure o funzioni del generatore.

Dai un'occhiata a Dill , che estende la libreria pickle di Python per supportare una maggiore varietà di tipi, comprese le funzioni:

>>> import dill as pickle
>>> def f(x): return x + 1
...
>>> g = pickle.dumps(f)
>>> f(1)
2
>>> pickle.loads(g)(1)
2

Supporta anche i riferimenti agli oggetti nella chiusura della funzione:

>>> def plusTwo(x): return f(f(x))
...
>>> pickle.loads(pickle.dumps(plusTwo))(1)
3

Pyro è in grado di farlo per te .

Il modo più semplice è probabilmente inspect.getsource(object)(vedere il modulo inspect ) che restituisce una stringa con il codice sorgente per una funzione o un metodo.

Tutto dipende dal fatto che si generi la funzione in fase di esecuzione o meno:

Se lo fai inspect.getsource(object), non funzionerà per le funzioni generate dinamicamente poiché ottiene l'origine dell'oggetto dal .pyfile, quindi solo le funzioni definite prima dell'esecuzione possono essere recuperate come origine.

E se le tue funzioni sono comunque inserite nei file, perché non dare al ricevitore l'accesso ad esse e passare solo i nomi dei moduli e delle funzioni.

L'unica soluzione per le funzioni create dinamicamente a cui posso pensare è costruire la funzione come una stringa prima della trasmissione, la sorgente di trasmissione e poi eval()dal lato del ricevitore.

Modifica: la marshalsoluzione sembra anche piuttosto intelligente, non sapevo che puoi serializzare qualcos'altro che non sia integrato

Il cloudpacchetto (pip install cloud) può pickle codice arbitrario, comprese le dipendenze. Vedi https://stackoverflow.com/a/16891169/1264797 .

code_string = '' '
def foo (x):
    return x * 2
def bar (x):
    return x ** 2
'' '

obj = pickle.dumps (code_string)

Adesso

exec (pickle.loads (obj))

foo (1)
> 2
bar (3)
> 9

Puoi farlo:

def fn_generator():
    def fn(x, y):
        return x + y
    return fn

Ora transmit(fn_generator())invierà la definizione effettiva fn(x,y)invece di un riferimento al nome del modulo.

Puoi usare lo stesso trucco per inviare classi attraverso la rete.

Le funzioni di base utilizzate per questo modulo coprono la tua query, inoltre ottieni la migliore compressione in rete; guarda il codice sorgente istruttivo:

y_serial.py module :: warehouse oggetti Python con SQLite

"Serializzazione + persistenza :: in poche righe di codice, comprime e annota oggetti Python in SQLite; quindi recuperali cronologicamente tramite parole chiave senza SQL. Modulo" standard "più utile per un database per memorizzare dati senza schema."

http://yserial.sourceforge.net

Cloudpickle è probabilmente quello che stai cercando. Cloudpickle è descritto come segue:

cloudpickle è particolarmente utile per il cluster computing in cui il codice Python viene spedito sulla rete per essere eseguito su host remoti, possibilmente vicini ai dati.

Esempio di utilizzo:

def add_one(n):
  return n + 1

pickled_function = cloudpickle.dumps(add_one)
pickle.loads(pickled_function)(42)

Ecco una classe helper che puoi usare per racchiudere le funzioni in modo da renderle selezionabili. marshalSi applicano gli avvertimenti già menzionati per , ma viene fatto uno sforzo per utilizzare il sottaceto quando possibile. Non viene fatto alcuno sforzo per preservare le globali o le chiusure attraverso la serializzazione.

    class PicklableFunction:
        def __init__(self, fun):
            self._fun = fun

        def __call__(self, *args, **kwargs):
            return self._fun(*args, **kwargs)

        def __getstate__(self):
            try:
                return pickle.dumps(self._fun)
            except Exception:
                return marshal.dumps((self._fun.__code__, self._fun.__name__))

        def __setstate__(self, state):
            try:
                self._fun = pickle.loads(state)
            except Exception:
                code, name = marshal.loads(state)
                self._fun = types.FunctionType(code, {}, name)