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_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 _export_video(self, filename=None, rate=None, **kwargs):
"""For a list of kwargs, see pims.export"""
# TODO Save the canvas instead of the reader (including annotations)
presets = dict(avi=dict(codec='libx264', quality=23),
mp4=dict(codec='mpeg4', quality=5),
mov=dict(codec='mpeg4', quality=5),
wmv=dict(codec='wmv2', quality=0.005))
ext = path.splitext(filename)[-1]
if ext[0] == '.':
ext = ext[1:]
try:
_kwargs = presets[ext]
except KeyError:
raise ValueError(
"Extension '.{}' is not a known format.".format(ext))
_kwargs.update(kwargs)
if rate is None:
try:
rate = float(self.reader.frame_rate)
except AttributeError or ValueError:
rate = 25.
self.reader.iter_axes = 't'
self.update_statusbar(override='Saving to "{}"'.format(filename))
# PIMS v0.4 export() has a bug having to do with float precision
# fix that here using limit_denominator() from fractions
export(
pipeline(to_rgb_uint8)(self.reader), filename,
Fraction(rate).limit_denominator(66535), **kwargs)
self.update_statusbar(override='Done saving to "{}"'.format(filename))
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_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_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_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_true(hasattr(a, 'attr1'))
assert_false(hasattr(a, 'attr2'))
assert_true(hasattr(a, 's'))
assert_false(hasattr(a, 'close'))
assert_equal(a.attr1, 'hello')
with assert_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_true(hasattr(b, 'attr1'))
assert_false(hasattr(b, 'attr2'))
assert_true(hasattr(b, 's'))
assert_false(hasattr(b, 'close'))
assert_equal(b.attr1, 'hello')
with assert_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_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_true(hasattr(a, 'attr1'))
assert_false(hasattr(a, 'attr2'))
assert_true(hasattr(a, 's'))
assert_false(hasattr(a, 'close'))
assert_equal(a.attr1, 'hello')
with assert_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_true(hasattr(b, 'attr1'))
assert_false(hasattr(b, 'attr2'))
assert_true(hasattr(b, 's'))
assert_false(hasattr(b, 'close'))
assert_equal(b.attr1, 'hello')
with assert_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_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_true(hasattr(a, "attr1"))
assert_false(hasattr(a, "attr2"))
assert_true(hasattr(a, "s"))
assert_false(hasattr(a, "close"))
assert_equal(a.attr1, "hello")
with assert_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_true(hasattr(b, "attr1"))
assert_false(hasattr(b, "attr2"))
assert_true(hasattr(b, "s"))
assert_false(hasattr(b, "close"))
assert_equal(b.attr1, "hello")
with assert_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_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_simple():
capitalize = pipeline(_capitalize)
cap_v = capitalize(v[:1])
assert_letters_equal([cap_v[0]], [_capitalize(v[0])])
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_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_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])])
