def test_with_complex_line_in_source_code(self):
pickled_f1, pickled_f2 = self.dummy_method(pickleable(lambda x: x + 1), pickleable(lambda x, y: x + y)) # pylint: disable=line-too-long
f1 = pickle.loads(pickled_f1)
f2 = pickle.loads(pickled_f2)
self.assertEqual(3, f1(2))
self.assertEqual(5, f2(2, 3))
def test_with_super_complex_line_in_source_code(self):
pickled_f1, pickled_f2 = self.dummy_method(pickleable(lambda size: [int(y) for y in [str(x) for x in range(size) if x % 2 == 0]]), pickleable(lambda x, y: x + y)) # pylint: disable=line-too-long
f1 = pickle.loads(pickled_f1)
f2 = pickle.loads(pickled_f2)
self.assertEqual([0, 2, 4, 6, 8], f1(9))
self.assertEqual(5, f2(2, 3))
def test():
"""Lambda send as pickled object."""
lam = lambda x: [print(y) for y in range(int(x))]
proc = Process(target=pickleable(lam), args=(int(1e4), ))
proc.start()
print("process started...")
proc.join()
print("process finished")
def test_make_partial_func_pickleable_not_raise_err(self):
partial_func = partial(incr, x=2)
proxy = pickleable(partial_func)
self.assertEqual(3, proxy())
def test_make_class_method_pickleable_not_raise_err(self):
proxy = pickleable(self.dummy_func)
self.assertEqual(3, proxy(2))
def test_make_func_pickleable_not_raise_err(self):
proxy = pickleable(incr)
self.assertEqual(3, proxy(2))
def __init__(self, release_buffer_func):
super().__init__()
self._state = {}
self._release_buffer = pickleable(release_buffer_func)
def __init__(self, func=None):
super().__init__()
self._func = pickleable(func)
def test_use_func_in_lambda(self):
pickled_f1, _ = self.dummy_method(pickleable(lambda y: incr(y)))
f1 = pickle.loads(pickled_f1)
self.assertEqual(3, f1(2))
def __init__(self, key_func=None, reverse=False):
super().__init__()
self._store = []
self._key_func = pickleable(key_func)
self._reverse = reverse
from pickleablelambda import pickleable
import pickle
L = lambda x: x+1
print("L(10)=" + str(L(10)))
with open('lambda.pickle', 'wb') as f:
pickle.dump(pickleable(L), f)
def __init__(self, init_value_func, new_value_func):
super().__init__()
self._init_value_func = pickleable(init_value_func)
self._new_value_func = pickleable(new_value_func)
self._state = {}
def __init__(self, stop_condition=None, sleep_sec=5):
super().__init__()
self._stop_condition = pickleable(stop_condition)
self._num_iteration = 0 #no worries! int will switch to long once it will exceed int max size
self._sleep_sec = sleep_sec
def __init__(self, on_data=None, on_completed=None, on_error=None):
super().__init__()
self._on_data = pickleable(on_data)
self._on_completed = pickleable(on_completed)
self._on_error = pickleable(on_error)
def test_make_partial_func_2args_pickleable_not_raise_err(self):
partial_func = partial(mysum, y=2)
proxy = pickleable(partial_func)
self.assertEqual(3, proxy(1))
def test_pickle_with_lamdba_proxy(self):
lmb = lambda x: x + 1
pickle_bin = pickle.dumps(pickleable(lmb))
lmb2 = pickle.loads(pickle_bin)
self.assertEqual(lmb(10), lmb2(10))
self.assertTrue(isinstance(lmb2, types.FunctionType))
def test_use_lambda_proxy(self):
lmb = lambda x: x + 1
proxy = pickleable(lmb)
self.assertEqual(lmb(100), proxy(100))
def test_with_nested_lambdas(self):
#wired nested lambda calculus
pickled_f1, _ = self.dummy_method(
pickleable(lambda F, m: lambda x: F(x) * m))
f1 = pickle.loads(pickled_f1)
self.assertEqual(12, f1(lambda x: x**2, 3)(2))
def test_use_lambda_proxy_2_args(self):
lmb = lambda x, y: x + y
proxy = pickleable(lmb)
self.assertEqual(lmb(100, 200), proxy(100, 200))
def __init__(self, map_func, _filter_func):
super().__init__()
self._map = pickleable(map_func)
self._filter = pickleable(_filter_func)
def test_use_lambda_second_order_equation(self):
lmb = lambda x: 5 * x**2 + 3 * x + 4
proxy = pickleable(lmb)
self.assertEqual(lmb(2), proxy(2))
def __init__(self, func=lambda x: x):
super().__init__()
self._func = pickleable(func)
def __init__(self, split_func):
super().__init__()
self._split_func = pickleable(split_func)
self._template = None #pypeline.root()
self._parallel_jobs = {}
self._collector = None
