¿Existe una manera fácil de seleccionar una función de Python (o serializar su código)?

Estoy tratando de transferir una función a través de una conexión de red (usando asyncore). ¿Existe una manera fácil de serializar una función de Python (una que, al menos en este caso, no tendrá efectos secundarios) para una transferencia como esta?

Idealmente, me gustaría tener un par de funciones similares a estas:

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

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

Puede serializar el código de bytes de la función y luego reconstruirlo en la persona que llama. El módulo marshal se puede utilizar para serializar objetos de código, que luego se pueden volver a ensamblar en una función. es decir:

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

Luego, en el proceso remoto (después de transferir code_string):

import marshal, types

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

func(10)  # gives 100

Algunas advertencias:

• El formato de marshal (cualquier código de bytes de Python para el caso) puede no ser compatible entre las principales versiones de Python.

• Solo funcionará para la implementación de cpython.

• Si la función hace referencia a globales (incluidos módulos importados, otras funciones, etc.) que necesita recoger, deberá serializarlos también o recrearlos en el lado remoto. Mi ejemplo simplemente le da el espacio de nombres global del proceso remoto.

• Probablemente deba hacer un poco más para admitir casos más complejos, como cierres o funciones de generador.

Consulte Dill , que amplía la biblioteca pickle de Python para admitir una mayor variedad de tipos, incluidas funciones:

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

También admite referencias a objetos en el cierre de la función:

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

Pyro puede hacer esto por usted .

La forma más sencilla es probablemente inspect.getsource(object)(ver el módulo de inspección ) que devuelve una cadena con el código fuente de una función o método.

Todo depende de si genera la función en tiempo de ejecución o no:

Si lo hace inspect.getsource(object), no funcionará para funciones generadas dinámicamente, ya que obtiene la fuente del objeto del .pyarchivo, por lo que solo las funciones definidas antes de la ejecución se pueden recuperar como fuente.

Y si sus funciones se colocan en archivos de todos modos, ¿por qué no dar acceso al receptor a ellas y solo pasar los nombres de los módulos y las funciones?

La única solución para las funciones creadas dinámicamente que se me ocurre es construir la función como una cadena antes de la transmisión, la fuente de transmisión y luego eval() en el lado del receptor.

Editar: la marshalsolución también parece bastante inteligente, no sabía que podía serializar algo más que los incorporados

El cloudpaquete (pip install cloud) puede seleccionar código arbitrario, incluidas las dependencias. Consulte https://stackoverflow.com/a/16891169/1264797 .

cadena_código = '' '
def foo (x):
    devolver x * 2
def bar (x):
    volver x ** 2
'' '

obj = pickle.dumps (cadena_código)

Ahora

exec (pickle.loads (obj))

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

Puedes hacerlo:

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

Ahora, transmit(fn_generator())enviará la definición real de en fn(x,y)lugar de una referencia al nombre del módulo.

Puede utilizar el mismo truco para enviar clases a través de la red.

Las funciones básicas utilizadas para este módulo cubren su consulta, además de que obtiene la mejor compresión por cable; ver el código fuente instructivo:

Módulo y_serial.py :: almacén de objetos Python con SQLite

"Serialización + persistencia :: en unas pocas líneas de código, comprima y anote objetos Python en SQLite; luego recupérelos cronológicamente por palabras clave sin SQL. El módulo" estándar "más útil para una base de datos para almacenar datos sin esquema".

http://yserial.sourceforge.net

Cloudpickle es probablemente lo que estás buscando. Cloudpickle se describe de la siguiente manera:

cloudpickle es especialmente útil para la computación en clúster donde el código Python se envía a través de la red para ejecutarse en hosts remotos, posiblemente cerca de los datos.

Ejemplo de uso:

def add_one(n):
  return n + 1

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

Aquí hay una clase de ayuda que puede usar para ajustar funciones a fin de hacerlas seleccionables. Se marshalaplicarán las advertencias ya mencionadas , pero se hace un esfuerzo para usar pickle siempre que sea posible. No se hace ningún esfuerzo para preservar globales o cierres a través de la serialización.

    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)