def test_pipe_valve_non_iterable(self): data_1 = 4, 2, 8, -5 data_1_min = min(data_1) data_2 = () # test method that directly passes the data through Pipe.add_map_method(lambda val: val, 'pass_through') # min Pipe.add_method(min, is_valve=True, empty_error=ValueError) ''' The Pipe has been preloaded and a valve has been added to the pipe. When the preloaded and a valve is added the reservoir should be drained by the pipe into the valve function and the result should be returned. ''' self.assertEqual( Pipe(data_1).min(), data_1_min ) self.assertEqual( Pipe(data_1).pass_through().min(), data_1_min ) ''' Pipe has not been preloaded and a Pipe should be returned. ''' pipe_1 = Pipe().min() self.assertEqual(pipe_1(data_1), data_1_min) self.assertEqual(pipe_1(data_1), data_1_min) # not a repeat pipe_2 = Pipe().pass_through().min() self.assertEqual(pipe_2(data_1), data_1_min) self.assertEqual(pipe_2(data_1), data_1_min) # not a repeat pip_3 = Pipe().min().pass_through() self.assertEqual(next(pip_3(data_1)), data_1_min) pip_4 = Pipe().min().min() self.assertEqual(pipe_1(data_1), data_1_min) pipe_5 = pipe_1.pass_through() self.assertEqual( next(pipe_5(data_1)), next(pip_3(data_1)) ) pipe_6 = pipe_1.min() self.assertEqual( pipe_6(data_1), pip_4(data_1) ) # empty preloaded iterator with self.assertRaises(ValueError): print(Pipe(data_2).min())
def test_init_next_iter(self): Pipe.add_map_method(lambda a: a**2, 'square') data_1 = (1, 2), (3, 4), (5, 6) drip_1 = Drip() res_1 = Reservoir(data_1) pipe_1 = Pipe(reservoir=drip_1).square() result_1 = tuple((a, b**2) for a, b in data_1) def carry_key(key_val): return key_val[0], key_val[1] def re_key(key, bypass_val): return key, bypass_val bpp = Bypass( bypass=pipe_1, iterable=res_1, drip_handle=drip_1, split=carry_key, merge=re_key, ) self.assertEqual(tuple(bpp), result_1)
def test_add_map_method(self): data_1 = 1, 2, 7, 9 data_2 = (1, 2), (3, 4) data_3 = dict(a=1, b=2), dict(a=3, b=4) Pipe.add_map_method(lambda a: a**2, 'square') self.assertEqual( tuple(Pipe(data_1).square()), tuple(d**2 for d in data_1) ) # method call includes a value Pipe.add_map_method(min) self.assertEqual( tuple(Pipe(data_1).min(5, key=lambda a: 1 / a)), (5, 5, 7, 9) ) self.assertEqual( tuple(Pipe(data_2).min()), (1, 3) ) self.assertEqual( tuple(Pipe(data_2).min(key=lambda a: 1 / a)), (2, 4) ) # single star Pipe.add_map_method(lambda a, b: a + b, 'add', star_wrap=True) self.assertEqual( tuple(Pipe(data_2).add()), (3, 7) ) # double star Pipe.add_map_method(lambda a, b: a + b, 'add', double_star_wrap=True, no_over_write=False) self.assertEqual( tuple(Pipe(data_3).add()), (3, 7) )
for word in first_letter(data): print(word) print(all_letters(data)) ''' Adding Methods (It is SOOOO EASY!) So, you thought that the above lambda functions were ugly and hard to read. We can fix that with Pipe.add_method or Pipe.add_map_method. Those methods allow for simple and complex methods to be added to Pipe. Below is an example of how to add the above examples methods to Pipe and get the same result. ''' # this as the string class method upper Pipe.add_map_method(str.upper) # lambda functions can also be added Pipe.add_map_method(lambda word: word[0].upper() + word[1:], name='first_upper') # lets try again and see how much better this looks first_letter = Pipe().first_upper() all_letters = first_letter.upper().tuple() ''' Carry Values Meaning, avoiding the bs of passing values through every function and having to work around them in every method. This allows you to carry the key/value in a key value pair, a dict, list, or object that you