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']) async def _start(self): await 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 _setup_server(self): print("Setting up server {}, {}".format(self.host_ip, self.in_port)) self.dispatcher = Dispatcher() self.dispatcher.map("/handshake/", self._handshake_handler) self.dispatcher.map("/ping/", self._ping_handler) self.dispatcher.map("/start/", self._start_handler) self.dispatcher.map("/stop/", self._stop_handler) self.server = AsyncIOOSCUDPServer((self.host_ip, self.in_port), self.dispatcher, asyncio.get_event_loop())
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()
def __init__(self, address=("127.0.0.1", 9900), listen_port=9002): self.beat_callback = None self.startup_callback = None self.listen_port = listen_port #------------------------------------------------------------------------ # Handler callbacks for particular messages from Live. # Used so that other processes can register callbacks when states change. #------------------------------------------------------------------------ self.handlers = {} self.osc_address = address if OSC_BACKEND == 'liblo': self.osc_target = liblo.Address(address[0], address[1]) self.osc_server = liblo.Server(listen_port) self.osc_server.add_method(None, None, self.handler) self.osc_server.add_bundle_handlers(self.start_bundle_handler, self.end_bundle_handler) elif OSC_BACKEND == 'pythonosc': # TODO how to deal w/ bundles? even necessary? # (the handlers seem to be just logging...) # (i think only some of the clip code refers to bundles at all) ip = address[0] self.osc_client = SimpleUDPClient(ip, address[1]) self.dispatcher = Dispatcher() self.dispatcher.set_default_handler(self.pythonosc_handler_wrapper) # TODO TODO may need to take more care that this, or the other # pythonosc objects, actually close all of their connections before # exit / atexit # for some reason, maybe most likely something else, there seem to # be less frequent apparent "connection" issues with liblo than with # pythonosc... self.osc_server = ThreadingOSCUDPServer((ip, listen_port), self.dispatcher) self.osc_server_thread = None self.osc_read_event = None self.osc_timeout = 3.0 self.osc_server_events = {} self.query_address = None self.query_rv = [] self.listen()
def main_func(ip, port): dispatcher = Dispatcher() dispatcher.map("/%%/*", address_handler) dispatcher.map("/%/*", data_handler) dispatcher.set_default_handler(default_handler) server = BlockingOSCUDPServer((ip, port), dispatcher) server.serve_forever() # Blocks forever
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()
class MessageReceiver: def __init__(self, port): print(f'Setting up Receiver with port: {port}') self.dispatcher = Dispatcher() self.server = BlockingOSCUDPServer(('127.0.0.1', port), self.dispatcher) self.dispatcher.set_default_handler(self.handleMessage) self.thread = Thread(target=self.run) self.thread.start() def run(self): self.server.serve_forever() print('done with receiver thread') def handleMessage(self, adress, *args): print(f'handler: {adress}: {args}')
def __init__(self, client_type, host=None, inport=None, outport=None, obs_size=64): self.type = client_type self.action_queue = [] self.joints_queue = [] self.obs_queue = [] self.obs_parts = [] self.obs_size = obs_size self.last_obs = np.zeros((obs_size, obs_size)) if (host==None or inport==None or outport==None): with open('config/osc.json') as f: config = json.load(f) self.host = config.get('client.host') self.inport = int(config.get('client.port')) self.outport = int(config.get('server.port')) else: self.host = host self.inport = int(inport) self.outport = int(outport) self.client = SimpleUDPClient(self.host, self.outport) self.handshake = True self.finished = False self.terminate = False self.save_obs = False self.fitness = [] self.clock = 0.0 self.oscillator = 0.0 self.brush = 0.5 self.dispatcher = Dispatcher() if client_type == ClientType.ROLLOUT: self.dispatcher.map(f'{OSC_HELLO}*', self.__dispatch_hello) self.dispatcher.map(f'{OSC_BYE}*', self.__dispatch_bye) self.dispatcher.map(f'{OSC_INFO}*', self.__dispatch_info) self.dispatcher.map(f'{OSC_END_ROLLOUT}*', self.__dispatch_end) self.dispatcher.map(f'{OSC_JOINTS}*', self.__dispatch_joints_packets) self.dispatcher.map(f'{OSC_ARTIFACT_START}*', self.__dispatch_start_packets) self.dispatcher.map(f'{OSC_ARTIFACT_PART}*', self.__dispatch_append_packets) self.dispatcher.map(f'{OSC_ARTIFACT_END}*', self.__dispatch_process_packets) else: self.dispatcher.map(f'{OSC_FITNESS}*', self.__dispatch_fitness)
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 run(self) -> None: """ raises: OSError is server already is in use """ osc_dispatcher: Dispatcher = Dispatcher() osc_dispatcher.map(self.SERVER_ADDRESS, self.__process_osc) osc_dispatcher.set_default_handler(self.__unmatched_osc) self._server: BlockingOSCUDPServer = BlockingOSCUDPServer( (Server.DEFAULT_IP, self._inport), osc_dispatcher) self._server.serve_forever()
def __init__(self, host='0.0.0.0', port=7401, **kwargs): self._host = host self._port = port self._client = None self._server = None self._server_thread = None Logged.__init__(self, **kwargs) self._dispatcher = Dispatcher() self._dispatcher.set_default_handler(self.receive) self._routes = {} for osc_path, callback in find_routes(self): self._dispatcher.map(osc_path, callback) self._routes[osc_path] = callback
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 __init__(self, hostlisten='127.0.0.1', portlisten=33217, hostconnect=None, portconnect=None): self.hostlisten = hostlisten self.portlisten = portlisten self.hostconnect = hostconnect self.portconnect = portconnect self.server = None self.transport = None self.protocol = None self.dispatcher = Dispatcher() self.client_connection_sender_timer = None self.user_on_connection_timeout = None self.connected_hosts = dict() self.callbacks = dict() self.cmd_queue = []
def server(): dispatcher = Dispatcher() server = ThreadingOSCUDPServer(("127.0.0.1", SERVER_PORT), dispatcher) server_thread = threading.Thread(target=server.serve_forever) server_thread.daemon = True server_thread.start() yield server server.shutdown() server_thread.join()
def __init__( self, server_ip: str, server_port: int, default_receiver_ip: str, default_receiver_port: int, ) -> None: """Create an OSC communication server Parameters ---------- server_ip : str IP address to use for this server server_port : int port to use for this server default_receiver_ip : str IP address used for sending by default default_receiver_port : int port used for sending by default """ self._receivers: Dict[Tuple[str, int], str] = {} self._default_receiver: Tuple[str, int] = ( default_receiver_ip, default_receiver_port, ) # bundling messages support self._bundling_lock = RLock() self._bundling_bundles = [] # create server while True: try: self._osc_server = ThreadingOSCUDPServer( (server_ip, server_port), Dispatcher()) self._osc_server_running = True _LOGGER.debug("This OSCCommunication instance is at port: %s", server_port) break except OSError as error: if error.errno == errno.EADDRINUSE: server_port += 1 # start server thread self._osc_server_thread = threading.Thread( target=self._osc_server.serve_forever) self._osc_server_thread.daemon = True self._osc_server_thread.start() # init queues for msg pairs, must be after self._osc_server self._msg_queues: Dict[str, MessageQueue] = {} self._reply_addresses: Dict[str, str] = {} atexit.register(self.quit)
async def _run(self): """ raises: OSError is server already is in use """ osc_dispatcher: Dispatcher = Dispatcher() osc_dispatcher.map(self.address, self.__process_osc) osc_dispatcher.set_default_handler(self.__unmatched_osc) self.server: AsyncIOOSCUDPServer = AsyncIOOSCUDPServer((self.ip, self.recv_port), osc_dispatcher, asyncio.get_event_loop()) transport, protocol = await self.server.create_serve_endpoint() self.target.send(SendProtocol.AGENT_INSTANTIATED, Target.WRAPPED_BANG) await self._main_loop() transport.close()
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 __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}." )
def __init__(self, client_host='127.0.0.1', client_port=57120, server_host='127.0.0.1', server_port=57130): """ Class constructor :param client_host: URL used to reach OSC listener of SuperCollider :param client_port: port used to reach OSC listener of SuperCollider :param server_host: URL used to reach this running OSC server instance :param server_port: port used to reach this running OSC server instance """ # 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) # Save some init params to the class self._server_host = server_host self._server_port = server_port # Initiate OSC server self._start_server()
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
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()
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 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()
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
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()
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 __init__(self, ip, port): self.lines = [""]*Orac.MAX_LINES self.selectedLine = 0 self.params = [{"name": "", "value": "", "ctrl": 0.0} for _ in range(Orac.MAX_PARAMS)] self.oscDispatcher = Dispatcher() self.oscDispatcher.map("/text", self.textHandler) self.oscDispatcher.map("/selectText", self.selectTextHandler) self.oscDispatcher.map("/clearText", self.clearTextHandler) self.oscDispatcher.map("/P*Desc", self.paramDescHandler) self.oscDispatcher.map("/P*Ctrl", self.paramCtrlHandler) self.oscDispatcher.map("/P*Value", self.paramValueHandler) self.oscDispatcher.map("/module", self.moduleHandler) self.oscDispatcher.map("/*", self.allOtherHandler) self.server = BlockingOSCUDPServer(('', args.listen), self.oscDispatcher) self.client = udp_client.SimpleUDPClient(args.ip, args.port) self.client.send_message("/Connect", args.listen) self.linesClearedCallbacks = [] self.lineChangedCallbacks = [] self.paramNameChangedCallbacks = [] self.paramValueChangedCallbacks = [] self.paramCtrlChangedCallbacks = [] self.lineChangedNotificationsEnabled = True self.screenTimer = None self.linesSnapshot = None self.paramNotificationsEnabled = True self.paramTimer = None self.paramsSnapshot = None self.changingModule = False
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_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 __init__(self, reader, writer, osc_spec=1.0): self.reader = reader self.writer = writer self.osc_spec = osc_spec self._slip_driver = None if self.osc_spec == 1.1: self._slip_driver = SlipDriver() self.dispatcher: Dispatcher = Dispatcher() self.dispatcher.map("/oscrouter/register", self.register) self.dispatcher.map("*", self.call_notification_callbacks) self.user = None self._leave = False self._to_write = asyncio.Queue() self._reader_task = asyncio.create_task(self._reader_coro()) self._writer_task = asyncio.create_task(self._writer_coro()) logging.info(f"New connection from '{self}'")
from pythonosc.dispatcher import Dispatcher from typing import List, Any dispatcher = Dispatcher() 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)
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
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"))
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
def setUp(self): super().setUp() self.dispatcher = Dispatcher()