Existe uma maneira fácil de selecionar uma função Python (ou serializar seu código)?

Estou tentando transferir uma função através de uma conexão de rede (usando asyncore). Existe uma maneira fácil de serializar uma função Python (uma que, neste caso, pelo menos, não terá efeitos colaterais) para transferência como esta?

Idealmente, gostaria de ter um par de funções semelhantes 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()

Você poderia serializar o bytecode da função e, em seguida, reconstruí-lo no chamador. O módulo marshal pode ser usado para serializar objetos de código, que podem ser remontados em uma função. ie:

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

Então, no processo remoto (após transferir code_string):

import marshal, types

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

func(10)  # gives 100

Algumas advertências:

• O formato do marshal (qualquer bytecode python para esse assunto) pode não ser compatível entre as versões principais do python.

• Só funcionará para implementação de cpython.

• Se a função faz referência a globais (incluindo módulos importados, outras funções, etc.) que você precisa selecionar, será necessário serializá-los também ou recriá-los no lado remoto. Meu exemplo apenas fornece o namespace global do processo remoto.

• Você provavelmente precisará fazer um pouco mais para oferecer suporte a casos mais complexos, como encerramentos ou funções de gerador.

Confira Dill , que estende a biblioteca pickle do Python para oferecer suporte a uma grande variedade de tipos, incluindo funções:

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

Ele também oferece suporte a referências a objetos no encerramento da função:

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

O Pyro pode fazer isso por você .

A maneira mais simples é provavelmente inspect.getsource(object)(consulte o módulo inspect ) que retorna uma String com o código-fonte de uma função ou método.

Tudo depende se você gera a função em tempo de execução ou não:

Se você fizer isso - inspect.getsource(object)não funcionará para funções geradas dinamicamente, uma vez que obtém a fonte do objeto do .pyarquivo, portanto, apenas as funções definidas antes da execução podem ser recuperadas como fonte.

E se suas funções são colocadas em arquivos de qualquer maneira, por que não dar ao receptor acesso a eles e apenas passar nomes de módulos e funções.

A única solução para funções criadas dinamicamente que posso pensar é construir a função como uma string antes da transmissão, transmitir a fonte e, em seguida eval(), no lado do receptor.

Editar: a marshalsolução também parece muito inteligente, não sabia que você pode serializar algo que não seja integrado

O cloudpacote (pip install cloud) pode selecionar código arbitrário, incluindo dependências. Consulte https://stackoverflow.com/a/16891169/1264797 .

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

obj = pickle.dumps (code_string)

Agora

exec (pickle.loads (obj))

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

Você consegue fazer isso:

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

Agora, transmit(fn_generator())enviará a definição real de em fn(x,y)vez de uma referência ao nome do módulo.

Você pode usar o mesmo truque para enviar classes pela rede.

As funções básicas usadas para este módulo abrangem sua consulta, além de obter a melhor compactação durante a transmissão; veja o código fonte instrutivo:

y_serial.py module :: warehouse objetos Python com SQLite

"Serialização + persistência :: em algumas linhas de código, comprima e anote objetos Python em SQLite; depois recupere-os cronologicamente por palavras-chave sem qualquer SQL. Módulo" padrão "mais útil para um banco de dados para armazenar dados sem esquema."

http://yserial.sourceforge.net

Cloudpickle é provavelmente o que você está procurando. Cloudpickle é descrito da seguinte maneira:

cloudpickle é especialmente útil para computação em cluster, onde o código Python é enviado pela rede para ser executado em hosts remotos, possivelmente perto dos dados.

Exemplo de uso:

def add_one(n):
  return n + 1

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

Aqui está uma classe auxiliar que você pode usar para agrupar funções a fim de torná-las selecionáveis. As advertências já mencionadas para marshalserão aplicadas, mas um esforço é feito para usar picles sempre que possível. Nenhum esforço é feito para preservar globais ou encerramentos na serialização.

    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)