def __init__(self):
self.socketIO = SocketIO(host, port)
def on_connect():
print("Server connected")
def on_disconnect(*args):
print("Server disconnected")
def on_reconnect():
print("Server reconnected")
def on_time(*args):
print(args[0])
self.socketIO.on('connect', on_connect) # This is not working
self.socketIO.on('disconnect', on_disconnect) # This works
self.socketIO.on('reconnect', on_reconnect) # This is not working
self.socketIO.on('time', on_time)
self.receive_events_thread = Thread(target=self._receive_events_thread)
self.receive_events_thread.daemon = True
self.receive_events_thread.start()
while True:
some_input = input("Please input: ")
self.socketIO.emit('custom', some_input)
def sendToNode(channel, data):
"""
Send string to Node.js server
No reply expected
WARNING: while trying to connect, the main loop is blocked
"""
if debug_sockets: print("[SCK] To Node (on {}): {}".format(channel, data))
with SocketIO('localhost', 8081, wait_for_connection=False) as socket:
socket.connect()
if debug_sockets: print("[SCK] Connected to Node server on 8081")
if (type(data) == dict):
socket.emit(channel, json.dumps(dict2list(data),
ensure_ascii=False))
else:
socket.emit(channel, json.dumps(data, ensure_ascii=False))
if debug_sockets: print("[SCK] To Node: sent")
def emit(name, data=None):
return
if not WS_ENABLED:
return
try:
if data is None:
data = {}
from socketIO_client_nexus import SocketIO
with SocketIO(WS_BASE,
WS_PORT,
wait_for_connection=False,
transports=["websocket"]) as socketIO:
socketIO.emit(name, data)
socketIO.disconnect()
except:
pass
def run(self):
print("trying to connect to", self.url)
#with SocketIO('http://localhost:8005') as socketIO:
with SocketIO(self.url) as socketIO:
print("got socketIO", socketIO)
self.socket = socketIO
socketIO.on('connect', lambda args, s=self: s.on_connect(args))
#
print("Send status.join message")
socketIO.emit('MUSE',
{'type': 'status.join', 'clientType': 'Python'})
socketIO.on('MUSE', lambda msg, s=self: s.onMessage(msg))
#socketIO.wait_for_callbacks(seconds=1)
while 1:
socketIO.wait(seconds=10)
print("wait some more...")
class SocketMessenger():
def __init__(self, hostname, port):
imageio.plugins.freeimage.download()
self.hostname = hostname
self.port = port
self.socket = SocketIO(self.hostname, self.port)
self.messenger_namespace = self.socket.define(MessengerNameSpace,
Config.Socket.NAMESPACE)
def send_alert(self, **kwargs):
json_string = json.dumps(kwargs)
self.messenger_namespace.emit(Config.Socket.ALERT_EVENT, json_string)
def send_statistic(self, **kwargs):
json_string = json.dumps(kwargs)
print(json_string)
self.messenger_namespace.emit(Config.Socket.STATISTIC, json_string)
def _setup_socket(self):
"""Create socket handlers and registers the socket"""
self.socketIO = SocketIO(self.server_url, self.port)
def on_socket_open(*args):
shared_utils.print_and_log(
logging.DEBUG,
'Socket open: {}'.format(args)
)
self._send_world_alive()
self.alive = True
def on_disconnect(*args):
"""Disconnect event is a no-op for us, as the server reconnects
automatically on a retry"""
shared_utils.print_and_log(
logging.INFO,
'World server disconnected: {}'.format(args)
)
self.alive = False
def on_message(*args):
"""Incoming message handler for ACKs, ALIVEs, HEARTBEATs,
and MESSAGEs"""
message_data = args[0]
shared_utils.print_and_log(
logging.DEBUG,
'Message data recieved: {}'.format(message_data)
)
for message_packet in message_data['entry']:
self.message_callback(message_packet['messaging'][0])
# Register Handlers
self.socketIO.on('socket_open', on_socket_open)
self.socketIO.on('disconnect', on_disconnect)
self.socketIO.on('new_packet', on_message)
# Start listening thread
self.listen_thread = threading.Thread(
target=self.socketIO.wait,
name='Main-Socket-Thread'
)
self.listen_thread.daemon = True
self.listen_thread.start()
def connect(self):
io = SocketIO(self.server, self.port)
iron_namespace = io.define(IRONNamespace, '/iron')
flash_namespace = io.define(FLASHNamespace, '/flash')
mega_namespace = io.define(MEGANamespace, '/mega')
io.emit('login', {'app_client_secret_id': os.environ.get('SOCKBOT_APPCLIENT_SECRET'),
'name': 'AUTOBOT'}, callback_login)
#login update socketid
io.wait_for_callbacks(seconds=1)
#io.wait()
return dict(io=io,iron_namespace=iron_namespace, flash_namespace=flash_namespace, mega_namespace=mega_namespace)
def run(self):
url = 'http://localhost:8000'
print "Connecting to SocketIO", url
with SocketIO(url) as socketIO:
print "got socketIO", socketIO
socketIO.on('connect', lambda args, s=self: s.on_connect(args))
#
print "Send status.join message"
socketIO.emit('MUSE', {
'type': 'status.join',
'clientType': 'Python'
})
socketIO.on('MUSE', lambda msg, s=self: s.onMessage(msg))
#socketIO.wait_for_callbacks(seconds=1)
while 1:
socketIO.wait(seconds=10)
print "wait some more..."
def socketio(
url,
callback,
channel="",
field="",
sendinit=None,
json=False,
wrap=False,
interval=1,
):
"""Connect to socketIO server and pipe results through the callback
Args:
url (str): url to connect to
callback (callable): function to call on websocket data
channel (str): socketio channel to connect through
field (str): field to index result by
sendinit (list): data to send on socketio connection open
json (bool): load websocket data as json
wrap (bool): wrap result in a list
interval (int): socketio wai interval
"""
from socketIO_client_nexus import SocketIO as SIO
o = urlparse(url)
socketIO = SIO(o.scheme + "://" + o.netloc, o.port)
if sendinit:
socketIO.emit(sendinit)
while True:
_data = []
socketIO.on(channel, lambda data: _data.append(data))
socketIO.wait(seconds=interval)
for msg in _data:
if json:
msg = json.loads(msg)
if field:
msg = msg[field]
if wrap:
msg = [msg]
callback(msg)
def get_points_sample():
start = time.time()
simq = ""
x = 0
for question in sample_questions:
x = x + 1
options = sample_questions[question]
with SocketIO('localhost', 3000, LoggingNamespace) as socketIO:
socketIO.emit('new question', {'q': question,
'c1': options[0], 'c2': options[1], 'c3': options[2]}, on_bbb_response)
socketIO.wait_for_callbacks(seconds=1)
start = time.time()
printResult(question, options)
end = time.time()
print(end - start)
def parse_ripe_ris(connection, prefix, host):
exchange = Exchange('bgp-update',
channel=connection,
type='direct',
durable=False)
exchange.declare()
def on_ris_msg(msg):
try:
producer = Producer(connection)
normalize_ripe_ris(msg)
if mformat_validator(msg):
msgs = normalize_msg_path(msg)
for msg in msgs:
key_generator(msg)
log.debug(msg)
producer.publish(msg,
exchange=exchange,
routing_key='update',
serializer='json')
else:
log.warning('Invalid format message: {}'.format(msg))
except Exception:
log.exception('exception')
with SocketIO('http://stream-dev.ris.ripe.net/stream2',
wait_for_connection=False) as socket_io:
socket_io.on('ris_message', on_ris_msg)
socket_io.emit(
'ris_subscribe', {
'host': host,
'type': 'UPDATE',
'prefix': prefix,
'moreSpecific': True,
'lessSpecific': False,
'socketOptions': {
'includeBody': False,
'explodePrefixes': True,
}
})
socket_io.wait()
def parse_rrcs(self) -> NoReturn:
"""
SocketIO connection to RIPE RIS to retrieve all active Route Collectors.
"""
try:
socket_io = SocketIO('http://stream-dev.ris.ripe.net/stream',
wait_for_connection=False)
def on_msg(msg):
self.available_ris = set(msg)
socket_io.disconnect()
socket_io.on('ris_rrc_list', on_msg)
socket_io.wait(seconds=3)
except Exception:
log.warning('RIPE RIS server is down. Try again later..')
def socketio(url, callback, channel='', field='', sendinit=None, json=False, wrap=False, interval=1):
o = urlparse(url)
socketIO = SIO(o.scheme + '://' + o.netloc, o.port)
if sendinit:
socketIO.emit(sendinit)
while True:
_data = []
socketIO.on(channel, lambda data: _data.append(data))
socketIO.wait(seconds=interval)
for msg in _data:
if json:
msg = json.loads(msg)
if field:
msg = msg[field]
if wrap:
msg = [msg]
callback(msg)
def __init__(self):
self.socketIO = SocketIO(host, port)
def on_socket_open(*args):
print("on_socket_open: ", args[0])
self.socketIO.emit('agent_alive', {'task_group_id': 'test_group', 'agent_id': '[World]'})
def on_disconnect(*args):
print("Server disconnected", args[0])
def on_new_messgae(*args):
print(args[0])
self.socketIO.on('socket_open', on_socket_open)
self.socketIO.on('disconnect', on_disconnect) # This works
self.socketIO.on('new_message', on_new_messgae)
self.receive_events_thread = Thread(target=self._receive_events_thread)
self.receive_events_thread.daemon = True
self.receive_events_thread.start()
while True:
some_input = input("Hit ENTER to send message:")
self.socketIO.emit('new_message', {'task_group_id': 'test_group', 'receiver_agent_id': 'Worker'})
def calibrate_PH():
"""
This function creates a client endpoint in socket connection between nodeJS
and python process, listens continuosly to socketIO event, calibrates PH-circuit
with received information.
If calibration succeed, send back a success message.
Else, send back an error message.
"""
devices = AtlasI2C();
socket_url = "localhost"
socketIO = SocketIO(socket_url, 9000, verify=False)
def start_calibrate(*arg):
try:
print(arg)
a = arg[0][u'data']
print(a)
commandList = { "low": "cal,low,4", "medium": "cal,mid,7","high":"cal,high,10"}
command = commandList.get(a)
logger.info(command)
mutex.acquire()
tempRecalibration = "T,"+str(measure_temperature(26))
devices.query(tempRecalibration)
sleep(0.3)
devices.query(command)
sleep(0.3)
status = devices.query('cal,?')
status = status[-1]
socketIO.emit('success',status)
f = open("/home/pi/Public/main/Server/status.txt","w+")
f.write(status)
f.close()
logger.info("Calibration Command Successful,"+str(a))
mutex.release()
except :
socketIO.emit("error")
logger.debug("Wrong Command")
socketIO.on('send_data',start_calibrate) #Listen to calibrating event
socketIO.wait()
while True: #keep the thread alive to continue listening to socket event
pass
def main():
attempts = 0
while attempts < 3:
try:
socketIO = SocketIO(FMF_SERVER,
8080,
Namespace,
verify=False,
wait_for_connection=False)
socketIO.emit('authenticate', {
"app_id": APP_ID,
"device_id": DEVICE_ID
})
socketIO.wait()
except ConnectionError:
attempts += 1
time.sleep(30)
print "Can't connect to server, trying again..."
class Client(object):
def __init__(self):
self.socketio = SocketIO("http://twitchplaysnintendoswitch.com:8110")
# self.socketio.on("controllerState1", self.on_controller_state1)
# self.socketio.on("controllerState2", self.on_controller_state2)
# self.socketio.on("controllerState3", self.on_controller_state3)
self.socketio.on("controllerState5", self.on_controller_state1)
self.socketio.on("turnTimesLeft", self.on_turn_times_left)
self.socketio.emit("join", "wiiu3dscontroller")
self.receive_events_thread = Thread(target=self._receive_events_thread)
self.receive_events_thread.daemon = True
self.receive_events_thread.start()
self.start = time.clock()
self.end = time.clock()
self.botstart = time.clock()
self.botend = time.clock()
self.controllerStart = time.clock()
self.controllerEnd = time.clock()
self.lockon = False
self.yeaVotes = 0
self.nayVotes = 0
self.voting = False
self.currentPlayers = []
self.laglessEnabled = True
self.currentGame = "none"
self.oldArgs2 = "800000000000000 128 128 128 128"
def _receive_events_thread(self):
self.socketio.wait()
def on_event(self, event):
#print(event)
pass
def on_controller_command(*args):
nextCommands.append(args)
def on_turn_times_left(*args):
try:
client.currentPlayers = args[1]["usernames"]
except:
pass
def on_controller_state(*args):
if(not client.laglessEnabled):
return
state = args[1]
cNum = args[2]
print("controller state" + str(cNum) + ":", state)
client.oldArgs2 = state
controller = None
if(cNum == 0):
controller = controller1
elif(cNum == 1):
controller = controller2
elif(cNum == 2):
return
cNum = 1
controller = controller2
elif(cNum == 3):
return
cNum = 1
controller = controller2
elif(cNum == 4):
return
cNum = 1
controller = controller2
controller.reset()
inputs = state.split()
cPlayer = ""
try:
cPlayer = client.currentPlayers[cNum]
except:
pass
btns = inputs[0]
LX = inputs[1]
LY = inputs[2]
RX = inputs[3]
RY = inputs[4]
controller.dpad = int(btns[0])
if (btns[1] == "1"):
controller.lstick = 1;
if (btns[2] == "1"):
controller.l = 1;
if (btns[3] == "1"):
controller.zl = 1;
if (btns[4] == "1"):
controller.minus = 1;
if (btns[5] == "1"):
try:
if (cPlayer.lower() in modlist):
controller.capture = 1
else:
controller.capture = 0
except:
controller.capture = 0
if (btns[6] == "1"):
controller.a = 1;
if (btns[7] == "1"):
controller.b = 1;
if (btns[8] == "1"):
controller.x = 1;
if (btns[9] == "1"):
controller.y = 1;
if (btns[10] == "1"):
controller.rstick = 1;
if (btns[11] == "1"):
controller.r = 1;
if (btns[12] == "1"):
controller.zr = 1;
if (btns[13] == "1"):
try:
if (cPlayer.lower() in pluslist):
controller.plus = 1
else:
controller.plus = 0
except:
controller.plus = 0
if (btns[14] == "1"):
try:
if (cPlayer.lower() in modlist):
controller.home = 1
else:
controller.home = 0
except:
controller.home = 0
try:
controller.LX = int(LX)
controller.LY = 255-int(LY)
controller.RX = int(RX)
controller.RY = 255-int(RY)
except:
pass
duration = 0.001
reset = 0
if(cNum == 0):
send_and_reset(duration, reset)
elif(cNum == 1):
send_and_reset2(duration, reset)
elif(cNum == 2):
send_and_reset3(duration, reset)
elif(cNum == 3):
send_and_reset4(duration, reset)
# player 1:
def on_controller_state1(*args):
client.on_controller_state(args[1], 0)
def handleChat(self, username, message):
print(message)
# handle chat messages here
def decreaseQueue(self):
# handle queue from handlechat
pass
def loop(self):
# control switch here:
# every 5 minutes:
self.botend = time.clock()
diffInMilliSeconds = (self.botend - self.botstart)*1000
if(diffInMilliSeconds > 1000*60*5):
self.socketio.emit("join", "wiiu3dscontroller")
self.botstart = time.clock()
# msg = "Join the discord server! https://discord.gg/ARTbddH\
# hate the stream delay? go here! https://twitchplaysnintendoswitch.com"
# twitchBot.chat(msg)
# every 6 seconds, probably doesn't need to do this so often:
self.controllerEnd = time.clock()
diffInMilliSeconds2 = (self.controllerEnd - self.controllerStart)*1000
if(diffInMilliSeconds2 > 6000):
self.socketio.emit("join", "wiiu3dscontroller")
self.controllerStart = time.clock()
response = twitchBot.stayConnected()
if(response != "none"):
# prevent crash
try:
username = re.search(r"\w+", response).group(0) # return the entire match
username = username.lower()
message = CHAT_MSG.sub("", response)
message = message.strip()
message = message.lower()
self.handleChat(username, message)
except:
pass
self.decreaseQueue()
def _receive_events_thread(self):
self.socketio.wait()
def _setup_socket(self):
"""Create socket handlers and registers the socket"""
self.socketIO = SocketIO(self.server_url, self.port)
def on_socket_open(*args):
shared_utils.print_and_log(
logging.DEBUG,
'Socket open: {}'.format(args)
)
self._send_world_alive()
self.alive = True
def on_disconnect(*args):
"""Disconnect event is a no-op for us, as the server reconnects
automatically on a retry"""
shared_utils.print_and_log(
logging.INFO,
'World server disconnected: {}'.format(args)
)
self.alive = False
def on_message(*args):
"""Incoming message handler for ACKs, ALIVEs, HEARTBEATs,
and MESSAGEs"""
packet = Packet.from_dict(args[0])
packet_id = packet.id
packet_type = packet.type
connection_id = packet.get_sender_connection_id()
if packet_type == Packet.TYPE_ACK:
if packet_id not in self.packet_map:
# Don't do anything when acking a packet we don't have
return
# Acknowledgements should mark a packet as acknowledged
shared_utils.print_and_log(
logging.DEBUG,
'On new ack: {}'.format(args)
)
self.packet_map[packet_id].status = Packet.STATUS_ACK
# If the packet sender wanted to do something on acknowledge
if self.packet_map[packet_id].ack_func:
self.packet_map[packet_id].ack_func(packet)
# clear the stored packet data for memory reasons
self.packet_map[packet_id].data = None
elif packet_type == Packet.TYPE_HEARTBEAT:
# Heartbeats update the last heartbeat time and respond in kind
self.last_heartbeat[connection_id] = time.time()
self._send_response_heartbeat(packet)
else:
# Remaining packet types need to be acknowledged
shared_utils.print_and_log(
logging.DEBUG,
'On new message: {}'.format(args)
)
self._send_ack(packet)
# Call the appropriate callback
if packet_type == Packet.TYPE_ALIVE:
self.last_heartbeat[connection_id] = time.time()
self.alive_callback(packet)
elif packet_type == Packet.TYPE_MESSAGE:
self.message_callback(packet)
# Register Handlers
self.socketIO.on(data_model.SOCKET_OPEN_STRING, on_socket_open)
self.socketIO.on(data_model.SOCKET_DISCONNECT_STRING, on_disconnect)
self.socketIO.on(data_model.SOCKET_NEW_PACKET_STRING, on_message)
# Start listening thread
self.listen_thread = threading.Thread(
target=self.socketIO.wait,
name='Main-Socket-Thread'
)
self.listen_thread.daemon = True
self.listen_thread.start()
class SocketManager():
"""SocketManager is a wrapper around socketIO to stabilize its packet
passing. The manager handles resending packet, as well as maintaining
alive status for all the connections it forms
"""
# Time to acknowledge different message types
ACK_TIME = {Packet.TYPE_ALIVE: 2,
Packet.TYPE_MESSAGE: 2}
# Default time before socket deemed dead
DEF_SOCKET_TIMEOUT = 8
def __init__(self, server_url, port, alive_callback, message_callback,
socket_dead_callback, task_group_id,
socket_dead_timeout=None):
"""
server_url: url at which the server is to be run
port: port for the socket to operate on
alive_callback: function to be called on alive Packets, defined
alive_callback(self, pkt)
message_callback: function to be called on message Packets, defined
message_callback(self, pkt)
socket_dead_callback: function to be called when a socket dies, should
return false if the socket_manager should ignore
the death and treat the socket as alive defined
on_socket_dead(self, worker_id, assignment_id)
socket_dead_timeout: time to wait between heartbeats before dying
"""
self.server_url = server_url
self.port = port
self.alive_callback = alive_callback
self.message_callback = message_callback
self.socket_dead_callback = socket_dead_callback
if socket_dead_timeout == None:
self.socket_dead_timeout = self.DEF_SOCKET_TIMEOUT
else:
self.socket_dead_timeout = socket_dead_timeout
self.task_group_id = task_group_id
self.socketIO = None
# initialize the state
self.listen_thread = None
self.queues = {}
self.threads = {}
self.run = {}
self.last_heartbeat = {}
self.packet_map = {}
# setup the socket
self._setup_socket()
def get_my_sender_id(self):
"""Gives the name that this socket manager should use for its world"""
return '[World_{}]'.format(self.task_group_id)
def _send_world_alive(self):
"""Registers world with the passthrough server"""
self.socketIO.emit(
data_model.SOCKET_AGENT_ALIVE_STRING,
{'id': 'WORLD_ALIVE', 'sender_id': self.get_my_sender_id()}
)
def _send_response_heartbeat(self, packet):
"""Sends a response heartbeat to an incoming heartbeat packet"""
self.socketIO.emit(
data_model.SOCKET_ROUTE_PACKET_STRING,
packet.swap_sender().set_data('').as_dict()
)
def _send_ack(self, packet):
"""Sends an ack to a given packet"""
ack = packet.get_ack().as_dict()
self.socketIO.emit(data_model.SOCKET_ROUTE_PACKET_STRING, ack, None)
def _send_packet(self, packet, connection_id, send_time):
"""Sends a packet, blocks if the packet is blocking"""
# Send the packet
pkt = packet.as_dict()
shared_utils.print_and_log(
logging.DEBUG,
'Send packet: {}'.format(packet.data)
)
def set_status_to_sent(data):
packet.status = Packet.STATUS_SENT
self.socketIO.emit(
data_model.SOCKET_ROUTE_PACKET_STRING,
pkt,
set_status_to_sent
)
# Handles acks and blocking
if packet.requires_ack:
if packet.blocking:
# blocking till ack is received or timeout
start_t = time.time()
while True:
if packet.status == Packet.STATUS_ACK:
# Clear the data to save memory as we no longer need it
packet.data = None
break
if time.time() - start_t > self.ACK_TIME[packet.type]:
# didn't receive ACK, resend packet keep old queue time
# to ensure this packet is processed first
packet.status = Packet.STATUS_INIT
self._safe_put(connection_id, (send_time, packet))
break
time.sleep(shared_utils.THREAD_SHORT_SLEEP)
else:
# non-blocking ack: add ack-check to queue
t = time.time() + self.ACK_TIME[packet.type]
self._safe_put(connection_id, (t, packet))
def _setup_socket(self):
"""Create socket handlers and registers the socket"""
self.socketIO = SocketIO(self.server_url, self.port)
def on_socket_open(*args):
shared_utils.print_and_log(
logging.DEBUG,
'Socket open: {}'.format(args)
)
self._send_world_alive()
self.alive = True
def on_disconnect(*args):
"""Disconnect event is a no-op for us, as the server reconnects
automatically on a retry"""
shared_utils.print_and_log(
logging.INFO,
'World server disconnected: {}'.format(args)
)
self.alive = False
def on_message(*args):
"""Incoming message handler for ACKs, ALIVEs, HEARTBEATs,
and MESSAGEs"""
packet = Packet.from_dict(args[0])
packet_id = packet.id
packet_type = packet.type
connection_id = packet.get_sender_connection_id()
if packet_type == Packet.TYPE_ACK:
if packet_id not in self.packet_map:
# Don't do anything when acking a packet we don't have
return
# Acknowledgements should mark a packet as acknowledged
shared_utils.print_and_log(
logging.DEBUG,
'On new ack: {}'.format(args)
)
self.packet_map[packet_id].status = Packet.STATUS_ACK
# If the packet sender wanted to do something on acknowledge
if self.packet_map[packet_id].ack_func:
self.packet_map[packet_id].ack_func(packet)
# clear the stored packet data for memory reasons
self.packet_map[packet_id].data = None
elif packet_type == Packet.TYPE_HEARTBEAT:
# Heartbeats update the last heartbeat time and respond in kind
self.last_heartbeat[connection_id] = time.time()
self._send_response_heartbeat(packet)
else:
# Remaining packet types need to be acknowledged
shared_utils.print_and_log(
logging.DEBUG,
'On new message: {}'.format(args)
)
self._send_ack(packet)
# Call the appropriate callback
if packet_type == Packet.TYPE_ALIVE:
self.last_heartbeat[connection_id] = time.time()
self.alive_callback(packet)
elif packet_type == Packet.TYPE_MESSAGE:
self.message_callback(packet)
# Register Handlers
self.socketIO.on(data_model.SOCKET_OPEN_STRING, on_socket_open)
self.socketIO.on(data_model.SOCKET_DISCONNECT_STRING, on_disconnect)
self.socketIO.on(data_model.SOCKET_NEW_PACKET_STRING, on_message)
# Start listening thread
self.listen_thread = threading.Thread(
target=self.socketIO.wait,
name='Main-Socket-Thread'
)
self.listen_thread.daemon = True
self.listen_thread.start()
def open_channel(self, worker_id, assignment_id):
"""Opens a channel for a worker on a given assignment, doesn't re-open
if the channel is already open. Handles creation of the thread that
monitors that channel"""
connection_id = '{}_{}'.format(worker_id, assignment_id)
if connection_id in self.queues and self.run[connection_id]:
shared_utils.print_and_log(
logging.DEBUG,
'Channel ({}) already open'.format(connection_id)
)
return
self.run[connection_id] = True
self.queues[connection_id] = PriorityQueue()
def channel_thread():
"""Handler thread for monitoring a single channel"""
# while the thread is still alive
while self.run[connection_id]:
try:
# Check if client is still alive
if (time.time() - self.last_heartbeat[connection_id]
> self.socket_dead_timeout):
self.run[connection_id] = False
self.socket_dead_callback(worker_id, assignment_id)
# Make sure the queue still exists
if not connection_id in self.queues:
self.run[connection_id] = False
break
# Get first item in the queue, check if we can send it yet
item = self.queues[connection_id].get(block=False)
t = item[0]
if time.time() < t:
# Put the item back into the queue,
# it's not time to pop yet
self._safe_put(connection_id, item)
else:
# Try to send the packet
packet = item[1]
if not packet:
# This packet was deleted out from under us
continue
if packet.status is not Packet.STATUS_ACK:
# either need to send initial packet
# or resend not-acked packet
self._send_packet(packet, connection_id, t)
except Empty:
pass
finally:
time.sleep(shared_utils.THREAD_MEDIUM_SLEEP)
# Setup and run the channel sending thread
self.threads[connection_id] = threading.Thread(
target=channel_thread,
name='Socket-Queue-{}'.format(connection_id)
)
self.threads[connection_id].daemon = True
self.threads[connection_id].start()
def close_channel(self, connection_id):
"""Closes a channel by connection_id"""
shared_utils.print_and_log(
logging.DEBUG,
'Closing channel {}'.format(connection_id)
)
self.run[connection_id] = False
if connection_id in self.queues:
# Clean up packets
packet_ids = list(self.packet_map.keys())
for packet_id in packet_ids:
if connection_id == \
self.packet_map[packet_id].get_receiver_connection_id():
del self.packet_map[packet_id]
# Clean up other resources
del self.queues[connection_id]
del self.threads[connection_id]
def delay_heartbeat_until(self, connection_id, delayed_time):
"""Delay a heartbeat prolong a disconnect until delayed_time"""
self.last_heartbeat[connection_id] = delayed_time
def close_all_channels(self):
"""Closes a channel by clearing the list of channels"""
shared_utils.print_and_log(logging.DEBUG, 'Closing all channels')
connection_ids = list(self.queues.keys())
for connection_id in connection_ids:
self.close_channel(connection_id)
def socket_is_open(self, connection_id):
return connection_id in self.queues
def queue_packet(self, packet):
"""Queues sending a packet to its intended owner"""
connection_id = packet.get_receiver_connection_id()
if not self.socket_is_open(connection_id):
# Warn if there is no socket to send through for the expected recip
shared_utils.print_and_log(
logging.WARN,
'Can not send packet to worker_id {}: packet queue not found. '
'Message: {}'.format(connection_id, packet.data)
)
return
shared_utils.print_and_log(
logging.DEBUG,
'Put packet ({}) in queue ({})'.format(packet.id, connection_id)
)
# Get the current time to put packet into the priority queue
self.packet_map[packet.id] = packet
item = (time.time(), packet)
self._safe_put(connection_id, item)
def get_status(self, packet_id):
"""Returns the status of a particular packet by id"""
return self.packet_map[packet_id].status
def _safe_put(self, connection_id, item):
"""Ensures that a queue exists before putting an item into it, logs
if there's a failure
"""
if connection_id in self.queues:
self.queues[connection_id].put(item)
else:
shared_utils.print_and_log(
logging.WARN,
'Queue {} did not exist to put a message in'.format(
connection_id
)
)
class MessageSocket():
"""MessageSocket is a wrapper around socketIO to simplify message sends
and recieves into parlai from FB messenger.
"""
def __init__(self, server_url, port, secret_token, message_callback):
"""
server_url: url at which the server is to be run
port: port for the socket to operate on
message_callback: function to be called on incoming message objects
format: message_callback(self, data)
"""
self.server_url = server_url
self.port = port
self.message_callback = message_callback
self.socketIO = None
self.auth_args = {'access_token': secret_token}
# initialize the state
self.listen_thread = None
# setup the socket
self._setup_socket()
def _send_world_alive(self):
"""Registers world with the passthrough server"""
self.socketIO.emit(
'world_alive', {'id': 'WORLD_ALIVE', 'sender_id': 'world'}
)
def send_fb_payload(self, receiver_id, payload):
"""Sends a payload to messenger, processes it if we can"""
api_address = 'https://graph.facebook.com/v2.6/me/messages'
if payload['type'] == 'list':
data = create_compact_list_message(payload['data'])
else:
data = payload['data']
message = {
"messaging_type": 'RESPONSE',
"recipient": {
"id": receiver_id
},
"message": {
"attachment": data,
}
}
response = requests.post(
api_address,
params=self.auth_args,
json=message,
)
result = response.json()
shared_utils.print_and_log(
logging.INFO,
'"Facebook response from message send: {}"'.format(result)
)
return result
def send_fb_message(self, receiver_id, message, is_response,
quick_replies=None):
"""Sends a message directly to messenger"""
api_address = 'https://graph.facebook.com/v2.6/me/messages'
if quick_replies is not None:
quick_replies = [create_reply_option(x, x) for x in quick_replies]
ms = create_text_message(message, quick_replies)
results = []
for m in ms:
if m['text'] == '':
continue # Skip blank messages
payload = {
"messaging_type": 'RESPONSE' if is_response else 'UPDATE',
"recipient": {
"id": receiver_id
},
"message": m
}
response = requests.post(
api_address,
params=self.auth_args,
json=payload
)
result = response.json()
shared_utils.print_and_log(
logging.INFO,
'"Facebook response from message send: {}"'.format(result)
)
results.append(result)
return results
def _setup_socket(self):
"""Create socket handlers and registers the socket"""
self.socketIO = SocketIO(self.server_url, self.port)
def on_socket_open(*args):
shared_utils.print_and_log(
logging.DEBUG,
'Socket open: {}'.format(args)
)
self._send_world_alive()
self.alive = True
def on_disconnect(*args):
"""Disconnect event is a no-op for us, as the server reconnects
automatically on a retry"""
shared_utils.print_and_log(
logging.INFO,
'World server disconnected: {}'.format(args)
)
self.alive = False
def on_message(*args):
"""Incoming message handler for ACKs, ALIVEs, HEARTBEATs,
and MESSAGEs"""
message_data = args[0]
shared_utils.print_and_log(
logging.DEBUG,
'Message data recieved: {}'.format(message_data)
)
for message_packet in message_data['entry']:
self.message_callback(message_packet['messaging'][0])
# Register Handlers
self.socketIO.on('socket_open', on_socket_open)
self.socketIO.on('disconnect', on_disconnect)
self.socketIO.on('new_packet', on_message)
# Start listening thread
self.listen_thread = threading.Thread(
target=self.socketIO.wait,
name='Main-Socket-Thread'
)
self.listen_thread.daemon = True
self.listen_thread.start()
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BCM)
GPIO.setup(12, GPIO.OUT)
pwm = GPIO.PWM(12, 100)
pwm.start(float(85) / 10.0 + 2.5)
from socketIO_client_nexus import SocketIO, LoggingNamespace
Sock = SocketIO('38.88.74.79', 80)
def unlock():
duty = float(185) / 10.0 + 2.5
pwm.ChangeDutyCycle(duty)
#start = time.time()
print("door unlocked")
def lock():
duty = float(85) / 10.0 + 2.5
pwm.ChangeDutyCycle(duty)
print("door locked")
def status(*args):
if args[0] == 1: lock()
elif args[0] == 0: unlock()
else: print("error")
from config import token,ip,pathSource,selemiunIP
from Utils.logs import write_log
import os, sys, time, json
import shutil
import traceback
from webwhatsapi import WhatsAPIDriver
from webwhatsapi.objects.message import Message, MediaMessage
import shutil
from uuid import uuid4
from threading import Thread
##### Setting for start ######
profiledir=os.path.join(".","firefox_cache_v2")
if not os.path.exists(profiledir): os.makedirs(profiledir)
socketIO = SocketIO(ip,3000, LoggingNamespace)
wsp = None
driver = None
awaitLogin = None
#####################################
# Functions Auth #
#####################################
def on_connect(*args):
write_log('Socket-Info','Connection whit server')
socketIO.emit('Auth',token)
def on_welcome(*args):
try:
global driver
write_log('Socket-Info','Connection success')
# sudo python phat.py
# sudo apt-get install python-fourletterphat
# curl https://get.pimoroni.com/fourletterphat | bash ... then reboot
#
import os
import time
import logging
import fourletterphat as flp
from socketIO_client_nexus import SocketIO, LoggingNamespace
logging.getLogger('socketIO-client').setLevel(logging.DEBUG)
logging.basicConfig(level=logging.DEBUG)
socketIO = SocketIO('https://coffee-pot-pi.herokuapp.com')
def on_connect():
print 'Connected to server'
socketIO.emit('piConnected')
def on_reconnect():
print('Reconnected to server')
socketIO.emit('piConnected')
def on_disconnect():
print('disconnected')
socketIO.emit('piDisconnected')
print('reconnect')
def on_Response_B(*args):
print('I got a reponse from server for event_B', args)
def on_Response_C(*args):
print('I got a reponse from server for event_C', args)
def FuncA():
print('FuncA: Now I got a message from server.')
socketIO = SocketIO('localhost', 3000, LoggingNamespace)
socketIO.on('connect', on_connect)
socketIO.on('disconnect', on_disconnect)
socketIO.on('reconnect', on_reconnect)
socketIO.on('event_A', FuncA)
# Listen
socketIO.on('Response_B', on_Response_B)
socketIO.emit('event_B')
socketIO.emit('event_B')
socketIO.wait(seconds=1)
# Stop listening
socketIO.off('Response_B')
socketIO.emit('event_B')
socketIO.wait(seconds=1)
tr = (int(0), int(width))
bl = (int(height), int(0))
br = (int(height), int(width))
#------------------------------------------------------------------------------
# Main
#------------------------------------------------------------------------------
if __name__ == '__main__':
if len(sys.argv) > 1 and sys.argv[1] == 'DEBUG':
print 'DEBUG MODE'
debug_mode = True
# with SocketIO('localhost', 3001, LoggingNamespace) as socketIO:
# socketIO.emit('aaa')
# socketIO.wait(seconds=1)
with SocketIO('127.0.0.1', 3001, LoggingNamespace) as socketIO:
socketInit()
try:
while True:
time.sleep(0.03)
detect()
if debug_mode:
cv2.imshow("obs", cv2.resize(img, (width // 2, height // 2)))
#cv2.imshow("banner", banner)
cv2.waitKey(1)
# get coords
array = [[int(tl[0]), int(tl[1])],[int(tr[0]), int(tr[1])],[int(br[0]), int(br[1])],[int(bl[0]), int(bl[1])]]
quad = np.float32(array)
source = np.float32([[0,0],[banner_width,0],[banner_width,banner_height],[0,banner_height]])
M = cv2.getPerspectiveTransform(source, quad)
CLOSE_MICROPHONE = embedded_assistant_pb2.DialogStateOut.CLOSE_MICROPHONE
PLAYING = embedded_assistant_pb2.ScreenOutConfig.PLAYING
DEFAULT_GRPC_DEADLINE = 60 * 3 + 5
GPIO.setmode(GPIO.BCM)
query = "hi"
#set GPIO Pins
GPIO_TRIGGER = 23
GPIO_ECHO = 24
GPIO.setup(GPIO_TRIGGER, GPIO.OUT)
GPIO.setup(GPIO_ECHO, GPIO.IN)
resp_text = ""
mute = True
startMouth = True
#~ num=""
beep = False
socket = SocketIO('127.0.0.1', 8000, LoggingNamespace)
faceFound = False
name2 = []
onceface = False
keyboard_on = False
class SampleAssistant(object):
"""Sample Assistant that supports conversations and device actions.
Args:
device_model_id: identifier of the device model.
device_id: identifier of the registered device instance.
conversation_stream(ConversationStream): audio stream
for recording query and playing back assistant answer.
channel: authorized gRPC channel for connection to the
def __init__(self, host, port):
self.host = host
self.port = port
self.socket = SocketIO(host, port, wait_for_connection=False)
SOCKET_ID = None
GPIO.setup(PIN_TRIGGER, GPIO.OUT)
GPIO.setup(PIN_ECHO, GPIO.IN)
GPIO.output(PIN_TRIGGER, False)
print('Waiting for Sensor to settle')
time.sleep(2)
SERVER_IP = 'http://192.168.0.29'
# SERVER_IP = 'http://192.168.1.128'
SERVER_PORT = 3001
socket = SocketIO(SERVER_IP, SERVER_PORT)
START_MSG = "START"
STOP_MSG = "STOP"
q = Queue()
def continuous_loop():
while True:
# get start message (blocking)
while q.get() != START_MSG:
pass
while get_poll(q) != STOP_MSG:
distance = get_measurement()
json_blob = {
def __init__(self,
videoPath,
onboardingMode,
imageProcessingEndpoint="",
imageProcessingParams="",
showVideo=False,
verbose=False,
loopVideo=False,
convertToGray=False,
resizeWidth=0,
resizeHeight=0,
annotate=False,
cognitiveServiceKey="",
modelId=""):
self.videoPath = videoPath
self.onboardingMode = onboardingMode
# Avihay's bug fix:
# TODO: add argument to choose which kind of processing - file or stream
# Explanation: in the original demo, only a number was passed as path, because in RasPi webcam it is the case.
# the different is when it's a webcam (True) - we take the latest frame at each point. In case it's a video (False) - we run on ALL frames
if not self.__IsInt(videoPath):
# case of a stream
self.isWebcam = True
else:
# case of a video file
self.isWebcam = False
# TODO: remove all commands related to imageProcessingEndpoint. It's irelevant
self.imageProcessingEndpoint = imageProcessingEndpoint
if imageProcessingParams == "":
self.imageProcessingParams = ""
else:
self.imageProcessingParams = json.loads(imageProcessingParams)
self.showVideo = showVideo
self.verbose = verbose
self.loopVideo = loopVideo
self.convertToGray = convertToGray
self.resizeWidth = resizeWidth
self.resizeHeight = resizeHeight
self.annotate = (self.imageProcessingEndpoint !=
"") and self.showVideo & annotate
self.nbOfPreprocessingSteps = 0
self.autoRotate = False
self.vs = None
# TODO: wrap in try and add default value
self.monitor_id = os.getenv("DEVICE_ID")
self.results_list = []
if not self.onboardingMode: # live-stream mode, will use known boundries
self.__get_boundries()
# connect to server
SOCKET_URL = os.getenv("SOCKET_URL")
try:
socketIO = SocketIO(SOCKET_URL, 443, BaseNamespace, False)
time.sleep(3)
self.ocrSocket = socketIO.define(SocketNamespace, '/ocr')
except:
print("Failed to open socket!")
raise SocketInitVAOCVError(
"Can't establish a connection to the socket")
else:
self.__get_device_type_for_onboarding()
if self.convertToGray:
self.nbOfPreprocessingSteps += 1
if self.resizeWidth != 0 or self.resizeHeight != 0:
self.nbOfPreprocessingSteps += 1
self.cognitiveServiceKey = cognitiveServiceKey
self.modelId = modelId
if self.verbose:
print("Container vesrion: --> v1.3 - Intel OCR TEST")
print(
"Initialising the camera capture with the following parameters: "
)
print(" - Video path: " + str(self.videoPath))
print(" - OnBoarding mode: " + str(self.onboardingMode))
print(" - Device ID: " + str(self.monitor_id))
print(" - Device type: " + str(self.device_type))
print(" - Computer vision model: " +
str(os.getenv('CV_MODEL', "")))
# print(" - Image processing endpoint: " + self.imageProcessingEndpoint)
# print(" - Image processing params: " + json.dumps(self.imageProcessingParams))
# print(" - Show video: " + str(self.showVideo))
# print(" - Loop video: " + str(self.loopVideo))
# print(" - Convert to gray: " + str(self.convertToGray))
# print(" - Resize width: " + str(self.resizeWidth))
# print(" - Resize height: " + str(self.resizeHeight))
# print(" - Annotate: " + str(self.annotate))
print()
self.displayFrame = None
# if self.showVideo:
# self.imageServer = ImageServer(5012, self)
# self.imageServer.start()
# # self.imageServer.run()
COMPUTER_VISION_ENDPOINT = os.environ["COMPUTER_VISION_ENDPOINT"]
COMPUTER_VISION_SUBSCRIPTION_KEY = os.environ[
"COMPUTER_VISION_SUBSCRIPTION_KEY"]
self.computervision_client = ComputerVisionClient(
COMPUTER_VISION_ENDPOINT,
CognitiveServicesCredentials(COMPUTER_VISION_SUBSCRIPTION_KEY))
def main(_):
counter = 0
# Definition of the paths
weights_path = 'yolov2-tiny-voc.weights'
input_img_path = 'test_zzh_1.jpg'
output_image_path = 'output/zzh_out.jpg'
# If you do not have the checkpoint yet keep it like this! When you will run test.py for the first time it will be created automatically
ckpt_folder_path = './ckpt/'
# Definition of the parameters
input_height = 416
input_width = 416
score_threshold = 0.1
iou_threshold = 0.1
# Definition of the session
sess = tf.InteractiveSession()
tf.global_variables_initializer().run()
# Check for an existing checkpoint and load the weights (if it exists) or do it from binary file
print('Looking for a checkpoint...')
saver = tf.train.Saver()
_ = weights_loader.load(sess, weights_path, ckpt_folder_path, saver)
# ---------------------q-learning---------------------
N_STATES = [1, 2, 3, 4, 5, 6, 7, 8, 9] # 9种states
ACTIONS = ["1", "2", "3", "4", "5", "6", "7", "8", "9"] # 可能的actions
EPSILON = 0.9 # greedy policy 的概率
ALPHA = 0.1 # for learning rate 的大小
GAMMA = 0.9 # for discount factor 的大小
episode = 0
q_table = q_learning.build_q_table(N_STATES, ACTIONS) # Initialize Q(s, a)
print(q_table)
step_counter = 0 # init step
S = 1 # init state
q_learning.update_env(episode, step_counter) # update env
# ---------------------q-learning---------------------
# ------------------------预定义和加载数据-----------------------
# -----------------连接目标服务器-------------------------------
socketIO = SocketIO('10.8.204.12', 3333, LoggingNamespace)
socketIO.on('connection', on_connect)
socketIO.on('disconnect', on_disconnect)
socketIO.on('reconnect', on_reconnect)
# -------------------------------------------------------------
time_1 = 0
time_2 = 0
Fps_past = 0
Fps = 0
host = '127.0.0.1'
port = 12345
buffsize = 65535
ADDR = (host, port)
soc = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
soc.bind(ADDR)
soc.listen(2)
print('Wait for connection ...')
soc_client, addr = soc.accept()
print("Connection from :", addr)
# 进行长连接不断接受信号， 每次data=的时候都会刷新所有接收到的值
while True:
data = ""
data = soc_client.recv(buffsize).decode()
while True:
# data为初始化值是系统等待， 以防while占用太大的运算量
if data == "":
time.sleep(0.1)
else:
break
# 服务器端 send 各个命令执行的操作
if data == "time_start":
# 用来记录总时间 （未用到）
start_time = time.time()
print(start_time)
soc_client.send("done".encode())
elif data == "time_stop":
# 结束记录总时间 （未用到）
stop_time = time.time()
total_time = stop_time - start_time
print(total_time)
soc_client.send("done".encode())
elif data == "finish":
# 用来结束连接（未用到）
soc_client.close()
elif data == "time_1":
# 用来接受time_1信息（初始化时间长度）
soc_client.send("recive".encode())
time_1 = soc_client.recv(buffsize).decode()
time_1 = float(time_1)
soc_client.send("done".encode())
elif data == "time_2":
# 用来接受time_2信息 （处理的时间长度）
soc_client.send("recive".encode())
time_2 = soc_client.recv(buffsize).decode()
time_2 = float(time_2)
soc_client.send("done".encode())
elif data == "send_original_image":
# 用来接受输出的原始图像 （记录下下载图像的时间为 recive_time）
soc_client.send("recive".encode())
recive_time = time.time()
data_batches = ""
new_data = ""
# 开始下载
print("downloading...")
while True:
new_data = soc_client.recv(buffsize).decode()
# 结束时的处理
if ((new_data[-1] == '%')):
data_batches = data_batches + new_data[:-1]
break
# 循环体
data_batches = data_batches + new_data
print("processing...")
# 加载下载的原图像解析为np array（注意imshow输出时要转化成np.uint8格式否则会黑屏）（<-坑）
data_text = json.loads(data_batches)
input_image = np.array(data_text)
# 下载时间记录 （下载 + 解析）
recive_time = time.time() - recive_time
print("total time: {}".format(recive_time))
soc_client.send("done".encode())
elif data == "send_weight_cutpoint":
# ---------------------q-learning---------------------
Fps_past = Fps
A = q_learning.choose_action(S, q_table, EPSILON)
# ---------------------q-learning---------------------
soc_client.send("{}".format(A).encode())
# 记录时间 p4
point_4 = time.time()
data_batches = ""
new_data = ""
cut_point = ""
# 开始下载
print("downloading...")
while True:
new_data = soc_client.recv(buffsize).decode()
# 结束时的处理 （cut point 作为倒数第二个值被接受在新变量中）
if ((new_data[-1] == '%')):
data_batches = data_batches + new_data[:-2]
cut_point = new_data[-2:-1]
# print(cut_point)
break
# 循环体
data_batches = data_batches + new_data
# 记录时间 p5 （time_3 为下载weight的时间）
point_5 = time.time()
time_3 = point_5 - point_4
print("downloading time: {}".format(time_3))
print("processing...")
# 加载和解析数据
data_text = json.loads(data_batches)
predictions = np.array(data_text)
cut_point = int(cut_point)
predictions = inference(sess, predictions, cut_point)
# 记录时间 p6 （time_4 为解析数据的时间）
point_6 = time.time()
time_4 = point_6 - point_5
print("processing time: {}".format(time_4))
print('Postprocessinasg...')
# out_put images
output_image = postprocessing(predictions, input_image,
score_threshold, iou_threshold,
input_height, input_width)
# 记录时间 p7
# time_5 为后处理的时间
# 计算出后端的运行时间，中间的下载时间， 前端的预处理时间（不包括初始化时间），算出fps
point_7 = time.time()
time_5 = point_7 - point_6
time_backend = time_4 + time_5
time_downloading = time_3 + recive_time
time_frontend = time_2
time_total = time_backend + time_frontend + time_downloading
Fps = 1. / time_total
fps = "fps = {}".format(Fps)
# 将图像格式转换成uint8 否则黑屏
# 输出fps， 输出处理后的图像
output_image = np.uint8(output_image)
cv2.putText(output_image, str(fps), (5, 15),
cv2.FONT_HERSHEY_SIMPLEX, 0.3, (0, 0, 255), 1)
#cv2.imshow("hello", output_image)
#if cv2.waitKey(1) & 0xFF == ord('q'):
#break
# 打印出所有可能用到的时间
counter += 1
print("time_load_model = {}".format(time_1))
print("time_preprocess = {}".format(time_2))
print("time_send_original_image = {}".format(recive_time))
print("time_downloading = {}".format(time_downloading))
print("time_load_jsons = {}".format(time_4))
print("time_postprocess = {}".format(time_5))
print("time_backend = {}".format(time_backend))
print("time_frontend = {}".format(time_frontend))
print("Fps = {}".format(Fps))
# ---------------------q-learning---------------------
S_, R = q_learning.get_env_feedback(A, Fps_past, Fps)
print(str(S_) + " " + str(S))
q_predict = q_table.loc[S, A]
with pd.option_context('display.max_rows', None,
'display.max_columns', None):
print(q_table)
q_target = R + GAMMA * q_table.loc[S_, :].max(skipna=True)
q_table.loc[S, A] += ALPHA * (q_target - q_predict) # q_table 更新
S = S_ # 探索者移动到下一个 state
q_learning.update_env(episode, step_counter + 1) # 环境更新
step_counter += 1
# ---------------------q-learning---------------------
#--------------------多线程发送------------
# Create a thread
thread_socketIO = myThread(1, socketIO, "Frame-" + str(counter),
output_image, Fps, cut_point,
q_table.values)
# Start a thread
thread_socketIO.start()
thread_socketIO.join()
# --------------------多线程发送------------
# 返回确认done
soc_client.send("done".encode())
# 下一个循环待命
# ------------send---------
pass
else:
pass
import random
from kafka import KafkaProducer
import time
#import RNN
#import svm
_SIO_URL_PREFIX = 'https://ws-api.iextrading.com'
_SIO_PORT = 443
SYMBOLS = [
"AAPL", "MSFT", "AABA", "ACN", "ADP", "FB", "AMZN", "GOOGL", "IBM", "LMT"
]
producer = KafkaProducer(
bootstrap_servers='127.0.0.1:9092',
value_serializer=lambda v: ujson.dumps(v).encode('utf-8'))
socketIO = SocketIO(_SIO_URL_PREFIX, _SIO_PORT)
#socketIO.define(LoggingNamespace, path='/1.0/tops')
def predict(data):
'''
dummy pyspark function. Use as wrapper and add all predictions here
data: dict object of the form:
{
symbol: ,
marketPercent:
bidSize:
bidPrice:
askSize:
askPrice:
from socketIO_client_nexus import SocketIO, LoggingNamespace
from config import infoClient
import os, sys, time, json
from webwhatsapi import WhatsAPIDriver
from webwhatsapi.objects.message import Message, MediaMessage
import shutil
socketIO = SocketIO('172.18.0.4', 4000, LoggingNamespace)
wsp = {'status': 'off', 'data': None, 'token': infoClient['token']}
if os.path.exists('./firefox_cache_v2'): shutil.rmtree('./firefox_cache_v2')
profiledir = os.path.join(".", "firefox_cache_v2")
if not os.path.exists(profiledir): os.makedirs(profiledir)
driver = WhatsAPIDriver(profile=profiledir,
client='remote',
command_executor=os.environ["SELENIUM"])
def on_connect():
print('connect')
socketIO.emit('status', wsp)
def on_welcome():
print('Sesion completada')
def on_disconnect():
print('Session desconectada')
class SocketManager():
"""SocketManager is a wrapper around socketIO to stabilize its packet
passing. The manager handles resending packet, as well as maintaining
alive status for all the connections it forms
"""
# Time to acknowledge different message types
ACK_TIME = {Packet.TYPE_ALIVE: 2, Packet.TYPE_MESSAGE: 2}
# Default time before socket deemed dead
DEF_SOCKET_TIMEOUT = 8
def __init__(self,
server_url,
port,
alive_callback,
message_callback,
socket_dead_callback,
task_group_id,
socket_dead_timeout=None):
"""
server_url: url at which the server is to be run
port: port for the socket to operate on
alive_callback: function to be called on alive Packets, defined
alive_callback(self, pkt)
message_callback: function to be called on message Packets, defined
message_callback(self, pkt)
socket_dead_callback: function to be called when a socket dies, should
return false if the socket_manager should ignore
the death and treat the socket as alive defined
on_socket_dead(self, worker_id, assignment_id)
socket_dead_timeout: time to wait between heartbeats before dying
"""
self.server_url = server_url
self.port = port
self.alive_callback = alive_callback
self.message_callback = message_callback
self.socket_dead_callback = socket_dead_callback
if socket_dead_timeout == None:
self.socket_dead_timeout = self.DEF_SOCKET_TIMEOUT
else:
self.socket_dead_timeout = socket_dead_timeout
self.task_group_id = task_group_id
self.socketIO = None
# initialize the state
self.listen_thread = None
self.queues = {}
self.threads = {}
self.run = {}
self.last_heartbeat = {}
self.packet_map = {}
# setup the socket
self._setup_socket()
def get_my_sender_id(self):
"""Gives the name that this socket manager should use for its world"""
return '[World_{}]'.format(self.task_group_id)
def _send_world_alive(self):
"""Registers world with the passthrough server"""
self.socketIO.emit(data_model.SOCKET_AGENT_ALIVE_STRING, {
'id': 'WORLD_ALIVE',
'sender_id': self.get_my_sender_id()
})
def _send_response_heartbeat(self, packet):
"""Sends a response heartbeat to an incoming heartbeat packet"""
self.socketIO.emit(data_model.SOCKET_ROUTE_PACKET_STRING,
packet.swap_sender().set_data('').as_dict())
def _send_ack(self, packet):
"""Sends an ack to a given packet"""
ack = packet.get_ack().as_dict()
self.socketIO.emit(data_model.SOCKET_ROUTE_PACKET_STRING, ack, None)
def _send_packet(self, packet, connection_id, send_time):
"""Sends a packet, blocks if the packet is blocking"""
# Send the packet
pkt = packet.as_dict()
print_and_log('Send packet: {}'.format(packet.data))
def set_status_to_sent(data):
packet.status = Packet.STATUS_SENT
self.socketIO.emit(data_model.SOCKET_ROUTE_PACKET_STRING, pkt,
set_status_to_sent)
# Handles acks and blocking
if packet.requires_ack:
if packet.blocking:
# blocking till ack is received or timeout
start_t = time.time()
while True:
if packet.status == Packet.STATUS_ACK:
# Clear the data to save memory as we no longer need it
packet.data = None
break
if time.time() - start_t > self.ACK_TIME[packet.type]:
# didn't receive ACK, resend packet keep old queue time
# to ensure this packet is processed first
packet.status = Packet.STATUS_INIT
self._safe_put(connection_id, (send_time, packet))
break
time.sleep(THREAD_SHORT_SLEEP)
else:
# non-blocking ack: add ack-check to queue
t = time.time() + self.ACK_TIME[packet.type]
self._safe_put(connection_id, (t, packet))
def _setup_socket(self):
"""Create socket handlers and registers the socket"""
self.socketIO = SocketIO(self.server_url, self.port)
def on_socket_open(*args):
print_and_log('Socket open: {}'.format(args), False)
self._send_world_alive()
self.alive = True
def on_disconnect(*args):
"""Disconnect event is a no-op for us, as the server reconnects
automatically on a retry"""
print_and_log('World server disconnected: {}'.format(args), False)
self.alive = False
def on_message(*args):
"""Incoming message handler for ACKs, ALIVEs, HEARTBEATs,
and MESSAGEs"""
packet = Packet.from_dict(args[0])
packet_id = packet.id
packet_type = packet.type
connection_id = packet.get_sender_connection_id()
if packet_type == Packet.TYPE_ACK:
if packet_id not in self.packet_map:
# Don't do anything when acking a packet we don't have
return
# Acknowledgements should mark a packet as acknowledged
print_and_log('On new ack: {}'.format(args), False)
self.packet_map[packet_id].status = Packet.STATUS_ACK
# If the packet sender wanted to do something on acknowledge
if self.packet_map[packet_id].ack_func:
self.packet_map[packet_id].ack_func(packet)
# clear the stored packet data for memory reasons
self.packet_map[packet_id].data = None
elif packet_type == Packet.TYPE_HEARTBEAT:
# Heartbeats update the last heartbeat time and respond in kind
self.last_heartbeat[connection_id] = time.time()
self._send_response_heartbeat(packet)
else:
# Remaining packet types need to be acknowledged
print_and_log('On new message: {}'.format(args), False)
self._send_ack(packet)
# Call the appropriate callback
if packet_type == Packet.TYPE_ALIVE:
self.last_heartbeat[connection_id] = time.time()
self.alive_callback(packet)
elif packet_type == Packet.TYPE_MESSAGE:
self.message_callback(packet)
# Register Handlers
self.socketIO.on(data_model.SOCKET_OPEN_STRING, on_socket_open)
self.socketIO.on(data_model.SOCKET_DISCONNECT_STRING, on_disconnect)
self.socketIO.on(data_model.SOCKET_NEW_PACKET_STRING, on_message)
# Start listening thread
self.listen_thread = threading.Thread(target=self.socketIO.wait,
name='Main-Socket-Thread')
self.listen_thread.daemon = True
self.listen_thread.start()
def open_channel(self, worker_id, assignment_id):
"""Opens a channel for a worker on a given assignment, doesn't re-open
if the channel is already open. Handles creation of the thread that
monitors that channel"""
connection_id = '{}_{}'.format(worker_id, assignment_id)
if connection_id in self.queues and self.run[connection_id]:
print_and_log('Channel ({}) already open'.format(connection_id),
False)
return
self.run[connection_id] = True
self.queues[connection_id] = PriorityQueue()
def channel_thread():
"""Handler thread for monitoring a single channel"""
# while the thread is still alive
while self.run[connection_id]:
try:
# Check if client is still alive
if (time.time() - self.last_heartbeat[connection_id] >
self.socket_dead_timeout):
self.run[connection_id] = False
self.socket_dead_callback(worker_id, assignment_id)
# Make sure the queue still exists
if not connection_id in self.queues:
self.run[connection_id] = False
break
# Get first item in the queue, check if we can send it yet
item = self.queues[connection_id].get(block=False)
t = item[0]
if time.time() < t:
# Put the item back into the queue,
# it's not time to pop yet
self._safe_put(connection_id, item)
else:
# Try to send the packet
packet = item[1]
if not packet:
# This packet was deleted out from under us
continue
if packet.status is not Packet.STATUS_ACK:
# either need to send initial packet
# or resend not-acked packet
self._send_packet(packet, connection_id, t)
except Empty:
pass
finally:
time.sleep(THREAD_MEDIUM_SLEEP)
# Setup and run the channel sending thread
self.threads[connection_id] = threading.Thread(
target=channel_thread,
name='Socket-Queue-{}'.format(connection_id))
self.threads[connection_id].daemon = True
self.threads[connection_id].start()
def close_channel(self, connection_id):
"""Closes a channel by connection_id"""
print_and_log('Closing channel {}'.format(connection_id), False)
self.run[connection_id] = False
if connection_id in self.queues:
# Clean up packets
packet_ids = list(self.packet_map.keys())
for packet_id in packet_ids:
if connection_id == \
self.packet_map[packet_id].get_receiver_connection_id():
del self.packet_map[packet_id]
# Clean up other resources
del self.queues[connection_id]
del self.threads[connection_id]
def delay_heartbeat_until(self, connection_id, delayed_time):
"""Delay a heartbeat prolong a disconnect until delayed_time"""
self.last_heartbeat[connection_id] = delayed_time
def close_all_channels(self):
"""Closes a channel by clearing the list of channels"""
print_and_log('Closing all channels')
connection_ids = list(self.queues.keys())
for connection_id in connection_ids:
self.close_channel(connection_id)
def socket_is_open(self, connection_id):
return connection_id in self.queues
def queue_packet(self, packet):
"""Queues sending a packet to its intended owner"""
connection_id = packet.get_receiver_connection_id()
if not self.socket_is_open(connection_id):
# Warn if there is no socket to send through for the expected recip
print_and_log(
'Can not send packet to worker_id {}: packet queue not found. '
'Message: {}'.format(connection_id, packet.data))
return
print_and_log(
'Put packet ({}) in queue ({})'.format(packet.id, connection_id),
False)
# Get the current time to put packet into the priority queue
self.packet_map[packet.id] = packet
item = (time.time(), packet)
self._safe_put(connection_id, item)
def get_status(self, packet_id):
"""Returns the status of a particular packet by id"""
return self.packet_map[packet_id].status
def _safe_put(self, connection_id, item):
"""Ensures that a queue exists before putting an item into it, logs
if there's a failure
"""
if connection_id in self.queues:
self.queues[connection_id].put(item)
else:
print_and_log('Queue {} did not exist to put a message in'.format(
connection_id))
class MainClient:
def __init__(self, token):
self.APIServer = '13.209.66.217'
self.port = 3000
self.Sensor = Sensor(self)
self.token = token
self.gid = -1
self.gname = 'default gateway name'
self.SocketIO = SocketIO(
self.APIServer, self.port,
headers = {'x-access-token': self.token},
)
self.Socket = self.SocketIO.define(BaseNamespace, '/gateway')
self.IRSerial = IRSerial(self)
self.IRSerialTemp = []
self._setOnListener()
# Check Setting backfile
if os.path.isfile('setting.json'):
settings = json.loads(open('setting.json').read())
self.gid = settings['gid']
self.gname = settings['gname']
self._emit_notifyGid()
else:
self.macAddr = self._getMAC('wlan0')
self._emit_gatewayInit()
def Run(self):
print('MainClient Start!')
self.Sensor.start()
while True:
self.SocketIO.wait()
def _setOnListener(self):
self.Socket.on('reconnect', self._on_reconnect)
self.Socket.on('res/gateway/create', self._on_setGid)
self.Socket.on('res/sensor/create', self._on_setSID)
self.Socket.on('req/sensor/refresh', self._on_refreshSensor)
self.Socket.on('req/sensor/update/name', self._on_setSensorName)
self.Socket.on('req/sensor/update/interval', self._on_setSensorInterval)
self.Socket.on('req/remocon/learn', self._on_getIRSerial)
self.Socket.on('req/remocon/learn/OK', self._on_updateIRSerial)
def _on_reconnect(self):
print('reconnect')
self._emit_notifyGid()
def _on_setGid(self, obj):
if obj['status'] is True:
self.gid = obj['data']['gatewayID']
f = open('setting.json', 'w', encoding='utf-8')
f.write(json.dumps({
'gid': self.gid,
'gname': self.gname
}, ensure_ascii=False, indent="\t"))
f.close()
self._emit_notifyGid()
def _on_setSID(self, obj):
if obj['status'] is True:
baseID = obj['data']['_id']
sid = obj['data']['sensorID']
self.Sensor.updateServerSensorID(baseID, sid)
def _on_refreshSensor(self, obj):
self.Sensor.refreshSensor(obj['sid'])
def _on_setSensorName(self, obj):
self.Sensor.updateSensorName(obj['sid'], obj['name'])
def _on_setSensorInterval(self, obj):
self.Sensor.updateSensorInterval(obj['sid'], obj['interval'])
def _on_getIRSerial(self, obj):
print('On getIRSerial!')
# self.IRSerial.mode = 'in'
# self.IRSerial.start()
def _on_updateIRSerial(self, obj):
self.IRSerial.start()
def _emit_gatewayInit(self):
self.Socket.emit('req/gateway/create',{
'token': self.token,
'name': self.gname,
'mac_addr': self.macAddr
})
self.SocketIO.wait(seconds=1)
def _emit_notifyGid(self):
self.Socket.emit('req/connection/init',{
'gid': self.gid
})
self.SocketIO.wait(seconds=1)
def _emit_createSensor(self, s):
self.Socket.emit('req/sensor/create', {
'_id' : s['bid'],
'gid' : self.gid,
'type' : s['type'],
'name' : s['name'],
})
def _emit_updateValueSensor(self, sid, value, time):
self.Socket.emit('req/sensor/update', {
'sid' : sid,
'gid' : self.gid,
'token': self.token,
'time' : time,
'value' : value,
})
def _emit_res_getIRSerial(self):
self.Socket.emit('res/remocon/learn')
def _getMAC(self, interface):
try:
str = open('/sys/class/net/%s/address' %interface).read()
except:
str = "00:00:00:00:00:00"
return str[0:17]
class TelemetryReporter:
"""
This is used to report boat and environment statistics (e.g. position, heading, wind speed & direction) to a
telemetry server for remote monitoring.
"""
def __init__(self):
self.reporter = None
self.socketIO = None
self.rosbag_process = None
# Register as a ROS node
rospy.init_node('telemetry_reporter')
# Listen for ROS boat position messages TODO Reference name from another file
self.subscribers = {}
self.publishers = {}
# Listen for SIGINT (process termination requests)
signal.signal(signal.SIGINT, self.terminate)
def connect(self, server_address, port, use_ssl=False):
print('Connecting to {} on port {} {}using SSL'.format(server_address, port, '' if use_ssl else 'without '))
self.socketIO = SocketIO(server_address, port, verify=(not use_ssl))
self.reporter = self.socketIO.define(ReportingNamespace, '/reporting')
self.reporter.on('publishROSMessage', self._handle_server_publish_msg)
self.reporter.on('getTopics', self._handle_get_published_topics_request)
self.reporter.on('startStopRosbag', self.start_stop_rosbag)
self.socketIO.wait() # Don't finish execution
def terminate(self, *args):
if self.socketIO:
print('Disconnecting...')
self.socketIO.disconnect()
def listen_to_topic(self, topic_name, msg_type, save_to_db=True, max_transmit_rate=0, queue_size=1):
"""
Sets up a subscriber on the given ROS topic.
:param {string} topic_name: the name of the ROS topic
:param {string|genpy.Message} msg_type: the type of ROS message
:param {boolean} save_to_db: whether or not messages sent to the server should be stored in the database
or just forwarded on to connected observers
:param {number} max_transmit_rate: the maximum rate at which to broadcast updates to the server (Hz)
:param {number} queue_size: the maximum number of ROS messages to hold in the buffer
:return: True if a subscriber was successfully registered, False otherwise
"""
# Try to resolve the message type if it is not already a ROS message class
if not issubclass(msg_type, Message):
if type(msg_type) == str:
# Try to look up in our dictionary
msg_type = ROS_MSG_TYPES.get(msg_type)
if not msg_type: # Couldn't find given message type in dictionary
return False
else: # Not a subclass of genpy.Message and not a string
return False
# Define a handler to serialize the ROS message and send it to the server
def msg_handler(msg):
self.transmit_message(topic_name, msg, msg_type, save_to_db=save_to_db)
self.subscribers[topic_name] = rospy.Subscriber(topic_name, msg_type, msg_handler, queue_size=queue_size)
print('Registered listener for ' + topic_name)
return True
def transmit_message(self, topic_name, msg, msg_type, save_to_db=True):
"""
Transmits a message to the server.
:param {string} topic_name: the name of the ROS topic
:param {genpy.Message} msg: the actual ROS message
:param {type} msg_type: the type of ROS message
:param {boolean} save_to_db: whether or not the message should be saved to the database
"""
if not self.reporter:
print('Not connected to /reporter')
return
payload = {
'topicName': topic_name,
'type': msg_type.__name__,
'data': self._serialize_ros_message(msg),
'timestamp': str(datetime.now()),
'saveToDb': save_to_db
}
self.reporter.emit('message', payload)
@staticmethod
def _serialize_ros_message(msg):
"""
Converts a ROS message into a dictionary that can be serialized and sent to the server.
:param {genpy.Message} msg: the raw ROS message
:return: a dictionary with the important values from the message
"""
msg_type = type(msg)
if msg_type == Pose2D:
return {
'x': msg.x,
'y': msg.y,
'theta': msg.theta
}
elif msg_type == Float32 \
or msg_type == Float64 \
or msg_type == UInt8 \
or msg_type == UInt16 \
or msg_type == UInt32 \
or msg_type == UInt64:
return msg.data
elif msg_type == Float32MultiArray \
or msg_type == Float64MultiArray:
return list(msg.data)
elif msg_type == GridMap:
return {
'grid': TelemetryReporter._serialize_ros_image_message(msg.grid),
'minLatitude': msg.minLatitude.data,
'maxLatitude': msg.maxLatitude.data,
'minLongitude': msg.minLongitude.data,
'maxLongitude': msg.maxLongitude.data
}
elif msg_type == WaypointList:
points = []
for lat, long in zip(msg.latitudes.data, msg.longitudes.data):
points.append({'lat': lat, 'long': long})
return points
return None
@staticmethod
def _serialize_ros_image_message(msg):
"""
Converts a ROS Image message into a dictionary.
:param msg: the ROS Image message (from sensor_msgs.msg)
:return: a dictionary with the image width, height, encoding, and pixel data
"""
return {
'height': msg.height,
'width': msg.width,
'encoding': msg.encoding,
'data': msg.data
}
def publish_message(self, topic_name, msg_type, data):
"""
Publishes a message to the given ROS topic.
:param {string} topic_name: the name of the ROS topic to publish to
:param {type} msg_type: the ROS message type
:param data: the message payload
"""
# Turn the data into a ROS message
msg = self._build_ros_msg(data, msg_type)
if msg is not None:
# Register a publisher if one is not already registered for this topic
if topic_name not in self.publishers:
self.configure_publisher(topic_name, msg_type)
# Note: Messages sent shortly after configuring publisher will likely be lost.
# See https://github.com/ros/ros_comm/issues/176 for more info.
self.publishers[topic_name].publish(msg)
def _convert_unicode(self, data):
"""
Recursively converts attributes unicode string attributes or elements on an object to UTF-8 strings.
:param data: a dict, list, or string to convert to UTF-8.
:return: the converted object
"""
if isinstance(data, dict):
return {self._convert_unicode(key): self._convert_unicode(value)
for key, value in data.iteritems()}
elif isinstance(data, list):
return [self._convert_unicode(element) for element in data]
elif isinstance(data, unicode):
return data.encode('utf-8')
else:
return data
def configure_publisher(self, topic_name, msg_type, queue_size=1):
"""
Sets up a ROS message publisher.
:param topic_name: the name of the ROS topic to publish to
:param msg_type: the type of messages to publish
:param queue_size: the number of messages to queue up for sending before dropping old ones
"""
if topic_name not in self.publishers:
self.publishers[topic_name] = rospy.Publisher(topic_name, msg_type, queue_size=queue_size)
def _build_ros_msg(self, data, msg_type):
"""
Constructs a ROS message to transmit the given data.
:param data: the data to hold in the message
:param {genpy.Message} msg_type: the type of message to construct
:return: a ROS message containing the data
"""
try:
# TODO Ints and arrays of ints
if msg_type == UInt8 \
or msg_type == UInt16: # Integers
return msg_type(data=int(data))
if msg_type == Float32 \
or msg_type == Float64: # Floating-point numbers
return msg_type(data=float(data))
if msg_type == Float32MultiArray or msg_type == Float64MultiArray: # Array of floating-point numbers
return msg_type(data=[float(x) for x in data])
if msg_type == String:
return msg_type(data=data)
if msg_type == Pose2D and 'x' in data and 'y' in data:
return Pose2D(x=float(data['x']), y=float(data['y']))
except ValueError:
error_msg = 'Problem parsing data: ' + data + '. Supposed to be of type ' + str(msg_type)
self.publish_message(ERROR_TOPIC_NAME, String, error_msg)
return None
def _handle_server_publish_msg(self, msg):
"""
Handles WebSockets "publish" events from the server by publishing their info to ROS.
:param msg: the WebSockets message payload
"""
# Convert Unicode strings to UTF-8
msg = self._convert_unicode(msg)
# Make sure message type is specified and try to resolve it to ROS message class
if 'type' in msg:
msg_type = ROS_MSG_TYPES.get(msg['type'])
if not msg_type:
return self._publish_error_msg('Could not understand message type "' + msg['type'] + '".')
else:
return self._publish_error_msg('Attribute "type" must be specified.')
# Check for the topic name
if 'topicName' not in msg:
return self._publish_error_msg('Attribute "topicName" must be specified.')
# Check for the message payload
elif 'data' not in msg:
self._publish_error_msg('Attribute "data" must be specified.')
self.publish_message(msg['topicName'], msg_type, msg['data'])
def _publish_error_msg(self, error):
"""
Logs an error by publishing it to the error log topic.
:param {string} error: the content of the message
"""
print(error)
self.publish_message(ERROR_TOPIC_NAME, String, String(data=error))
def _handle_get_published_topics_request(self, data):
"""
Gets a list of the published ROS topics and their associated message types
:param
:return: A list of dictionaries of the form {name: topicName, type: topicType}
:rtype list
"""
res = []
# Reformat the list items as dictionaries rather than arrays
for topic in rospy.get_published_topics():
res.append({
'name': topic[0],
'type': topic[1]
})
# Send the topics to the server
self.reporter.emit('topicList', res)
def start_stop_rosbag(self, data):
"""
Handles a request from an observer to start or stop rosbag on the boat.
This currently only supports one instance of rosbag. Attempts to start
a second instance without first ending the first will be ignored.
:param data: the WebSockets message from the observer
"""
if 'action' not in data:
return
action = data['action']
if self.rosbag_process and action == 'stop': # Stop rosbag
print('Stopping rosbag...')
os.killpg(os.getpgid(self.rosbag_process.pid), signal.SIGINT)
self.rosbag_process = None
elif action == 'start': # Start rosbag
print('Starting rosbag...')
cmd = 'rosbag record --all'
if 'args' in data:
cmd += ' ' + data['args']
self.rosbag_process = subprocess.Popen(cmd, cwd=os.environ.get('HOME'), shell=True, preexec_fn=os.setsid)
def run(self):
self.socketIO = SocketIO(_SIO_URL_PREFIX, _SIO_PORT)
self.namespace = self.socketIO.define(self._Namespace, self.addr)
if self.sendinit:
self.namespace.emit(*self.sendinit)
self.socketIO.wait()
print('on_chiotte_response', args)
def on_connect(self):
print('[Connected]')
def on_reconnect(self):
print('[Reconnected]')
def on_disconnect(self):
print('[Disconnected]')
socketIO = SocketIO(WS_HOST, WS_PORT, LoggingNamespace)
socketIO.on('chiotte_response', on_chiotte_response)
distance_in_mm_old = 0
while running:
distance_in_mm = tof.get_distance()
if (distance_in_mm != distance_in_mm_old and 100 <= distance_in_mm <= 230):
distance_in_mm_old = distance_in_mm
data = json.dumps({
"id": ID,
"gender": POOP_LOCATION,
"pq": distance_in_mm
})
print(data)
socketIO.emit('chiotte', data)
time.sleep(0.5)
