def test_example_1(self): # Specify streams x = Stream('x') y = Stream('y') # Specify encapsulated functions (if any) def f(v): return 2 * v # Specify agents. map_element(func=f, in_stream=x, out_stream=y) # Execute a step # Put test values in the input streams. x.extend(list(range(3))) # Execute a step run() # Look at recent values of output streams. assert recent_values(y) == [0, 2, 4] # Execute a step # Put test values in the input streams. x.extend([10, 20, 30]) # Execute a step run() # Look at recent values of output streams. assert recent_values(y) == [0, 2, 4, 20, 40, 60] # Execute a step # Put test values in the input streams. x.extend([0, -10]) # Execute a step run() # Look at recent values of output streams. assert recent_values(y) == [0, 2, 4, 20, 40, 60, 0, -20]
def test_timed_window(self): x = Stream('x') y = Stream('y') def f(v): return v timed_window(func=f, in_stream=x, out_stream=y, window_duration=10, step_time=10) x.extend([(1, 'a'), (8, 'b'), (12, 'c')]) run() assert (recent_values(y) == [(10, [(1, 'a'), (8, 'b')])]) x.extend([(14, 'd'), (36, 'e'), (43, 'g'), (75, 'h')]) run() assert (recent_values(y) == [(10, [(1, 'a'), (8, 'b')]), (20, [(12, 'c'), (14, 'd')]), (40, [(36, 'e')]), (50, [(43, 'g')])]) x.extend([(79, 'i'), (101, 'j')]) run() assert (recent_values(y) == [(10, [(1, 'a'), (8, 'b')]), (20, [(12, 'c'), (14, 'd')]), (40, [(36, 'e')]), (50, [(43, 'g')]), (80, [(75, 'h'), (79, 'i')])]) return
def test_None_in_stream(self): x = Stream('x', discard_None=False) y = Stream(name='y', discard_None=False) z = Stream(name='z') map_element(lambda v: v, x, y) map_element(lambda v: v, x, z) x.extend([0, None, 1, None, 2, _no_value, 3]) run() assert (recent_values(y) == [0, None, 1, None, 2, 3]) assert (recent_values(z) == [0, 1, 2, 3])
def test_operators_on_three_streams(self): x = Stream('x') y = Stream('y') z = x + y w = x - y + z DATA = list(range(5)) x.extend(DATA) y.extend(DATA) run() assert recent_values(z) == [2 * v for v in DATA] assert recent_values(w) == [2 * v for v in DATA]
def test_example_4(self): # Illustrates a cycle of agents and also shows use # of a class within a wrapper. # Specify network: streams, functions, agents # (a) Specify streams x = Stream('x') y = Stream('y') # (b) Specify encapsulated functions (if any) def f(v, state): final, prefinal = state next_output = final + prefinal # In the next state: # prefinal becomes final # final becomes next_output next_state = next_output, final return next_output, next_state class G(object): def __init__(self): self.divisor = 4 def g(self, v): if v % self.divisor == 0: return _no_value else: return v # (c) Specify agents. encapsulator = G() map_element(func=f, in_stream=y, out_stream=x, state=(0, 1)) map_element(func=encapsulator.g, in_stream=x, out_stream=y) # Drive the network in steps. # Execute a step # Put test values in the input streams. y.append(0) # Execute a step run() # Look at recent values of output streams. assert recent_values(x) == [1, 1, 2, 3, 5, 8] # Execute a step after changing agent parameters encapsulator.divisor = 2 # Put test values in the input streams. y.append(0) # Execute a step run() # Look at recent values of output streams. assert recent_values(x) == \ [1, 1, 2, 3, 5, 8, 13, 21, 34]
def test_prepend(self): x = Stream() y = Stream() prepend(list(range(10)), x, y) z = fprepend(list(range(10)), x) x.extend(list(range(100, 105))) run() assert recent_values(x) == [100, 101, 102, 103, 104] assert recent_values(y) == [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 100, 101, 102, 103, 104 ] assert recent_values(z) == [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 100, 101, 102, 103, 104 ]
def test_iot_class(self): x = StreamArray(name='x', dtype=int) y = StreamArray(name='y', dtype=int) # Create an agent that wraps np.sum sw = self.sliding_window_test( func=np.sum, in_stream=x, out_stream=y, window_size=5, step_size=2) x.extend(np.arange(10, dtype=int)) run() assert np.array_equal(recent_values(y), np.array([10, 20, 30])) x.extend(np.arange(10, 20, dtype=int)) run() assert np.array_equal(recent_values(y), np.array([10, 20., 30, 40, 50, 60, 70, 80]))
def test_multiply_function_with_multidimensional_array(self): x = StreamArray(dimension=2, dtype=int) # Create a stream array y. y = f_mul(x, 2) A = np.array([[1, 10], [2, 20], [3, 30]]) x.extend(A) run() assert np.array_equal(recent_values(y), [[2, 20], [4, 40], [6, 60]]) x.append(np.array([4, 40])) run() assert np.array_equal(recent_values(y), [[2, 20], [4, 40], [6, 60], [8, 80]])
def test_r_sub(self): x = Stream() y = Stream() r_sub(x, y, 2) x.extend(list(range(5))) run() assert recent_values(y) == [-2, -1, 0, 1, 2]
def test_class(self): class C(object): def __init__(self): return def f(self, value): if value > 0: return self.pos(value) else: return self.neg(value) def pos(self, value): return value * value def neg(self, value): return value + value s = Stream('s') t = Stream('t') c = C() @map_e def g(v): return c.f(v) g(in_stream=s, out_stream=t) s.extend(list(range(-4, 4))) run() assert (recent_values(t) == [-8, -6, -4, -2, 0, 1, 4, 9])
def test_f_add(self): x = Stream() K = 5 y = f_add(x, K) x.extend(list(range(3))) run() assert recent_values(y) == [5, 6, 7]
def test_source_file(self, filename='tests/test_source_file_name.txt'): s = Stream('s') with open(filename, 'r') as input_file: for line in input_file: s.append(int(line)) run() assert recent_values(s) == [1, 2, 3]
def test_r_mul(self): x = Stream() y = Stream() a = r_mul(x, y, 2) x.extend(list(range(5))) run() assert recent_values(y) == [0, 2, 4, 6, 8]
def test_plus_operator(self): x = Stream() y = Stream() z = x + y x.extend(list(range(3))) y.extend(list(range(100, 105))) run() assert recent_values(z) == [100, 102, 104] x.extend(list(range(3, 7))) run() assert recent_values(z) == [100, 102, 104, 106, 108] run() assert recent_values(z) == [100, 102, 104, 106, 108]
def test_halt_agent(self): x = Stream('x') y = Stream('y') a = map_window(func=sum, in_stream=x, out_stream=y, window_size=2, step_size=2) x.extend(list(range(6))) run() assert recent_values(y) == [1, 5, 9] a.halt() run() assert recent_values(y) == [1, 5, 9] x.extend(list(range(10, 15))) run() assert recent_values(y) == [1, 5, 9]
def test_r_add(self): x = Stream() y = Stream() z = 5 r_add(x, y, z) x.extend(list(range(3))) run() assert recent_values(y) == [5, 6, 7]
def test_echo(self): spoken = Stream('spoken') heard = make_echo(spoken, D=1, A=0.5) spoken.extend([64, 32, 16, 8, 4, 2, 1, 0, 0, 0, 0]) run() assert recent_values(heard) == [ 64.0, 64.0, 48.0, 32.0, 20.0, 12.0, 7.0, 3.5, 1.75, 0.875, 0.4375 ]
def test_halt_agent(self): def double(v): return v * 2 x = Stream('x') y = Stream('y') a = map_element(func=double, in_stream=x, out_stream=y) x.extend(list(range(5))) run() assert recent_values(y) == [0, 2, 4, 6, 8] a.halt() run() assert recent_values(y) == [0, 2, 4, 6, 8] x.extend(list(range(10, 15))) run() assert recent_values(y) == [0, 2, 4, 6, 8] assert recent_values(x) == list(range(5)) + list(range(10, 15))
def test_fmap_with_stream_array(self): x = StreamArray(dimension=2, dtype=int) @fmap_e def g(v): return 2 * v y = g(x) A = np.array([[1, 10], [2, 20], [3, 30]]) x.extend(A) run() assert np.array_equal(recent_values(y), [[2, 20], [4, 40], [6, 60]]) x.append(np.array([4, 40])) run() assert np.array_equal(recent_values(y), [[2, 20], [4, 40], [6, 60], [8, 80]])
def test_multiply_operator_with_arrays(self): x = StreamArray(dtype=int) y = StreamArray(dtype=int) z = y * x x.extend(np.arange(3)) y.extend(np.arange(100, 105, 2)) run() assert np.array_equal(recent_values(z), np.array([0, 102, 208]))
def test_minus_operator_with_arrays(self): x = StreamArray(dtype=int) y = StreamArray(dtype=int) z = y - x x.extend(np.arange(3)) y.extend(np.arange(100, 105, 2)) run() assert np.array_equal(recent_values(z), np.array([100, 101, 102]))
def test_map_with_state_and_keyword_arg(self): x = Stream() y = Stream() @map_e def f(v, state, k): return v + k + state, state + 1 @fmap_e def g(v, state, k): return v + k + state, state + 1 f(x, y, state=0, k=10) z = g(x, state=0, k=10) x.extend(list(range(5))) run() assert recent_values(y) == [10, 12, 14, 16, 18] assert recent_values(z) == [10, 12, 14, 16, 18]
def test_iot(self): x = StreamArray(dtype=int) y = StreamArray(dtype=int) z = StreamArray(dtype=int) u = StreamArray(dtype=int) v = StreamArray(dtype=int) def f(A, y, z): """ Function wrapped by an iot agent. The first parameter 'A' is an array obtained from the input stream of the agent. The other parameters, y and z, are positional arguments (*args) of the function. The function returns a pointer into the input stream. In this example, each call to the function processes the entire input array 'A' and so the function returns len(A). """ y.extend(2*A) z.extend(3*A) # Return a pointer into the input array. return len(A) def g(A, u, v): """ Parameters are similar to f. """ u.extend(A+A) v.extend(A**2) return len(A) # Create agents that wrap functions f and g. iot(f, x, y, z) iot(g, x, u, v) # Extend stream x with an array x.extend(np.arange(5, dtype=int)) run() assert np.array_equal(recent_values(y), 2*np.arange(5, dtype=int)) assert np.array_equal(recent_values(z), 3*np.arange(5, dtype=int)) assert np.array_equal(recent_values(u), 2*np.arange(5, dtype=int)) assert np.array_equal(recent_values(v), np.arange(5, dtype=int)**2) # Extend stream x with another array x.extend(np.arange(5, 10, dtype=int)) run() assert np.array_equal(recent_values(y), 2*np.arange(10, dtype=int)) assert np.array_equal(recent_values(z), 3*np.arange(10, dtype=int)) assert np.array_equal(recent_values(u), 2*np.arange(10, dtype=int)) assert np.array_equal(recent_values(v), np.arange(10, dtype=int)**2)
def test_initial_value(self): def double(v): return v * 2 x = Stream('x') y = Stream(name='y', initial_value=[0] * 5) a = map_element(func=double, in_stream=x, out_stream=y) x.extend(list(range(5))) run() assert recent_values(y) == [0] * 5 + [0, 2, 4, 6, 8]
def test_plus_operator_with_arrays_1(self): x = StreamArray(dtype=int) y = StreamArray(dtype=int) z = x + y x.extend(np.arange(3)) y.extend(np.arange(100, 105)) run() assert isinstance(recent_values(z), np.ndarray) assert np.array_equal(recent_values(z), np.array([100, 102, 104])) x.extend(np.arange(3, 7)) run() assert np.array_equal(recent_values(z), np.array([100, 102, 104, 106, 108])) run() assert np.array_equal(recent_values(z), np.array([100, 102, 104, 106, 108]))
def test_simple_merge_1(self): scheduler = Stream.scheduler x = Stream('x') u = Stream('u') s = Stream('s') d = zip_map(func=sum, in_streams=[x, u], out_stream=s, name='d') x.extend(list(range(3))) u.extend([10, 15, 18]) run() assert (recent_values(s) == [10, 16, 20])
def test_plus_operator_with_arrays(self): x = StreamArray(dimension=2, dtype=int) y = StreamArray(dimension=2, dtype=int) z = x + y A = np.arange(6).reshape((3, 2)) B = np.arange(100, 110).reshape((5, 2)) x.extend(A) y.extend(B) run() assert isinstance(z, StreamArray) assert np.array_equal(recent_values(z), np.array([[100, 102], [104, 106], [108, 110]])) C = np.arange(6, 12).reshape((3, 2)) x.extend(C) run() assert np.array_equal( recent_values(z), np.array([[100, 102], [104, 106], [108, 110], [112, 114], [116, 118]]))
def test_minus_operator_with_arrays_and_dimension(self): x = StreamArray(dimension=3, dtype=int) y = StreamArray(dimension=3, dtype=int) z = y - x A = np.array([[10, 20, 30], [40, 50, 60]]) B = np.array([[100, 100, 100], [200, 200, 200], [300, 300, 00]]) x.extend(A) y.extend(B) run() assert np.array_equal(recent_values(z), np.array([[90, 80, 70], [160, 150, 140]]))
def test_map_list_with_arrays(self): from IoTPy.agent_types.op import map_list x = StreamArray(dtype=int) y = StreamArray(dtype=int) def f(A): return 2 * A map_list(f, x, y) x.extend(np.arange(5)) run() assert np.array_equal(recent_values(y), 2 * np.arange(5))
def test_filter_number_1(self): input_list = list(range(-5, 5)) in_stream = Stream('input') out_stream = Stream('output') def f(v): return v > 0 filter_element(f, in_stream, out_stream) in_stream.extend(input_list) run() assert recent_values(out_stream) == list(filter(f, input_list))