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 f(in_streams, out_streams, index, even, odd): def g(v): if (0 < index) and (index < N - 1): if v % 2 == 0: odd[index] = (even[index - 1] + even[index] + even[index + 1]) / 3.0 else: even[index] = (odd[index - 1] + odd[index] + odd[index + 1]) / 3.0 return v + 1 def r(lst, state): if state < M: return lst[0], state + 1 else: return _no_value, state for out_stream in out_streams: out_stream.extend([0]) synch_stream = Stream('synch_stream') zip_map(r, in_streams, synch_stream, state=0, name='zip_map_' + str(index)) map_element(g, synch_stream, out_streams[0], name='grid' + str(index)) run()
def g(in_streams, out_streams, attenuation, q): def gg(v): # v is the sound heard q.put(v) # v*attenuation is the echo return v * attenuation map_element(gg, in_streams[0], out_streams[0])
def f_echo(in_streams, out_streams, delay): sound_made, attenuated = in_streams echo = Stream('echo') echo.extend([0] * delay) map_element(lambda v: v, attenuated, echo) # The zip_map output is the sound heard which is # the sound heard plus the echo. zip_map(sum, [sound_made, echo], out_streams[0])
def f_echo(in_streams, out_streams, delay, attenuation, q): echo = StreamArray('echo', initial_value=np.array([0.0] * delay, dtype='float'), dtype='float') #Note: sound_made = in_streams[0] sound_heard = in_streams[0] + echo map_element(lambda v: v * attenuation, sound_heard, echo) stream_to_queue(sound_heard, q)
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(): publisher = PikaPublisher( routing_key='temperature', exchange='publications', host='localhost') x = Stream('x') y = Stream('y') map_element(lambda v: 2*v, x, y) publisher.publish(y) for i in range(3): x.extend(list(range(i*4, (i+1)*4))) run() time.sleep(0.001)
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_example_1(self): # Get scheduler scheduler = Stream.scheduler # 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) for i in range(8): x.extend(list(range(i*5, (i+1)*5))) run()
def test_1(self): # From map_element_examples x = Stream('x') y = Stream('y') def f(in_stream_element): out_stream_element = 2 * in_stream_element return out_stream_element map_element(func=f, in_stream=x, out_stream=y) x.extend(list(range(5))) run() assert recent_values(y) == [0, 2, 4, 6, 8]
def test_stream_arrays_2(self): """ Example where the input stream of an agent is a stream array and its output stream is not a stream array. """ x = StreamArray(name='x', dimension=3, dtype=float) y = Stream() map_element(func=np.median, in_stream=x, out_stream=y) x.append(np.array([1., 2., 3.])) run() assert y.recent[:y.stop] == [2.0] x.extend(np.array([[4., 5., 6.], [7., 8., 9.]])) run() assert y.recent[:y.stop] == [2.0, 5.0, 8.0]
def test_pass_parameter(self): result = [] def f(v, state, result): state += v result.append(state) return v, state x = Stream('x') y = Stream('y') map_element(func=f, in_stream=x, out_stream=y, state=0, result=result) x.extend(list(range(5))) run() assert result == [0, 1, 3, 6, 10]
def test_multiple_relations(self): def double(v): return v * 2 def add10(v): return v + 10 x = Stream('x') y = Stream('y') z = Stream('z') a = map_element(func=add10, in_stream=z, out_stream=y) b = map_element(func=double, in_stream=x, out_stream=y) c = map_element(func=double, in_stream=x, out_stream=y) x.extend(list(range(5))) z.extend(list(range(100, 106))) run()
def g(in_streams, out_streams): s = Stream('s') t = Stream('t') map_element(get_tweet_fields, in_streams[0], out_stream=s, fields={ '-': ['text', 'sentiment'], 'user': [ 'name', 'screen_name', 'description', 'favorites_count', 'followers_count' ] }) filter_element(filter_tweet, in_stream=s, out_stream=out_streams[0], required_phrases=['covid', 'vaccine', 'Fauci', 'Birks'], avoid_phrases=['evil'])
def test_2(self): # From map_element_examples x = Stream('x') y = Stream('y') def multiply_and_add(in_stream_element, multiplicand, addend): out_stream_element = \ multiplicand*in_stream_element + addend return out_stream_element map_element(func=multiply_and_add, in_stream=x, out_stream=y, multiplicand=2, addend=10) x.extend(list(range(5))) run() assert recent_values(y) == [10, 12, 14, 16, 18]
def test_class(self): class example(object): def __init__(self, multiplicand): self.multiplicand = multiplicand self.running_sum = 0 def step(self, v): result = v * self.multiplicand + self.running_sum self.running_sum += v return result x = Stream() y = Stream() eg = example(multiplicand=2) map_element(func=eg.step, in_stream=x, out_stream=y) x.extend(list(range(5))) run() assert y.recent[:y.stop] == [0, 2, 5, 9, 14]
def f(in_streams, out_streams): s = Stream('s') t = Stream('t') map_element(get_tweet_fields, in_streams[0], out_stream=s, fields={ '-': ['text', 'created_at', 'sentiment'], 'user': [ 'name', 'screen_name', 'description', 'favorites_count', 'followers_count' ] }) filter_element( filter_tweet, in_stream=s, out_stream=out_streams[0], required_phrases=['Biden'], avoid_phrases=['#MAGA', '@thedemocrat', 'stable genius'])
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_3(self): # From map_element_examples x = Stream('x') y = Stream('y') # In this example, the output stream is the same as the input stream # except that only values that are less than the threshold are passed # through to the output stream. Here threshold is a keyword argument def f(in_stream_element, threshold): if in_stream_element < threshold: out_stream_element = in_stream_element else: out_stream_element = _no_value return out_stream_element map_element(func=f, in_stream=x, out_stream=y, threshold=5) x.extend(list(range(20))) run() assert recent_values(y) == [0, 1, 2, 3, 4]
def test_4(self): # From map_element_examples x = Stream('x') y = Stream('y') def f(in_stream_element): x, y = in_stream_element if x > 5 and y > 5: out_stream_element = _multivalue((x, y)) elif x > 5: out_stream_element = x elif y > 5: out_stream_element = y else: out_stream_element = _no_value return out_stream_element map_element(func=f, in_stream=x, out_stream=y) x.extend([(10, 10), (2, 20), (30, 3), (4, 4), (1, 3), (60, 70)]) run() assert recent_values(y) == [10, 10, 20, 30, 60, 70]
def test_example_3(self): # Specify streams x = Stream('x') y = Stream('y') # 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 def g(v, divisor): if v % divisor == 0: return _no_value else: return v # Specify agents. map_element(func=f, in_stream=y, out_stream=x, state=(0, 1)) map_element(func=g, in_stream=x, out_stream=y, divisor=4) # 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 # 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, 55, 89, 144]
def test_example_5(self): # Fibonacci # Illustrates use of a dict to save state. # Specify network: streams, functions, agents # (a) Specify streams x = Stream('x') y = Stream('y') s = {'a': 0, 'b': 1} # (b) Specify encapsulated functions (if any) def f(v, s): final, prefinal = s['a'], s['b'] post_final = final + prefinal # In the next state: # prefinal becomes final # final becomes next_output s['a'], s['b'] = post_final, final return final map_element(f, x, y, s=s) x.extend(list(range(10))) run() assert recent_values(y) == [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
def test_example_6(self): import numpy as np # Fibonacci # Illustrates use of a dict to save state. # Specify network: streams, functions, agents # (a) Specify streams x = Stream('x') y = Stream('y') s = {'final': 0, 'prefinal': 1} # (b) Specify encapsulated functions (if any) def f(v, s): post_final = s['final'] + s['prefinal'] # In the next state: # prefinal becomes final # final becomes next_output s['prefinal'] = s['final'] s['final'] = post_final return s['prefinal'] map_element(f, x, y, s=s) x.extend(list(range(10))) run() assert recent_values(y) == [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
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_element_simple(self): # SPECIFY STREAMS m = Stream('m') n = Stream('n') o = Stream('o') q = Stream('q') r = Stream('r') s = Stream('s') t = Stream('t') u = Stream('u') v = Stream('v') w = Stream('w') x = Stream('x') y = Stream('y') z = Stream('z') #---------------------------------------------------------------- # Test simple map using map_element # func operates on an element of the input stream and returns an element of # the output stream. # SPECIFY ENCAPSULATED FUNCTIONS (IF ANY) def double(v): return 2 * v # SPECIFY AGENTS a = map_element(func=double, in_stream=x, out_stream=y, name='a') ymap = map_element_f(func=double, in_stream=x) #---------------------------------------------------------------- #---------------------------------------------------------------- # Test filtering def filtering(v): return v <= 2 # yfilter is a stream consisting of those elements in stream x with # values less than or equal to 2. # The elements of stream x that satisfy the boolean, filtering(), are # passed through. yfilter = filter_element_f(func=filtering, in_stream=x) #---------------------------------------------------------------- #---------------------------------------------------------------- # Test map with state using map_element # func operates on an element of the input stream and state and returns an # element of the output stream and the new state. def f(x, state): return x + state, state + 2 b = map_element(func=f, in_stream=x, out_stream=z, state=0, name='b') bmap = map_element_f(func=f, in_stream=x, state=0) #---------------------------------------------------------------- #---------------------------------------------------------------- # Test map with call streams # The agent executes a state transition when a value is added to call_streams. c = map_element(func=f, in_stream=x, out_stream=v, state=10, call_streams=[w], name='c') #---------------------------------------------------------------- #---------------------------------------------------------------- # Test _no_value # func returns _no_value to indicate that no value # is placed on the output stream. def f_no_value(v): """ Filters out odd values """ if v % 2: # v is odd. So filter it out. return _no_value else: # v is even. So, keep it in the output stream. return v no_value_stream = Stream(name='no_value_stream') no_value_agent = map_element(func=f_no_value, in_stream=x, out_stream=no_value_stream, name='no_value_agent') no_value_map = map_element_f(func=f_no_value, in_stream=x) #---------------------------------------------------------------- #---------------------------------------------------------------- # Test _multivalue # func returns _multivalue(output_list) to indicate that # the list of elements in output_list should be placed in the # output stream. def f_multivalue(v): if v % 2: return _no_value else: return _multivalue([v, v * 2]) multivalue_stream = Stream('multivalue_stream') multivalue_agent = map_element(func=f_multivalue, in_stream=x, out_stream=multivalue_stream, name='multivalue_agent') multivalue_map = map_element_f(func=f_multivalue, in_stream=x) #---------------------------------------------------------------- #---------------------------------------------------------------- # Test map_element with args def function_with_args(x, multiplicand, addition): return x * multiplicand + addition ## EXPLANATION FOR agent BELOW ## agent_test_args = map_element( ## func=function_with_args, in_stream = x, out_stream=r, ## state=None, call_streams=None, name='agent_test_args', ## multiplicand=2, addition=10) agent_test_args = map_element(function_with_args, x, r, None, None, 'agent_test_args', 2, 10) stream_test_args = map_element_f(function_with_args, x, None, 2, 10) #---------------------------------------------------------------- #---------------------------------------------------------------- # Test map_element with kwargs agent_test_kwargs = map_element(func=function_with_args, in_stream=x, out_stream=u, state=None, call_streams=None, name='agent_test_kwargs', multiplicand=2, addition=10) #---------------------------------------------------------------- #---------------------------------------------------------------- # Test map_element with state and kwargs # func operates on an element of the input stream and state and returns an # element of the output stream and the new state. def f_map_args_kwargs(u, state, multiplicand, addend): return u * multiplicand + addend + state, state + 2 agent_test_kwargs_and_state = map_element( func=f_map_args_kwargs, in_stream=x, out_stream=s, state=0, name='agent_test_kwargs_and_state', multiplicand=2, addend=10) #---------------------------------------------------------------- #---------------------------------------------------------------- # Test map_element with state and args aa_map_args_agent = map_element(f_map_args_kwargs, x, t, 0, None, 'aa_map_args_agent', 2, 10) #---------------------------------------------------------------- #---------------------------------------------------------------- # Test filter_element def is_even_number(v): return not v % 2 filter_element(func=is_even_number, in_stream=x, out_stream=q) #---------------------------------------------------------------- #---------------------------------------------------------------- # Test filter_element with state def less_than_n(v, state): return v <= state, state + 1 x0 = Stream('x0') q0 = Stream('q0') # state[i] = i # Pass through elements in x0 where x0[i] <= state[i] filter_element(func=less_than_n, in_stream=x0, out_stream=q0, state=0) #---------------------------------------------------------------- #---------------------------------------------------------------- # Test filter_element_stream # p is a stream consisting of odd-numbered elements of x # Even-numbered elements are filtered out. p = filter_element_f(is_even_number, x) #---------------------------------------------------------------- #---------------------------------------------------------------- # Test cycles in the module connection graph filter_element(func=lambda v: v <= 5, in_stream=o, out_stream=n) map_element(func=lambda v: v + 2, in_stream=n, out_stream=o) #---------------------------------------------------------------- #---------------------------------------------------------------- # PUT TEST VALUES INTO INPUT STREAMS #---------------------------------------------------------------- # Put test values into streams x, x0 and n. x.extend(list(range(3))) x0.extend([0, 1, 3, 3, 6, 8]) n.append(0) # STEP 6: EXECUTE A STEP OF THE SCHEDULER run() # STEP 7: LOOK AT OUTPUT STREAMS assert recent_values(x) == [0, 1, 2] assert recent_values(y) == [0, 2, 4] assert recent_values(q0) == [0, 1, 3] assert recent_values(ymap) == recent_values(y) assert recent_values(yfilter) == [0, 1, 2] assert recent_values(z) == [0, 3, 6] assert recent_values(bmap) == recent_values(z) assert recent_values(v) == [] assert recent_values(no_value_stream) == [0, 2] assert recent_values(no_value_map) == recent_values(no_value_stream) assert recent_values(multivalue_stream) == [0, 0, 2, 4] assert recent_values(multivalue_map) == recent_values( multivalue_stream) assert recent_values(r) == [10, 12, 14] assert recent_values(stream_test_args) == recent_values(r) assert recent_values(u) == recent_values(r) assert recent_values(s) == [10, 14, 18] assert recent_values(s) == recent_values(t) assert recent_values(q) == [0, 2] assert recent_values(q) == recent_values(p) assert recent_values(n) == [0, 2, 4] assert recent_values(o) == [2, 4, 6] #---------------------------------------------------------------- #---------------------------------------------------------------- x.extend(list(range(3, 5, 1))) run() assert recent_values(x) == [0, 1, 2, 3, 4] assert recent_values(y) == [0, 2, 4, 6, 8] assert recent_values(ymap) == recent_values(y) assert recent_values(yfilter) == [0, 1, 2] assert recent_values(z) == [0, 3, 6, 9, 12] assert recent_values(bmap) == recent_values(z) assert recent_values(no_value_stream) == [0, 2, 4] assert recent_values(no_value_map) == recent_values(no_value_stream) assert recent_values(multivalue_stream) == [0, 0, 2, 4, 4, 8] assert recent_values(multivalue_map) == recent_values( multivalue_stream) assert recent_values(r) == [10, 12, 14, 16, 18] assert recent_values(stream_test_args) == recent_values(r) assert recent_values(u) == recent_values(r) assert recent_values(s) == [10, 14, 18, 22, 26] assert recent_values(s) == recent_values(t) assert recent_values(q) == [0, 2, 4] assert recent_values(q) == recent_values(p) #---------------------------------------------------------------- #---------------------------------------------------------------- w.append(0) run() assert recent_values(x) == [0, 1, 2, 3, 4] assert recent_values(y) == [0, 2, 4, 6, 8] assert recent_values(ymap) == recent_values(y) assert recent_values(yfilter) == [0, 1, 2] assert recent_values(z) == [0, 3, 6, 9, 12] assert recent_values(bmap) == recent_values(z) assert recent_values(v) == [10, 13, 16, 19, 22] assert recent_values(no_value_stream) == [0, 2, 4] assert recent_values(no_value_map) == recent_values(no_value_stream) assert recent_values(multivalue_stream) == [0, 0, 2, 4, 4, 8] assert recent_values(multivalue_map) == recent_values( multivalue_stream) assert recent_values(r) == [10, 12, 14, 16, 18] assert recent_values(stream_test_args) == recent_values(r) assert recent_values(u) == recent_values(r) assert recent_values(s) == [10, 14, 18, 22, 26] assert recent_values(s) == recent_values(t) assert recent_values(q) == [0, 2, 4] assert recent_values(q) == recent_values(p) #---------------------------------------------------------------- #------------------------------------------------------------------------------------------------ # ELEMENT AGENT TESTS FOR STREAM ARRAY #------------------------------------------------------------------------------------------------ import numpy as np m = StreamArray('m') n = StreamArray('n') o = StreamArray('o') map_element(func=np.sin, in_stream=m, out_stream=n) filter_element(func=lambda v: v <= 0.5, in_stream=n, out_stream=o) input_array = np.linspace(0.0, 2 * np.pi, 20) m.extend(input_array) run() expected_output = np.sin(input_array) assert np.array_equal(recent_values(n), expected_output) expected_output = expected_output[expected_output <= 0.5] assert np.array_equal(recent_values(o), expected_output) return
def f(in_streams, out_streams): map_element(lambda v: v + 100, in_streams[0], out_streams[0])
def f(in_streams, out_streams, ADDEND): map_element(lambda a: a + ADDEND, in_streams[0], out_streams[0])
def g(in_streams, out_streams, q): s = Stream('s') map_element(lambda v: v * 2, in_streams[0], s) stream_to_queue(s, q)
def test_multithread_2(self): from IoTPy.agent_types.sink import sink_element, stream_to_queue from IoTPy.agent_types.merge import zip_map, zip_stream from IoTPy.agent_types.op import map_element # Declare output queues z_q = queue.Queue() b_q = queue.Queue() # Create threads to read output queues of IoTPy thread. z_output = [] z_output_thread = threading.Thread(target=self.output_thread_target, args=(z_q, z_output)) b_output = [] b_output_thread = threading.Thread(target=self.output_thread_target, args=(b_q, b_output)) # Declare streams x = Stream('x') y = Stream('y') z = Stream('z') a = Stream('a') b = Stream('b') # Declare agents zip_stream(in_streams=[x, y], out_stream=z) stream_to_queue(z, z_q) def g(v): return 2 * v map_element(func=g, in_stream=a, out_stream=b) stream_to_queue(b, b_q) # Create threads ithread_1 = iThread(in_streams=[x, y], output_queues=[z_q]) ithread_2 = iThread(in_streams=[a], output_queues=[b_q]) # Start threads. ithread_1.start() ithread_2.start() z_output_thread.start() b_output_thread.start() # Put data into streams. x_data = list(range(5)) y_data = list(range(100, 105)) a_data = list(range(1000, 1008)) ithread_1.extend(in_stream_name='x', list_of_elements=x_data) ithread_1.extend(in_stream_name='y', list_of_elements=y_data) ithread_2.extend(in_stream_name='a', list_of_elements=a_data) # Indicate stream is finished ithread_1.finished() ithread_2.finished() # Join threads ithread_1.join() ithread_2.join() z_output_thread.join() b_output_thread.join() # Check output assert z_output == list(zip(x_data, y_data)) assert b_output == [g(v) for v in a_data]
def g(in_streams, out_streams): s = Stream('s') map_element(lambda v: v * 2, in_streams[0], s) print_stream(s, 's')