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_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_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_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_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_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))