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