Czy istnieje łatwy sposób na wytrawienie funkcji Pythona (lub w inny sposób serializowanie jej kodu)?

Próbuję przenieść funkcję przez połączenie sieciowe (przy użyciu asyncore). Czy istnieje łatwy sposób serializacji funkcji Pythona (takiej, która przynajmniej w tym przypadku nie będzie miała żadnych skutków ubocznych) do takiego transferu?

Idealnie chciałbym mieć parę funkcji podobnych do tych:

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

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

Możesz serializować kod bajtowy funkcji, a następnie zrekonstruować go w obiekcie wywołującym. Marszałek moduł może być stosowane do przedmiotów uszeregować kodów, które mogą być ponownie zmontowane w funkcji. to znaczy:

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

Następnie w procesie zdalnym (po przesłaniu code_string):

import marshal, types

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

func(10)  # gives 100

Kilka zastrzeżeń:

• Format marszałka (w tym przypadku dowolny kod bajtowy Pythona) może nie być kompatybilny między głównymi wersjami Pythona.

• Działa tylko w przypadku implementacji cpython.

• Jeśli funkcja odwołuje się do elementów globalnych (w tym zaimportowanych modułów, innych funkcji itp.), Które musisz odebrać, musisz je również serializować lub odtworzyć po stronie zdalnej. Mój przykład podaje tylko globalną przestrzeń nazw zdalnego procesu.

• Prawdopodobnie będziesz musiał zrobić trochę więcej, aby obsługiwać bardziej złożone przypadki, takie jak zamknięcia lub funkcje generatora.

Sprawdź Dill , który rozszerza bibliotekę pickle Pythona o obsługę większej liczby typów, w tym funkcji:

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

Obsługuje również odniesienia do obiektów w zamknięciu funkcji:

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

Pyro jest w stanie zrobić to za Ciebie .

Najprostszym sposobem jest prawdopodobnie inspect.getsource(object)(zobacz moduł inspect ), który zwraca String z kodem źródłowym funkcji lub metody.

Wszystko zależy od tego, czy generujesz funkcję w czasie wykonywania, czy nie:

Jeśli to zrobisz - inspect.getsource(object)nie będzie działać dla funkcji generowanych dynamicznie, ponieważ pobiera źródło obiektu z .pypliku, więc jako źródło można pobrać tylko funkcje zdefiniowane przed wykonaniem.

A jeśli twoje funkcje i tak są umieszczone w plikach, dlaczego nie dać odbiorcom dostępu do nich i przekazywać tylko nazwy modułów i funkcji.

Jedynym rozwiązaniem dla dynamicznie tworzonych funkcji, które przychodzi mi do głowy, jest skonstruowanie funkcji jako łańcucha przed transmisją, nadaniem źródła, a następnie eval()po stronie odbiornika.

Edycja: marshalrozwiązanie wygląda również całkiem sprytnie, nie wiedziałem, że możesz serializować coś innego niż wbudowane

cloudPakiet (PIP zainstalować chmurę) może marynowane dowolnego kodu, w tym zależności. Zobacz https://stackoverflow.com/a/16891169/1264797 .

code_string = '' '
def foo (x):
    powrót x * 2
def bar (x):
    powrót x ** 2
'' '

obj = pickle.dumps (ciąg_kodowy)

Teraz

exec (pickle.loads (obj))

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

Możesz to zrobić:

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

Teraz transmit(fn_generator())wyśle ​​rzeczywistą definicję fn(x,y)zamiast odniesienia do nazwy modułu.

Możesz użyć tej samej sztuczki do wysyłania klas przez sieć.

Podstawowe funkcje używane w tym module obejmują zapytanie, a ponadto zapewniają najlepszą kompresję w sieci; zobacz pouczający kod źródłowy:

y_serial.py module :: hurtownia obiektów Pythona z SQLite

„Serializacja + trwałość: w kilku linijkach kodu skompresuj i dodaj adnotacje do obiektów Pythona do SQLite, a następnie odzyskaj je chronologicznie za pomocą słów kluczowych bez żadnego SQL. Najbardziej przydatny„ standardowy ”moduł bazy danych do przechowywania danych bez schematu.”

http://yserial.sourceforge.net

Cloudpickle jest prawdopodobnie tym, czego szukasz. Cloudpickle jest opisana w następujący sposób:

Cloudpickle jest szczególnie przydatna do przetwarzania w klastrach, w przypadku których kod Pythona jest wysyłany przez sieć w celu wykonania na zdalnych hostach, prawdopodobnie blisko danych.

Przykład użycia:

def add_one(n):
  return n + 1

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

Oto klasa pomocnicza, której możesz użyć do zawijania funkcji, aby były one pikowalne. Zastrzeżenia, o których już wspomniano, marshalbędą miały zastosowanie, ale staramy się używać marynaty, gdy tylko jest to możliwe. Nie podejmuje się żadnych wysiłków, aby zachować wartości globalne lub zamknięcia podczas serializacji.

    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)