def stream_to_output(input_stream, num_channels=1, \ sample_width=2, frame_rate=44100): """ Parameters ---------- py_audio: instance of PyAudio input_stream: Stream of audio samples num_channels: number of audio channels (1 or 2 for mono/stereo) sample_width: number of bytes per sample frame_rate: rate at which samples are played back (samples/second) """ py_audio = pyaudio.PyAudio() logging.info('Preparing output audio stream') audio_stream = py_audio.open(format=py_audio.get_format_from_width(sample_width), channels=num_channels, rate=frame_rate, output=True, input=False) wf = wave.open("modified.wav", 'wb') wf.setsampwidth(sample_width) wf.setnchannels(num_channels) wf.setframerate(frame_rate) def write_samples_to_output(formatted_samples): print "Play" audio_stream.write(formatted_samples.encode("ISO-8859-1")) wf.writeframes(formatted_samples.encode("ISO-8859-1")) stream_agent(inputs=input_stream, outputs=[], f_type='element', f=write_samples_to_output)
def make_output_manager(stream_dict, output_stream_names_dict): output_stream_names_list = output_stream_names_dict.keys() output_stream_list = [stream_dict[stream_name] for stream_name in output_stream_names_list] print " output_stream_names_list", output_stream_names_list print "output_stream_list", output_stream_list def send_message_to_queue(value_and_index_tuple): message_content, stream_index = value_and_index_tuple output_stream_name = output_stream_names_list[stream_index] receiver_queue = output_stream_names_dict[output_stream_name] message = (output_stream_name, message_content) receiver_queue.put(message) stream_agent(inputs=output_stream_list, outputs=None, f_type="asynch_element", f=send_message_to_queue, f_args=None)
def echo_list(in_stream, out_stream): def _copy(lst): print 'echo, lst = ', lst return lst return stream_agent( inputs=in_stream, outputs= out_stream, f_type='list', f=_copy)
def echo(in_stream, out_stream): def _copy(v): print 'echo, v = ', v return v return stream_agent( inputs=in_stream, outputs= out_stream, f_type='element', f=_copy)
def test(): in_1 = Stream(name='in_1') out_1 = Stream(name='out_1') out_2 = Stream(name= 'out_2') check(out_1, [4, 8]) check(out_2, [3, 5]) stream_agent( inputs=in_1, outputs=[out_1, out_2], f_type='element', f=number_even_odd) in_1.extend([3, 4, 5, 8]) out_1.print_recent() out_2.print_recent() check_empty()
def echo(in_streams, out_streams): def _copy(v_list): print 'echo, v_list = ', v_list return [v_list[1], v_list[0]] return stream_agent( inputs=in_streams, outputs= out_streams, f_type='element', f=_copy)
def add_count(in_stream, out_stream): def _add(v,count): print 'output is ', v+1 return (v+1, count+1) return stream_agent( inputs=in_stream, outputs= out_stream, f_type='element', f=_add, state=0)
def single_stream_of_random_numbers(trigger_stream, out_stream): def ran(): return random.random() return stream_agent( inputs=None, f_type='element', f=ran, outputs=out_stream, call_streams=[trigger_stream])
def make_output_manager(stream_dict, output_stream_names_dict): output_stream_names_list = output_stream_names_dict.keys() output_stream_list = \ [stream_dict[stream_name] for stream_name in output_stream_names_list] print ' output_stream_names_list', output_stream_names_list print 'output_stream_list', output_stream_list def send_message_to_queue(value_and_index_tuple): message_content, stream_index = value_and_index_tuple output_stream_name = output_stream_names_list[stream_index] receiver_queue = output_stream_names_dict[output_stream_name] message = (output_stream_name, message_content) receiver_queue.put(message) stream_agent( inputs=output_stream_list, outputs=None, f_type='asynch_element', f=send_message_to_queue, f_args=None)
def keep_every_nth_value(input_stream, output_stream, n): def drop(lst): print "Drop" return lst[0] return stream_agent( inputs=input_stream, # The input is input_stream outputs=output_stream, f_type='window', # Identifies 'window' wrapper f=drop, # The function that is wrapped window_size=n, step_size=n)
def package_into_lists(input_stream, output_stream, window_size): def identity(lst): print "Package" return lst return stream_agent( inputs=input_stream, # The input is input_stream outputs=output_stream, f_type='window', # Identifies 'window' wrapper f=identity, # The function that is wrapped window_size=window_size, step_size=window_size)
def print_agent(input_streams, output_streams): input_stream = input_streams[0] def p(v): if v != _close: print 'print_agent', input_stream.name, v return stream_agent( inputs=input_stream, outputs=[], f_type='element', f=p)
def print_agent(input_streams, output_streams): from Stream import Stream, _close, _no_value from Operators import stream_agent, stream_agent input_stream = input_streams[0] def p(v): if v != _close: print 'print_agent', input_stream.name, v return stream_agent( inputs=input_stream, outputs=[], f_type='element', f=p)
def insert_interpolated_values(input_stream, output_stream, n): def interpolate(lst): if len(lst) < 2: return lst increment = (lst[1] - lst[0])/float(n) return_list = [lst[0]+k*increment for k in range(n)] return _multivalue(return_list) return stream_agent( inputs=input_stream, # The input is input_stream outputs=output_stream, f_type='window', # Identifies 'window' wrapper f=interpolate, # The function that is wrapped window_size=2, step_size=1)
def echo_n_times(in_stream, out_stream, n): def echo_value(v,count): if count < n: print 'echo_value. receive', v count += 1 return(v+1, count) else: return(_close, count) return stream_agent( inputs=in_stream, outputs=out_stream, f_type='element', f=echo_value, state=0)
def number_even_odd(m): if m%2: # since n is odd, the zero-th element is # _no_value, and the first element is n # in the returned list return [_no_value, m] else: # since n is even, the zero-th element is # n, and the first element is _no_value # in the returned list. return [m, _no_value] return stream_agent( inputs=in_stream, outputs=[out_stream_0, out_stream_1], f_type='element', f=number_even_odd)
def apply_func_agent(input_streams, output_streams): input_stream = input_streams[0] output_stream = output_streams[0] def apply_func(v): # When the input stream is closed, return # _close to cause the output stream to close. if v == _close: return _close else: return f(v) return stream_agent( inputs=input_stream, outputs=output_stream, f_type='element', f=apply_func)
def format_audio_output(input_stream, output_stream): """ Parameters ---------- stream: stream of lists of shorts that need to be converted to byte data for audio output """ def format_data(shorts): print "Format" format = 'h'*len(shorts) packed = struct.pack(format, *shorts) return packed return stream_agent( inputs=input_stream, outputs=output_stream, f_type='element', f=format_data)
def apply_func_agent(input_streams, output_streams): from Stream import Stream, _close, _no_value from Operators import stream_agent, stream_agent def f(v): return 2*v input_stream = input_streams[0] output_stream = output_streams[0] def apply_func(v): # When the input stream is closed, return # _close to cause the output stream to close. if v == _close: return _close else: print "Apply func" return f(v) return stream_agent( inputs=input_stream, outputs=output_stream, f_type='element', f=apply_func)
def make_output_manager(self): """ Creates an agent, called the output manager, that receives messages on streams and inserts these messages into queues. The output manager receives messages on all streams in the list output_streams and output_streams[j] is associated with the list of queues, output_queues_list[j]. Note that output_queues_list[j] is a list of queues and not a singleton queue. A message that arrives on the stream output_streams[j] is copied to each of the queues in output_queues_list[j]. When a message is placed in a queue the message is a tuple (stream_name, message_content). Each queue is either Multiprocessing.Queue or StreamPy.RemoteQueue. Parameters ---------- output_streams : list of Stream list of output streams output_queues_list : list of list of Queue list of list of output queues. output_queues_list[j] is the list of queues to which messages in output_streams[j] should be sent. assert len(output_streams) == len(output_queues_list) Returns ------- None """ # The sequential program that implements state-transitions of the agent. def send_message_to_queue(msg_content_and_stream_index_tuple): """ The parameter msg_content_and_stream_index_tuple specifies the content of a message and an index, j, which specifies a stream, namely output_streams[j]. Append the message content to the each of the queues in the list of queues, output_queues_list[j]. The message placed on the queue is a tuple (output_stream_name, message_content). Parameter --------- msg_content_and_index_tuple: tuple (message_content, stream_index) message_content: value to be inserted into queues of processes that receive the specified stream. stream_index: int The slot of the sending stream in the list output_stream_names_list. """ message_content, stream_index = msg_content_and_stream_index_tuple # receiver_queue_list is the list of queues to # which this message is copied. receiver_process_list = self.output_process_list[stream_index] # output_streams[stream_index] is the output stream # on which this message arrived. # output_stream_name is the name of the stream on which # this message arrived. output_stream_name = self.output_streams[stream_index].name # The messages in the queue must be serializable. The # object _close is not serializable; so convert it into a # string '_close'. The receiving agent will convert this # string back into the object _close. if message_content is _close: message_content = '_close' # The message placed in each of the receiver queues is # a tuple (name of the stream, content of the message). message = json.dumps((output_stream_name, message_content)) for process_id in receiver_process_list: if process_id not in self.process_conns: self.process_conns[process_id] = self.node.create_process_conn(process_id) print "Process {0} sending message {1} to process {2}".format(self.id, message, process_id) self.process_conns[process_id].send(message) self.process_conns[process_id].close() del self.process_conns[process_id] print "Success!" return _no_value # Create the agent stream_agent( # The agent listens to output streams of func inputs=self.output_streams, # The agent does not generate its own output streams. outputs=[Stream('empty_stream')], # The agent processes messages from all its input # streams as the messages arrive. The agent does not # synchronize messages across different input streams. # So, f_type is 'asynch_element' rather than 'element'. f_type='asynch_element', f=send_message_to_queue)
print 'put message', message receiver_queue.put(message) #time.sleep(0.1) except Exception, err: print 'Error', err return return _no_value # Create the agent stream_agent( # The agent listens to output streams of func inputs=output_streams, # The agent does not generate its own output streams. outputs=[Stream('empty_stream')], # The agent processes messages from all its input # streams as the messages arrive. The agent does not # synchronize messages across different input streams. # So, f_type is 'asynch_element' rather than 'element'. f_type='asynch_element', f=send_message_to_queue) def make_process( input_stream_names, output_stream_names, func, input_queue, output_queues_list): """ Makes a process that gets messages on its single input queue, processes the messages and puts messages on its output queues. An output queue of this process is an input queue of another process.
def make_output_manager(output_streams, output_conn_list): """ Creates an agent, called the output manager, that receives messages on streams and inserts these messages into queues. The output manager receives messages on all streams in the list output_streams and output_streams[j] is associated with the list of queues, output_queues_list[j]. Note that output_queues_list[j] is a list of queues and not a singleton queue. A message that arrives on the stream output_streams[j] is copied to each of the queues in output_queues_list[j]. When a message is placed in a queue the message is a tuple (stream_name, message_content). Each queue is either Multiprocessing.Queue or StreamPy.RemoteQueue. Parameters ---------- output_streams : list of Stream list of output streams output_queues_list : list of list of Queue list of list of output queues. output_queues_list[j] is the list of queues to which messages in output_streams[j] should be sent. assert len(output_streams) == len(output_queues_list) Returns ------- None """ # The sequential program that implements state-transitions of the agent. def send_message_to_queue(msg_content_and_stream_index_tuple): """ The parameter msg_content_and_stream_index_tuple specifies the content of a message and an index, j, which specifies a stream, namely output_streams[j]. Append the message content to the each of the queues in the list of queues, output_queues_list[j]. The message placed on the queue is a tuple (output_stream_name, message_content). Parameter --------- msg_content_and_index_tuple: tuple (message_content, stream_index) message_content: value to be inserted into queues of processes that receive the specified stream. stream_index: int The slot of the sending stream in the list output_stream_names_list. """ message_content, stream_index = msg_content_and_stream_index_tuple # receiver_queue_list is the list of queues to # which this message is copied. receiver_conn_list = output_conn_list[stream_index] # output_streams[stream_index] is the output stream # on which this message arrived. # output_stream_name is the name of the stream on which # this message arrived. output_stream_name = output_streams[stream_index].name # The messages in the queue must be serializable. The # object _close is not serializable; so convert it into a # string '_close'. The receiving agent will convert this # string back into the object _close. if message_content is _close: message_content = '_close' # The message placed in each of the receiver queues is # a tuple (name of the stream, content of the message). message = json.dumps((output_stream_name, message_content)) for receiver_conn in receiver_conn_list: host, port = receiver_conn try: logging.info('make_output_manager. send_message_to_queue') logging.info('put message' + str(message)) logging.info("Connecting to {0}:{1}".format(host, port)) s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) s.connect((host, port)) s.send(message) s.close() except socket.error as error_msg: logging.error(error_msg) continue return _no_value # Create the agent stream_agent( # The agent listens to output streams of func inputs=output_streams, # The agent does not generate its own output streams. outputs=[Stream('empty_stream')], # The agent processes messages from all its input # streams as the messages arrive. The agent does not # synchronize messages across different input streams. # So, f_type is 'asynch_element' rather than 'element'. f_type='asynch_element', f=send_message_to_queue)
def make_output_manager(output_streams, output_conn_list): """ Creates an agent, called the output manager, that receives messages on streams and inserts these messages into queues. The output manager receives messages on all streams in the list output_streams and output_streams[j] is associated with the list of queues, output_queues_list[j]. Note that output_queues_list[j] is a list of queues and not a singleton queue. A message that arrives on the stream output_streams[j] is copied to each of the queues in output_queues_list[j]. When a message is placed in a queue the message is a tuple (stream_name, message_content). Each queue is either Multiprocessing.Queue or StreamPy.RemoteQueue. Parameters ---------- output_streams : list of Stream list of output streams output_queues_list : list of list of Queue list of list of output queues. output_queues_list[j] is the list of queues to which messages in output_streams[j] should be sent. assert len(output_streams) == len(output_queues_list) Returns ------- None """ # The sequential program that implements state-transitions of the agent. def send_message_to_queue(msg_content_and_stream_index_tuple): """ The parameter msg_content_and_stream_index_tuple specifies the content of a message and an index, j, which specifies a stream, namely output_streams[j]. Append the message content to the each of the queues in the list of queues, output_queues_list[j]. The message placed on the queue is a tuple (output_stream_name, message_content). Parameter --------- msg_content_and_index_tuple: tuple (message_content, stream_index) message_content: value to be inserted into queues of processes that receive the specified stream. stream_index: int The slot of the sending stream in the list output_stream_names_list. """ message_content, stream_index = msg_content_and_stream_index_tuple # receiver_queue_list is the list of queues to # which this message is copied. receiver_conn_list = output_conn_list[stream_index] # output_streams[stream_index] is the output stream # on which this message arrived. # output_stream_name is the name of the stream on which # this message arrived. output_stream_name = output_streams[stream_index].name # The messages in the queue must be serializable. The # object _close is not serializable; so convert it into a # string '_close'. The receiving agent will convert this # string back into the object _close. if message_content is _close: message_content = '_close' # The message placed in each of the receiver queues is # a tuple (name of the stream, content of the message). message = json.dumps((output_stream_name, message_content)) for receiver_conn in receiver_conn_list: host, port = receiver_conn try: logging.info('make_output_manager. send_message_to_queue') logging.info('put message' + str(message)) logging.info("Connecting to {0}:{1}".format(host, port)) s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) s.connect((host, port)) s.send(message) s.close() except socket.error as error_msg: logging.error(error_msg) continue return _no_value # Create the agent stream_agent( # The agent listens to output streams of func inputs=output_streams, # The agent does not generate its own output streams. outputs=[Stream('empty_stream')], # The agent processes messages from all its input # streams as the messages arrive. The agent does not # synchronize messages across different input streams. # So, f_type is 'asynch_element' rather than 'element'. f_type='asynch_element', f=send_message_to_queue)
from Stream import Stream from Operators import stream_agent from examples_element_wrapper import print_stream import numpy as np """ Example of an element-wrapper to create an agent with a single input stream and a single output stream. The function that is wrapped is np.sin. """ # Create a stream x and call it 'input' input_stream = Stream('input') # Create a stream y and call it 'sine of input' output_stream = Stream('sine of input') # Create an agent that prints stream input_stream. # This agent will print elements that enter input_stream. print_stream(input_stream) # Create an agent that prints stream output_stream. print_stream(output_stream) # Create an agent that puts the sine of elements of # input_stream into output_stream. This agent is created by # wrapping np.sin using the element wrapper. # As elements are added to input_stream, this agent will put # sine of these elements in output_stream. stream_agent(inputs=input_stream, outputs=output_stream, f_type='element', f=np.sin) # Put numbers into the input stream to drive all # the other agents. for _ in range(2): input_stream.extend(np.linspace(0, np.pi, 8))
def make_network(stream_names_tuple, agent_descriptor_dict): """ This function makes a network of agents given the names of the streams in the network and a description of the agents in the network. Parameters ---------- stream_names_tuple: tuple of lists A tuple consisting of names of streams in the network. Each stream in the network must have a unique name. agent_descriptor_dict: dict of tuples The key is an agent name The value is a tuple: in_list, out_list, f, f_type, f_args, state where: in_list: list of input stream names out_list: list of output stream names f: function associated with the agent f_type: 'element', 'list', 'window', etc f_args: tuple of arguments for functions f state: the state associated with this agent. Local Variables --------------- stream_dict: dict key: stream name value: Stream agent_dict: dict key: agent name value: agent with the specified description: in_list, out_list, f, f_type, f_args, state, call_streams=[timer_stream] where one timer stream is associated with each agent. agent_timer_dict: dict key: agent_name value: Stream The value is the timer stream associated with the agent. When the timer stream has a message, the agent is made to execute a step. """ # Create streams and insert streams into stream_dict. stream_dict = dict() for stream_name in stream_names_tuple: stream_dict[stream_name] = Stream(stream_name) agent_dict = dict() agent_timer_dict = dict() # Create agents with the specified description # and put the agents into agent_dict. for agent_name in agent_descriptor_dict.keys(): in_list, out_list, f, f_type, f_args, state, call_streams = \ agent_descriptor_dict[agent_name] # Replace a list consisting of a single input stream # by the stream itself. if len(in_list) == 1: single_input_stream_name = in_list[0] inputs = stream_dict[single_input_stream_name] else: inputs = list() for input_stream_name in in_list: inputs.append(stream_dict[input_stream_name]) # Replace a list consisting of a single output stream # by the stream itself. if len(out_list) == 1: single_output_stream_name = out_list[0] outputs = stream_dict[single_output_stream_name] else: outputs = list() for output_stream_name in out_list: outputs.append(stream_dict[output_stream_name]) # Create timer streams and insert them into agent_timer_dict agent_timer_dict[agent_name] = Stream(agent_name + ':timer') # Create agents and insert them into agent_dict agent_dict[agent_name] = stream_agent( inputs, outputs, f_type, f, f_args, state, call_streams=[agent_timer_dict[agent_name]]) # Set the name for this agent. agent_dict[agent_name].name = agent_name return (stream_dict, agent_dict, agent_timer_dict)
from examples_element_wrapper import print_stream import numpy as np from random import random """ Simple example of a windows-wrapper. """ x = Stream('x') y = Stream('y') z = Stream('z') print_stream(x) print_stream(y) print_stream(z) stream_agent(inputs=x, outputs=y, f_type='window', f=np.mean, window_size=5, step_size=5) # Alternative form wf(x, z, np.mean, 5, 5) x.extend([99.5+random() for _ in range(21)]) # Second example # Illustrates that step_size may be larger than window_size. # Stream b samples every n-th element of stream a. a = Stream('a') b = Stream('b') print_stream(a) print_stream(b) n = 6 wf(a, b, lambda l: l[0], 1, n) a.extend(range(18))
def make_network(stream_names_tuple, agent_descriptor_dict): """ This function makes a network of agents given the names of the streams in the network and a description of the agents in the network. Parameters ---------- stream_names_tuple: tuple of lists A tuple consisting of names of streams in the network. Each stream in the network must have a unique name. agent_descriptor_dict: dict of tuples The key is an agent name The value is a tuple: in_list, out_list, f, f_type, f_args, state where: in_list: list of input stream names out_list: list of output stream names f: function associated with the agent f_type: 'element', 'list', 'window', etc f_args: tuple of arguments for functions f state: the state associated with this agent. Local Variables --------------- stream_dict: dict key: stream name value: Stream agent_dict: dict key: agent name value: agent with the specified description: in_list, out_list, f, f_type, f_args, state, call_streams=[timer_stream] where one timer stream is associated with each agent. agent_timer_dict: dict key: agent_name value: Stream The value is the timer stream associated with the agent. When the timer stream has a message, the agent is made to execute a step. """ # Create streams and insert streams into stream_dict. stream_dict = dict() for stream_name in stream_names_tuple: stream_dict[stream_name] = Stream(stream_name) agent_dict = dict() agent_timer_dict = dict() # Create agents with the specified description # and put the agents into agent_dict. for agent_name in agent_descriptor_dict.keys(): in_list, out_list, f, f_type, f_args, state, call_streams = \ agent_descriptor_dict[agent_name] # Replace a list consisting of a single input stream # by the stream itself. if len(in_list) == 1: single_input_stream_name = in_list[0] inputs = stream_dict[single_input_stream_name] else: inputs = list() for input_stream_name in in_list: inputs.append(stream_dict[input_stream_name]) # Replace a list consisting of a single output stream # by the stream itself. if len(out_list) == 1: single_output_stream_name = out_list[0] outputs = stream_dict[single_output_stream_name] else: outputs = list() for output_stream_name in out_list: outputs.append(stream_dict[output_stream_name]) # Create timer streams and insert them into agent_timer_dict agent_timer_dict[agent_name] = Stream( agent_name + ':timer') # Create agents and insert them into agent_dict agent_dict[agent_name] = stream_agent( inputs, outputs, f_type, f, f_args, state, call_streams=[agent_timer_dict[agent_name]]) # Set the name for this agent. agent_dict[agent_name].name = agent_name return (stream_dict, agent_dict, agent_timer_dict)
#_____________________________________________________ #_____________________________________________________ # EXAMPLE 1A. SAME EXAMPLE USING AGENTS #_____________________________________________________ #_____________________________________________________ # MEAN OF SLIDING WINDOW # USES STREAM_AGENT RATHER THAN STREAM_FUNC #_____________________________________________________ mean_of_x_a = Stream('Mean of x for agent') stream_agent( inputs=x, outputs=mean_of_x_a, f_type='window', f=np.mean, window_size=window_size, step_size=step_size) print_stream(mean_of_x_a) # Drive the example. # Add values to stream x. x.extend([random.random() for _ in range(N)]) #_____________________________________________________ # EXAMPLE 2. STANDARD DEVIATION OF SLIDING WINDOW #_____________________________________________________ # SPECIFICATION:
#_____________________________________________________ #_____________________________________________________ # EXAMPLE 1A. SAME EXAMPLE USING AGENTS #_____________________________________________________ #_____________________________________________________ # MEAN OF SLIDING WINDOW # USES STREAM_AGENT RATHER THAN STREAM_FUNC #_____________________________________________________ mean_of_x_a = Stream('Mean of x for agent') stream_agent( inputs=x, outputs=mean_of_x_a, f_type='window', f=np.mean, window_size=window_size, step_size=step_size) print_stream(mean_of_x_a) # Drive the example. # Add values to stream x. x.extend([random.random() for _ in range(N)]) #_____________________________________________________ # EXAMPLE 2. STANDARD DEVIATION OF SLIDING WINDOW #_____________________________________________________ # SPECIFICATION: