def test_chain(self):
with self.subTest("Test chain function with two lists"):
iter_1 = [1, 2, 3]
iter_2 = "abcd"
result = list(generators.chain(iter_1, iter_2))
self.assertEqual(result, [1, 2, 3, "a", "b", "c", "d"])
with self.subTest("Test chain function with emty list"):
iter_1 = []
iter_2 = iter_1
self.assertEqual(list(generators.chain(iter_1, iter_2)), [])
def __getattribute__(self, key):
if key in VList._slots:
return object.__getattribute__(self, key)
else:
# run the attribute query on all elements in self
g = lambda: gen.chain((fv for fv in getattr(v, key)) for v in self)
return VList(g())
def sets():
strategies = easy_street.strings(), easy_street.ints(
), easy_street.floats(), easy_street.bools()
strategies = list(
gen.chain(product(strategies, repeat=len(strategies))))
lengths = cycle(list(range(0, 21)))
for _ in gen.loop():
for length in lengths:
for strat in strategies:
yield {i for i in islice(strat, length)}
def dicts():
strategies = easy_street.strings(), easy_street.ints(
), easy_street.floats(), easy_street.bools()
strategies = list(
gen.chain(product(strategies, repeat=len(strategies))))
lengths = cycle(list(range(1, 21)))
for _ in gen.loop():
for length in lengths:
for strat in strategies:
yield {
k: v
for k, v in gen.chunks(islice(strat, length * 2), 2)
}
def garbage():
strategies = [
easy_street.strings(),
easy_street.ints(),
easy_street.floats(),
easy_street.bools(),
easy_street.dicts(),
easy_street.sets(),
easy_street.lists(),
easy_street.tuples()
]
while 1:
shuffle(strategies)
for strat in gen.chain(product(strategies,
repeat=len(strategies))):
yield next(strat)
def test_whether_in_chain_list_and_set_arguments_are_given_and_return_value_is_converted_in_list(
self):
list_result = list(generators.chain([1, 2, 3], {3, 2}))
expected_result = [1, 2, 3, 2, 3]
self.assertEqual(list_result, expected_result)
def test_wheter_in_chain_two_sets_are_given_and_return_value_is_converted_in_set(
self):
set_result = set(generators.chain({1, 2, 3}, {3, 2, 'i'}))
expected_result = {1, 2, 3, 'i'}
self.assertEqual(set_result, expected_result)
def test_chain(self):
res = list(chain(range(0, 4), range(4, 8)))
expected = [0, 1, 2, 3, 4, 5, 6, 7]
self.assertEqual(res, expected)
for i in range(1, 5):
print(i)
db[5].greater_than = i
print(db[5].greater_than.to(list))
db.show_objects()
db.show_relations()
print(list(db.relations_of(5)))
print()
print(
list(
gen.chain(((r, i.obj) for i in db.find(5, r))
for r in db.relations_of(5))))
for r in db.relations_of(5):
print(r)
print([i.obj for i in db.find(5, r)])
print(db(5).greater_than(list))
print(db(5).greater_than.where(lambda i: i % 2 == 0)(list))
print(db(5).greater_than.precedes(list))
print(
db(5).greater_than.precedes.precedes.precedes.precedes.precedes.
precedes(list))
print(db(5).greater_than.where('even', lambda i: i == True)(list))
print(db(5).greater_than.where('even', bool)(list))
def test_chain_when_two_ranges_are_passed_then_returns_another_one_that_concatenate_the_two_iterables(self):
expr1 = range(0,4)
expr2 = range(4, 8)
expected_result = [0, 1, 2, 3, 4, 5, 6, 7]
self.assertEqual(list(generators.chain(expr1, expr2)), expected_result)
def test_if_iterables_are_passed_to_chain_list_of_both_is_returned(self):
expected_result = [0, 1, 2, 3, 4, 5, 6, 7]
actual_result = list(chain(range(0, 4), range(4, 8)))
self.assertEqual(expected_result, actual_result)
def test_when_one_iterable_is_list_and_other_is_set(self):
chained = list(chain([1, 3, 3], {2, 3, 1}))
expected_result = [1, 3, 3, 1, 2, 3]
self.assertEqual(chained, expected_result)
def floats():
non_zero_ints = (i for i in easy_street.ints() if i != 0)
stream1 = gen.chain(i[:8] for i in gen.chunks(non_zero_ints, 10))
stream2 = gen.chain(i[:8] for i in gen.chunks(non_zero_ints, 12))
for i in stream1:
yield next(stream2) / (1.0 * i)
def test_chain_chains_two_different_types(self):
testgenerator = chain(range(0, 6), [6, 7, 8, 9, 10])
result = list(testgenerator)
expected = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
self.assertEqual(result, expected)
def test_chain(self):
expected = [0, 1, 2, 3, 4, 5, 6, 7]
actual = list(chain(range(0, 4), range(4, 8)))
self.assertEqual(actual, expected)
def test_if_when_sets_are_passed_list_of_both_is_returned(self):
expected_result = [1, 2, 3, 3, 4, 5]
actual_result = list(chain({1, 2, 3}, {3, 4, 5}))
self.assertEqual(expected_result, actual_result)
def test_if_when_list_and_set_are_passed_list_of_both_is_returned(self):
expected_result = [1, 2, 3, 3, 4, 5, 6]
actual_result = list(chain([1, 2, 3], {3, 4, 5, 6}))
self.assertEqual(expected_result, actual_result)
def test_when_both_iterables_are_sets(self):
chained = list(chain({1, 3, 4}, {2, 5, 6}))
expected_result = [1, 3, 4, 2, 5, 6]
self.assertEqual(chained, expected_result)
def connections_of(self, target):
''' generate tuples containing (relation, object_that_applies) '''
return gen.chain(((r, i) for i in self.find(target, r))
for r in self.relations_of(target))
def test_when_both_iterables_are_range(self):
chained = list(chain(range(0, 4), range(4, 8)))
expected_result = [0, 1, 2, 3, 4, 5, 6, 7]
self.assertEqual(chained, expected_result)
def run_tests():
''' use this function to ensure everything is working correctly with graphdb '''
db = GraphDB()
for i in range(1, 10):
src, dst = (i - 1, i)
#print(db._id_of(i))
print('testing', (src, 'precedes', dst))
db.store_relation(src, 'precedes', dst)
db.store_relation(src, 'even', (not src % 2))
db(src).odd = bool(src % 2)
print(6 in db) # search the db to see if youve already stored something
#db.show_objects()
#db.show_relations()
for i in range(5):
for ii in db.find(i, 'precedes'):
print(i, ii)
print(list(db.relations_of(7)))
print(list(db[6].precedes()))
print(db[6].precedes.even.to(list))
print(list(db[6].precedes.even()))
print(db[6].precedes.precedes.to(list))
print(db[6].precedes.precedes.even.to(list))
seven = db[6].precedes
print(seven)
print(seven.to(list))
print('setting an attribute')
db.show_objects()
db.show_relations()
seven.prime = True
print(db[5].precedes.precedes.prime.to(list))
print(db._id_of(99))
for i in range(1, 5):
print(i)
db[5].greater_than = i
print(db[5].greater_than.to(list))
#db.show_objects()
#db.show_relations()
print(list(db.relations_of(5)))
print()
print(
list(
gen.chain(
((r, i) for i in db.find(5, r)) for r in db.relations_of(5))))
for r in db.relations_of(5):
print(r)
print(list(db.find(5, r)))
print(db(5).greater_than(list))
print(db(5).greater_than.where(lambda i: i % 2 == 0)(list))
print(db(5).greater_than.precedes(list))
print(
db(5).greater_than.precedes.precedes.precedes.precedes.precedes.
precedes(list))
print(db(5).greater_than.where('even', lambda i: i == True)(list))
print(db(5).greater_than.where('even', bool)(list))
db.delete_relation(5, 'greater_than', 2)
db.delete_relation(5, 'greater_than', 2)
db.delete_relation(5, 'greater_than', 3)
db.show_relations()
print('-')
print(list(db.relations_of(5)))
print('-')
print(list(db.relations_of(5, True)))
print('-')
print(list(db.relations_to(5)))
print('-')
print(list(db.relations_to(5, True)))
db.replace_item(5, 'waffles')
db.delete_item(6)
db.show_relations()
for i in db:
print(i)
for i in db.list_relations():
print(i)
db._destroy()
def test_chain_when_two_sets_are_passed_then_returns_another_one_that_concatenate_the_two_iterables(self):
expr1 = {1,2,3,4}
expr2 = {1,7,8}
expected_result = [1, 2, 3, 4, 1, 7, 8]
self.assertEqual(list(generators.chain(expr1, expr2)).sort(), expected_result.sort())
