async def _call_handlers_for_packet(data, client_address, dispatcher): handler_futures = [] try: packet = osc_packet.OscPacket(data) for timed_msg in packet.messages: handlers = dispatcher.handlers_for_address( timed_msg.message.address) if not handlers: continue for handler in handlers: handler_futures.append( asyncio.ensure_future( _handle_callback( handler, timed_msg.message.address, client_address, timed_msg.time, *timed_msg.message, ))) except: # osc_packet.ParseError: # Pass? Probably not best, but this is a re-implementation for now #pass raise finally: if len(handler_futures): await asyncio.wait(handler_futures)
def call_handlers_for_packet(self, data, client_address): """ This function calls the handlers registered to the dispatcher for every message it found in the packet. The process/thread granularity is thus the OSC packet, not the handler. If parameters were registered with the dispatcher, then the handlers are called this way: handler('/address that triggered the message', registered_param_list, osc_msg_arg1, osc_msg_arg2, ...) if no parameters were registered, then it is just called like this: handler('/address that triggered the message', osc_msg_arg1, osc_msg_arg2, osc_msg_param3, ...) """ # Get OSC messages from all bundles or standalone message. try: packet = osc_packet.OscPacket(data) for timed_msg in packet.messages: now = time.time() handlers = self.handlers_for_address(timed_msg.message.address) if not handlers: continue # If the message is to be handled later, then so be it. if timed_msg.time > now: time.sleep(timed_msg.time - now) for handler in handlers: handler.invoke(client_address, timed_msg.message) except osc_packet.ParseError: pass
def call_handlers_for_packet(self, data: bytes, client_address: Tuple[str, int]) -> None: """Invoke handlers for all messages in OSC packet The incoming OSC Packet is decoded and the handlers for each included message is found and invoked. Args: data: Data of packet client_address: Address of client this packet originated from """ # Get OSC messages from all bundles or standalone message. try: packet = osc_packet.OscPacket(data) for timed_msg in packet.messages: now = time.time() handlers = self.handlers_for_address(timed_msg.message.address) if not handlers: continue # If the message is to be handled later, then so be it. if timed_msg.time > now: time.sleep(timed_msg.time - now) for handler in handlers: handler.invoke(client_address, timed_msg.message) except osc_packet.ParseError: pass
def receive_message_from_client(localclient): data, server = localclient._sock.recvfrom(4096) packet = osc_packet.OscPacket(data) for timed_msg in packet.messages: now = time.time() return timed_msg.message.params
def handle(self): data = self.request[0].strip() socket = self.request[1] client_address = self.client_address[0] packet = osc_packet.OscPacket(data) for osc_msg in packet.messages: check_rules(client_address, osc_msg.message.address, osc_msg.message.params[0])
def handle(self): data = self.request[0].strip() socket = self.request[1] client_address = self.client_address[0] packet = osc_packet.OscPacket(data) for osc_msg in packet.messages: print("Received from [" + client_address + "/" + osc_msg.message.address + "]: '" + osc_msg.message.params[0] + "'")
def handle(self): data = self.request[0].strip() # Get OSC messages from all bundles or standalone message. try: packet = osc_packet.OscPacket(data) for timed_msg in packet.messages: now = calendar.timegm(time.gmtime()) handlers = self.server.dispatcher.handlers_for_address( timed_msg.message.address) if not handlers: continue # If the message is to be handled later, then so be it. if timed_msg.time > now: time.sleep(timed_msg.time - now) for handler in handlers: if handler.args: handler.callback(handler.args, *timed_msg.message) else: handler.callback(*timed_msg.message) except osc_packet.ParseError: pass
def handle_request(self, request): try: packet = osc_packet.OscPacket(request[0]) for timed_msg in packet.messages: now = time.time() handlers = self.dispatcher.handlers_for_address( timed_msg.message.address) if not handlers: continue # If the message is to be handled later, then so be it. if timed_msg.time > now: time.sleep(timed_msg.time - now) for handler in handlers: if handler.args: handler.callback(timed_msg.message.address, handler.args, *timed_msg.message) else: handler.callback(timed_msg.message.address, *timed_msg.message) except osc_packet.ParseError: pass
def test_nested_mess_bundle(self): packet = osc_packet.OscPacket(_DGRAM_NESTED_MESS) self.assertEqual(4, len(packet.messages)) self.assertTrue(packet.messages[0][0], packet.messages[1][0]) self.assertTrue(packet.messages[1][0], packet.messages[2][0]) self.assertTrue(packet.messages[2][0], packet.messages[3][0])
def test_empty_bundle(self): packet = osc_packet.OscPacket(_DGRAM_EMPTY_BUNDLE) self.assertEqual(0, len(packet.messages))
def test_two_messages_in_a_bundle(self): packet = osc_packet.OscPacket(_DGRAM_TWO_MESSAGES_IN_BUNDLE) self.assertEqual(2, len(packet.messages))
async def ws_broadcast(self, dgram: bytes) -> None: """broadcast is called when OSC packets arrive from REAPER""" for timed_msg in osc_packet.OscPacket(dgram).messages: self._state[timed_msg.message.address] = timed_msg.message await super().ws_broadcast(dgram)