def test_default_handler(): results = [] def test(address, *values): results.append((address, values)) osc = OSCThreadServer(default_handler=test) osc.listen(default=True) @osc.address(b'/passthrough') def passthrough(*values): pass osc.send_bundle(( (b'/test', []), (b'/passthrough', []), (b'/test/2', [1, 2, 3]), ), *osc.getaddress()) timeout = time() + 2 while len(results) < 2: if time() > timeout: raise OSError('timeout while waiting for success message.') sleep(10e-9) expected = ( (b'/test', tuple()), (b'/test/2', (1, 2, 3)), ) for e, r in zip(expected, results): assert e == r
def test_bind_multi(): osc = OSCThreadServer() sock1 = osc.listen() port1 = sock1.getsockname()[1] sock2 = osc.listen() port2 = sock2.getsockname()[1] cont = [] def success1(*values): cont.append(True) def success2(*values): cont.append(False) osc.bind(b'/success', success1, sock1) osc.bind(b'/success', success2, sock2) send_message(b'/success', [b'test', 1, 1.12345], 'localhost', port1) send_message(b'/success', [b'test', 1, 1.12345], 'localhost', port2) timeout = time() + 5 while len(cont) < 2: if time() > timeout: raise OSError('timeout while waiting for success message.') assert True in cont and False in cont
def test_get_routes(): osc = OSCThreadServer(encoding='utf8') osc.listen(default=True) values = [] @osc.address(u'/test_route') def dummy(*val): pass @osc.address(u'/_oscpy/routes/answer') def cb(*routes): values.extend(routes) send_message(b'/_oscpy/routes', [osc.getaddress()[1]], *osc.getaddress(), encoding='utf8', encoding_errors='strict') timeout = time() + 2 while not values: if time() > timeout: raise OSError('timeout while waiting for success message.') sleep(10e-9) assert u'/test_route' in values
def test_send_bundle_without_socket(): osc = OSCThreadServer() with pytest.raises(RuntimeError): osc.send_bundle([], 'localhost', 0) osc.listen(default=True) osc.send_bundle(((b'/test', []), ), 'localhost', 1)
def setup_service(): Logger.info('service: setup_service') setup_logger('mi') # add this dir to module search path app_dir = os.path.join(mi2app_utils.get_files_dir(), "app") sys.path.append(os.path.join(app_dir, 'service')) Logger.info('service: sys path added: ' + str(sys.path)) # setup control and listen to osc signal control = Control() Logger.info('service: control created' + repr(control)) osc = OSCThreadServer() osc.listen(port=OSCConfig.service_port, default=True) # def dummy_callback(msg, *args): # Logger.info('service: dummy callback: ' + str(msg)) # osc.bind(OSCID, dummy_callback, OSCConfig.control_addr) osc.bind(bytes(OSCConfig.control_addr, "ascii"), control.osc_callback) # Logger.info('service: osc setup, id: ' + OSCID) Logger.info('service: osc setup') gps_provider = GpsListener(on_gps) gps_provider.start() osc_client = OSCClient("127.0.0.1", OSCConfig.service_port) osc_client.send_message(bytes(OSCConfig.control_addr, "ascii"), ['service ready',]) Logger.info('service SEND>: service ready msg sent') while True: # osc.readQueue(thread_id=OSCID) time.sleep(.5)
def __dump(options): def dump(address, *values): print(u'{}: {}'.format( address.decode('utf8'), ', '.join( '{}'.format( v.decode(options.encoding or 'utf8') if isinstance(v, bytes) else v ) for v in values if values ) )) osc = OSCThreadServer( encoding=options.encoding, encoding_errors=options.encoding_errors, default_handler=dump ) osc.listen( address=options.host, port=options.port, default=True ) return osc
def test_listen_default(): osc = OSCThreadServer() sock = osc.listen(default=True) with pytest.raises(RuntimeError) as e_info: # noqa osc.listen(default=True) osc.close(sock) osc.listen(default=True)
def test_getaddress(): osc = OSCThreadServer() sock = osc.listen() assert osc.getaddress(sock)[0] == '127.0.0.1' with pytest.raises(RuntimeError): osc.getaddress() sock2 = osc.listen(default=True) assert osc.getaddress(sock2)[0] == '127.0.0.1' osc.stop(sock)
def test_stop_all(): osc = OSCThreadServer() sock = osc.listen(default=True) host, port = sock.getsockname() osc.listen() assert len(osc.sockets) == 2 osc.stop_all() assert len(osc.sockets) == 0 osc.listen(address=host, port=port) assert len(osc.sockets) == 1 osc.stop_all()
def test_close(): osc = OSCThreadServer() osc.listen(default=True) osc.close() with pytest.raises(RuntimeError) as e_info: # noqa osc.close() if platform != 'win32': filename = mktemp() unix = osc.listen(address=filename, family='unix') assert exists(filename) osc.close(unix) assert not exists(filename)
def follow_logs(self): try: server = OSCThreadServer(encoding='utf8') server.listen(address='127.0.0.1', port=4558, default=True) server.bind('/log/multi_message', self.handle_multi_message) server.bind('/multi_message', self.handle_multi_message) server.bind('/log/info', self.handle_log_info) server.bind('/info', self.handle_log_info) server.bind('/error', self.handle_runtime_error) server.bind('/syntax_error', self.handle_syntax_error) while True: time.sleep(1) except Exception as e: return e
class OSC: """Ne fait que envoyer avec self.client et recevoir avec self.server, en com avec service.py """ def __init__(self): self.sensor = "\nRecherche d'un capteur ..." # a, b, c, activity, num, tempo self.display_list = [0, 0, 0, 0, 0, 1, 0] # Conservation de tout l'historique self.histo_xyz = [] self.server = OSCThreadServer() self.server.listen(address=b'localhost', port=3003, default=True) self.server.bind(b'/acc', self.on_acc) self.server.bind(b'/sensor', self.on_sensor) self.server.bind(b'/offset', self.on_offset) self.client = OSCClient(b'localhost', 3001) self.t_init = None def on_offset(self, offset): """Valeur possible: Android Virtual No sensor""" self.offset = offset * 1000000 print("self.offset =", self.offset) def on_sensor(self, sens): """Valeur possible: Android Virtual No sensor""" self.sensor = sens.decode('utf-8') def on_acc(self, *args): # Nessressaire pour maj affichage si acc ne tourne pas self.display_list = [ args[0], args[1], args[2], args[3], args[4], args[5], args[6] ] a, b, c, t = (args[0], args[1], args[2], args[6]) # dans service: t=int(time()*1000)-1604000000000 avec get_datetime() t_absolute = get_datetime(t, self.offset) # Datetime du début if not self.t_init: self.t_init = t_absolute t_relativ = t_absolute - self.t_init # En secondes tx = t_relativ.total_seconds() norme = int((a**2 + b**2 + c**2)**0.5) # Par axe if norme > 1: # Bug au début self.histo_xyz.append((tx, (a, b, c)))
def test_server_different_port(): # server, will be tested: server_3000 = OSCThreadServer(encoding='utf8') sock_3000 = server_3000.listen(address='0.0.0.0', port=3000, default=True) server_3000.bind(b'/callback_3000', callback_3000) # clients sending to different ports, used to test the server: client_3000 = OSCClient(address='localhost', port=3000, encoding='utf8') # server sends message to himself, should work: server_3000.send_message(b'/callback_3000', ["a"], ip_address='localhost', port=3000) sleep(0.05) # client sends message to server, will be received properly: client_3000.send_message(b'/callback_3000', ["b"]) sleep(0.05) # sever sends message on different port, might crash the server on windows: server_3000.send_message(b'/callback_3000', ["nobody is going to receive this"], ip_address='localhost', port=3001) sleep(0.05) # client sends message to server again. if server is dead, message will not be received: client_3000.send_message(b'/callback_3000', ["c"]) sleep(0.1) # give time to finish transmissions # if 'c' is missing in the received checklist, the server thread crashed and could not recieve the last message from the client: assert checklist == ['a', 'b', 'c'] server_3000.stop() # clean up
def create_osc_listener(port=8000, callback=None): ''' Create a threaded OSC server that listens for incoming UDP messages ''' from oscpy.server import OSCThreadServer logger.debug('[create_osc_listener port={}]'.format(port)) def converter(addr, *args): logger.debug("[create_osc_listener.converter] addr={} args={}".format(addr, args)) if callback: callback(addr.decode('utf-8'), args) osc = OSCThreadServer(advanced_matching=True, encoding='utf8', default_handler=converter) # See sources for all the arguments sock = osc.listen(address='0.0.0.0', port=port, default=True) # osc.bind_all(converter, get_address=True) def disconnect(): osc.stop() # Stop the default socket osc.stop_all() # Stop all sockets # Here the server is still alive, one might call osc.listen() again osc.terminate_server() # Request the handler thread to stop looping osc.join_server() return osc, disconnect
def test_oscclient(): osc = OSCThreadServer() sock = osc.listen() port = sock.getsockname()[1] acc = [] def success(*values): acc.append(values[0]) osc.bind(b'/success', success, sock) client = OSCClient('localhost', port) timeout = time() + 5 while len(acc) < 50: if time() > timeout: raise OSError('timeout while waiting for success message.') client.send_message(b'/success', [1]) while len(acc) < 100: if time() > timeout: raise OSError('timeout while waiting for success message.') client.send_bundle([(b'/success', [i]) for i in range(10)])
def test_validate_message_address_disabled(): osc = OSCThreadServer(validate_message_address=False) osc.listen(default=True) received = [] @osc.address(b'malformed') def malformed(*val): received.append(val[0]) send_message(b'malformed', [b'message'], *osc.getaddress()) timeout = time() + 2 while not received: if time() > timeout: raise OSError('timeout while waiting for success message.') sleep(10e-9)
def test_bind_default(): osc = OSCThreadServer() osc.listen(default=True) port = osc.getaddress()[1] cont = [] def success(*values): cont.append(True) osc.bind(b'/success', success) send_message(b'/success', [b'test', 1, 1.12345], 'localhost', port) timeout = time() + 5 while not cont: if time() > timeout: raise OSError('timeout while waiting for success message.')
def receive_values_from_max(ip, port): while (1): osc = OSCThreadServer() sock = osc.listen(address=ip, port=port, default=True) #osc.bind(b'/crowd-accel',acceleration_data) osc.bind(b'/crowd-pos', positional_data) sleep(1) osc.stop() return True
def receive_values_from_max(ip, port): while (1): osc = OSCThreadServer() sock = osc.listen(address=ip, port=port, default=True) osc.bind(b'/density', printer) osc.bind(b'/cluster', printer) osc.bind(b"/mob_speed", printer) sleep(1000) osc.stop() return True
def start_osc(self): global osc def callback(*values): print("<<<<<<>>>>>> got values: {}".format(values)) print("STARTING OSC SERVER>>>>>>>>>>>>>>>>>") osc = OSCThreadServer() sock = osc.listen(address='0.0.0.0', port=8888, default=True) osc.bind(b'/address', callback)
def test_bind_address(): osc = OSCThreadServer() osc.listen(default=True) result = [] @osc.address(b'/test') def success(*args): result.append(True) timeout = time() + 1 send_message(b'/test', [], *osc.getaddress()) while len(result) < 1: if time() > timeout: raise OSError('timeout while waiting for success message.') sleep(10e-9) assert True in result
def test_encoding_receive(): osc = OSCThreadServer(encoding='utf8') osc.listen(default=True) values = [] @osc.address(u'/encoded') def encoded(*val): for v in val: assert not isinstance(v, bytes) values.append(val) send_message(b'/encoded', [b'hello world', u'ééééé ààààà'.encode('utf8')], *osc.getaddress()) timeout = time() + 2 while not values: if time() > timeout: raise OSError('timeout while waiting for success message.') sleep(10e-9)
class OSC: """Ne fait que envoyer avec self.client et recevoir avec self.server, en com avec service.py """ def __init__(self): self.sensor = "Recherche d'un capteur ..." # a, b, c, activity, num, tempo self.display_list = [0, 0, 0, -2, 0, 1, 0] self.histo = [] self.server = OSCThreadServer() self.server.listen(address=b'localhost', port=3003, default=True) self.server.bind(b'/acc', self.on_acc) self.server.bind(b'/sensor', self.on_sensor) self.client = OSCClient(b'localhost', 3001) self.t_init = 0 def on_sensor(self, sens): """Vlaleur possible: Andoid Virtual No sensor""" self.sensor = sens.decode('utf-8') def on_acc(self, *args): self.display_list = args a, b, c, t = (self.display_list[0], self.display_list[1], self.display_list[2], self.display_list[6]) norme = int((a**2 + b**2 + c**2)**0.5) # 920736845 # 36845 if self.t_init: tx = (t - self.t_init) / 100 else: self.t_init = t tx = 0 print(tx) # liste de couple (x, y) self.histo.append((tx, norme)) if len(self.histo) > 100: del self.histo[0]
def test_get_sender(): osc = OSCThreadServer(encoding='utf8') osc.listen(default=True) values = [] @osc.address(u'/test_route') def callback(*val): values.append(osc.get_sender()) with pytest.raises(RuntimeError, match='get_sender\(\) not called from a callback'): osc.get_sender() send_message(b'/test_route', [osc.getaddress()[1]], *osc.getaddress(), encoding='utf8') timeout = time() + 2 while not values: if time() > timeout: raise OSError('timeout while waiting for success message.') sleep(10e-9)
class ctrlOSC(object): def __init__(self): super(ctrlOSC, self).__init__() # self.isrunning = True self.osc = OSCThreadServer() self.sock = self.osc.listen(address='0.0.0.0', port=8000, default=True) self.osc.bind(b'/address', self.callback) # def run(self): # while self.isrunning: # @osc.address(b'/address') def callback(self, values, *args): print("got values: {}, {}, {}".format(type(values), values, args))
def test_get_version(): osc = OSCThreadServer(encoding='utf8') osc.listen(default=True) values = [] @osc.address(u'/_oscpy/version/answer') def cb(val): print(val) values.append(val) send_message(b'/_oscpy/version', [osc.getaddress()[1]], *osc.getaddress(), encoding='utf8', encoding_errors='strict') timeout = time() + 2 while not values: if time() > timeout: raise OSError('timeout while waiting for success message.') sleep(10e-9) assert __version__ in values
def test_reuse_callback(): osc = OSCThreadServer() sock = osc.listen() port = sock.getsockname()[1] cont = [] def success(*values): cont.append(True) osc.bind(b'/success', success, sock) osc.bind(b'/success', success, sock) osc.bind(b'/success2', success, sock) assert len(osc.addresses.get((sock, b'/success'))) == 1 assert len(osc.addresses.get((sock, b'/success2'))) == 1
def test_bind_address_class(): osc = OSCThreadServer() osc.listen(default=True) @ServerClass class Test(object): def __init__(self): self.result = [] @osc.address_method(b'/test') def success(self, *args): self.result.append(True) timeout = time() + 1 test = Test() send_message(b'/test', [], *osc.getaddress()) while len(test.result) < 1: if time() > timeout: raise OSError('timeout while waiting for success message.') sleep(10e-9) assert True in test.result
def test_intercept_errors(caplog): cont = [] def success(*values): cont.append(True) def broken_callback(*values): raise ValueError("some bad value") osc = OSCThreadServer() sock = osc.listen() port = sock.getsockname()[1] osc.bind(b'/broken_callback', broken_callback, sock) osc.bind(b'/success', success, sock) send_message(b'/broken_callback', [b'test'], 'localhost', port) sleep(0.01) send_message(b'/success', [b'test'], 'localhost', port) assert not osc.join_server(timeout=0.02) # Thread not stopped assert cont == [True] assert len(caplog.records) == 1, caplog.records record = caplog.records[0] assert record.msg == "Unhandled exception caught in oscpy server" assert not record.args assert record.exc_info osc = OSCThreadServer(intercept_errors=False) sock = osc.listen() port = sock.getsockname()[1] osc.bind(b'/broken_callback', broken_callback, sock) send_message(b'/broken_callback', [b'test'], 'localhost', port) assert osc.join_server( timeout=0.02) # Thread properly sets termination event on crash assert len(caplog.records) == 1, caplog.records # Unchanged
def test_send_message(): osc = OSCThreadServer() sock = osc.listen() port = sock.getsockname()[1] acc = [] def success(*values): acc.append(values[0]) osc.bind(b'/success', success, sock) timeout = time() + 5 while len(acc) < 100: if time() > timeout: raise OSError('timeout while waiting for success message.') send_message(b'/success', [1], 'localhost', port)
CLIENT = OSCClient('localhost', 3002) def ping(*_): 'answer to ping messages' CLIENT.send_message( b'/message', [ ''.join(sample(ascii_letters, randint(10, 20))) .encode('utf8'), ], ) def send_date(): 'send date to the application' CLIENT.send_message( b'/date', [asctime(localtime()).encode('utf8'), ], ) if __name__ == '__main__': SERVER = OSCThreadServer() SERVER.listen('localhost', port=3000, default=True) SERVER.bind(b'/ping', ping) while True: sleep(1) send_date()