def test_to_dict(self):
s1 = from_items(1, 2, 3, 4, 5)
s2 = from_items(1, 1, 1, 1, 1)
m = zipped(s1, s2) | to_dict("a", "b")
m2 = zipped(s1, s2) | mapped(lambda a: {"a": a[0], "b": a[1]})
self.assertEqual(list(m2), list(m))
self.assertRaises(AssertionError,
lambda: list(zipped(s1, s2) | to_dict("a")))
self.assertRaises(
AssertionError,
lambda: list(zipped(s1, s2) | to_dict("a", "b", "c")))
self.assertRaises(AssertionError,
lambda: zipped(s1, s2) | to_dict("a", "a"))
def test_map2(self):
"""
test for `pattern mapping`
:return:
"""
s1 = from_items(*range(5))
def map_func(a):
return a * 2
s2 = s1.map(lambda i: (i, i * 2))
self.assertEqual([(i, i * 2) for i in range(5)], list(s2))
map1 = s2.map((None, map_func))
self.assertEqual([(i, i * 4) for i in range(5)], list(map1))
s2 = s1.map(lambda i: {"v": i, "double_v": i * 2})
self.assertEqual([{
"v": i,
"double_v": i * 2
} for i in range(5)], list(s2))
map3 = s2.map({"double_v": lambda x: x - 1})
self.assertEqual([{
"v": i,
"double_v": i * 2 - 1
} for i in range(5)], list(map3))
def test_random_access(self):
s1 = from_items(1, 2, 3, 4, 5)
self.assertEqual(1, s1[0])
self.assertEqual(2, s1[1])
self.assertEqual([3, 4, 5], list(s1[2:]))
self.assertTrue(s1[2:].random_accessible)
self.assertEqual(3, s1[2:][0])
self.assertEqual(4, s1[2:][1])
self.assertEqual(5, s1[2:][2])
self.assertRaises(IndexError, lambda: s1[2:][3])
self.assertEqual([1, 2, 3], list(s1[:3]))
self.assertEqual([2, 3], list(s1[1:3]))
s1 = from_array(list(range(20)))
self.assertEqual(0, s1[0])
self.assertEqual(1, s1[1])
self.assertEqual([5, 7, 9], list(s1[5:10:2]))
self.assertEqual([5, 7, 9], list(s1[5:10:2]))
self.assertEqual(6, s1[4:10:2][1])
self.assertEqual([4, 7], list(s1[4:10:3]))
self.assertEqual([4, 7, 10], list(s1[4:11:3]))
self.assertEqual(17, s1[-3])
self.assertEqual([], list(s1[999:]))
self.assertEqual([17, 18, 19], list(s1[-3:]))
self.assertEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], list(s1[:-10]))
for i in range(-10, 30):
self.assertEqual(list(range(20)), list(s1[:i]) + list(s1[i:]))
def test_hash3(self):
s1 = from_items(1, 2, 3, 4, 5)
s2 = s1 | split()
s3 = s1 | select("key")
self.assertNotEqual(s1.hash, s2.hash)
self.assertNotEqual(s1.hash, s3.hash)
self.assertNotEqual(s2.hash, s3.hash)
def test_flat_map(self):
s1 = from_items(1, 2, 3)
m = s1.flat_map(lambda a: range(a))
self.assertFalse(m.has_length)
self.assertEqual([0, 0, 1, 0, 1, 2], list(m))
m2 = s1 | flat_mapped(lambda a: range(a))
self.assertEqual([0, 0, 1, 0, 1, 2], list(m2))
# flatmap could also flatten the Source object
m3 = s1 | flat_mapped(lambda a: from_array(list(range(a))))
self.assertEqual([0, 0, 1, 0, 1, 2], list(m3))
s2 = from_items([0, 1], [2, 3, 4])
m3 = s2 | flat_mapped(lambda a: a)
self.assertEqual([0, 1, 2, 3, 4], list(m3))
def test_zipped(self):
s1 = from_items(1, 2, 3, 4, 5)
s2 = from_items(1, 1, 1, 1, 1)
z = zipped(s1, s2)
self.assertEqual([
(1, 1),
(2, 1),
(3, 1),
(4, 1),
(5, 1),
], list(z))
s1 = from_items(1, 2, 3, 4, 5)
s2 = from_items(1, 1, 1, 1, 1, 1, 1, 1, 1)
z2 = zipped(s1, s2)
self.assertEqual(list(z), list(z2),
"zipped sequence has same length as shorter one")
def test_hash4(self):
s1 = from_items(1, 2, 3, 4, 5)
self.assertNotEqual(
s1.hash, s1[:].hash,
"sliced source should have a different hash from the parent")
self.assertNotEqual(s1.hash, s1[1:].hash)
self.assertNotEqual(s1.hash, s1[:5].hash)
self.assertNotEqual(s1[1:].hash, s1[:5].hash)
def test_lines_splits(self):
s = lines(Path(__file__).parent / "sample_text.txt")
s2 = from_items(Path(__file__).parent / "sample_text.txt") | lines
s3 = from_items(
Path(__file__).parent / "sample_text.txt") | lines | flatten
self.assertEqual(4, len(s))
self.assertEqual("hello 10", s[0])
self.assertEqual(list(s), list(s2[0]))
self.assertEqual(list(s), list(s3))
s = s | split()
self.assertEqual(4, len(s))
self.assertEqual(["hello", "10"], s[0])
s |= (None, int)
self.assertEqual(4, len(s))
self.assertEqual(("hello", 10), s[0])
def test_filter(self):
s1 = from_items(1, 2, 3, 4, 5)
m = s1.filter(lambda a: a % 2 == 0)
self.assertEqual(m.parents, [s1])
self.assertFalse(m.has_length)
l = [a for a in m]
self.assertEqual([2, 4], l)
def test_select(self):
s1 = from_items(1, 2, 3, 4, 5)
s2 = from_items(1, 1, 1, 1, 1)
m = zipped(s1, s2) | to_dict("a", "b")
a = m | select("a")
self.assertEqual([1, 2, 3, 4, 5], list(a))
b = m | select("b")
self.assertEqual([1, 1, 1, 1, 1], list(b))
a2, b2 = m | select("a", "b")
self.assertEqual(list(a), list(a2))
self.assertEqual(list(b), list(b2))
a2, a3, b2 = m | select("a", "a", "b")
self.assertEqual(list(a), list(a2))
self.assertEqual(list(a), list(a3))
self.assertEqual(list(b), list(b2))
def test_hash2(self):
s1 = from_items(1, 2, 3, 4, 5)
s2 = s1 | mapped(lambda a: a * 2)
s2_2 = s1.map(lambda a: a * 2)
self.assertEqual(s2.hash, s2_2.hash)
self.assertNotEqual(s1.hash, s2.hash)
s3a = s1 | mapped(lambda a: a * 2, dependencies=[2])
s3b = s1 | mapped(lambda a: a * 3, dependencies=[3])
self.assertNotEqual(s3a.hash, s3b.hash)
def test_filter(self):
s1 = from_items(1, 2, 3, 4, 5)
s2 = from_items(6, 7, 8, 9, 10)
r = zipped(s1, s2) | (filtered(lambda a: a % 2 == 0), None)
self.assertFalse(r.random_accessible)
r.mem_cache()
self.assertTrue(r.random_accessible)
self.assertEqual((2, 7), r[0])
self.assertEqual((4, 9), r[1])
r2 = r | (None, filtered(lambda a: a == 7))
self.assertEqual(1, len(list(r2)))
self.assertEqual((2, 7), r2.search_item(0))
r2 = zipped(s1, s2) | (filtered(lambda a: a % 2 == 0),
filtered(lambda a: a % 3 == 0))
self.assertEqual(1, len(list(r2)))
self.assertEqual((4, 9), r2.search_item(0))
def test_mapped_dict(self):
s1 = from_items(1, 2, 3, 4, 5)
s2 = from_items(1, 1, 1, 1, 1)
r = zipped(s1, s2) | mapped(lambda a: {"a": a[0], "b": a[1]})
self.assertEqual({"a": 3, "b": 1}, r[2])
r2 = r | {
"a": mapped(lambda a: a + 1),
"b": mapped(lambda a: a * 2),
}
r3 = r | {
"a": lambda a: a + 1,
"b": lambda a: a * 2,
}
r4 = r | mapped({
"a": lambda a: a + 1,
"b": lambda a: a * 2,
})
self.assertEqual([
{
"a": 2,
"b": 2
},
{
"a": 3,
"b": 2
},
{
"a": 4,
"b": 2
},
{
"a": 5,
"b": 2
},
{
"a": 6,
"b": 2
},
], list(r2))
self.assertEqual(list(r2), list(r3))
self.assertEqual(list(r2), list(r4))
def test_simple_length(self):
s2 = from_array([1, 2, 3, 4, 5])
self.assertEqual(5, len(s2))
self.assertEqual(2, s2[1])
self.assertEqual([1, 2, 3, 4, 5], list(s2))
s2 = from_items(1, 2, 3, 4, 5)
self.assertEqual(5, len(s2))
self.assertEqual(2, s2[1])
self.assertEqual([1, 2, 3, 4, 5], list(s2))
def test_length_cache(self):
s1 = from_items(1, 2, 3, 4, 5)
s1.cache("test", length_only=True)
self.assertTrue(s1.cache("test", check_only=True))
self.assertTrue(s1.cache("test", check_only=True, length_only=True))
s1 = from_iterable([1, 2, 3, 4, 5])
self.assertFalse(s1.has_length)
self.assertFalse(s1.random_accessible)
s1.cache("test", length_only=True)
self.assertTrue(s1.has_length)
self.assertFalse(s1.random_accessible)
def test_map(self):
s1 = from_items(1, 2, 3, 4, 5)
m = s1.map(lambda a: a * 2)
self.assertTrue(m.has_length)
self.assertEqual(m.parents, [s1])
self.assertEqual(5, len(m))
s1 = from_iterable([1, 2, 3, 4, 5])
m = s1.map(lambda a: a * 2)
self.assertFalse(m.has_length)
self.assertEqual([2, 4, 6, 8, 10], list(m))
def test_hash(self):
s1 = from_items(1, 2, 3, 4, 5)
m = s1.filter(lambda a: a % 2 == 0)
self.assertNotEqual(s1.hash, m.hash)
m2 = s1.filter(lambda a: a % 2 == 0, dependencies=[2])
self.assertNotEqual(s1.hash, m2.hash)
self.assertNotEqual(m.hash, m2.hash)
m3 = s1.map(lambda a: a % 2 == 0)
self.assertNotEqual(m.hash, m3.hash)
self.assertNotEqual(m2.hash, m3.hash)
m4 = s1.map(lambda a: a % 2 == 0, dependencies=[2])
self.assertNotEqual(m3.hash, m4.hash)
def test_cache_and_clear(self):
s1 = from_items(1, 2, 3, 4, 5)
self.assertFalse(s1.cache("test", check_only=True))
self.assertFalse(s1.cache("test", check_only=True, length_only=True))
s1.cache("test")
self.assertTrue(s1.cache("test", check_only=True))
self.assertTrue(s1.cache("test", check_only=True, length_only=True))
self.assertEqual([1, 2, 3, 4, 5], list(s1))
self.assertEqual([1, 2, 3, 4, 5], list(s1[:]))
self.assertEqual([1, 2], list(s1[:2]))
s1.cache("test", clear_cache="clear")
self.assertFalse(s1.cache("test", check_only=True))
self.assertFalse(s1.cache("test", check_only=True, length_only=True))
def test_decorator(self):
def kk(k):
@depend(k)
def f(a):
return a * k
return f
s1 = from_items(1, 2, 3, 4, 5)
m1 = s1 | mapped(kk(2))
m2 = s1 | mapped(kk(3))
self.assertNotEqual(m1.hash, m2.hash)
m1 = s1 | mapped(lambda a: a * 2, dependencies=[2])
m2 = s1 | mapped(lambda a: a * 3, dependencies=[3])
self.assertNotEqual(m1.hash, m2.hash)
m1 = s1 | mapped(lambda a: a * 2)
m2 = s1 | mapped(lambda a: a * 3)
self.assertEqual(m1.hash, m2.hash)
def test_filter2(self):
"""
test for `pattern filtering`
:return:
"""
s1 = from_items(*range(5))
def filter_func(a):
return a % 2 == 0
s2 = s1.map(lambda i: (i, i * 2))
map1 = s2.filter((None, filter_func))
self.assertEqual([(i, i * 2) for i in range(5)], list(map1))
map1 = s2.filter((filter_func, None))
self.assertEqual([
(0, 0),
(2, 4),
(4, 8),
], list(map1))
s2 = s1.map(lambda i: {"v": i, "double_v": i * 2})
map3 = s2.filter({"v": filter_func})
self.assertEqual(
[
{
"v": 0,
"double_v": 0 * 2
},
# {"v": 1, "double_v": 1*2},
{
"v": 2,
"double_v": 2 * 2
},
# {"v": 3, "double_v": 3*2},
{
"v": 4,
"double_v": 4 * 2
},
],
list(map3))
def test_mapped(self):
s1 = from_items(1, 2, 3, 4, 5)
self.assertRaises(TypeError,
lambda: s1 | 42) # must has type Pipe or pattern
m = s1 | mapped(lambda a: a + 1)
m2 = s1 | (lambda a: a + 1)
self.assertEqual([2, 3, 4, 5, 6], list(m))
self.assertEqual(m.parents, [s1])
self.assertEqual(len(m), 5)
self.assertEqual(list(m), list(m2),
"callable is assumed to be mapped implicitly")
m = s1 | mapped(lambda a: a + 1) | mapped(lambda a: a * 2)
m2 = s1 | (lambda a: a + 1) | mapped(lambda a: a * 2)
m3 = s1 | mapped(lambda a: a + 1) | (lambda a: a * 2)
m4 = s1 | (mapped(lambda a: a + 1) | mapped(lambda a: a * 2))
self.assertEqual([4, 6, 8, 10, 12], list(m))
self.assertEqual(5, len(m))
self.assertEqual(list(m), list(m2))
self.assertEqual(list(m), list(m3))
self.assertEqual(list(m), list(m4))
self.assertRaises(TypeError, lambda: mapped(lambda a: a + 1) | 42)
self.assertRaises(TypeError, lambda: 42 | mapped(lambda a: a + 1))
s1 = from_items(1, 2, 3, 4, 5)
s2 = from_items(1, 1, 1, 1, 1)
z = zipped(s1, s2)
r = z | (mapped(lambda a: a + 1), mapped(lambda a: a - 1))
r2 = z | ((lambda a: a + 1), mapped(lambda a: a - 1))
r3 = z | (mapped(lambda a: a + 1), (lambda a: a - 1))
r4 = z | ((lambda a: a + 1), (lambda a: a - 1))
self.assertEqual([
(2, 0),
(3, 0),
(4, 0),
(5, 0),
(6, 0),
], list(r))
self.assertEqual(list(r), list(r2))
self.assertEqual(list(r), list(r3))
self.assertEqual(list(r), list(r4))
r = z | (mapped(lambda a: a + 1), None) | (mapped(lambda a: a * 2),
None)
self.assertEqual([
(2 * 2, 1),
(3 * 2, 1),
(4 * 2, 1),
(5 * 2, 1),
(6 * 2, 1),
], list(r))
r = z | (None, mapped(lambda a: a + 1))
self.assertEqual([
(1, 2),
(2, 2),
(3, 2),
(4, 2),
(5, 2),
], list(r))
r = z | (mapped(lambda a: a + 1), None) | (None,
mapped(lambda a: a * 2))
self.assertEqual([
(2, 2),
(3, 2),
(4, 2),
(5, 2),
(6, 2),
], list(r))
