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 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()
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 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 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 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')
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): 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()
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()
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
async def init_main(): if args.offline: # OFFLINE : ... x, xl, y, bs = timing.load_XY(args.take) x, xl, yh = timing.prepare_X(x, xl, None, 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, 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) since = time.time() if args.valid: gmd = GMDdataset(csv_file=args.root_dir + args.valid, root_dir=args.root_dir) val_data = [ gmd[i] for i in range(len(gmd)) if gmd[i]['split'] != 'dropped' ] train_data = [{'X': x, 'X_lengths': xl, 'Y': y, 'split': 'train'}] dl = {} dl['train'] = DataLoader(train_data, batch_size=1, shuffle=False) if args.valid: dl['val'] = DataLoader(val_data, batch_size=64, shuffle=True, num_workers=1, collate_fn=pad_collate) time_elapsed = time.time() - since print('Data loaded in {:.0f}m {:.0f}s\n==========='.format( time_elapsed // 60, time_elapsed % 60)) trained_model, loss = timing.train(model, dl, minibatch_size=int(batch_size), epochs=30, lr=1e-3) 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() X, X_lengths, batch_size = parseMIDItoX() # define model for LIVE. model = timing.TimingLSTM(input_dim=feat_vec_size, batch_size=batch_size if args.seq2seq else 1, 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) trainer = {} trainer['next_delay'] = 0 trainer['train_time'] = 0.15 # seconds trainer['indices'] = -1 trainer['writer'] = SummaryWriter() # Enter main loop of program X, Y_hat, X_lengths = await parseMIDItoFV(model, trainer, X, X_lengths, batch_size) client.send_message("/record", 0) X, X_lengths, Y_hat = timing.prepare_X(X, X_lengths, Y_hat, batch_size) Y_hat, Y = timing.prepare_Y( X_lengths, X[:, :, 14], Y_hat, A=args.A, B=args.B, # style='diff') # JUST FOR TESTING # style='EMA', value=0.8) style='constant') total_loss = model.loss(Y_hat, Y, X[:, :, 14]) 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, Y, Y_hat) client.send_message("/save", filename[11:-3] + "wav") if args.train_online and get_y_n("Save trained model? "): PATH = "models/last.pt" torch.save(model.state_dict(), PATH) print("Saved trained model to", PATH) writer.add_hparams( { 'layers': model.nb_layers, 'lstm_units': model.nb_lstm_units, 'lr': lr, 'epochs': epochs }, { 'hparam/best_val_loss': best_loss, 'hparam/test_loss': total_loss }) writer.flush() transport.close() # Clean up serve endpoint
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()