def __init__(self):
'''
OSC
'''
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=12345,
help="The port the OSC server is listening on")
args = parser.parse_args()
self.client = udp_client.UDPClient(args.ip, args.port)
parser1 = argparse.ArgumentParser()
parser1.add_argument("--ip",
default="127.0.0.1",
help="The ip of the OSC server")
parser1.add_argument("--port",
type=int,
default=12346,
help="The port the OSC server is listening on")
args1 = parser1.parse_args()
self.client1 = udp_client.UDPClient(args1.ip, args1.port)
print("initialized")
def main():
ipAddress = sys.argv[1]
portToDriver = int(sys.argv[2])
portFromDriver = int(sys.argv[3])
toDriverUDPClient = udp_client.UDPClient(ipAddress, portToDriver)
fromDriverUDPClient = udp_client.UDPClient(ipAddress, portFromDriver)
tasks = [(toDriverUDPClient, getTestMessagesToDriver()),
(fromDriverUDPClient, getTestMessagesFromDriver())]
for udpClient, messages in tasks:
for msg in messages:
udpClient.send(msg)
def run(self, edit):
self.settings = sublime.load_settings('Antescofo.sublime-settings')
address = self.settings.get('antescofoip', 'localhost')
port = self.settings.get('antescofoport', 5678)
# Walk through each region in the selection
for region in self.view.sel():
# If no region, then just send the line!
if region.empty():
# Expand the region to the full line it resides on, excluding the newline
line = self.view.line(region)
# Extract the string for the line, and add a newline
Contents = self.view.substr(line) + '\n'
else:
# if region, then send the region
# Get the selected text
Contents = self.view.substr(region) + '\n'
# Send OSC message
if pyosc:
## Send using pyosc
client = OSC.OSCClient()
client.connect((address, port))
oscmsg = OSC.OSCMessage('/antescofo/cmd')
oscmsg.append('playstring')
oscmsg.append(Contents)
client.send(oscmsg)
else:
client = udp_client.UDPClient(address, port)
oscmsg = osc_message_builder.OscMessageBuilder(
address="/antescofo/cmd")
oscmsg.add_arg("playstring")
oscmsg.add_arg(Contents)
oscmsg = oscmsg.build()
client.send(oscmsg)
def send_questions_to_line_editor():
"""
Sends data for display to Line Editor
"""
data = get_api_interact_data()['questions']
print("Called send question to the line editor")
#client = udp_client.UDPClient(ip_osc_editor, port_client_editor,1)
#builder = osc_message_builder.OscMessageBuilder(address='/textques')
#for k,v in data.items():
# builder.add_arg(v)
#builder.add_arg(.75)
#print('builder ', builder.address)
#client.send(builder.build())
#osc_dispatch('/textquest', .75, ip=ip_osc_server, port=port_client_editor)
# print("sent {0} to {1}:{2}".format(builder.args, ip_osc_editor, port_client_editor))
ip = ip_osc
port = port_client_editor
client = udp_client.UDPClient(ip, port, 1)
print("Send Data to Line Editor {}:{}", ip, port)
builder = osc_message_builder.OscMessageBuilder(address='/textques')
for k, v in data.items():
print(k, v)
builder.add_arg(v)
client.send(builder.build())
print("sent {0} to {1}:{2}".format(builder.args, ip, port))
broadcast_state()
return None
def send_message(address, message):
client = udp_client.UDPClient(server_ip, server_port)
# msg = osc_message_builder.OscMessageBuilder(address=address)
msg = osc_message_builder.OscMessageBuilder()
msg.address = address
msg.add_arg(message)
client.send(msg.build())
def parse_config():
global config_dict
global osc_client
global messages_and_bundles
global sources
messages_and_bundles = {}
success = True
try:
host = config_dict["HOST"]
port = config_dict["PORT"]
osc_client = udp_client.UDPClient(host, port)
except Exception as e:
print("ERROR: Invalid host/port config")
print("Failed with exception", e)
success = False
if success:
try:
messages = config_dict["MESSAGES"]
for msg_id in messages:
msg = messages[msg_id]
addr_id = msg["ADDRESS"]
addr = config_dict["ADDRESSES"][addr_id]
osc_msg = osc_message_builder.OscMessageBuilder(addr)
for arg in msg["ARGUMENTS"]:
osc_msg.add_arg(arg)
messages_and_bundles[msg_id] = osc_msg.build()
except Exception as e:
print("ERROR: Message parsing failed")
print("Failed with exception", e)
success = False
if success:
try:
for bnd_id in config_dict["BUNDLES"]:
success = parse_bundle(bnd_id)
if not success:
break
except Exception as e:
print("ERROR: Bundle parsing failed")
print("Failed with exception", e)
success = False
if success:
for src_id in config_dict["SOURCES"]:
msg_bnd_id = config_dict["SOURCES"][src_id]
if msg_bnd_id in messages_and_bundles:
sources[src_id] = msg_bnd_id
else:
print(
"ERROR: Source parsing failed. No message or bundle found with the name \""
+ msg_bnd_id + "\".")
success = False
break
return success
def execute(self, context):
global _report
bcw = bpy.context.window_manager
#For sending
try:
self.client = udp_client.UDPClient(bcw.addosc_udp_out, bcw.addosc_port_out)
msg = osc_message_builder.OscMessageBuilder(address="/blender")
msg.add_arg("Hello from Blender, simple test.")
msg = msg.build()
self.client.send(msg)
except OSError as err:
_report[1] = err
return {'CANCELLED'}
#Setting up the dispatcher for receiving
try:
self.dispatcher = dispatcher.Dispatcher()
self.dispatcher.set_default_handler(OSC_callback)
self.server = osc_server.ThreadingOSCUDPServer((bcw.addosc_udp_in, bcw.addosc_port_in), self.dispatcher)
self.server_thread = threading.Thread(target=self.server.serve_forever)
self.server_thread.start()
except OSError as err:
_report[0] = err
return {'CANCELLED'}
#inititate the modal timer thread
context.window_manager.modal_handler_add(self)
self._timer = context.window_manager.event_timer_add(bcw.addosc_rate/1000, context.window)
context.window_manager.status = "Running"
return {'RUNNING_MODAL'}
def init_osc_sender(ip, port):
osc_client = udp_client.UDPClient(ip, port)
# 設定のログ出し
print("[Sender] sender_ip:{}, sender_port:{}, address:/data".format(
ip, port))
return osc_client
def createClient(
self,
hostname: str = None,
port: int = None,
enableBroadcast: bool = False,
) -> None:
"""
One client per instance. Client sends to server at hostname:port.
"""
if self._client:
log.critical("Client is ALREADY CREATED.")
self._validateHostnameAndPort(hostname, port)
self._client = udp_client.UDPClient(self.hostname, self.port,
enableBroadcast)
#
enableBroadcastString = ""
if enableBroadcast:
enableBroadcastString = " Broadcast IS ENABLED."
log.info(
f"Created client to {self.hostname}:{self.port}.{enableBroadcastString}"
)
def respond_message(address='/1/status', data=0, client=None, port=9000):
if client is not None:
active_client = udp_client.UDPClient(client, port)
msg = osc_message_builder.OscMessageBuilder(address=address)
msg.add_arg(data)
msg = msg.build()
active_client.send(msg)
def do_osc(arg):
print('Sending package')
# client = udp_client.UDPClient('127.0.0.1', 5005)
client = udp_client.UDPClient('localhost', 5005)
msg = osc_message_builder.OscMessageBuilder(address="/debug")
# msg.add_arg(random.random())
msg = msg.build()
client.send(msg)
def __init__(self, un_seance_controller, ip, port):
'''
Create a client UDP with an OSC protocol
'''
self.seance_controller = un_seance_controller
self.client = udp_client.UDPClient(ip, port)
def setupOutputServer(self, context, envars):
#For sending
self.outputServer = udp_client.UDPClient(envars.udp_out, envars.port_out)
msg = osc_message_builder.OscMessageBuilder(address="/NodeOSC")
msg.add_arg("Python server started up")
msg = msg.build()
self.outputServer.send(msg)
print("Python Server sended test message to " + envars.udp_out + " on port " + str(envars.port_out))
def start_server_comms():
ip = "127.0.0.1"
port = 57120 # SuperCollider
client = udp_client.UDPClient(ip, port)
osc_statemachine['status'] = RUNNING
osc_msg = osc_message_builder.OscMessageBuilder
osc_statemachine['osc_msg'] = osc_msg
osc_statemachine['client'] = client
def preload_destinations():
for destination in config['destinations']:
if not destination['name'] in destinations:
if DEBUG:
print("Adding client [" + destination['name'] + "]: " +
destination['address'] + ":" + str(destination['port']))
destinations[destination['name']] = udp_client.UDPClient(
destination['address'], destination['port'])
def test_send(self, mock_socket_ctor):
mock_socket = mock_socket_ctor.return_value
client = udp_client.UDPClient('::1', 31337)
msg = osc_message_builder.OscMessageBuilder('/').build()
client.send(msg)
self.assertTrue(mock_socket.sendto.called)
mock_socket.sendto.assert_called_once_with(msg.dgram, ('::1', 31337))
def run(self, edit):
self.settings = sublime.load_settings('Antescofo.sublime-settings')
address = self.settings.get('antescofoip', 'localhost')
port = self.settings.get('antescofoport', 5678)
ascographip = self.settings.get('ascographip', 'localhost')
ascographport = self.settings.get('ascographport', 6789)
filename = self.view.file_name()
print('Antescofo Loading ', filename)
if pyosc:
# We are in Sublime 2!
# send to Antescofo Max/Pd objects
client = OSC.OSCClient()
client.connect((address, port))
oscmsg = OSC.OSCMessage('/antescofo/cmd')
oscmsg.append('score')
oscmsg.append(filename)
client.send(oscmsg)
# send to Ascograph
ascoclient = OSC.OSCClient()
ascoclient.connect((ascographip, ascographport))
oscmsg2 = OSC.OSCMessage('/antescofo/loadscore')
oscmsg2.append(filename)
ascoclient.send(oscmsg2)
else:
# We are in Sublime 3 / use PythonOSC
#filename = self.window.extract_variables()['file']
# Send to Antescofo object in Max/Pd
client = udp_client.UDPClient(address, port)
oscmsg = osc_message_builder.OscMessageBuilder(
address="/antescofo/cmd")
oscmsg.add_arg("score")
oscmsg.add_arg(filename)
oscmsg = oscmsg.build()
client.send(oscmsg)
# Send to AscoGraph if any
ascoclient = udp_client.UDPClient(ascographip, ascographport)
oscmsg2 = osc_message_builder.OscMessageBuilder(
address="/antescofo/loadscore")
oscmsg2.add_arg(filename)
oscmsg2 = oscmsg2.build()
ascoclient.send(oscmsg2)
def setupOSC(self):
# setup OSC server
ip = '127.0.0.1'
port_num = 8002
parser = argparse.ArgumentParser()
parser.add_argument("--ip", default=ip, help="The ip of th OSC Server")
parser.add_argument("--port", type=int, default=port_num, help="The port the OSC server is listening on")
args = parser.parse_args()
self.client = udp_client.UDPClient(args.ip, args.port)
print('OSC server on: ' + ip + ':' + str(port_num))
def main():
ip = '127.0.0.1'
port = 6700
client = udp_client.UDPClient(ip, port)
args = [0, 228, 123]
data = OscMessageBuilder(address='/address')
data.add_arg(args)
data = data.build()
client.send(data)
def prepare_synth_streaming(scHost=None, scPort=None, scMsg='/b_setn', scIndex=0, scFirstFrame=None):
print("obci_wifi.eeg_channels_per_sample:", obci_wifi.eeg_channels_per_sample)
global osc_sender_synth, osc_synth_addr, osc_beginning_arr
# osc_sender_synth = udp_client.SimpleUDPClient(scHost, scPort)
osc_sender_synth = udp_client.UDPClient(scHost, scPort)
osc_synth_addr = scMsg
osc_synth_num_messages = 1 + obci_wifi.eeg_channels_per_sample + 3 # counter, eeg, accelerometer
print("scFirstFrame", scFirstFrame)
if scFirstFrame is not None:
osc_beginning_arr = [int(scIndex), int(scFirstFrame), int(osc_synth_num_messages)]
else:
osc_beginning_arr = [int(scIndex), int(osc_synth_num_messages)]
def __init__(self, ip="127.0.0.1", port=5005):
self.beads = []
self.bgcolor = Color(0,0,0)
self.effects = []
self.osc_ip = ip
self.osc_port = port
self.effect_id = 0;
self.BEAD_COUNT=60
self.run_mainloop = False
self.mainloop_delay = 0.03
self.effect_registry = {}
self.osc_client = udp_client.UDPClient(self.osc_ip, self.osc_port)
for i in range(self.BEAD_COUNT):
self.beads.append(Bead(i))
# some useful predefined sets of beads
self.Set_None = frozenset()
self.Set_All = frozenset(self.beads)
self.Set_Stem = frozenset(self.beads[0:4])
self.Set_Ring = frozenset(self.beads[4:60])
self.Set_Eighth0 = frozenset(self.beads[4:11])
self.Set_Eighth1 = frozenset(self.beads[11:18])
self.Set_Eighth2 = frozenset(self.beads[18:25])
self.Set_Eighth3 = frozenset(self.beads[25:32])
self.Set_Eighth4 = frozenset(self.beads[32:39])
self.Set_Eighth5 = frozenset(self.beads[39:46])
self.Set_Eighth6 = frozenset(self.beads[46:53])
self.Set_Eighth7 = frozenset(self.beads[53:60])
self.Set_Quadrent0 = frozenset(self.beads[4:18])
self.Set_Quadrent1 = frozenset(self.beads[18:32])
self.Set_Quadrent2 = frozenset(self.beads[32:46])
self.Set_Quadrent3 = frozenset(self.beads[46:60])
self.Set_Half01 = frozenset(self.Set_Quadrent0.union(self.Set_Quadrent1))
self.Set_Half12 = frozenset(self.Set_Quadrent1.union(self.Set_Quadrent2))
self.Set_Half23 = frozenset(self.Set_Quadrent2.union(self.Set_Quadrent3))
self.Set_Half30 = frozenset(self.Set_Quadrent3.union(self.Set_Quadrent0))
self.Set_Even_All = frozenset(self.beads[0:60:2])
self.Set_Even_Ring = frozenset(self.beads[4:60:2])
self.Set_Odd_All = frozenset(self.beads[1:60:2])
self.Set_Odd_Ring = frozenset(self.beads[5:60:2])
# some useful predefined colors
self.Color_White = Color(1,1,1)
self.Color_Red = Color(1,0,0)
self.Color_Yellow = Color(1,1,0)
self.Color_Green = Color(0,1,0)
self.Color_Blue = Color(0,0,1)
self.Color_Violet = Color(1,0,1)
self.Color_Cyan = Color(0,1,1)
self.Color_Black = Color(0,0,0)
def __init__(self):
self.registered = False
self.robot = Robot.Robot(secondes=ROBOT_UPDATE_TIME)
#self.update_robot()
self.dispatcher = dispatcher.Dispatcher()
self.dispatcher.map("/clock", self.update_robot, "TEST")
self.dispatcher.map("/hack", self.server_hack, "Hack")
self.dispatcher.map("/player", self.get_player, "Player")
self.server = osc_server.ThreadingOSCUDPServer(("0.0.0.0", 5006),
self.dispatcher)
self.server_thread = threading.Thread(target=self.server.serve_forever)
self.server_thread.start()
self.to_server_client = udp_client.UDPClient("255.255.255.255", 5005)
self.to_client_client = udp_client.UDPClient("255.255.255.255", 5006)
if hasattr(socket, 'SO_BROADCAST'):
self.to_server_client._sock.setsockopt(socket.SOL_SOCKET,
socket.SO_BROADCAST, 1)
if hasattr(socket, 'SO_BROADCAST'):
self.to_client_client._sock.setsockopt(socket.SOL_SOCKET,
socket.SO_BROADCAST, 1)
print("Registering to server...")
msg = osc_message_builder.OscMessageBuilder(address="/register")
msg.add_arg(player_name)
msg.add_arg(my_ip) #
msg = msg.build()
self.to_server_client.send(msg)
print("Waiting for server")
self.root = tk.Tk()
self.root.geometry('{}x{}'.format(200, 500))
self.root.protocol("WM_DELETE_WINDOW", self.on_closing)
self.players_list = {}
self.playerListBox = tk.Listbox()
self.playerListBox.pack()
self.playerListBox.insert(tk.END, player_name + " 0")
self.root.mainloop()
def main():
global args
global client
args = setup()
client = udp_client.UDPClient(args.ip, args.port)
mqttc = mqtt.Client()
mqttc.connect(HOST, PORT)
mqttc.subscribe('wrapper')
mqttc.on_message = on_message
while True:
mqttc.loop()
def main():
parser = argparse.ArgumentParser()
parser.add_argument("destination", help="Destination UDP IP")
parser.add_argument("--port",
help="Destination UDP port",
default=DEFAULT_UDP_PORT)
parser.add_argument(
"-v",
"--visualise",
help=
"Send OSC to visualisation server, the format for this argument is ip:port"
)
parser.add_argument("-d", "--debug", action="store_true")
parser.add_argument("-l", "--log")
opts = parser.parse_args()
logging.basicConfig(level=logging.DEBUG if opts.debug else logging.INFO, )
client = udp_client.UDPClient(opts.destination, opts.port)
def logging_callback(*_):
pass
def visualise_callback(_):
pass
if opts.log:
logging_callback = Logger(opts.log).logging_callback
if opts.visualise is not None:
ip, port = opts.visualise.split(":")
vis_client = udp_client.UDPClient(ip, int(port))
def visualise_callback(message):
vis_client.send(message)
server = Server(DEFAULT_SERVER_PORT, client, visualise_callback,
logging_callback)
server.run_forever()
def __init__(self):
port_num = 8884
parser = argparse.ArgumentParser()
parser.add_argument("--ip",
default="127.0.0.1",
help="The ip of th OSC Server")
parser.add_argument("--port",
type=int,
default=port_num,
help="The port the OSC server is listening on")
args = parser.parse_args()
self.client = udp_client.UDPClient(args.ip, args.port)
print("ip:127.0.0.1, port:" + str(port_num) + ", address:/filter")
def init_osc():
parser = argparse.ArgumentParser()
parser.add_argument("--ip",
default="127.0.0.1",
help="The ip of th OSC Server")
parser.add_argument("--port",
type=int,
default=config.port_num,
help="The port the OSC server is listening on")
args = parser.parse_args()
osc_client = udp_client.UDPClient(args.ip, args.port)
# 設定のログ出し
print("ip:127.0.0.1, port:" + str(config.port_num) + ", address:/data")
return osc_client
def osc_dispatch(addr, msg, ip=ip_osc, port=port_client, num_tries=1):
"""
Dispatches a message in state change over OSC to all listeners
"""
client = udp_client.UDPClient(ip, port, 1)
## SimpleOSCClientRedux(client)
## client._sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
builder = osc_message_builder.OscMessageBuilder(address=addr)
builder.add_arg(msg)
for _ in range(num_tries):
client.send(builder.build())
logger.info("Sending {0} with {1} to {2} at {3}, Attempt {4}".format(
addr, msg, ip, port, _))
return None
def osc_dispatch(addr, msg, ip=ip_osc, port=port_client):
"""
Dispatches a message in state change over OSC to all listeners
"""
client = udp_client.UDPClient(ip, port, 1)
## SimpleOSCClientRedux(client)
## client._sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
print("Sent {0} with {1} to {2} at {3}".format(addr, msg, ip, port))
builder = osc_message_builder.OscMessageBuilder(address=addr)
builder.add_arg(msg)
client.send(builder.build())
## print(client(addr, msg))
return None
def make_video(tag):
clips = []
for video in mergeSequence:
#print mergeSequence
#print each video of the sequence and tagsself.and colors
#filename = "./videos/" + video['id']
filename = video["path"]
#print video
#print filename
clip = Clip(filename, start=video['start'], end=video['end'])
if "abstract" in video["tags"]:
clip.fadein(1)
clip.fadeout(1.5)
if video in beginning:
clip.fadein(3)
if video in ending:
clip.fadeout(1.5)
if video in randomSounds:
clip.fadein(1)
clip.fadeout(1.5)
clip.glow()
clips.append(clip)
#print (mergeSequence[0]["id"])
composition = Composition(clips, singletrack=True, width=800, height=800)
#videoName = "render/videoConnected10" + datetime.datetime.now().strftime("%Y%m%d%H%M%S") +".mp4"
# videoName = "render/video_" + tag + datetime.datetime.now().strftime("%Y%m%d%H%M%S") +".mp4"
videoName = "render/video_" + tag + datetime.datetime.now().strftime(
"%Y%m%d%H%M%S") + ".mov"
composition.save(videoName)
#composition.save(videoName)
#datetime.datetime.now().strftime("%Y%m%d%H%M&S")
#setup a client (api adress, localhost)
client = udp_client.UDPClient("127.0.0.1", 8000)
print("testing message")
#composition.preview()
#now built the messagingSenderId
msg = osc_message_builder.OscMessageBuilder(address="/video")
msg.add_arg("nature")
msg = msg.build()
client.send(msg)
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()
