def test_conj_reducer(self):
conj_reducer = T.get_immutable_appender()
self.assertEqual(self.conjoining.__class__.__name__, 'Conjoining')
result = T.transduce(T.compose(T.mapping(lambda x: x)),
self.conjoining, range(5))
self.assertEqual((0, 1, 2, 3, 4), result)
def test_first(self):
transducer = T.compose(
T.filtering(lambda x: True if x > 4 else False),
T.first(lambda x: True if x * x > 64 else False))
result = T.transduce(transducer, T.single(), range(1000))
self.assertEqual(9, result)
def test_transduce(self):
transducer = T.compose(T.filtering(is_prime),
T.mapping(lambda x: x + 1))
self.assertEqual(transducer.__class__.__name__, 'function')
result = T.transduce(transducer, self.appending, range(20))
self.assertEqual([3, 4, 6, 8, 12, 14, 18, 20], result)
def generator():
try:
print('Generator is starting:', data)
while True:
iterrable = (yield)
if this.cashe.get(tuple(iterrable)) == None:
if transducer is not None:
new_itterable = T.transduce(
transducer, reducer, iterrable)
this.cashe[tuple(iterrable)] = new_itterable
print('.', data, new_itterable)
else:
if action is not None:
new_itterable = action(iterrable)
this.cashe[tuple(iterrable)] = new_itterable
print('.', data, new_itterable)
else:
new_itterable = this.cashe[tuple(iterrable)]
print('.c', data, new_itterable)
try:
if this.target == None:
pass
else:
this.target.send(new_itterable)
except StopIteration as e:
return e.value
except GeneratorExit:
print("Generator is closing:", data)
def solve(self,
transducers=None,
actions=None,
generators=None,
target=None,
reducer=T.get_mutable_appender()):
current_target = target
for action in reversed(actions):
a = self.create_generator(target=current_target,
action=action,
data=action.__name__)
current_target = a.get()
for transducer in reversed(transducers):
a = self.create_generator(target=current_target,
transducer=transducer,
reducer=reducer,
data=transducer.__name__)
current_target = a.get()
for generator in reversed(generators):
generator.set_target(current_target)
current_target = generator.get()
return current_target
def setUp(self):
self.appending = T.get_mutable_appender()
self.conjoining = T.get_immutable_appender()
def test_enumerating(self):
transducer = T.compose(T.mapping(lambda x: x * 2 + 3), T.enumerating())
result = T.transduce(transducer, self.appending, range(4))
self.assertEqual([(0, 3), (1, 5), (2, 7), (3, 9)], result)
def test_repeating(self):
transducer = T.compose(T.mapping(lambda x: x * x), T.repeating(2))
result = T.transduce(transducer, self.appending, range(2))
self.assertEqual([0, 0, 1, 1], result)
def test_chunking(self):
transducer = T.compose(T.mapping(lambda x: x * x), T.chunking(2))
result = T.transduce(transducer, self.appending, range(5))
self.assertEqual([[0, 1], [4, 9], [16]], result)
def test_appending_reducer(self):
self.assertEqual(self.appending.__class__.__name__, 'Appending')
result = T.transduce(T.compose(T.mapping(lambda x: x)), self.appending,
range(5))
self.assertEqual([0, 1, 2, 3, 4], result)
def test2(data):
# Any actions
return data
def test_generator(data):
# Any actions
return data
master = master()
output_sink = output()
generator1 = master.create_generator(action=test_generator,
data='Generator_test')
transducer2 = T.compose(T.mapping(lambda x: x), T.filtering(is_prime))
transducer1 = T.compose(T.mapping(lambda x: x + 1),
T.filtering(lambda x: True if x > 1 else False))
chain = master.solve(generators=[generator1],
transducers=[transducer1, transducer2],
actions=[test1, test2],
target=output_sink)
input(iterable=range(15), target=chain)
print('\nCashed:\n')
input(iterable=range(20), target=chain)