class TwoWayClient(object):
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 _receive_events_thread(self):
self.socketIO.wait()
class TwoWayClient(object):
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 _receive_events_thread(self):
self.socketIO.wait()
def transmit():
while True:
time.sleep(1)
# If there's something to transmit, make a connection and sent it out
if (len(queue) > 0):
# Attempt to connect, transmit all in queue if success
print("Attempting connection...")
try:
sio = SocketIO(sys.argv[1],
verify=False,
wait_for_connection=False,
cert=('client.crt', 'client.key'))
sio.wait(seconds=1)
print("Connected")
#sio.on('disconnect', on_disconnect)
sio.on('response', on_response)
queue2 = queue[:] # Copy the list to resolve a bug in how the for loop works
for id in queue2:
print("Transmitting " + str(id))
sio.emit('attend', {'ID': id})
sio.wait(seconds=1)
#sio.disconnect()
except ConnectionError:
print('Server unreachable. Retrying shortly')
class TwoWayClient(object):
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 _receive_events_thread(self):
self.socketIO.wait()
def __init__(
self,
node,
url,
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)
def _sio(data, field=field, json=json, wrap=wrap, interval=interval):
if json:
data = JSON.loads(data)
if field:
data = data[field]
if wrap:
data = [data]
socketIO.emit(data)
socketIO.wait(seconds=interval)
return data
super().__init__(foo=_sio, name="SocketIO", inputs=1)
node >> self
def AsyncSocketIO(url, 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)
async def _sio(url, channel, field='', json=False, wrap=False, interval=1):
while True:
_data = []
socketIO.on(channel, lambda data: _data.append(data))
socketIO.wait(seconds=interval)
for msg in _data:
# FIXME clear _data
if json:
msg = json.loads(msg)
if field:
msg = msg[field]
if wrap:
msg = [msg]
yield msg
return _wrap(_sio, dict(url=url, channel=channel, field=field, json=json, wrap=wrap, interval=interval), name='SocketIO')
class SIOHelper(GenBase):
def __init__(self, psp, url, send=None, channel='', records=False):
self.validate(url, 'sio')
self.__type = 'sio'
self.url = url.replace('sio://', '')
self.send = send
self.channel = channel
self.records = records
self._data = []
o = urlparse(self.url)
self.socketIO = SocketIO(o.scheme + '://' + o.netloc, o.port)
self.socketIO.on(self.channel, lambda data: self._data.append(data))
self.url = o.path
super(SIOHelper, self).__init__(psp)
async def getData(self):
if self.send:
self.socketIO.emit(*self.send)
t = threading.Thread(target=self.socketIO.wait)
t.start()
while 1:
if self._data:
c = 0
for item in self._data:
c += 1
yield item
self._data = self._data[:c]
else:
await asyncio.sleep(1)
def start_process(self):
"""main process start from here. """
self.jwt_token = self.get_auth_code()
# print("jwt token is: {}\n".format(self.jwt_token))
params1 = self.util_obj.socket_connection['params1']
params1["token"] = self.jwt_token
# socketIO = SocketIO('192.168.0.60', 8080, params=params1)
socketIO = SocketIO(self.util_obj.socket_connection['ip'],
self.util_obj.socket_connection['port'],
params=params1)
socketIO.emit('server.version', {})
socketIO.on('server.version', self.get_server_version)
pLocationNamespace = socketIO.define(self.LocationNamespace,
'/location')
filterData = self.util_obj.filterData
pLocationNamespace.emit('location:monitor:send:filter', filterData)
pLocationNamespace.on('location:monitor:receive', self.on_aaa_response)
try:
socketIO.wait()
# engineSocket.wait()
except ConnectionError as ex:
print("got connection error %s" % ex)
class TwoWayClient(object):
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 _receive_events_thread(self):
self.socketIO.wait()
class socket:
def __init__(self, id):
self.id = id
self.socketIO = None
self.token = None
self.missatge_doctor = None
self.esperar = True
self.createsocket(id)
def desconectar(self, id):
self.socketIO.emit('disconnect', {'id': id})
def createsocket(self, id):
print id
self.socketIO = SocketIO('https://ptin2018.herokuapp.com',
params={"id": id})
print "Socket creado"
self.socketIO.wait(seconds=3)
def receive_general(self, *args):
print "Recibido"
print args[0]
self.token = args[0]
def response(self, *args):
print "response"
print args
def response_doctor(self, *args):
print "response doctor"
print args
self.missatge_doctor = args
self.esperar = False
def envia_confirmacio(self):
self.socketIO.wait(seconds=1)
self.socketIO.emit('generalAuthentication', {
'requester': self.id,
'token': self.token
})
self.socketIO.on("generalResponse", self.response)
self.socketIO.wait(seconds=1)
def esperar_doctor(self):
self.socketIO.on('pacientLocation', self.response_doctor)
while self.esperar:
self.socketIO.wait(seconds=3)
self.esperar = True
return self.missatge_doctor
def envia_general(self, lat, lon):
self.socketIO.emit('alarm', {
'type': 2,
'latitude': lat,
'longitude': lon
})
print self.socketIO
self.socketIO.on("generalAuthentication", self.receive_general)
self.socketIO.wait(seconds=1)
class SocketIoHandler:
SOCKET_IO_URL = 'http://localhost'
SOCKET_IO_PORT = 3000
def __init__(self):
self.socketIO = SocketIO(self.SOCKET_IO_URL, self.SOCKET_IO_PORT)
def publish(self, topic, message):
self.socketIO.emit(topic, message)
class FrontendConnection:
def __init__(self, host, port):
self.host = host
self.port = port
self.socket = SocketIO(host, port, wait_for_connection=False)
#self.receiveStatus()
def on_posicion_response(self, *args):
# print('Posicion enviada al frontend:', args[0], args[1])
pass
def on_send_status_response(self, *args):
# print('Estado enviado al frontend:', args[0], args[1])
pass
def on_reconocimiento_response(self, response):
if response == "ok":
# print('Reconocimiento ok')
pass
else:
# print("El servidor no te reconoce")
exit()
def on_change_attributtes_response(self, *args):
# print('Cambiados atributos:', args[0], args[1])
pass
def send(self, topic, data, callback):
self.socket.emit(topic, data, callback)
def recognizeAgent(self, agent_info):
self.send("agent/recognition", agent_info,
self.on_reconocimiento_response)
def repositionAgent(self, agent_id, posicion):
self.send("agent/position", {
"position": posicion,
"agent_id": agent_id
}, self.on_posicion_response)
def sendStatus(self, agent_id, status):
self.send("agent/status", {
"status": status,
"agent_id": agent_id
}, self.on_send_status_response)
def changeAttributtes(self, agent_id, attributtes):
self.send("agent/attributes", {
"agent_id": agent_id,
"attributes": attributtes
}, self.on_change_attributtes_response)
def wait(self, segs):
self.socket.wait(segs)
def envoyerValeurDirect(jsonDonnee):
global jsonValeur
jsonValeur = jsonDonnee
print(jsonValeur)
connection = SocketIO('vps202433.vps.ovh.ca', 8080, LoggingNamespace)
#connection = SocketIO('vps202845.vps.ovh.ca', 8080, LoggingNamespace)
connection.on('salutation', lors_connection)
connection.on('donnee_recu', on_send)
connection.emit('emission-donnees-bouee', jsonValeur) #envoie du json
print("sent")
connection.disconnect()
def envoyerDonneesAuServeur():
global data
donneeNonFormatee = data.decode()
#donneeFormatee = json.dumps(donneeNonFormatee)
print(donneeNonFormatee)
connection = SocketIO('vps202433.vps.ovh.ca', 8080, LoggingNamespace)
#connection = SocketIO('vps202845.vps.ovh.ca', 8080, LoggingNamespace)
connection.on('salutation', lors_connection)
connection.on('donnee_recu',on_send)
connection.emit('deverser-donnees-bouee', donneeNonFormatee) #envoie du json
print("sent")
connection.disconnect()
def connect_socket_io(dtable_server_url, dtable_uuid, jwt_token):
host, port = parse_dtable_server_url(dtable_server_url)
params = {'dtable_uuid': dtable_uuid}
socketIO = SocketIO(host, port, params=params)
socketIO.on('connect', on_connect)
socketIO.on('reconnect', on_reconnect)
socketIO.on('disconnect', on_disconnect)
socketIO.emit(JOIN_ROOM, dtable_uuid, jwt_token)
print('[ Seatable Socket IO Connected]')
socketIO.on(UPDATE_DTABLE, on_update_dtable)
socketIO.on(NEW_NOTIFICATION, on_new_notification)
return socketIO
def SocketIO(node,
url,
channel='',
field='',
sendinit=None,
json=False,
wrap=False,
interval=1):
'''Connect to socketIO server and send updates
Args:
node (Node): input stream
url (str): url to connect to
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
'''
o = urlparse(url)
socketIO = SIO(o.scheme + '://' + o.netloc, o.port)
if sendinit:
socketIO.emit(sendinit)
def _sio(data, field=field, json=json, wrap=wrap, interval=interval):
if json:
data = JSON.loads(data)
if field:
data = data[field]
if wrap:
data = [data]
socketIO.emit(data)
socketIO.wait(seconds=interval)
return data
ret = Node(foo=_sio,
name='SocketIO',
inputs=1,
graphvizshape=_OUTPUT_GRAPHVIZSHAPE)
node >> ret
return ret
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 __init__(
self,
url,
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)
async def _sio(
url=url,
channel=channel,
field=field,
json=json,
wrap=wrap,
interval=interval,
):
while True:
_data = []
socketIO.on(channel, lambda data: _data.append(data))
socketIO.wait(seconds=interval)
for msg in _data:
# FIXME clear _data
if json:
msg = JSON.loads(msg)
if field:
msg = msg[field]
if wrap:
msg = [msg]
yield msg
super().__init__(foo=_sio)
self._name = "SocketIO"
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 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..."
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)
class Client(object):
def __init__(self):
self.socketio = SocketIO("http://twitchplaysnintendoswitch.com:8110")
self.socketio.on("disableInternet", self.on_disable_internet)
self.socketio.on("enableInternet", self.on_enable_internet)
self.socketio.on("getInternetStatus", self.on_get_internet_status)
self.socketio.on("disconnect", self.on_disconnect)
self.socketio.emit("join", "proxy")
self.receive_events_thread = Thread(target=self._receive_events_thread)
self.receive_events_thread.daemon = True
self.receive_events_thread.start()
self.start = time.process_time()
self.end = time.process_time()
self.status = False
def _receive_events_thread(self):
self.socketio.wait()
def on_event(self, event):
#print(event)
pass
def on_disconnect(self):
print("disconnected")
os.system("killall python3")
def on_disable_internet(*args):
print("disabling proxy!")
client.status = False
sudoPassword = "******"
command = "service squid stop"
p = os.system("echo %s|sudo -S %s" % (sudoPassword, command))
def on_enable_internet(*args):
print("enabling proxy!")
client.status = True
sudoPassword = "******"
command = "service squid restart"
p = os.system("echo %s|sudo -S %s" % (sudoPassword, command))
def on_get_internet_status(*args):
print("checking status!")
self.socketio.emit("internetStatus", client.status)
def loop(self):
self.end = time.process_time()
diffInMilliSeconds = (self.end - self.start) * 1000
if (diffInMilliSeconds > 1000 * 60 * 5):
self.socketio.emit("join", "proxy")
self.start = time.process_time()
from socketIO_client_nexus import SocketIO
import json
socketIO = SocketIO('localhost', 3000)
def welcome():
print('welcome received')
socketIO.on('welcome', welcome)
message = {
'name': 'hoang',
'ids': ['54fjadb70f9756', '39f1ax451f6567'],
'relation': 'nguoi la',
'date': '06/05/2018'
}
socketIO.emit('client-event', json.loads(json.dumps(message)))
socketIO.wait()
pulse_duration = pulse_end - pulse_start
distance = round(17150 * pulse_duration, 2)
return distance
# get_measurement()
# while (True):
# distance = get_measurement()
# print('Distance is:', distance)
# time.sleep(.05)
thread = Thread(target=continuous_loop)
thread.setDaemon(True)
thread.start()
socket.on('connect', on_connect)
socket.on('disconnect', on_disconnect)
socket.on('reconnect', on_reconnect)
socket.on('command', on_command)
socket.on('socket_id', on_socket_id)
socket.emit('connect_rover')
socket.wait()
class NodeProvider(object):
def __init__(self, hostname, port, username, password, cb1, cb2):
self.hostname = hostname
self.port = port
self.username = username
self.password = password
self.auth_token = None
self.socketIO = None
self.next_msg_id = 0
self.msg_id_to_callback = {}
self._after_connect = cb1
self._after_error = cb2
self.closed = False
def login(self):
login_url = self.hostname + ':' + str(self.port) + '/login'
values = {
'username': self.username, 'password': self.password
}
data = urllib.parse.urlencode(values).encode('ascii')
request = urllib.request.Request(login_url, data)
print('Connecting to ' + login_url)
attempts = 0
attempt_limit = 4
while True:
try:
with urllib.request.urlopen(request,timeout=5) as response:
content = response.read()
content_obj = json.loads(content.decode('ascii'))
if 'token' in content_obj:
self.auth_token = content_obj['token']
self.configure_socket()
break
else:
raise Exception('Authentication failed no token in response')
except urllib.error.URLError as e:
attempts += 1
if attempts == attempt_limit:
print('Informing caller of error')
self.after_error(e)
break
print('Sleeping!')
print(e)
time.sleep(10)
except Exception as e:
print(e)
self.after_error(e)
break
def configure_socket(self):
if self.hostname.startswith('https'):
needs_sslv4 = True
else:
needs_sslv4 = False
print('Creating WebSocket connection')
self.socketIO = SocketIO(self.hostname, self.port, LoggingNamespace,False,transports=['xhr-polling'],needs_sslv4=needs_sslv4)
time.sleep(3)
self.socketIO.on('authenticated', self._socket_authenticated)
self.socketIO.emit('authenticate', {'token': self.auth_token})
self.socketIO.on('__response__', self._process_response)
self.socketIO.on('reconnect', self._socket_authenticated)
self.socketIO.on('connect', self._socket_authenticated)
self.socketIO.on('disconnect', self._disconnected)
self.socketIO.on('open', self._socket_authenticated)
try:
self.socketIO.wait()
except Exception as e:
raise e
self.after_error(e)
def _disconnected(self):
if self.closed:
return
print('Disconnected')
self.closed = True
def _process_response(self, data):
if 'bioinfJobId' in data:
msg_id = data['bioinfJobId']
if msg_id in self.msg_id_to_callback:
error = None
json = None
if 'error' in data:
error = data['error']
elif 'json' in data and 'error' in data['json']:
error = data['json']['error']
else:
error = None
if 'json' in data:
json = data['json']
self.msg_id_to_callback[msg_id](error, json)
self.msg_id_to_callback.pop(msg_id)
#Important - otherwise we leak file descriptors
# TODO: Check that this still closes file handles on Linux
if hasattr(data, 'close'):
data.close()
else:
print('Warning message not found ' + msg_id)
def handle_fetch(self, error, data):
print(data)
def _authenticate_socket(self):
print('Authenticating')
self.socketIO.emit('authenticate', {token: self.auth_token})
def _socket_authenticated(self):
self.after_connect()
def after_connect(self):
self._after_connect()
def set_after_connect(self, cb):
self._after_connect = cb
def after_error(self, error):
self._after_error(error)
def get_by_named_query(self, query_id, data, cb):
json = {"queryId": query_id, 'parameters': self._serialise(data)}
def _cb(error, json):
cb(error, data['objects'])
self.run_query('_remote_provider_._data_request_objects_namedquery', json, cb)
def upload_file(self, filename, cb):
f = open(filename, 'rb')
chunk_size = 1024 * 60000
scope_obj = {'file_identifier': None}
def upload_chunk():
byte_buf = f.read(chunk_size)
eof = len(byte_buf) != chunk_size
def _cb(error, upload_id):
if error is not None:
f.close()
cb(error, None)
scope_obj['file_identifier'] = upload_id
if not eof:
upload_chunk()
else:
f.close()
cb(None, scope_obj['file_identifier'])
self.upload_bytes_as_file(byte_buf, scope_obj['file_identifier'], _cb)
upload_chunk()
def upload_bytes_as_file(self, contents, file_identifer, cb):
contents_b64 = base64.b64encode(contents).decode('ascii')
json = {'contents': contents_b64, 'file_identifier': file_identifer}
def _cb(error, json):
cb(error, json['upload_id'])
self.run_query('_remote_provider_._data_request_upload_file', json, _cb)
def _convert_dictionaries(self, obj):
for key in obj.keys():
if type(obj[key]) == dict:
obj[key] = self._convert_dictionaries(obj[key])
return _hx_AnonObject(obj)
def _serialise(self, params):
a = self._convert_dictionaries(params)
param_str = haxe_Serializer.run([a])
return param_str
def run_query(self, api_command, json, cb):
msg_id = self.increment_next_id()
json['msgId'] = msg_id
self.register_callback(msg_id, cb)
self.socketIO.emit(api_command, json)
def register_callback(self, msg_id, cb):
self.msg_id_to_callback[msg_id] = cb
def increment_next_id(self):
i = self.next_msg_id
self.next_msg_id += 1
return str(i)
def on_disconnect():
print('disconnect')
def on_reconnect():
print('reconnect')
def on_say(words):
print('on_say', words)
call(['espeak "' + words + '"'], shell=True)
def on_play(file):
print('on_play', file)
pygame.mixer.music.load("%s/%s" % (sfx_path, file))
pygame.mixer.music.play()
socketIO = SocketIO(config.websocket["url"], config.websocket["port"],
LoggingNamespace)
socketIO.on('connect', on_connect)
socketIO.on('disconnect', on_disconnect)
socketIO.on('reconnect', on_reconnect)
# Listen
socketIO.on('say', on_say)
socketIO.on('play', on_play)
socketIO.emit('jambot')
socketIO.wait()
import json
import time
import random
import math
sock_client = SocketIO('localhost', 3000, LoggingNamespace)
i = 0
while True:
arr = [10,20,30,40,50]
x_1, x_2, x_3 = arr[i], arr[4-i], 50
y_1, y_2, y_3 = arr[i], arr[4-i], 30
hand1_x_1, hand1_y_1 = x_1 - 5, y_1 + 5
hand2_x_1, hand2_y_1 = x_1 + 30, y_1 + 5
hand1_x_2, hand1_y_2 = x_2 - 5, y_2 + 5
hand2_x_2, hand2_y_2 = x_2 + 30, y_2 + 5
sock_client.emit('messages',
json.dumps([
{'person_id': 'Billy', 'x': x_1, 'y': y_1, 'hand1_x': hand1_x_1, 'hand1_y': hand1_y_1, 'hand2_x': hand2_x_1, 'hand2_y': hand2_y_1},
{'person_id': 'Tommy', 'x': x_2, 'y': y_2, 'hand1_x': hand1_x_2, 'hand1_y': hand1_y_2, 'hand2_x': hand2_x_2, 'hand2_y': hand2_y_2},
{'person_id': 'Eric', 'x': x_3, 'y': y_3}
]))
i += 1
if i > 4:
i = 0
time.sleep(1)
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)
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)
# Listen only once
socketIO.once('Response_C', on_Response_C)
socketIO.emit('event_C') # Activate aaa_response
socketIO.emit('event_C') # Ignore
socketIO.wait(seconds=1)
(0, 255, 0), int(5 * bp.c))
# last_num_people = len(kpts[:, 0, 0])
package = list()
for i in range(len(heads)):
per_dict = dict()
per_dict['person_id'] = heads[i].p_id
per_dict['x'] = 100 - (100 * (heads[i].x_buf[-1] / 1280))
per_dict['y'] = 50 * (heads[i].y_buf[-1] / 720) + 10
if left_hands[i].x_buf[-1] > 0:
per_dict['hand1_x'] = 110 - (120 *
(left_hands[i].x_buf[-1] / 1280))
per_dict['hand1_y'] = 100 * (left_hands[i].y_buf[-1] /
720) + 40
if right_hands[i].x_buf[-1] > 0:
per_dict['hand2_x'] = 110 - (120 *
(right_hands[i].x_buf[-1] / 1280))
per_dict['hand2_y'] = 100 * (right_hands[i].y_buf[-1] /
720) + 40
package.append(per_dict)
print package
# Send to server
sock_client.emit('messages', json.dumps(package))
# Display the image
cv2.imshow("output", output_image)
cv2.waitKey(2)
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()
total = 0
def on_mission_download(var):
global total
global checker
print("DOWNLOAD MISSION COMMAND BY USER", var)
save_mission()
total = calculate_dist()
checker = True
try:
#socket = SocketIO('http://192.168.1.119', 3000, wait_for_connection=False)
socket = SocketIO('https://nicwebpage.herokuapp.com', verify=False)
socket.emit("joinPi")
except ConnectionError:
print('The server is down. Try again later.')
def on_initiate_flight(var):
socket.emit("success", "flight_success")
print("FLIGHT INITIATED BY USER")
arm_and_takeoff(5)
vehicle.mode = VehicleMode("AUTO")
# Get all vehicle attributes (state)
print("\nGet all vehicle attribute values:")
