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))
def test_filter_number_2(self): in_stream = Stream('input') out_stream = Stream('output') def f(v, threshold): # v is an element of the input stream # threshold is a constant return v > threshold # Create an agent by encapsulating f. filter_element(f, in_stream, out_stream, threshold=10) input_list = list(range(-20, 20)) in_stream.extend(input_list) run() assert recent_values(out_stream) == list(range(11, 20))
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_example_2(self): # Specify streams x = Stream('x') y = Stream('y') # Specify encapsulated functions (if any) def f(v): return v < 3 # Specify agents. filter_element(func=f, in_stream=x, out_stream=y) # Execute a step # Put test values in the input streams. x.extend(list(range(5))) # Execute a step run() # Look at recent values of output streams. assert recent_values(y) == [0, 1, 2]
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_filter_number_4(self): in_stream = Stream('input') out_stream = Stream('output') def f(v, w, increase): # v is an element of the input stream # w is the current state # increase is a constant parameter specified in the # call that creates the agent # return (1) a Boolean and (2) the next state. # In this example, the next state is the current input v. return v < w * increase, v # Create an agent by encapsulating function f. This agent # has an initial state of 0, and a parameter, increase, with constant value 1.01 filter_element(f, in_stream, out_stream, state=0, increase=1.01) input_list = [10, 10, 9, 200, 201, 200, 202, 203, 1, 0, 2] in_stream.extend(input_list) run() assert recent_values(out_stream) == [10, 9, 201, 200, 203, 1, 0]
def test_filter_number_3(self): in_stream = Stream('input') out_stream = Stream('output') def f(v, w): # w is the current state. # v is the current element of the input stream. # Returns: (1) a boolean: v <= w # If this boolean is true then # v appears in the output. # (2) the next state, v. # The next state is the current input, v. # Keeps those elements in the stream that are # decreasing return v < w, v # Create an agent with an initial state of 0 filter_element(f, in_stream, out_stream, state=0) input_list = [10, 9, 5, 7, 8, 12, 11, 3, 6, 9] in_stream.extend(input_list) run() assert recent_values(out_stream) == [9, 5, 11, 3]
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