Gibt es eine einfache Möglichkeit, eine Python-Funktion auszuwählen (oder ihren Code auf andere Weise zu serialisieren)?

Ich versuche, eine Funktion über eine Netzwerkverbindung zu übertragen (mit Asyncore). Gibt es eine einfache Möglichkeit, eine Python-Funktion (eine, die zumindest in diesem Fall keine Nebenwirkungen hat) für eine solche Übertragung zu serialisieren?

Idealerweise hätte ich gerne ein paar ähnliche Funktionen:

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

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

Sie können den Funktionsbytecode serialisieren und dann auf dem Aufrufer rekonstruieren. Das Marshall- Modul kann zum Serialisieren von Codeobjekten verwendet werden, die dann wieder zu einer Funktion zusammengesetzt werden können. dh:

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

Dann im Remote-Prozess (nach der Übertragung von code_string):

import marshal, types

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

func(10)  # gives 100

Ein paar Einschränkungen:

• Das Marshall-Format (ein beliebiger Python-Bytecode) ist möglicherweise nicht mit den wichtigsten Python-Versionen kompatibel.

• Funktioniert nur für die cpython-Implementierung.

• Wenn die Funktion auf globale Elemente (einschließlich importierter Module, anderer Funktionen usw.) verweist, die Sie abrufen müssen, müssen Sie diese ebenfalls serialisieren oder auf der Remote-Seite neu erstellen. In meinem Beispiel wird nur der globale Namespace des Remote-Prozesses angegeben.

• Sie müssen wahrscheinlich etwas mehr tun, um komplexere Fälle wie Schließungen oder Generatorfunktionen zu unterstützen.

Schauen Sie sich Dill an , das die Pickle-Bibliothek von Python erweitert, um eine größere Vielfalt von Typen zu unterstützen, einschließlich Funktionen:

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

Es werden auch Verweise auf Objekte beim Schließen der Funktion unterstützt:

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

Pyro kann das für Sie tun .

Der einfachste Weg ist wahrscheinlich inspect.getsource(object)(siehe das Inspect-Modul ), einen String mit dem Quellcode für eine Funktion oder eine Methode zurückzugeben.

Es hängt alles davon ab, ob Sie die Funktion zur Laufzeit generieren oder nicht:

Wenn Sie dies tun inspect.getsource(object), funktioniert dies nicht für dynamisch generierte Funktionen, da die Quelle des Objekts aus der .pyDatei abgerufen wird. Daher können nur Funktionen, die vor der Ausführung definiert wurden, als Quelle abgerufen werden.

Und wenn Ihre Funktionen ohnehin in Dateien abgelegt sind, können Sie dem Empfänger Zugriff darauf gewähren und nur Modul- und Funktionsnamen weitergeben.

Die einzige Lösung für dynamisch erstellte Funktionen, die ich mir vorstellen kann, besteht darin, die Funktion vor der Übertragung als Zeichenfolge zu konstruieren, die Quelle zu senden und dann eval()auf der Empfängerseite.

Bearbeiten: Die marshalLösung sieht auch ziemlich schlau aus, wusste nicht, dass Sie etwas anderes als eingebaute serialisieren können

Das cloudPaket (pip install cloud) kann beliebigen Code einschließlich Abhängigkeiten auswählen. Siehe 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)

Jetzt

exec (pickle.loads (obj))

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

Du kannst das:

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

Jetzt transmit(fn_generator())wird fn(x,y)anstelle eines Verweises auf den Modulnamen die eigentliche Definition von gesendet .

Mit demselben Trick können Sie Klassen über das Netzwerk senden.

Die für dieses Modul verwendeten Grundfunktionen decken Ihre Abfrage ab, und Sie erhalten die beste Komprimierung über das Kabel. Siehe den lehrreichen Quellcode:

y_serial.py module :: warehouse Python-Objekte mit SQLite

"Serialisierung + Persistenz :: Komprimieren und kommentieren Sie Python-Objekte in wenigen Codezeilen in SQLite und rufen Sie sie später chronologisch nach Schlüsselwörtern ohne SQL ab. Das nützlichste" Standard "-Modul für eine Datenbank zum Speichern schemaloser Daten."

http://yserial.sourceforge.net

Cloudpickle ist wahrscheinlich das, wonach Sie suchen. Cloudpickle wird wie folgt beschrieben:

Cloudpickle ist besonders nützlich für Cluster-Computing, bei dem Python-Code über das Netzwerk gesendet wird, um auf Remote-Hosts ausgeführt zu werden, möglicherweise in der Nähe der Daten.

Anwendungsbeispiel:

def add_one(n):
  return n + 1

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

Hier ist eine Hilfsklasse, mit der Sie Funktionen umbrechen können, um sie auswählbar zu machen. Die bereits erwähnten Vorsichtsmaßnahmen marshalgelten, es wird jedoch versucht, nach Möglichkeit Gurke zu verwenden. Es werden keine Anstrengungen unternommen, um Globale oder Verschlüsse während der Serialisierung zu erhalten.

    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)