def test_multiple_copies(self): """Check that the Mux class can be activated multiple times successfully. """ ab = pescador.Streamer('ab') cde = pescador.Streamer('cde') fghi = pescador.Streamer('fghi') mux = pescador.mux.StochasticMux([ab, cde, fghi], n_active=5, rate=2) gen1 = mux.iterate(6) gen2 = mux.iterate(8) # No streamers should be active until we actually start the generators assert mux.active == 0 # grab one sample each to make sure we've actually started the # generator _ = next(gen1) _ = next(gen2) assert mux.active == 2 # the first one should die after 5 more samples result1 = list(gen1) assert len(result1) == 5 assert mux.active == 1 # The second should die after 7 result2 = list(gen2) assert len(result2) == 7 assert mux.active == 0
def test_chain_generator_with_multiple_copies(self): def stream_gen(): things_to_generate = [ "a", "bb", [], "ccc" ] for item in things_to_generate: yield pescador.Streamer(item) mux = pescador.mux.ChainMux(stream_gen, mode="exhaustive") gen1 = mux.iterate(3) gen2 = mux.iterate() # n == 6 # No streamers should be active until we actually start the generators assert mux.active == 0 # grab one sample each to make sure we've actually started the # generator _ = next(gen1) _ = next(gen2) assert mux.active == 2 # the first one should die after two more samples result1 = list(gen1) assert "".join(result1) == "bb" assert len(result1) == 2 assert mux.active == 1 # The second should die after 6 result2 = list(gen2) assert "".join(result2) == "bbccc" assert len(result2) == 5 assert mux.active == 0
def test_rr_multiple_copies(self): ab = pescador.Streamer('ab') cde = pescador.Streamer('cde') fghi = pescador.Streamer('fghi') mux = pescador.mux.RoundRobinMux([ab, cde, fghi], 'exhaustive') gen1 = mux.iterate(3) gen2 = mux.iterate() # n == 9 # No streamers should be active until we actually start the generators assert mux.active == 0 # grab one sample each to make sure we've actually started the # generator _ = next(gen1) _ = next(gen2) assert mux.active == 2 # the first one should die after two more samples result1 = list(gen1) assert "".join(result1) == "cf" assert len(result1) == 2 assert mux.active == 1 # The second should die after 6 result2 = list(gen2) assert "".join(result2) == "cfbdgehi" assert len(result2) == 8 assert mux.active == 0
def test_multiple_copies(self): """Check that the Mux class can be activated multiple times successfully. """ ab = pescador.Streamer('ab') cde = pescador.Streamer('cde') fghi = pescador.Streamer('fghi') mux = pescador.mux.StochasticMux([ab, cde, fghi], n_active=5, rate=2) gen1 = mux.iterate(6) gen2 = mux.iterate(8) # No streamers should be active until we actually start the generators assert mux.active == 0 # grab one sample each to make sure we've actually started the # generator _ = next(gen1) _ = next(gen2) assert mux.active == 2 # the first one should die after 5 more samples result1 = list(gen1) assert len(result1) == 5 assert mux.active == 1 # The second should die after 7 result2 = list(gen2) assert len(result2) == 7 assert mux.active == 0
def test_rr_multiple_copies(self): ab = pescador.Streamer('ab') cde = pescador.Streamer('cde') fghi = pescador.Streamer('fghi') mux = pescador.mux.RoundRobinMux([ab, cde, fghi], 'exhaustive') gen1 = mux.iterate(3) gen2 = mux.iterate() # n == 9 # No streamers should be active until we actually start the generators assert mux.active == 0 # grab one sample each to make sure we've actually started the # generator _ = next(gen1) _ = next(gen2) assert mux.active == 2 # the first one should die after two more samples result1 = list(gen1) assert "".join(result1) == "cf" assert len(result1) == 2 assert mux.active == 1 # The second should die after 6 result2 = list(gen2) assert "".join(result2) == "cfbdgehi" assert len(result2) == 8 assert mux.active == 0
def test_chain_generator_with_multiple_copies(self): def stream_gen(): things_to_generate = [ "a", "bb", [], "ccc" ] for item in things_to_generate: yield pescador.Streamer(item) mux = pescador.mux.ChainMux(stream_gen, mode="exhaustive") gen1 = mux.iterate(3) gen2 = mux.iterate() # n == 6 # No streamers should be active until we actually start the generators assert mux.active == 0 # grab one sample each to make sure we've actually started the # generator _ = next(gen1) _ = next(gen2) assert mux.active == 2 # the first one should die after two more samples result1 = list(gen1) assert "".join(result1) == "bb" assert len(result1) == 2 assert mux.active == 1 # The second should die after 6 result2 = list(gen2) assert "".join(result2) == "bbccc" assert len(result2) == 5 assert mux.active == 0
def test_chain_mux_exhaustive(self): a = pescador.Streamer("abc") b = pescador.Streamer("def") mux = pescador.mux.ChainMux([a, b], mode="exhaustive") assert "".join(list(mux.iterate())) == "abcdef" # Make sure it's the same as itertools.chain assert list(mux.iterate()) == list( itertools.chain(a.iterate(), b.iterate()))
def test_chain_mux_exhaustive(self): a = pescador.Streamer("abc") b = pescador.Streamer("def") mux = pescador.mux.ChainMux([a, b], mode="exhaustive") assert "".join(list(mux.iterate())) == "abcdef" # Make sure it's the same as itertools.chain assert list(mux.iterate()) == list( itertools.chain(a.iterate(), b.iterate()))
def test_deepcopy__randomseed(self, mux_class, random_state): n_streams = 10 # We use an offset to make sure each stream produces unique values. # That way, we can tell when the mux copies have returned # the same streamer or not. streamers = [pescador.Streamer(T.infinite_generator, offset=i * 10) for i in range(n_streams)] mux = mux_class(streamers, random_state=random_state) copy_mux = copy.deepcopy(mux) assert mux.streamers is not copy_mux.streamers assert len(mux.streamers) == len(copy_mux.streamers) if random_state is None: assert mux.rng == np.random assert copy_mux.rng == np.random else: assert mux.rng is not copy_mux.rng s1 = mux.rng.get_state() s2 = copy_mux.rng.get_state() # Only the second parameter in the state tuple is useful to # compare. assert np.allclose(s1[1], s2[1]) # Using global state (random_state=None), we can't necessarily # guarantee that these will be the same withour resetting the seed, # but here with the local random state, we can. sample1 = list(mux.iterate(30)) sample2 = list(copy_mux.iterate(30)) assert T._eq_list_of_dicts(sample1, sample2)
def test_deepcopy__randomseed(self, mux_class, random_state): n_streams = 10 # We use an offset to make sure each stream produces unique values. # That way, we can tell when the mux copies have returned # the same streamer or not. streamers = [pescador.Streamer(T.infinite_generator, offset=i * 10) for i in range(n_streams)] mux = mux_class(streamers, random_state=random_state) copy_mux = copy.deepcopy(mux) assert mux.streamers is not copy_mux.streamers assert len(mux.streamers) == len(copy_mux.streamers) if random_state is None: assert mux.rng == np.random assert copy_mux.rng == np.random else: assert mux.rng is not copy_mux.rng s1 = mux.rng.get_state() s2 = copy_mux.rng.get_state() # Only the second parameter in the state tuple is useful to # compare. assert np.allclose(s1[1], s2[1]) # Using global state (random_state=None), we can't necessarily # guarantee that these will be the same withour resetting the seed, # but here with the local random state, we can. sample1 = list(mux.iterate(30)) sample2 = list(copy_mux.iterate(30)) assert T._eq_list_of_dicts(sample1, sample2)
def test_modes(self, mode): a = pescador.Streamer("abc") b = pescador.Streamer("def") mux = pescador.mux.ChainMux([a, b], mode="exhaustive") result = list(mux.iterate()) assert len(result) > 0
def test_modes(self, mode): a = pescador.Streamer("abc") b = pescador.Streamer("def") mux = pescador.mux.ChainMux([a, b], mode="exhaustive") result = list(mux.iterate()) assert len(result) > 0
def test_valid_modes(self, mode, n_samples): """Simply tests the modes to make sure they work.""" streamers = [pescador.Streamer(T.infinite_generator) for _ in range(4)] mux = pescador.mux.StochasticMux(streamers, 1, rate=10, mode=mode) output = list(mux.iterate(n_samples)) assert len(output) == n_samples
def test_critical_mux(self, mux_class): # Check on Issue #80 chars = 'abcde' streamers = [pescador.Streamer(x * 5) for x in chars] mux = mux_class(streamers, len(chars), rate=None, prune_empty_streams=False, random_state=135) samples = mux.iterate(max_iter=1000) print(collections.Counter(samples))
def test_valid_modes(self, mode, n_samples): """Simply tests the modes to make sure they work.""" streamers = [pescador.Streamer(T.infinite_generator) for _ in range(4)] mux = pescador.mux.StochasticMux(streamers, 1, rate=10, mode=mode) output = list(mux.iterate(n_samples)) assert len(output) == n_samples
def test_rr_with_empty_streams(self): things_to_generate = [ "aa", [], "bb", [], [], [], "cccc" ] streamers = [pescador.Streamer(x) for x in things_to_generate] mux = pescador.mux.RoundRobinMux(streamers, 'exhaustive') result = "".join(list(mux.iterate())) assert result == "abcabccc"
def test_critical_mux(self, mux_class): # Check on Issue #80 chars = 'abcde' streamers = [pescador.Streamer(x * 5) for x in chars] mux = mux_class(streamers, len(chars), rate=None, prune_empty_streams=False, random_state=135) samples = mux.iterate(max_iter=1000) print(collections.Counter(samples))
def test_rr_with_empty_streams(self): things_to_generate = [ "aa", [], "bb", [], [], [], "cccc" ] streamers = [pescador.Streamer(x) for x in things_to_generate] mux = pescador.mux.RoundRobinMux(streamers, 'exhaustive') result = "".join(list(mux.iterate())) assert result == "abcabccc"
def test_chain_empty_streamer_of_streams(self): def stream_gen(): # Yield causes it to be a generator, but the return exits first, # creating an 'empty' generator. return yield mux = pescador.mux.ChainMux(stream_gen, mode="exhaustive") result = "".join(list(mux.iterate())) assert len(result) == 0 assert result == ''
def test_chain_generatorfn_with_empty_streams(self): def stream_gen(): things_to_generate = ["aa", [], "bb", [], [], [], "cccc"] for item in things_to_generate: yield pescador.Streamer(item) mux = pescador.mux.ChainMux(stream_gen, mode="exhaustive") result = "".join(list(mux.iterate())) assert len(result) == 8 assert result == "aabbcccc"
def test_mux_single_active(self, mux_class, n_streams, n_samples, k, rate): streamers = [pescador.Streamer(T.finite_generator, 10) for _ in range(n_streams)] mux = mux_class(streamers, k, rate=rate) estimate = list(mux.iterate(n_samples)) # Make sure we get the right number of samples # This is highly improbable when revive=False assert len(estimate) == n_samples
def test_mux_single_active(self, mux_class, n_streams, n_samples, k, rate): streamers = [pescador.Streamer(T.finite_generator, 10) for _ in range(n_streams)] mux = mux_class(streamers, k, rate=rate) estimate = list(mux.iterate(n_samples)) # Make sure we get the right number of samples # This is highly improbable when revive=False assert len(estimate) == n_samples
def test_chain_empty_streamer_of_streams(self): def stream_gen(): # Yield causes it to be a generator, but the return exits first, # creating an 'empty' generator. return yield mux = pescador.mux.ChainMux(stream_gen, mode="exhaustive") result = "".join(list(mux.iterate())) assert len(result) == 0 assert result == ''
def test_mux_replacement(self, mux_class, n_streams, n_samples, n_active, rate, random_state): streamers = [pescador.Streamer(T.infinite_generator) for _ in range(n_streams)] mux = mux_class(streamers, n_active, rate=rate, random_state=random_state) estimate = list(mux.iterate(n_samples)) # Make sure we get the right number of samples assert len(estimate) == n_samples
def test_chain_mux_exhaustive_many(self): a = pescador.Streamer("a") b = pescador.Streamer("b") c = pescador.Streamer("c") d = pescador.Streamer("d") e = pescador.Streamer("e") f = pescador.Streamer("f") g = pescador.Streamer("g") mux = pescador.mux.ChainMux([a, b, c, d, e, f, g], mode="exhaustive") assert "".join(list(mux.iterate())) == "abcdefg"
def test_mux_replacement(self, mux_class, n_streams, n_samples, n_active, rate, random_state): streamers = [pescador.Streamer(T.infinite_generator) for _ in range(n_streams)] mux = mux_class(streamers, n_active, rate=rate, random_state=random_state) estimate = list(mux.iterate(n_samples)) # Make sure we get the right number of samples assert len(estimate) == n_samples
def test_chain_mux_exhaustive_many(self): a = pescador.Streamer("a") b = pescador.Streamer("b") c = pescador.Streamer("c") d = pescador.Streamer("d") e = pescador.Streamer("e") f = pescador.Streamer("f") g = pescador.Streamer("g") mux = pescador.mux.ChainMux([a, b, c, d, e, f, g], mode="exhaustive") assert "".join(list(mux.iterate())) == "abcdefg"
def test_chain_generatorfn_with_empty_streams(self): def stream_gen(): things_to_generate = [ "aa", [], "bb", [], [], [], "cccc" ] for item in things_to_generate: yield pescador.Streamer(item) mux = pescador.mux.ChainMux(stream_gen, mode="exhaustive") result = "".join(list(mux.iterate())) assert len(result) == 8 assert result == "aabbcccc"
def test_rr_permuted_cycle(self): a = pescador.Streamer('a') b = pescador.Streamer('bb') empty = pescador.Streamer([]) c = pescador.Streamer('c') mux = pescador.mux.RoundRobinMux([a, b, empty, c], 'permuted_cycle') result = list(mux.iterate(12)) counts = collections.Counter(result) assert len(counts) == 3 assert counts['a'] == 3 assert counts['b'] == 6 assert counts['c'] == 3
def test_rr_permuted_cycle(self): a = pescador.Streamer('a') b = pescador.Streamer('bb') empty = pescador.Streamer([]) c = pescador.Streamer('c') mux = pescador.mux.RoundRobinMux([a, b, empty, c], 'permuted_cycle') result = list(mux.iterate(12)) counts = collections.Counter(result) assert len(counts) == 3 assert counts['a'] == 3 assert counts['b'] == 6 assert counts['c'] == 3
def test_critical_mux(): # Check on Issue #80 chars = 'abcde' streamers = [pescador.Streamer(x * 5) for x in chars] mux = pescador.Mux(streamers, k=len(chars), rate=None, with_replacement=False, revive=True, prune_empty_streams=False, random_state=135) samples = mux.iterate(max_iter=1000) print(collections.Counter(samples))
def test_weighted_empty_streams(self, mux_class): def __empty(): if False: yield 1 reference = pescador.Streamer(T.finite_generator, 10) empty = pescador.Streamer(__empty) mux = mux_class([reference, empty], weights=[1e-10, 1e10]) estimate = list(mux.iterate(10)) ref = list(reference) assert len(ref) == len(estimate) for b1, b2 in zip(ref, estimate): T._eq_batch(b1, b2)
def test_mux_k_greater_n(self, mux_class, n_samples, rate, random_state): """Test that replacement works correctly. See #112: https://github.com/pescadores/pescador/issues/112 When streamers are activated, they should make copies of their underlying streamers, and this should work. Before the bug was fixed, this would fail. Note; this doesn't test underlying state at all, however. """ a = pescador.Streamer('a') b = pescador.Streamer('b') mux = mux_class([a, b], 6, rate, random_state=random_state) result = list(mux.iterate(n_samples)) assert len(result) == n_samples
def test_mux_k_greater_n(self, mux_class, n_samples, rate, random_state): """Test that replacement works correctly. See #112: https://github.com/pescadores/pescador/issues/112 When streamers are activated, they should make copies of their underlying streamers, and this should work. Before the bug was fixed, this would fail. Note; this doesn't test underlying state at all, however. """ a = pescador.Streamer('a') b = pescador.Streamer('b') mux = mux_class([a, b], 6, rate, random_state=random_state) result = list(mux.iterate(n_samples)) assert len(result) == n_samples
def test_mux_single_infinite(mux_class): """Test a single finite streamer for each mux class which can revive it's streamers. """ reference = list(T.finite_generator(50)) stream = pescador.Streamer(reference) mux = mux_class([stream]) estimate = list(mux.iterate(max_iter=100)) assert len(estimate) == 2 * len(reference) reference = (reference + reference) for i in range(len(reference)): assert set(reference[i].keys()) == set(estimate[i].keys()) for key in reference[i].keys(): assert np.all(reference[i][key] == estimate[i][key])
def test_mux_revive(n_streams, n_samples, k, rate): streamers = [ pescador.Streamer(T.finite_generator, 10) for _ in range(n_streams) ] mux = pescador.mux.Mux(streamers, k, rate=rate, with_replacement=False, revive=True) estimate = list(mux.iterate(n_samples)) # Make sure we get the right number of samples # This is highly improbable when revive=False assert len(estimate) == n_samples
def test_mux_single_infinite(mux_class): """Test a single finite streamer for each mux class which can revive it's streamers. """ reference = list(T.finite_generator(50)) stream = pescador.Streamer(reference) mux = mux_class([stream]) estimate = list(mux.iterate(max_iter=100)) assert len(estimate) == 2 * len(reference) reference = (reference + reference) for i in range(len(reference)): assert set(reference[i].keys()) == set(estimate[i].keys()) for key in reference[i].keys(): assert np.all(reference[i][key] == estimate[i][key])
def test_weighted_empty_streams(self, mux_class): def __empty(): if False: yield 1 reference = pescador.Streamer(T.finite_generator, 10) empty = pescador.Streamer(__empty) mux = mux_class([reference, empty], weights=[1e-10, 1e10]) estimate = list(mux.iterate(10)) ref = list(reference) assert len(ref) == len(estimate) for b1, b2 in zip(ref, estimate): T._eq_batch(b1, b2)
def test_shuffled_mux_simple(self): "Test that `ShuffledMux` samples from all provided streams" to_generate = ['a', 'b', 'c', 'd', 'e'] streams = [pescador.Streamer(_cycle, x) for x in to_generate] mux = pescador.ShuffledMux(streams, random_state=10) samples = list(mux.iterate(max_iter=1000)) counter = collections.Counter(samples) # Test that there is [a, b, c] in the set assert set(counter.keys()) == set(to_generate) # Test that the statistics line up with expected. for i, key in enumerate(to_generate): np.testing.assert_approx_equal(counter[key] / len(samples), mux.weights[i], significant=1)
def test_shuffled_mux_simple(self): "Test that `ShuffledMux` samples from all provided streams" to_generate = ['a', 'b', 'c', 'd', 'e'] streams = [pescador.Streamer(_cycle, x) for x in to_generate] mux = pescador.ShuffledMux(streams, random_state=10) samples = list(mux.iterate(max_iter=1000)) counter = collections.Counter(samples) # Test that there is [a, b, c] in the set assert set(counter.keys()) == set(to_generate) # Test that the statistics line up with expected. for i, key in enumerate(to_generate): np.testing.assert_approx_equal(counter[key] / len(samples), mux.weights[i], significant=1)
def test_empty_streams(): def __empty(): if False: yield 1 reference = pescador.Streamer(T.finite_generator, 10) empty = pescador.Streamer(__empty) mux = pescador.mux.Mux([reference, empty], 2, rate=None, with_replacement=False, weights=[1e-10, 1e10]) estimate = list(mux.iterate(10)) ref = list(reference) assert len(ref) == len(estimate) for b1, b2 in zip(ref, estimate): T.__eq_batch(b1, b2)
def test_chain_streamer_of_streams(self): """If you want to pass parameters to your generator function, you have to do it with a streamer. """ def stream_gen(n, source_letters): """ Parameters ---------- n : how many to stream. source_letters : list of things to stream. """ for char in source_letters: yield pescador.Streamer(char * n) streamers = pescador.Streamer(stream_gen, 10, "abcde") mux = pescador.mux.ChainMux(streamers, mode="exhaustive") result = "".join(list(mux.iterate())) assert len(result) == 50 assert result == "{}{}{}{}{}".format( 'a' * 10, 'b' * 10, 'c' * 10, 'd' * 10, 'e' * 10)
def test_critical_mux(self, mux_class): """This test checks the following: When `max_iter` is specified, the `Mux` should return / complete when the input generators are complete, and should not cycle infinitely. # Check on Issue #80 https://github.com/pescadores/pescador/issues/80 """ chars = 'abcde' n_reps = 7 streamers = [pescador.Streamer(x * n_reps) for x in chars] mux = mux_class(streamers, len(chars), rate=None, prune_empty_streams=False, random_state=135) samples = list(mux.iterate(max_iter=1000)) sample_counts = collections.Counter(samples) assert len(sample_counts) == len(chars) for k, v in sample_counts.items(): assert v == n_reps assert len(samples) == len(chars) * n_reps
def test_chain_streamer_of_streams(self): """If you want to pass parameters to your generator function, you have to do it with a streamer. """ def stream_gen(n, source_letters): """ Parameters ---------- n : how many to stream. source_letters : list of things to stream. """ for char in source_letters: yield pescador.Streamer(char * n) streamers = pescador.Streamer(stream_gen, 10, "abcde") mux = pescador.mux.ChainMux(streamers, mode="exhaustive") result = "".join(list(mux.iterate())) assert len(result) == 50 assert result == "{}{}{}{}{}".format( 'a' * 10, 'b' * 10, 'c' * 10, 'd' * 10, 'e' * 10)
def test_shuffled_mux_weights(self): "When sampling with weights, do the statistics line up?" a = pescador.Streamer(_cycle, 'a') b = pescador.Streamer(_cycle, 'b') c = pescador.Streamer(_cycle, 'c') weights = [.6, .3, .1] mux = pescador.ShuffledMux([a, b, c], weights=weights, random_state=10) samples = list(mux.iterate(max_iter=1000)) counter = collections.Counter(samples) # Test that there is [a, b, c] in the set assert set(counter.keys()) == set(['a', 'b', 'c']) # Test the statistics on the counts. # Does the sampling approximately match the weights? for i, key in enumerate(['a', 'b', 'c']): np.testing.assert_approx_equal(counter[key] / len(samples), weights[i], significant=1)
def test_shuffled_mux_weights(self): "When sampling with weights, do the statistics line up?" a = pescador.Streamer(_cycle, 'a') b = pescador.Streamer(_cycle, 'b') c = pescador.Streamer(_cycle, 'c') weights = [.6, .3, .1] mux = pescador.ShuffledMux([a, b, c], weights=weights, random_state=10) samples = list(mux.iterate(max_iter=1000)) counter = collections.Counter(samples) # Test that there is [a, b, c] in the set assert set(counter.keys()) == {'a', 'b', 'c'} # Test the statistics on the counts. # Does the sampling approximately match the weights? for i, key in enumerate(['a', 'b', 'c']): np.testing.assert_approx_equal(counter[key] / len(samples), weights[i], significant=1)
def test_critical_mux(self, mux_class): """This test checks the following: When `max_iter` is specified, the `Mux` should return / complete when the input generators are complete, and should not cycle infinitely. # Check on Issue #80 https://github.com/pescadores/pescador/issues/80 """ chars = 'abcde' n_reps = 7 streamers = [pescador.Streamer(x * n_reps) for x in chars] mux = mux_class(streamers, len(chars), rate=None, prune_empty_streams=False, random_state=135) samples = list(mux.iterate(max_iter=1000)) sample_counts = collections.Counter(samples) assert len(sample_counts) == len(chars) for k, v in sample_counts.items(): assert v == n_reps assert len(samples) == len(chars) * n_reps
def test_roundrobin_mux_simple(self): ab = pescador.Streamer('ab') cde = pescador.Streamer('cde') fghi = pescador.Streamer('fghi') mux = pescador.mux.RoundRobinMux([ab, cde, fghi], 'exhaustive') assert "".join(list(mux.iterate())) == "acfbdgehi"
def test_chain_mux_cycle(self): a = pescador.Streamer("abc") b = pescador.Streamer("def") mux = pescador.mux.ChainMux([a, b], mode="cycle") assert "".join(list(mux.iterate(max_iter=12))) == "abcdefabcdef"
def test_rr_basic_cycle(self): a = pescador.Streamer('a') b = pescador.Streamer('bb') mux = pescador.mux.RoundRobinMux([a, b], 'cycle') assert "".join(list(mux.iterate(7))) == "abbabba"
def test_chain_mux_cycle(self): a = pescador.Streamer("abc") b = pescador.Streamer("def") mux = pescador.mux.ChainMux([a, b], mode="cycle") assert "".join(list(mux.iterate(max_iter=12))) == "abcdefabcdef"
def test_rr_basic_cycle(self): a = pescador.Streamer('a') b = pescador.Streamer('bb') mux = pescador.mux.RoundRobinMux([a, b], 'cycle') assert "".join(list(mux.iterate(7))) == "abbabba"
def test_roundrobin_mux_simple(self): ab = pescador.Streamer('ab') cde = pescador.Streamer('cde') fghi = pescador.Streamer('fghi') mux = pescador.mux.RoundRobinMux([ab, cde, fghi], 'exhaustive') assert "".join(list(mux.iterate())) == "acfbdgehi"