Есть ли простой способ обработать функцию Python (или иначе сериализовать ее код)?

Я пытаюсь передать функцию через сетевое соединение (используя asyncore). Есть ли простой способ сериализации функции Python (которая, по крайней мере, в этом случае не будет иметь побочных эффектов) для такой передачи?

В идеале я бы хотел иметь пару функций, подобных этим:

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

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

Вы можете сериализовать байт-код функции, а затем восстановить его в вызывающей стороне. Модуль маршалинга может использоваться для сериализации объектов кода, которые затем могут быть повторно собраны в функцию. то есть:

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

Затем в удаленном процессе (после передачи code_string):

import marshal, types

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

func(10)  # gives 100

Несколько предостережений:

• Формат маршала (любой байт-код Python в этом отношении) может быть несовместим между основными версиями Python.

• Будет работать только для реализации cpython.

• Если функция ссылается на глобальные объекты (включая импортированные модули, другие функции и т. Д.), Которые вам нужно подобрать, вам также необходимо сериализовать их или воссоздать их на удаленной стороне. В моем примере просто указано глобальное пространство имен удаленного процесса.

• Вероятно, вам нужно будет сделать немного больше для поддержки более сложных случаев, таких как замыкания или функции генератора.

Обратите внимание на Dill , который расширяет библиотеку pickle Python для поддержки большего количества типов, включая функции:

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

Он также поддерживает ссылки на объекты в закрытии функции:

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

Поджигатель может сделать это за вас .

Самый простой способ - это, вероятно inspect.getsource(object)(см. Модуль inspect ), который возвращает строку с исходным кодом для функции или метода.

Все зависит от того, генерируете ли вы функцию во время выполнения или нет:

Если вы это сделаете - inspect.getsource(object)не будет работать для динамически генерируемых функций, поскольку он получает источник объекта из .pyфайла, поэтому только функции, определенные до выполнения, могут быть извлечены в качестве источника.

И если ваши функции все равно помещаются в файлы, почему бы не предоставить доступ к ним получателю и передать только имена модулей и функций.

Единственное решение для динамически создаваемых функций, которое я могу придумать, - это создать функцию в виде строки перед передачей, источником передачи, а затем eval()на стороне приемника.

Изменить: marshalрешение выглядит также довольно умным, не знал, что вы можете сериализовать что-то другое, встроенное

cloudПакет (ПГИ установить облако) может законсервировать произвольный код, в том числе зависимостей. См. Https://stackoverflow.com/a/16891169/1264797 .

code_string = '' '
def foo (x):
    вернуть x * 2
def bar (x):
    возврат x ** 2
'' '

obj = pickle.dumps (строка_кода)

Сейчас

exec (pickle.loads (объект))

фу (1)
> 2
бар (3)
> 9

Ты можешь сделать это:

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

Теперь transmit(fn_generator())будет отправлено фактическое определение fn(x,y)вместо ссылки на имя модуля.

Вы можете использовать тот же прием для отправки классов по сети.

Основные функции, используемые для этого модуля, охватывают ваш запрос, плюс вы получаете наилучшее сжатие по сети; см. поучительный исходный код:

y_serial.py module :: складские объекты Python с SQLite

«Сериализация + постоянство :: в нескольких строках кода сжимайте и аннотируйте объекты Python в SQLite; а затем извлекайте их в хронологическом порядке по ключевым словам без какого-либо SQL. Самый полезный« стандартный »модуль для базы данных для хранения данных без схемы».

http://yserial.sourceforge.net

Cloudpickle , вероятно, то, что вы ищете. Облако описывается следующим образом:

cloudpickle особенно полезен для кластерных вычислений, когда код Python доставляется по сети для выполнения на удаленных хостах, возможно, рядом с данными.

Пример использования:

def add_one(n):
  return n + 1

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

Вот вспомогательный класс, который вы можете использовать для обертывания функций, чтобы сделать их доступными для выбора. Уже упомянутые предостережения marshalприменимы, но по возможности стараемся использовать рассол. Не прилагается никаких усилий для сохранения глобальных объектов или замыканий при сериализации.

    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)