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)
