async def init_main():
"""
Asynchronous main, to be called from main()
"""
global config
global outputs
print("Setting up dispatcher")
dispatcher = Dispatcher()
dispatcher.map("/*", update_outputs)
print("Starting Client for {}:{}".format(config["Client"]["ip"],
config["Client"]["port"]))
client = udp_client.SimpleUDPClient(config["Client"]["ip"],
config["Client"]["port"])
client.send_message("/setBankStart", 1.0)
client.send_message("/1/busOutput", 1.0)
outputs.register_client(client)
print("Starting Server at {}:{}".format(config["Server"]["ip"],
config["Server"]["port"]))
server = AsyncIOOSCUDPServer(
(config["Server"]["ip"], config["Server"]["port"]), dispatcher,
asyncio.get_event_loop())
# Create datagram endpoint and start serving
transport, protocol = await server.create_serve_endpoint()
print("Listening...")
await loop()
transport.close()
class OscReceiver(threading.Thread):
def __init__(self,
ip,
receive_from_port,
quit_event,
address_list=["/clock*"],
address_handler_list=[None]):
"""
Constructor for OSC_SENDER CLASS
:param ip: ip address of client ==> 127.0.0.1 (for local host/ inter app communication on same machine)
:param receive_from_port: the port on which python listens for incoming data
"""
super(OscReceiver, self).__init__()
self.setDaemon(
True) # don't forget this line, otherwise, the thread never ends
self.ip = ip
self.receiving_from_port = receive_from_port
self.listening_thread = None
self.dispatcher = Dispatcher()
for ix, address in enumerate(address_list):
self.dispatcher.map(address, address_handler_list[ix])
self.dispatcher.set_default_handler(self.default_handler)
self.server = BlockingOSCUDPServer((self.ip, self.receiving_from_port),
self.dispatcher)
#self.server.request_queue_size = 0
self.quit_event = quit_event
def run(self):
print("running --- waiting for data")
count = 0
while not self.quit_event.is_set():
self.server.handle_request()
#count = (count+1) #% 8
#print("count {}".format(count))
def default_handler(self, address, *args):
# handler for osc messages with no specific defined decoder/handler
print(f"DEFAULT {address}: {args}")
def get_ip(self):
return self.ip
def get_receiving_from_port(self):
return self.receiving_from_port
def get_server(self):
return self.server
def change_ip_port(self, ip, port):
self.ip = ip
self.receiving_from_port = port
self.server = BlockingOSCUDPServer(self.ip, self.receiving_from_port)
def main_func(ip, port):
dispatcher = Dispatcher()
dispatcher.map("/Chordata/r*", data_handler)
dispatcher.set_default_handler(default_handler)
server = BlockingOSCUDPServer((ip, port), dispatcher)
server.serve_forever() # Blocks forever
def __init__(self,
ip: str = "127.0.0.1",
port_in: int = 8081,
port_out: int = 8080,
recv_address: str = "/pyosc",
parse_parenthesis_as_list: bool = False,
discard_duplicate_arguments: bool = True,
send_format: SendFormat = SendFormat.FLATTEN,
osc_log_level: Optional[int] = logging.INFO):
"""
:param ip:
:param port_in:
:param port_out:
:param parse_parenthesis_as_list:
:param send_format:
:param osc_log_level: Forward log messages to Max. Will not forward if set to None. To forward only some messages, override _handle_max_osc_error, _handle_type_error or _handle_error
"""
super(MaxOsc, self).__init__(parse_parenthesis_as_list,
discard_duplicate_arguments)
self.logger = logging.getLogger(__name__)
self.sender: Sender = Sender(ip, port_out, send_format)
if osc_log_level:
handler: OscLogHandler = OscLogHandler(self.sender, osc_log_level)
self.logger.addHandler(handler)
dispatcher = Dispatcher()
dispatcher.map(recv_address, self.main_callback)
dispatcher.set_default_handler(self._default_handler)
self._server = BlockingOSCUDPServer((ip, port_in), dispatcher)
self.logger.info(
f"MaxOsc initialized on ip {ip} with incoming port {port_in} and outgoing port {port_out}."
)
async def init_main():
"""
https://python-osc.readthedocs.io/en/latest/server.html#async-server
https://web.archive.org/web/20170809181820/http://developer.choosemuse.com/research-tools-example/grabbing-data-from-museio-a-few-simple-examples-of-muse-osc-servers
https://addshore.com/2018/06/python3-using-some-shared-state-in-2-async-methods/
:return:
"""
# with the connection made and inital state set, can start the main loops.
# https://python-osc.readthedocs.io/en/latest/dispatcher.html
# https://python-osc.readthedocs.io/en/latest/server.html#async-server
event_loop_local = asyncio.get_event_loop()
dispatcher = Dispatcher()
dispatcher.map("/muse/elements/experimental/concentration",
concentration_handler)
# creates an OSC server that's Async.
server = osc_server.AsyncIOOSCUDPServer((IP, OSC_PORT), dispatcher,
event_loop_local)
transport, protocol = await server.create_serve_endpoint(
) # Create datagram endpoint and start serving
print("OSC server running.")
await dummy_loop()
transport.close() # Clean up server endpoint
def run_server_forever(self):
dispatcher = Dispatcher()
dispatcher.map('/note_on', self._note_on_handler)
dispatcher.map('/note_off', self._note_off_handler)
server = osc_server.ThreadingOSCUDPServer((self.ip, self.port),
dispatcher)
print('Serving on {}'.format(server.server_address))
server.serve_forever()
def start_server_to_listen(self, imu_handler, emg_handler):
self.file_counter += 1
dispatcher = Dispatcher()
dispatcher.map("/imu", imu_handler)
dispatcher.map("/emg", emg_handler)
self.server = osc_server.OSCUDPServer((self.ip, self.port), dispatcher)
print("Serving on {}".format(self.server.server_address))
self.server.serve_forever()
class Osc_Interface(Thread):
"""
Class used to creat an OSC client to send message to an external synthesiser listening to OSC messages
"""
def __init__(self,
client_host='127.0.0.1',
client_port=57120,
server_host='127.0.0.1',
server_port=57130):
"""
Class constructor
:param host: URL used to reach OSC listener
:param port: port used to reach OSC listener
"""
# Initiate OSC client
self._osc_client = udp_client.SimpleUDPClient(client_host, client_port)
# Register a default dispatcher
self._dispatcher = Dispatcher()
self._dispatcher.set_default_handler(self._print_message)
self._server_host = server_host
self._server_port = server_port
# Initiate OSC server
self.start_server()
def _print_message(address, *args):
print(f"DEFAULT {address}: {args}")
def start_server(self):
self._running = True
Thread.__init__(self)
def run(self):
self._server = BlockingOSCUDPServer(
(self._server_host, self._server_port), self._dispatcher)
self._server.serve_forever()
def stop(self):
self._running = False
self._server.shutdown()
def is_running(self):
return self._running
def add_handler(self, trigger, handler):
self._dispatcher.map('/' + trigger, handler)
def send(self, osc_handler, msg):
"""
Send an OSC message to a synthesiser listening to OSC messages
:param url: used to trigger right instrument on synthesiser - most of the time this is instrument's name
:param notes: an array containing notes to play in midi note format
"""
self._osc_client.send_message('/' + osc_handler, msg)
class Controller(object):
def __init__(self):
self.dispatcher = Dispatcher()
self.dispatcher.map("/realsense*", self._onMessageReceived)
self.server = osc_server.ThreadingOSCUDPServer((IP, PORT),
self.dispatcher)
self.raw = (0.0, 0.0, 0.0)
self.offset = [0.0, 0.0, 0.0]
self.distance_cach = (0.0, 0.0, 0.0)
self.thread = threading.Thread(target=self._thread)
self.thread.setDaemon(True)
self.thread.start()
def cleanup(self):
self.server.shutdown()
self.thread.join()
def getPosition2d(self):
r = [self.raw[0] - self.offset[0], self.raw[2] - self.offset[2]]
if r[0] >= X_BOUNDARY:
r[0] = X_BOUNDARY
self.setCustomOffset2d(X_BOUNDARY, None)
if r[0] <= X_BOUNDARY * -1:
r[0] = X_BOUNDARY * -1
self.setCustomOffset2d(X_BOUNDARY * -1, None)
if r[1] >= Z_BOUNDARY:
r[1] = Z_BOUNDARY
self.setCustomOffset2d(None, Z_BOUNDARY)
if r[1] <= Z_BOUNDARY * -1:
r[1] = Z_BOUNDARY * -1
self.setCustomOffset2d(None, Z_BOUNDARY * -1)
#end adjusting
return r
def getDistance2d(self):
r = [
self.raw[0] - self.distance_cach[0],
self.raw[2] - self.distance_cach[2]
]
self.distance_cach = (self.raw[0], self.raw[1], self.raw[2])
return r
def recalibrate(self):
self.offset = [self.raw[0], self.raw[1], self.raw[2]]
def _onMessageReceived(self, unused_address, x, y, z, qw, qx, qy, qz):
self.raw = (x, y, z)
self.distance_cach = (0.0, 0.0, 0.0)
def setCustomOffset2d(self, x, z):
if x is not None: self.offset[0] = self.raw[0] - x
if z is not None: self.offset[2] = self.raw[2] - z
def _thread(self):
print("server")
self.server.serve_forever()
def main_func():
ip = "localhost"
port = 6565
dispatcher = Dispatcher()
dispatcher.map("/Chordata/*", data_handler)
dispatcher.set_default_handler(default_handler)
server = BlockingOSCUDPServer((ip, port), dispatcher)
server.serve_forever()
def osc_server():
dispatcher = Dispatcher()
dispatcher.map("/lightstick/preset", preset_handler)
dispatcher.set_default_handler(default_handler)
ip = "0.0.0.0"
port = 5000
server = BlockingOSCUDPServer((ip, port), dispatcher)
server.serve_forever()
def main():
ip = '127.0.0.1'
port = 6700
# URLにコールバック関数を割り当てる
dispatcher = Dispatcher()
dispatcher.map('/address', handler)
# サーバを起動する
server = osc_server.ThreadingOSCUDPServer((ip, port), dispatcher)
print('Server Start IP={} PORT={}'.format(ip, port))
server.serve_forever()
class Osc:
"""Control switches via OSC."""
def __init__(self, machine):
"""Initialise switch player."""
self.log = logging.getLogger('OSC Plugin')
self.machine = machine # type: MachineController
if 'osc_plugin' not in machine.config:
machine.log.debug('"osc_plugin:" section not found in '
'machine configuration, so the OSC'
'plugin will not be used.')
return
if not Dispatcher:
raise AssertionError(
"To use the OSC plugin you need to install the pythonosc extension."
)
self.config = self.machine.config['osc_plugin']
self.machine.config_validator.validate_config("osc_plugin",
self.config)
if not self.config['enabled']:
return
self.dispatcher = Dispatcher()
self.dispatcher.map("/sw/*", self.handle_switch)
self.server = AsyncIOOSCUDPServer(
(self.config['server_ip'], self.config['server_port']),
self.dispatcher, self.machine.clock.loop)
self.machine.events.add_async_handler("init_phase_5", self._start)
self.client = SimpleUDPClient(self.config['client_ip'],
self.config['client_port'])
@asyncio.coroutine
def _start(self):
yield from self.server.create_serve_endpoint()
self.machine.switch_controller.add_monitor(self._notify_switch_changes)
def __repr__(self):
"""Return string representation."""
return '<Osc>'
def handle_switch(self, switch_name, state):
"""Handle Switch change from OSC."""
self.machine.switch_controller.process_switch(switch_name,
bool(state),
logical=True)
def _notify_switch_changes(self, change: MonitoredSwitchChange):
"""Send switch change to OSC client."""
self.client.send_message("/sw/{}".format(change.name), change.state)
def __init__(self, addresses=[], ip='127.0.0.1', port=5005):
self._server = None
self._data = {}
self._lock = Lock()
if not addresses or not isinstance(addresses, list):
raise ValueError('You must provide a list of addresses.')
dispatcher = Dispatcher()
for address in addresses:
self._data[self._address_to_port(address)] = {'timestamps': [], 'rows': []}
dispatcher.map(address, self._handler)
self._server = BlockingOSCUDPServer((ip, port), dispatcher)
Thread(target=self._server.serve_forever).start()
async def initialize(self):
"""Initialise platform."""
self.config = self.machine.config['osc']
self.machine.config_validator.validate_config("osc", self.config)
self.client = SimpleUDPClient(self.config['remote_ip'], self.config['remote_port'])
dispatcher = Dispatcher()
dispatcher.map("/sw/*", self._handle_switch)
dispatcher.map("/event/*", self._handle_event)
server = AsyncIOOSCUDPServer((self.config['listen_ip'], self.config['listen_port']), dispatcher,
self.machine.clock.loop)
self.server, _ = await server.create_serve_endpoint()
for event in self.config['events_to_send']:
self.machine.events.add_handler(event, self._send_event, _event_name=event)
def __init__(self, backend, host, port):
super().__init__(backend)
self.client = SimpleUDPClient(host, port)
self._osc_server_lock = threading.Lock()
dispatcher = Dispatcher()
dispatcher.map("/track/*/volume/str", self.osc_volume_handler)
dispatcher.map("/track/*/mute/toggle", self.osc_mute_handler)
#dispatcher.set_default_handler(self.osc_default_handler)
self._osc_server = BlockingOSCUDPServer(("127.0.0.1", 8001),
dispatcher)
self._osc_server_thread = threading.Thread(
target=self._osc_server.serve_forever)
self._osc_server_thread.start()
def main_func():
global client
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(('localhost', 30001))
dispatcher = Dispatcher()
dispatcher.map("/%%/*", address_handler)
dispatcher.map("/%/*", data_handler)
dispatcher.set_default_handler(default_handler)
ip = "localhost"
port = 6565
server = BlockingOSCUDPServer((ip, port), dispatcher)
server.serve_forever() # Blocks forever
def __init__(self):
self._is_running = True
self._points = []
dispatcher = Dispatcher()
dispatcher.map(self.POINTS_LABEL, self._points_handler)
dispatcher.map(self.STOP_LABEL, self._stop_handler)
self._server = osc_server.ThreadingOSCUDPServer((self.IP, self.RECV_PORT), dispatcher)
self._thread = Thread(target=self._recv_thread)
self._thread.start()
self._client = udp_client.UDPClient(self.IP, self.SEND_PORT)
self._event = Event()
self._semphore = Semaphore()
def launchUDPServer():
# this is handling the messages received from EEGSonic
parser = argparse.ArgumentParser()
parser.add_argument('--ip', default='127.0.0.1',
help='The ip of the OSC server')
parser.add_argument('--port', type=int, default=7400,
help='the port the OSC server is listening on')
args = parser.parse_args()
dispatcher = Dispatcher()
dispatcher.map('*', relayOSC)
# this is receiving the messages from EEGsonic and forwarding to the front end
server = osc_server.BlockingOSCUDPServer(
(args.ip, args.port), dispatcher)
print(f'Serving on {server.server_address}')
server.serve_forever()
def configureDispatcher(self):
# setting the object which receives the messages and decides where to send them
dispatcher = Dispatcher()
dispatcher.map("/inputs/key_mapping/*", self.set_keyMappings)
dispatcher.map("/inputs/key_on/gen_MIDI", self.set_genMIDI)
dispatcher.map("/inputs/key_on", self.keyOn)
dispatcher.map("/inputs/key_off", self.keyOff)
dispatcher.set_default_handler(self.default_handler)
return dispatcher
async def main():
parser = argparse.ArgumentParser()
parser.add_argument("--ip", default="0.0.0.0", help="The ip to listen on")
parser.add_argument("--port", type=int, default=37339, help="The port to listen on")
args = parser.parse_args()
plt.ion()
# plt.show()
dispatcher = Dispatcher()
dispatcher.map("/pulse", pulse_handler)
loop = asyncio.get_event_loop()
server = osc_server.AsyncIOOSCUDPServer( (args.ip, args.port), dispatcher, loop)
# server = osc_server.ThreadingOSCUDPServer( (args.ip, args.port), dispatcher)
# server.serve()
transport, protocol = await server.create_serve_endpoint()
await asyncio.sleep(10**30)
def setup(self):
# ColorTerminal().warn('OscReader-setup')
if self.oscServer != None:
self.destroy()
ColorTerminal().output("Starting OSC Server with host {0} and port {1}".format(self.host, self.port))
dispatcher = Dispatcher()
dispatcher.map('/marker', self.oscMarkerHandler)
dispatcher.map("/rigidbody", self.oscRigidBodyHandler)
try:
self.oscServer = osc_server.BlockingOSCUDPServer((self.host, self.port), dispatcher)
self.oscServer.handle_timeout = self.handleTimeout
self.oscServer.timeout=0
#self.oscServer.serve_forever()
except OSError as err:
ColorTerminal().fail("Could not create OSC server: ", err)
self.oscServer = None
ColorTerminal().success("OSC Server running")
def thread_osc(threadname, _queue):
print("Start:" + threadname)
from pythonosc.dispatcher import Dispatcher
from pythonosc.osc_server import BlockingOSCUDPServer
def handler(address, *args):
if not _queue.empty():
_queue.get()
_queue.put(args)
#def default_handler(address, *args):
# print(f"DEFAULT {address}: {args}")
dispatcher = Dispatcher()
#dispatcher.map("/faciallandmarks/eyebrows", eyebrown_handler)
dispatcher.map("/landmarks", handler)
#dispatcher.set_default_handler(default_handler)
server = BlockingOSCUDPServer(("192.168.178.52", 9000), dispatcher)
server.serve_forever() # Blocks forever
def InitNetwork(self, client_ip, client_port, listen_port):
# client
self.client = udp_client.SimpleUDPClient(client_ip, client_port)
PrintManager("Connecting client on port {}.".format(client_port), 4)
# server callbacks
dispatch = Dispatcher()
dispatch.map("/move*", self.MoveNozzle) # /move/extrude and /move
dispatch.map("/extrude", self.ExtractMaterial)
dispatch.map("/retract", self.RetractMaterial)
dispatch.map("/req/nozzle_pos", self.RequestNozzlePosition)
dispatch.set_default_handler(
lambda _: PrintManager("Received message.", 1))
# TODO: Add other functions
# server
loop = asyncio.get_event_loop()
self.server = AsyncIOOSCUDPServer(("127.0.0.1", listen_port), dispatch,
asyncio.get_event_loop())
PrintManager("Serving on {}:{}".format("127.0.0.1", listen_port), 4)
self.server.serve()
# start the event loop for server
self.osc_thread = threading.Thread(target=loop.run_forever)
self.osc_thread.daemon = True
self.osc_thread.start()
def __init__(self, osculator_client, audience_client, performer_client,
machine, beat_manager, tonality):
self.osculator_client = osculator_client
self.audience_client = audience_client
self.performer_client = performer_client
self.song_machine = machine
self.beat_manager = beat_manager
self.tonality = tonality
dispatcher = Dispatcher()
dispatcher.map(settings.INTERPRETER_TARGET_ADDRESS,
self.interpreter_handler)
dispatcher.map(settings.SONG_BEAT_ADDRESS, self.beat_handler)
dispatcher.map(settings.SONG_SYNTH_RESET_ADDRESS, self.reset_handler)
self.server = ThreadingOSCUDPServer(
(settings.ip, settings.SONG_SERVER_PORT), dispatcher)
self.song_scenes = {
k: v
for k, v in zip(self.song_machine.parser.song_parts,
range(len(self.song_machine.parser.song_parts)))
}
self.osculator_client.send_message(
settings.SONG_ADVANCE_ADDRESS,
(self.song_machine.parser.INTRO_NOTE, 1.0))
self.osculator_client.send_message(
settings.SONG_ADVANCE_ADDRESS,
(self.song_machine.parser.INTRO_NOTE, 0.0))
self.osculator_client.send_message('/mid_{}'.format('praise'),
self.tonality.synth.ctrl_message)
self._send_init_to_display()
class OscServer:
def __init__(self, ip_adress="127.0.0.1", port=4321):
self.ip_adress = ip_adress
self.port = port
self.dispatcher = Dispatcher()
self.server = None
def register_default_handler(self, handler_function: FunctionType):
self.dispatcher.set_default_handler(handler_function)
def register_handler(self, route: str, handler_function: FunctionType):
self.dispatcher.map(route, handler_function)
def terminate(self):
self.server.shutdown()
def serve(self):
print(f"Listening for OSC messages on {self.ip_adress}:{self.port}")
self.server = BlockingOSCUDPServer((self.ip_adress, self.port),
self.dispatcher)
self.server.serve_forever()
class OSCReceiver:
def __init__(self, host='0.0.0.0', port=5300):
self.dispatcher = Dispatcher()
self.dispatcher.map("/state", self.setState)
self.oscServer = ThreadingOSCUDPServer((host, port), self.dispatcher)
self.oscServerThread = threading.Thread(
target=self.oscServer.serve_forever, daemon=True)
self.state = -1
def getState(self):
return self.state
def setState(self, endpoint, newState):
print('GOT STATE MESSAGE')
print(newState)
self.state = newState
def start(self):
self.oscServerThread.start()
return self
async def init_main():
"""
https://python-osc.readthedocs.io/en/latest/server.html#async-server
https://web.archive.org/web/20170809181820/http://developer.choosemuse.com/research-tools-example/grabbing-data-from-museio-a-few-simple-examples-of-muse-osc-servers
https://addshore.com/2018/06/python3-using-some-shared-state-in-2-async-methods/
:return:
"""
# making a super ghetto state to share b/w the two async contexts
# based on solution in https://addshore.com/2018/06/python3-using-some-shared-state-in-2-async-methods/
async_state = type('', (), {})()
async_state.focused = False
async_state.mentally_focused = False
async_state.wearing = False
async_state.hat_running = False
async_state.user_override = False
async_state.last_reading = datetime.datetime.now()
async_state.attention_lvl = 0.0
# Prepare the serial port
# make_connection
ser = serial.Serial(ARD_PORT, baudrate=9600, timeout=1)
connection_made = make_connection(ser, async_state)
if connection_made:
# with the connection made and inital state set, can start the main loops.
# https://python-osc.readthedocs.io/en/latest/dispatcher.html
# https://python-osc.readthedocs.io/en/latest/server.html#async-server
event_loop_local = asyncio.get_event_loop()
dispatcher = Dispatcher()
dispatcher.map("/muse/elements/experimental/concentration", concentration_handler, async_state)
# creates an OSC server that's Async.
server = osc_server.AsyncIOOSCUDPServer((IP, OSC_PORT), dispatcher, event_loop_local)
transport, protocol = await server.create_serve_endpoint() # Create datagram endpoint and start serving
await loop(ser, async_state) # Enter main loop of program.
transport.close() # Clean up serve endpoint
async def loop():
global transport
global window
# i = 0
while (True):
# i += 1
# print(f"Loop {i}")
event, values = window.Read(timeout=5)
if event != '__TIMEOUT__':
print(event, values)
if event is None or event == 'Exit':
break
if event == '_CONNECT_':
dispatcher = Dispatcher()
dispatcher.map(values['_ADDRESS_'], press_key_handler)
window.FindElement('_CONNECT_').Update(disabled=True)
# server setup logic
server = AsyncIOOSCUDPServer(
(values['_IP_'], int(values['_PORT_'])), dispatcher,
asyncio.get_event_loop())
# Create datagram endpoint and start serving
transport, protocol = await server.create_serve_endpoint()
await asyncio.sleep(0.005)
def _start_server(self):
dispatcher = Dispatcher()
self.server = OSCClientServer(("0.0.0.0", self.args.port),
self.ardour_addr, dispatcher,
self._service_action)
dispatcher.map("/rec_enable_toggle", self.handle_rec_enable_toggle)
dispatcher.map("/record_tally", self.handle_record_tally)
dispatcher.map("/heartbeat", self.handle_heartbeat)
dispatcher.set_default_handler(self.handle_any)
def set_filter(address: str, *args: List[Any]) -> None:
# We expect two float arguments
if not len(args) == 2 or type(args[0]) is not float or type(args[1]) is not float:
return
# Check that address starts with filter
if not address[:-1] == "/filter": # Cut off the last character
return
value1 = args[0]
value2 = args[1]
filterno = address[-1]
print(f"Setting filter {filterno} values: {value1}, {value2}")
dispatcher.map("/filter*", set_filter) # Map wildcard address to set_filter function
# Set up server and client for testing
from pythonosc.osc_server import BlockingOSCUDPServer
from pythonosc.udp_client import SimpleUDPClient
server = BlockingOSCUDPServer(("127.0.0.1", 1337), dispatcher)
client = SimpleUDPClient("127.0.0.1", 1337)
# Send message and receive exactly one message (blocking)
client.send_message("/filter1", [1., 2.])
server.handle_request()
client.send_message("/filter8", [6., -2.])
server.handle_request()
from pythonosc.osc_server import AsyncIOOSCUDPServer
from pythonosc.dispatcher import Dispatcher
import asyncio
def filter_handler(address, *args):
print(f"{address}: {args}")
dispatcher = Dispatcher()
dispatcher.map("/filter", filter_handler)
ip = "127.0.0.1"
port = 1337
async def loop():
"""Example main loop that only runs for 10 iterations before finishing"""
for i in range(10):
print(f"Loop {i}")
await asyncio.sleep(1)
async def init_main():
server = AsyncIOOSCUDPServer((ip, port), dispatcher, asyncio.get_event_loop())
transport, protocol = await server.create_serve_endpoint() # Create datagram endpoint and start serving
await loop() # Enter main loop of program
transport.close() # Clean up serve endpoint
def init_osc(loop):
dispatcher = Dispatcher()
dispatcher.map("/output_*", say_handler)
osc_server = AsyncIOOSCUDPServer(('127.0.0.1', 12000), dispatcher, loop)
osc_server.serve() # Calls 'run_until_complete' internally
class TestDispatcher(unittest.TestCase):
def setUp(self):
super().setUp()
self.dispatcher = Dispatcher()
def sortAndAssertSequenceEqual(self, expected, result):
def sort(lst):
return sorted(lst, key=lambda x: x.callback)
return self.assertSequenceEqual(sort(expected), sort(result))
def test_empty_by_default(self):
self.sortAndAssertSequenceEqual([], self.dispatcher.handlers_for_address('/test'))
def test_use_default_handler_when_set_and_no_match(self):
handler = object()
self.dispatcher.set_default_handler(handler)
self.sortAndAssertSequenceEqual([Handler(handler, [])], self.dispatcher.handlers_for_address('/test'))
def test_simple_map_and_match(self):
handler = object()
self.dispatcher.map('/test', handler, 1, 2, 3)
self.dispatcher.map('/test2', handler)
self.sortAndAssertSequenceEqual(
[Handler(handler, [1, 2, 3])], self.dispatcher.handlers_for_address('/test'))
self.sortAndAssertSequenceEqual(
[Handler(handler, [])], self.dispatcher.handlers_for_address('/test2'))
def test_example_from_spec(self):
addresses = [
"/first/this/one",
"/second/1",
"/second/2",
"/third/a",
"/third/b",
"/third/c",
]
for index, address in enumerate(addresses):
self.dispatcher.map(address, index)
for index, address in enumerate(addresses):
self.sortAndAssertSequenceEqual(
[Handler(index, [])], self.dispatcher.handlers_for_address(address))
self.sortAndAssertSequenceEqual(
[Handler(1, []), Handler(2, [])], self.dispatcher.handlers_for_address("/second/?"))
self.sortAndAssertSequenceEqual(
[Handler(3, []), Handler(4, []), Handler(5, [])],
self.dispatcher.handlers_for_address("/third/*"))
def test_do_not_match_over_slash(self):
self.dispatcher.map('/foo/bar/1', 1)
self.dispatcher.map('/foo/bar/2', 2)
self.sortAndAssertSequenceEqual(
[], self.dispatcher.handlers_for_address("/*"))
def test_match_middle_star(self):
self.dispatcher.map('/foo/bar/1', 1)
self.dispatcher.map('/foo/bar/2', 2)
self.sortAndAssertSequenceEqual(
[Handler(2, [])], self.dispatcher.handlers_for_address("/foo/*/2"))
def test_match_multiple_stars(self):
self.dispatcher.map('/foo/bar/1', 1)
self.dispatcher.map('/foo/bar/2', 2)
self.sortAndAssertSequenceEqual(
[Handler(1, []), Handler(2, [])], self.dispatcher.handlers_for_address("/*/*/*"))
def test_match_address_contains_plus_as_character(self):
self.dispatcher.map('/footest/bar+tender/1', 1)
self.sortAndAssertSequenceEqual(
[Handler(1, [])], self.dispatcher.handlers_for_address("/foo*/bar+*/*"))
self.sortAndAssertSequenceEqual(
[Handler(1, [])], self.dispatcher.handlers_for_address("/foo*/bar*/*"))
def test_call_correct_dispatcher_on_star(self):
self.dispatcher.map('/a+b', 1)
self.dispatcher.map('/aaab', 2)
self.sortAndAssertSequenceEqual(
[Handler(2, [])], self.dispatcher.handlers_for_address('/aaab'))
self.sortAndAssertSequenceEqual(
[Handler(1, [])], self.dispatcher.handlers_for_address('/a+b'))
def test_map_star(self):
self.dispatcher.map('/starbase/*', 1)
self.sortAndAssertSequenceEqual(
[Handler(1, [])], self.dispatcher.handlers_for_address("/starbase/bar"))
def test_map_root_star(self):
self.dispatcher.map('/*', 1)
self.sortAndAssertSequenceEqual(
[Handler(1, [])], self.dispatcher.handlers_for_address("/anything/matches"))
def test_map_double_stars(self):
self.dispatcher.map('/foo/*/bar/*', 1)
self.sortAndAssertSequenceEqual(
[Handler(1, [])], self.dispatcher.handlers_for_address("/foo/wild/bar/wild"))
self.sortAndAssertSequenceEqual(
[], self.dispatcher.handlers_for_address("/foo/wild/nomatch/wild"))
def test_multiple_handlers(self):
self.dispatcher.map('/foo/bar', 1)
self.dispatcher.map('/foo/bar', 2)
self.sortAndAssertSequenceEqual(
[Handler(1, []), Handler(2, [])], self.dispatcher.handlers_for_address("/foo/bar"))
def test_multiple_handlers_with_wildcard_map(self):
self.dispatcher.map('/foo/bar', 1)
self.dispatcher.map('/*', 2)
self.sortAndAssertSequenceEqual(
[Handler(1, []), Handler(2, [])], self.dispatcher.handlers_for_address("/foo/bar"))
