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"))