Apakah ada cara mudah untuk membuat acar fungsi python (atau membuat serial kodenya)?

Saya mencoba mentransfer fungsi melalui koneksi jaringan (menggunakan asyncore). Apakah ada cara mudah untuk membuat serial fungsi python (yang, setidaknya dalam kasus ini, tidak akan berpengaruh samping) untuk transfer seperti ini?

Idealnya saya ingin memiliki sepasang fungsi yang mirip dengan ini:

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

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

Anda dapat membuat kode bytecode fungsi dan kemudian menyusunnya kembali pada pemanggil. The marshal modul dapat digunakan untuk benda kode deserialisasi, yang kemudian dapat kembali ke dalam fungsi. yaitu:

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

Kemudian dalam proses jarak jauh (setelah mentransfer code_string):

import marshal, types

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

func(10)  # gives 100

Beberapa peringatan:

• format marshal (semua bytecode python dalam hal ini) mungkin tidak cocok antara versi python utama.

• Hanya akan berfungsi untuk implementasi cpython.

• Jika fungsi mereferensikan global (termasuk modul yang diimpor, fungsi lain, dll) yang perlu Anda ambil, Anda perlu membuat serial ini juga, atau membuatnya kembali di sisi jarak jauh. Contoh saya hanya memberikan namespace global proses jarak jauh.

• Anda mungkin perlu melakukan sedikit lebih banyak untuk mendukung kasus yang lebih kompleks, seperti penutupan atau fungsi generator.

Lihat Dill , yang memperluas pustaka acar Python untuk mendukung lebih banyak jenis, termasuk fungsi:

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

Ini juga mendukung referensi ke objek dalam penutupan fungsi:

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

Pyro dapat melakukan ini untuk Anda .

Cara yang paling sederhana mungkin inspect.getsource(object)(lihat modul inspeksi ) yang mengembalikan String dengan kode sumber untuk suatu fungsi atau metode.

Itu semua tergantung pada apakah Anda membuat fungsi saat runtime atau tidak:

Jika Anda melakukannya - inspect.getsource(object)tidak akan berfungsi untuk fungsi yang dibuat secara dinamis karena ia mendapatkan sumber objek dari .pyfile, jadi hanya fungsi yang ditentukan sebelum eksekusi yang dapat diambil sebagai sumber.

Dan jika fungsi Anda ditempatkan dalam file, mengapa tidak memberikan akses kepada penerima dan hanya menyebarkan nama modul dan fungsi.

Satu-satunya solusi untuk fungsi yang dibuat secara dinamis yang dapat saya pikirkan adalah membangun fungsi sebagai string sebelum transmisi, mengirimkan sumber, dan kemudian eval()di sisi penerima.

Sunting: marshalsolusinya terlihat juga cukup pintar, tidak tahu Anda dapat membuat serialisasi sesuatu yang lain yang ada di dalamnya

The cloudpaket (pip install awan) dapat acar kode sewenang-wenang, termasuk dependensi. Lihat https://stackoverflow.com/a/16891169/1264797 .

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

obj = pickle.dumps (code_string)

Sekarang

exec (pickle.loads (obj))

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

Kamu bisa melakukan ini:

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

Sekarang, transmit(fn_generator())akan mengirimkan definisi sebenarnya dari fn(x,y)alih-alih referensi ke nama modul.

Anda dapat menggunakan trik yang sama untuk mengirim kelas melalui jaringan.

Fungsi dasar yang digunakan untuk modul ini mencakup kueri Anda, ditambah lagi Anda mendapatkan kompresi terbaik; lihat kode sumber instruktif:

y_serial.py module :: gudang objek Python dengan SQLite

"Serialization + persistance :: dalam beberapa baris kode, kompres dan beri anotasi objek Python ke dalam SQLite; kemudian ambil secara kronologis dengan kata kunci tanpa SQL. Modul" standar "yang paling berguna untuk database untuk menyimpan data tanpa skema."

http://yserial.sourceforge.net

Cloudpickle mungkin adalah yang Anda cari. Cloudpickle dijelaskan sebagai berikut:

cloudpickle sangat berguna untuk komputasi cluster di mana kode Python dikirim melalui jaringan untuk dieksekusi pada host jarak jauh, mungkin dekat dengan data.

Contoh penggunaan:

def add_one(n):
  return n + 1

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

Berikut adalah kelas helper yang dapat Anda gunakan untuk menggabungkan fungsi agar dapat dipilih. Peringatan yang telah disebutkan untuk marshalakan berlaku tetapi diusahakan untuk menggunakan acar bila memungkinkan. Tidak ada upaya yang dilakukan untuk melestarikan global atau penutupan di seluruh serialisasi.

    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)