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'])
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()
async def init_main(args, dispatcher, sensor_dispatcher): """ Initialization routine """ loop = asyncio.get_event_loop() server = AsyncIOOSCUDPServer((args.ip, args.port), dispatcher, loop) transport, _ = await server.create_serve_endpoint() sensor_server = AsyncIOOSCUDPServer((args.controller_ip, args.controller_port), sensor_dispatcher, loop) server_transport, _ = await sensor_server.create_serve_endpoint() await main_loop(args.ledplay_startup, args.disable_sun, args.disable_sound) transport.close()
async def init_main(): server = AsyncIOOSCUDPServer((aserve.IAPComs.ip, aserve.IAPComs.portIn), dispatcher, asyncio.get_event_loop()) transport, protocol = await server.create_serve_endpoint( ) # Create datagram endpoint and start serving await iap.run() transport.close() # Clean up serve endpoint
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()
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
async def init_main(): server = AsyncIOOSCUDPServer(("127.0.0.1", 5006), dispatcher, asyncio.get_event_loop()) transport, protocol = await server.create_serve_endpoint() await loop() transport.close()
async def osc_listen_server(): server = AsyncIOOSCUDPServer((OSC_SRV_HOST, OSC_SRV_PORT), osc_dispatcher, asyncio.get_event_loop()) transport, protocol = await server.create_serve_endpoint( ) # Create datagram endpoint and start serving await osc_listen() # Enter main loop of program transport.close() # Clean up serve endpoint
async def init_main(args, dispatcher): """ Initialization routine """ loop = asyncio.get_event_loop() for i in range(0, 5): try: server = AsyncIOOSCUDPServer((args.ip, args.port), dispatcher, loop) LOGGER.info(f'Serving on {args.ip}:{args.port}') signal(0.05, 3) break except: signal(0.5, 3) LOGGER.warning(f'Unable to bind to {args.ip}, retrying {i + 1}') time.sleep(3) for i in range(0, 5): try: transport, _ = await server.create_serve_endpoint() LOGGER.info(f'Server endpoint established') signal(0.05, 3) break except Exception as e: signal(0.5, 3) LOGGER.warning('Unable to establish endpoint, retrying') time.sleep(5) await main_loop(args.on_offset, args.end_time, args.animate) transport.close()
async def runUdpServer(): print('Starting OSC UDP server') server = AsyncIOOSCUDPServer( (SOCKET_LISTEN_IP, ORAC_LISTEN_PORT), dispatcher, loop) global oracServerTransport oracServerTransport, protocol = await server.create_serve_endpoint() print('OSC UDP server started')
async def main(): address = (OSC_HOST, OSC_PORT) server = AsyncIOOSCUDPServer(address, dispatcher, asyncio.get_event_loop()) transport, protocol = await server.create_serve_endpoint() print(f"OSC server running at port {OSC_PORT}") await display() transport.close()
async def init_main(args, dispatcher): server = AsyncIOOSCUDPServer((args.ip, args.port), dispatcher, asyncio.get_event_loop()) transport, protocol = await server.create_serve_endpoint() await loop() transport.close()
async def init_main(): print('serving on:', server_ip, server_port) server = AsyncIOOSCUDPServer((server_ip, server_port), dispatcher_for_handler, asyncio.get_event_loop()) transport, protocol = await server.create_serve_endpoint( ) # Create datagram endpoint and start serving await master_loop() # Enter main loop of program transport.close() # Clean up serve endpoint
async def init_main(args, dispatcher): """ Initialization routine """ loop = asyncio.get_event_loop() server = AsyncIOOSCUDPServer((args.ip, args.port), dispatcher, loop) transport, protocol = await server.create_serve_endpoint() await main_loop() transport.close()
async def init_main(self): server = AsyncIOOSCUDPServer((self.ip, self.receiving_port), self.dispatcher, asyncio.get_event_loop()) ( transport, protocol, ) = (await server.create_serve_endpoint() ) # Create datagram endpoint and start serving await self.loop() # Enter main loop of program transport.close() # Clean up serve endpoint
async def __start(self, rollout=None): server = AsyncIOOSCUDPServer((self.host, self.inport), self.dispatcher, asyncio.get_event_loop()) transport, protocol = await server.create_serve_endpoint() if self.type == ClientType.ROLLOUT: await self.__loop(rollout) else: await self.__request() transport.close()
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()
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, server_address, maps=None): """ maps - collection of (osc_address_string, handler) mappings forward - collection of methods to forward raw OSC datagrams to """ self.maps = maps self.server_address = server_address loop = asyncio.get_event_loop() dsp = dispatcher.Dispatcher() for map in self.maps: dsp.map(map[0], map[1], needs_reply_address=(len(map)==3)) self.server = AsyncIOOSCUDPServer(server_address, dsp, loop)
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())
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)
async def init_main(): # Create datagram endpoint and start serving server_OSC = AsyncIOOSCUDPServer((local_ip, args.listenport), dispatcher, asyncio.get_event_loop()) transport, protocol = await server_OSC.create_serve_endpoint() dispatcher.map("/status", resend) tstick_wakeup() await receive_serial() transport.close() # Clean up serve endpoint sys.exit()
class OSCServer(): def __init__(self, server_address, maps=None): """ maps - collection of (osc_address_string, handler) mappings forward - collection of methods to forward raw OSC datagrams to """ self.maps = maps self.server_address = server_address loop = asyncio.get_event_loop() dsp = dispatcher.Dispatcher() for map in self.maps: dsp.map(map[0], map[1], needs_reply_address=(len(map)==3)) self.server = AsyncIOOSCUDPServer(server_address, dsp, loop) def serve(self): logging.info("OSCServer listening on {}".format(self.server_address)) return self.server.create_serve_endpoint()
async def init(self, loop=asyncio.get_event_loop(), on_connection_timeout=None, on_init_ok=None, _error_notify=True): if not self.transport: try: _LOGGER.info( f"OSC trying to init conpars={self.hostlisten}:{self.portlisten} -> {self.hostconnect}:{self.portconnect}" ) self.user_on_connection_timeout = on_connection_timeout self.server = AsyncIOOSCUDPServer( (self.hostlisten, self.portlisten), self.dispatcher, loop) if self.client_connection_sender_timer: self.client_connection_sender_timer = None self.dispatcher.map('/*', self.device_callback, needs_reply_address=True) self.transport, self.protocol = await self.server.create_serve_endpoint( ) except (Exception, OSError) as exception: _LOGGER.error(f"OSC init exception {traceback.format_exc()}") if on_init_ok and _error_notify: on_init_ok(exception) self.client_connection_sender_timer = Timer( 1, partial(self.init, loop=loop, on_connection_timeout=on_connection_timeout, on_init_ok=on_init_ok, _error_notify=False)) return try: if on_init_ok: on_init_ok(None) if self.hostconnect: self.connection_sender_timer_init(0) self.handle(COMMAND_CONNECTION, self.on_command_connection) except Exception: _LOGGER.error(f'OSC post init error {traceback.format_exc()}')
async def init_main(): parser = argparse.ArgumentParser() parser.add_argument("--ip", default="127.0.0.1", help="The ip to listen on") parser.add_argument("--port", type=int, default=12000, help="The port to listen on") args = parser.parse_args() server = AsyncIOOSCUDPServer((args.ip, args.port), dispatcher, asyncio.get_event_loop()) transport, protocol = await server.create_serve_endpoint( ) # Create datagram endpoint and start serving print('Server started') playsound('./sounds/welcome.wav') await loop() # 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)
async def create(cls, ip, port_in, port_out): self = communicateOSC() # setup the needed keyboards self.controller = midiKeyboard() # setting the IP to localhost self.ip = ip # setting the in and out port self.port_in = port_in self.port_out = port_out self.controller.setIpPort(ip, port_out) # setting the object which sents messages out self.client_out = SimpleUDPClient(self.ip, self.port_out) # trying an async server self.client_in = AsyncIOOSCUDPServer((self.ip, self.port_in), self.configureDispatcher(), asyncio.get_event_loop()) self.transport, _ = await self.client_in.create_serve_endpoint( ) # Create datagram endpoint and start serving return self
def get_server(self): return AsyncIOOSCUDPServer((self.args.ip, self.args.port), self.dispatcher, asyncio.get_event_loop())
async def init_main(): if args.offline: # OFFLINE : ... x, xl, dh, y, bs = timing.load_XY(args.take) x, xl, yh, dh = timing.prepare_X(x, xl, dh, dh, bs) batch_size = bs longest_seq = int(max(xl)) y = torch.DoubleTensor(y[:batch_size, :longest_seq]) # define model for offline: learn a batch model = timing.TimingLSTM(input_dim=feat_vec_size, batch_size=batch_size, bootstrap=args.bootstrap, seq2seq=args.seq2seq) if args.preload_model: trained_path = args.preload_model model.load_state_dict( torch.load(trained_path, map_location=timing.device)) print("Loaded pre-trained model weights from", trained_path) train_data = [{ 'X': x, 'X_lengths': xl, 'Y': y, 'diff_hat': dh, 'split': 'train' }] dl = {} dl['train'] = DataLoader(train_data, batch_size=1, shuffle=False) trained_model, loss = timing.train(model, dl, minibatch_size=int(batch_size / 2), minihop_size=int(batch_size / 4), epochs=20) if get_y_n("Save trained model? "): PATH = "models/last.pt" torch.save(trained_model.state_dict(), PATH) print("Saved trained model to", PATH) else: # ONLINE : # listen on port 5006 server = AsyncIOOSCUDPServer(("127.0.0.1", 5006), dispatcher, asyncio.get_event_loop()) # Create datagram endpoint and start serving transport, protocol = await server.create_serve_endpoint() # define model for LIVE. model = timing.TimingLSTM(input_dim=feat_vec_size, batch_size=1, bootstrap=args.bootstrap, seq2seq=args.seq2seq) if args.preload_model: trained_path = args.preload_model model.load_state_dict( torch.load(trained_path, map_location=timing.device)) print("Loaded pre-trained model weights from", trained_path) client.send_message("/record", 1) # Enter main loop of program X, Y, Y_hat, diff_hat, batch_size, X_lengths = await parseMIDItoFV( model) client.send_message("/record", 0) X, X_lengths, Y_hat, diff_hat = timing.prepare_X( X, X_lengths, Y_hat, diff_hat, batch_size) Y_hat, Y = timing.prepare_Y(X_lengths, diff_hat, Y_hat, Y, style='constant', value=0.01) total_loss = model.loss(Y_hat, Y, torch.DoubleTensor(diff_hat)) print('Take loss: {:4f}'.format(total_loss)) print('Take MSE (16th note) loss: {:4f}'.format(total_loss * 16 * 16)) if get_y_n("Save performance? "): rows, filename = timing.save_XY(X, X_lengths, diff_hat, Y, Y_hat) print("Saved", filename, ": ", rows, "rows.") client.send_message("/save", filename[11:-3] + "wav") transport.close() # Clean up serve endpoint
def async_server(host, port): logger.info(f'listening on {host}:{port}') loop = asyncio.get_event_loop() server = AsyncIOOSCUDPServer((host, port), dsp, loop) transport, protocol = yield from server.create_serve_endpoint() yield from asyncio.sleep(86400 * 7)
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
dispatcher = Dispatcher() dispatcher.map("/obs/scene/*", scene_handler) dispatcher.map("/obs/audio/*", audio_handler) dispatcher.map("/obs/osc/*", osc_handler) # +======== ASYNC/THREADED EVENT LOOP ========+ loop = asyncio.get_event_loop() loop.stop() loop = asyncio.new_event_loop() asyncio.set_event_loop(loop) def ticker_loop(delta_time): loop.stop() loop.run_forever() return True def script_tick(delta_time): ticker_loop(delta_time) server = AsyncIOOSCUDPServer((IP, PORT), dispatcher, asyncio.get_event_loop()) server.serve() # Finally refresh scenes refresh_scenes()