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