Existe-t-il un moyen simple de récupérer une fonction python (ou de sérialiser son code) ?

Question

J'essaie de transférer une fonction à travers une connexion réseau (en utilisant asyncore). Existe-t-il un moyen simple de sérialiser une fonction python (qui, dans ce cas au moins, n'aura pas d'effets secondaires) pour un transfert de ce type ?

J'aimerais idéalement avoir une paire de fonctions similaires à celles-ci :

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

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

Answer 1

Vous pourriez sérialiser le bytecode de la fonction et ensuite le reconstruire sur l'appelant. Le site maréchal peut être utilisé pour sérialiser des objets de code, qui peuvent ensuite être réassemblés dans une fonction, par exemple :

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

Puis dans le processus distant (après avoir transféré la chaîne de code) :

import marshal, types

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

func(10)  # gives 100

Quelques mises en garde :

• Le format de marshal (ou de tout autre bytecode python d'ailleurs) peut ne pas être compatible avec les principales versions de python.

• Ne fonctionnera que pour l'implémentation de cpython.

• Si la fonction fait référence à des éléments globaux (y compris des modules importés, d'autres fonctions, etc.) que vous devez récupérer, vous devrez également les sérialiser ou les recréer du côté distant. Mon exemple donne simplement l'espace de noms global du processus distant.

• Vous devrez probablement en faire un peu plus pour prendre en charge des cas plus complexes, comme les fermetures ou les fonctions génératrices.

Answer 2

Vérifiez Aneth qui étend la bibliothèque pickle de Python pour prendre en charge une plus grande variété de types, y compris les fonctions :

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

Il prend également en charge les références à des objets dans la fermeture de la fonction :

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

Answer 3

Pyro est capable de faire cela pour vous .

Answer 4

Le moyen le plus simple est probablement inspect.getsource(object) (voir le inspecter le module ) qui renvoie une chaîne de caractères contenant le code source d'une fonction ou d'une méthode.

Answer 5

Tout dépend si vous générez la fonction au moment de l'exécution ou non :

Si vous le faites - inspect.getsource(object) ne fonctionnera pas pour les fonctions générées dynamiquement puisqu'il récupère la source de l'objet à partir de .py de sorte que seules les fonctions définies avant l'exécution peuvent être récupérées comme source.

Et si vos fonctions sont de toute façon placées dans des fichiers, pourquoi ne pas donner au récepteur un accès à ces fichiers et ne transmettre que les noms de modules et de fonctions.

La seule solution pour les fonctions créées dynamiquement à laquelle je pense est de construire la fonction comme une chaîne de caractères avant la transmission, de transmettre la source, et ensuite eval() du côté du récepteur.

Edit : le marshal La solution semble également très intelligente, je ne savais pas que l'on pouvait sérialiser autre chose que les modules intégrés.