def test_pipeline_nesting():
capitalize = pipeline(_capitalize)
a_to_z = pipeline(_a_to_z)
nested_v = capitalize(a_to_z(v))
assert_letters_equal([nested_v[0]], ['Z'])
assert_letters_equal([nested_v[:1][0]], ['Z'])
def test_composed_pipelines():
a_to_z = pipeline(_a_to_z)
capitalize = pipeline(_capitalize_if_equal)
composed = capitalize(a_to_z(v), 'c')
assert_letters_equal(composed, 'zbCdefghij')
def test_from_class():
class Dummy(object):
"""DocString"""
def __init__(self):
self.frame = list('abcdefghij')
def __len__(self):
return len(self.frame)
def __getitem__(self, i):
"""Other Docstring"""
return self.frame[i] # actual code of get_frame
def __repr__(self):
return 'Repr'
DummySli = Slicerator.from_class(Dummy)
assert Dummy()[:2] == ['a', 'b'] # Dummy is unaffected
# class slots propagate
assert DummySli.__name__ == Dummy.__name__
assert DummySli.__doc__ == Dummy.__doc__
assert DummySli.__module__ == Dummy.__module__
dummy = DummySli()
assert isinstance(dummy, Dummy) # still instance of Dummy
assert repr(dummy) == 'Repr' # repr propagates
compare_slice_to_list(dummy, 'abcdefghij')
compare_slice_to_list(dummy[1:], 'bcdefghij')
compare_slice_to_list(dummy[1:][2:], 'defghij')
capitalize = pipeline(_capitalize_if_equal)
cap_b = capitalize(dummy, 'b')
assert_letters_equal(cap_b, 'aBcdefghij')
def test_pipeline_with_args():
capitalize = pipeline(_capitalize_if_equal)
cap_a = capitalize(v, 'a')
cap_b = capitalize(v, 'b')
assert_letters_equal(cap_a, 'Abcdefghij')
assert_letters_equal(cap_b, 'aBcdefghij')
assert_letters_equal([cap_a[0]], ['A'])
assert_letters_equal([cap_b[0]], ['a'])
assert_letters_equal([cap_a[0]], ['A'])
def test_getattr():
class MyList(list):
attr1 = 'hello'
attr2 = 'hello again'
@index_attr
def s(self, i):
return list('ABCDEFGHIJ')[i]
def close(self):
pass
a = Slicerator(MyList('abcdefghij'), propagate_attrs=['attr1', 's'])
assert_letters_equal(a, list('abcdefghij'))
assert hasattr(a, 'attr1')
assert not hasattr(a, 'attr2')
assert hasattr(a, 's')
assert not hasattr(a, 'close')
assert a.attr1 == 'hello'
with pytest.raises(AttributeError):
a[:5].nonexistent_attr
compare_slice_to_list(list(a.s), list('ABCDEFGHIJ'))
compare_slice_to_list(list(a[::2].s), list('ACEGI'))
compare_slice_to_list(list(a[::2][1:].s), list('CEGI'))
capitalize = pipeline(_capitalize)
b = capitalize(a)
assert_letters_equal(b, list('ABCDEFGHIJ'))
assert hasattr(b, 'attr1')
assert not hasattr(b, 'attr2')
assert hasattr(b, 's')
assert not hasattr(b, 'close')
assert b.attr1 == 'hello'
with pytest.raises(AttributeError):
b[:5].nonexistent_attr
compare_slice_to_list(list(b.s), list('ABCDEFGHIJ'))
compare_slice_to_list(list(b[::2].s), list('ACEGI'))
compare_slice_to_list(list(b[::2][1:].s), list('CEGI'))
def test_serialize():
# dump Slicerator
stream = BytesIO()
pickle.dump(v, stream)
stream.seek(0)
v2 = pickle.load(stream)
stream.close()
compare_slice_to_list(v2, list('abcdefghij'))
compare_slice_to_list(v2[4:], list('efghij'))
compare_slice_to_list(v2[4:][:-1], list('efghi'))
# dump sliced Slicerator
stream = BytesIO()
pickle.dump(v[4:], stream)
stream.seek(0)
v2 = pickle.load(stream)
stream.close()
compare_slice_to_list(v2, list('efghij'))
compare_slice_to_list(v2[2:], list('ghij'))
compare_slice_to_list(v2[2:][:-1], list('ghi'))
# dump sliced sliced Slicerator
stream = BytesIO()
pickle.dump(v[4:][:-1], stream)
stream.seek(0)
v2 = pickle.load(stream)
stream.close()
compare_slice_to_list(v2, list('efghi'))
compare_slice_to_list(v2[2:], list('ghi'))
compare_slice_to_list(v2[2:][:-1], list('gh'))
# test pipeline
capitalize = pipeline(_capitalize_if_equal)
stream = BytesIO()
pickle.dump(capitalize(v, 'a'), stream)
stream.seek(0)
v2 = pickle.load(stream)
stream.close()
compare_slice_to_list(v2, list('Abcdefghij'))
def test_pipeline_nesting_numeric():
add_one = pipeline(_add_one)
triple_nested = add_one(add_one(add_one(n)))
assert_letters_equal([triple_nested[0]], [3])
assert_letters_equal([triple_nested[:1][0]], [3])
def test_pipeline_propagation():
capitalize = pipeline(_capitalize)
cap_v = capitalize(v)
assert_letters_equal([cap_v[:1][0]], ['A'])
assert_letters_equal([cap_v[:1][:2][0]], ['A'])
def test_pipeline_simple():
capitalize = pipeline(_capitalize)
cap_v = capitalize(v[:1])
assert_letters_equal([cap_v[0]], [_capitalize(v[0])])