def run_flask():
root_dir = os.path.join(os.getcwd(), 'web')
app = Flask(__name__, static_folder=root_dir)
app.use_reloader = False
app.debug = False
app.config["SECRET_KEY"] = "OpenPoGoBot"
socketio = SocketIO(app, logging=False, engineio_logger=False)
logging_buffer = []
@app.route("/")
def index():
return app.send_static_file("index.html")
@app.route('/<path:path>')
def static_proxy(path):
return app.send_static_file(path)
@manager.on("logging")
def logging_event(event_name, output, color):
line = {"output": output, "color": color}
logging_buffer.append(line)
socketio.emit("logging", [line], namespace="/event")
@socketio.on("connect", namespace="/event")
def connect():
emit("logging", logging_buffer, namespace="/event")
logger.log("Client connected", "yellow", fire_event=False)
@socketio.on("disconnect", namespace="/event")
def disconnect():
logger.log("Client disconnected", "yellow", fire_event=False)
socketio.run(app, host="0.0.0.0", port=8000, debug=False, use_reloader=False, log_output=False)
def main(**kwargs):
opt = parse_cmdline()
app = Flask('supcast.wsapp')
app.config['SECRET_KEY'] = 'TODO: some secret?'
socketio = SocketIO(app, async_mode='eventlet')
eventlet.spawn(redis_listener, socketio)
supcast.config.set_redis_url(opt.redis)
socketio.run(app, host=opt.host, port=opt.port, **kwargs)
def new_server(viewer_queue, stop_page, port, secret_key):
# create server
app = Flask(__name__, static_url_path='/static')
app.config['SECRET_KEY'] = secret_key
# must be 'threading' for broadcast emitting
socketio = SocketIO(app, async_mode='threading',
logger=False, engineio_logger=False)
# rooting
@app.route('/')
def __index():
logger.info('Render viewer page')
return render_template('index.html', script="index.js")
if stop_page:
@app.route('/stop')
def __stop():
socketio.stop()
logger.info('Server stop request')
return 'This server is stopped'
@socketio.on('connect', namespace=IO_NAMESPACE)
def __on_viewer_connect():
logger.info('New viewer connection is established')
@socketio.on('disconnect', namespace=IO_NAMESPACE)
def __on_viewer_disconnect():
logger.info('Viewer connection is closed')
@socketio.on('update', namespace=IO_NAMESPACE)
def __on_update():
logger.info('Image updating request is received')
# get all of current data
emit_data = buffering_thread.get_data_all()
# emit all
logger.debug('Emit for update all')
emit('update', emit_data, namespace=IO_NAMESPACE)
def update_event(tab, name, data):
emit_data = [[tab, name, data]] # single data
# broadcast emit
logger.debug('Broadcast emit for update (tab: %s, name: %s)' %
(str(tab), str(name)))
socketio.emit('update', emit_data, namespace=IO_NAMESPACE)
# create image updating thread
if viewer_queue:
logger.info('Start image buffering thread')
buffering_thread = ImageBufferingThread(viewer_queue)
buffering_thread.daemon = True
buffering_thread.start()
buffering_thread.register_update_event_func(update_event)
# start server
logger.info('Start server on port %d' % port)
socketio.run(app, host='0.0.0.0', port=port, debug=False, log_output=False)
logger.info('Stop server on port %d' % port)
def main():
global socketio
signal.signal(signal.SIGINT, signal_handler)
print('Flask-SocketIO running...')
app = Flask(__name__)
# c = SimpleCache()
# c.clear()
Bootstrap(app)
app.debug = False
socketio = SocketIO(app)
ser = myComm.mySerial()
net = myComm.myNet()
@app.before_first_request
def initialize():
print('Called only once, when the first request comes in')
ser.onMsg = onSerialMsg
# ser.connect('COM3')
ser.connect('COM5')
# ser.connect('/dev/ttyACM0')
net.onMsg = onNetMsg
# net.connect('192.168.1.91', 12345)
net.connect('10.0.0.4', 12345)
@app.route('/')
def index():
print('Rendering index.html')
return render_template('index.html')
@app.route('/2')
def index2():
return render_template('index2.html')
@app.route('/3')
def index3():
return render_template('index3.html')
@socketio.on('ledACtrl', namespace='/test')
def ledACtrl(message):
print(message['led'])
if message['led']:
ser.sendMsg('l1')
else:
ser.sendMsg('l0')
@socketio.on('ledRCtrl', namespace='/test')
def ledRCtrl(message):
print(message['led'])
if message['led']:
net.sendMsg('l1')
else:
net.sendMsg('l0')
socketio.run(app, host = '0.0.0.0', port = 5001)
def front(port, working_dir, redis_host):
"""start the frontend server"""
import eventlet
eventlet.monkey_patch() # for flask_socketio message queue support
from flask_socketio import SocketIO
static = os.path.abspath(os.path.join(working_dir, 'static'))
templs = os.path.abspath(os.path.join(working_dir, 'templates'))
app = front_app(static_folder=static, template_folder=templs)
socketio = SocketIO(app, message_queue=redis_host)
socketio.run(app, host='0.0.0.0', port=port) # doesn't seem to work if debug=True
def run_socket_server():
app = Flask(__name__)
app.config["SECRET_KEY"] = "OpenPoGoBotSocket"
socketio = SocketIO(app, logging=False, engineio_logger=False, json=myjson)
state = {}
botevents.register_bot_events(socketio, state)
uievents.register_ui_events(socketio, state)
socketio.run(app, host="0.0.0.0", port=8000, debug=False, use_reloader=False, log_output=False)
def main():
app = flask.Flask('espelhos_sonoros')
app.config.from_object('config.Config')
socketio = SocketIO(app, async_mode='threading')
db = SQLAlchemy(app)
espelhos_sonoros(app, socketio, db)
app.logger.info('Started server.')
if not app.config['DEBUG']:
SSLify(app)
socketio.run(app, host=app.config['HOST'], port=app.config['PORT'])
def run_socket_server():
app = Flask(__name__)
app.config["SECRET_KEY"] = "OpenPoGoBotSocket"
socketio = SocketIO(app, logging=False, engineio_logger=False, json=myjson)
@app.route("/")
def redirect_online():
return redirect("http://openpogoui.nicontoso.eu")
state = {}
botevents.register_bot_events(socketio, state)
uievents.register_ui_events(socketio, state)
socketio.run(app, host="0.0.0.0", port=8000, debug=False, use_reloader=False, log_output=False)
class Server(threading.Thread):
def __init__(self, jukebox):
threading.Thread.__init__(self)
self.jukebox = jukebox
def run(self):
self.app = Flask(__name__)
self.app.config['SECRET_KEY'] = 'secret!'
self.socketio = SocketIO(self.app)
@self.socketio.on('connect')
def handle_connect():
emit('newSong', self.jukebox.current_song_name)
@self.socketio.on('playback')
def handle_message(playback):
if playback == "pause":
self.jukebox.pause()
elif playback == "play":
self.jukebox.play()
elif playback == "next":
self.jukebox.play_next_song()
return self.jukebox.current_song_name
print(playback)
@self.socketio.on('addToQueue')
def handle_add_to_queue(song):
if self.jukebox.add_to_queue(song):
return True
else:
return False
@self.app.route("/")
def index():
return render_template("queue.html")
@self.app.route("/playstyring")
@requires_auth
def control():
return render_template("index.html")
self.socketio.run(self.app, host='0.0.0.0', port=80)
def new_song(self, song):
with self.app.test_request_context('/'):
self.socketio.send('newSong', song)
def entry_point():
# Graceful shutdown when kill are received
signal.signal(signal.SIGTERM, lambda sig, frame: shutdown())
# Graceful shutdown when terminal session are closed
signal.signal(signal.SIGHUP, lambda sig, frame: shutdown())
main()
try:
_config = settings.get_config_file()
app.config['SECRET_KEY'] = _config.get('server', 'cookie_secret_key')
app.config['DEBUG'] = _config.getboolean('server', 'debug', fallback=True)
from scrapy_eagle.dashboard.views import servers, processes, root, jobs, react_app
app.register_blueprint(root.root, url_prefix='/')
app.register_blueprint(react_app.react_app, url_prefix='/app')
app.register_blueprint(servers.servers, url_prefix='/servers')
app.register_blueprint(processes.processes, url_prefix='/processes')
app.register_blueprint(jobs.jobs, url_prefix='/jobs')
CORS(app)
socketio = SocketIO(app, async_mode='gevent')
start_periodics(socketio)
# use_reloader: avoid Flask execute twice
socketio.run(
app=app,
host=_config.get('server', 'host', fallback='0.0.0.0'),
port=_config.getint('server', 'port', fallback=5000),
use_reloader=False
)
except (KeyboardInterrupt, SystemExit):
shutdown()
def run_socket_server(self):
app = Flask(__name__)
app.config["SECRET_KEY"] = "OpenPoGoBotSocket"
socketio = SocketIO(app, logging=False, engineio_logger=False, json=myjson)
@app.route("/")
def redirect_online():
return redirect("http://openpogoui.nicontoso.eu")
state = {}
BotEvents(self.bot, socketio, state, self.event_manager)
UiEvents(self.bot, socketio, state, self.event_manager, self.logger)
self.log("Starting socket server...")
socketio.run(
app,
host=self.config['socket_server']['host'] or '0.0.0.0',
port=self.config['socket_server']['port'] or 8080,
debug=False,
use_reloader=False,
log_output=False
)
class Listener():
def __init__(self, generator_domain):
self.generator_domain = generator_domain
def find_generator_by_url(self, url):
return generators.find_generator_by_url(url)
def on(self, url, callback):
generator = self.find_generator_by_url(url)
generator.set_callback(callback)
def emit(self, url, callback):
generator = self.find_generator_by_url(url)
#dictToSend = {'question':'what is the answer?', 'data':[1,2,3]}
# res = requests.post(self.generator_domain+'/'+url, json=dictToSend)
try:
res = requests.post(self.generator_domain+'/'+url)
callback(np.array(res.json()))
except:
callback({ "err": "post to dategenerator from listener failed!"})
def run(self, app, debug, port, host):
self.init_routers(app)
self.socketio = SocketIO(app)
return self.socketio.run(app, debug=debug, port=port, host=host)
def init_routers(self, app):
@app.route('/', defaults={'url': ''})
@app.route('/<path:url>', methods=['GET', 'POST'])
def catch_url_generator_request(url):
if(request.method == 'POST'):
generator = self.find_generator_by_url(url)
if(generator is None):
return 'no url match with a datagenerator!'
else:
generator.execute_callback(np.array(request.json))
return 'data transfered to client listener!'
else:
return generators.handle('listener', url)
socketio.emit('new_offer', {'notification': notification, 'user_id':user_id, 'url':url}, namespace='/new_offer')
elif action == 'new_request':
socketio.emit('new_request', {'notification': notification, 'user_id':user_id, 'url':url}, namespace='/new_offer')
elif action == 'offer_accepted':
socketio.emit('offer_accepted', {'notification': notification, 'user_id':user_id, 'url':url}, namespace='/new_offer')
elif action == 'offer_rejected':
socketio.emit('offer_rejected', {'notification': notification, 'user_id':user_id, 'url':url}, namespace='/new_offer')
elif action == 'counter_offer':
socketio.emit('counter_offer', {'notification': notification, 'user_id':user_id, 'url':url}, namespace='/new_offer')
elif action == 'DELIVERY':
socketio.emit('DELIVERY', {'notification': notification, 'user_id':user_id, 'url':url}, namespace='/new_offer')
elif action == 'schedule':
socketio.emit('schedule', {'notification': notification, 'user_id':user_id, 'url':url}, namespace='/new_offer')
elif action == 'schedule_reminder':
socketio.emit('schedule_reminder', {'notification': notification, 'user_id':user_id, 'url':url}, namespace='/new_offer')
return render_template('index.html')
@socketio.on('connect', namespace='/test')
def test_connect():
print('Client connected')
@socketio.on('disconnect', namespace='/test')
def test_disconnect():
print('Client disconnected')
if __name__ == '__main__':
socketio.run(app, port=8000)
# if user.is_authenticated():
# return 'Not Allowed'
user_data = args
print('connected socket_auth')
# your logic ...
# app.login(user_data)
@socketio.on('join_room', namespace='/long_task')
def on_room(*args, **kwargs):
room = str(session['uid'])
print('join room {}'.format(room))
join_room(room)
@socketio.on('join_room', namespace='/schedule_task')
def on_room(*args, **kwargs):
print('connected schedule_task')
if __name__ == "__main__":
import logging
logging.basicConfig(filename='error.log', level=logging.DEBUG)
socketio.run(flask_app, debug=True, host="0.0.0.0")
# if request.method=="POST":
# oldpass = request.form['oldpassword']
# newpass = request.form['password1']
# conn = connectToDB()
# cur = conn.cursor()
# query = cur.mogrify("""SELECT * FROM users WHERE email = %s AND password = crypt(%s, password);""", (currentUser, oldpass))
# print(query)
# cur.execute(query)
# results = cur.fetchall()
# print results
# if results != []:
# try:
# query = cur.mogrify("""UPDATE users SET password=crypt(%s, gen_salt('bf')) WHERE email = %s;""", (newpass, currentUser))
# print query
# cur.execute(query)
# conn.commit()
# passChanged = True
# print "Password changed"
# except:
# print("Error changing password")
# conn.rollback()
# passFailed = True
# else:
# wrongPass = True
# print "Incorrect password"
# return render_template('resetpassword.html', loggedIn=loggedIn, passChanged=passChanged, passFailed=passFailed,
# wrongPass=wrongPass)
if __name__ == '__main__':
socketio.run(app, host=os.getenv('IP', '0.0.0.0'), port =int(os.getenv('PORT', 8080)), debug=True)
@game_req("target error")
def kill_player(args):
player, target = args
game.do_assassin_kill(player, target)
@sio.on('propose players', namespace='/private')
@authenticated_only
@game_req("proposal error")
def propose_players(args):
player, players = args
game.propose(player, players)
@sio.on('vote request', namespace='/private')
@authenticated_only
@game_req("vote error")
def vote(args):
player, truefalse = args
game.vote_on_questers(player, truefalse)
@sio.on('qvote request', namespace='/private')
@authenticated_only
@game_req("qvote error")
def qvote(args):
player, truefalse = args
game.do_quest_vote(player, truefalse)
if __name__ == '__main__':
sio.run(app, host=hostname, port=portnum)
session.modified = True
set_winsize(fd, 50, 50)
app.logger.debug("child pid = {}".format(child_pid))
app.logger.debug("rooms of this session = {}".format(rooms()))
socketio.start_background_task(read_and_forward_pty_output, fd,
child_pid,
rooms()[0])
app.logger.debug("background task running")
# print(session)
@socketio.on('disconnect', namespace='/pty')
def pty_disconnect():
try:
child_process = psutil.Process(
session.get('terminal_config').get('child_pid'))
except psutil.NoSuchProcess as err:
disconnect()
session['terminal_config'] = TERM_INIT_CONFIG
return
if child_process.status() in ('running', 'sleeping'):
# if visitor just close the browser tab then left alone the pty here
# it should be terminated by the parent process after
child_process.terminate()
app.logger.debug('user left the pty alone, terminated')
app.logger.debug('Client disconnected')
if __name__ == "__main__":
socketio.run(app, host='0.0.0.0', debug=True, port=5000)
#y = randint(100, 400)
print(x,y)
position = {
"pos": {"x": x, "y": y}
}
socketio.emit("json", dumps(position), namespace='/position') # send to all clients in the namespace
time.sleep(0.1)
@app.route('/')
def index():
return app.send_static_file('index.html')
@socketio.on('connect', namespace='/position')
def test_connect():
print("New client connected")
@socketio.on('disconnect', namespace='/position')
def handle_disconnect():
print('Client disconnected')
if __name__ == '__main__':
t1 = Thread(target=emitter_thread)
#t1 = socketio.start_background_task(emitter_thread)
print("bla")
t1.start()
socketio.run(app, log_output=False)
@socketio.on('my event', namespace='/test')
def test_message(message):
session['receive_count'] = session.get('receive_count', 0) + 1
emit('my response',
{'data': message['data'], 'count': session['receive_count']})
@socketio.on('disconnect request', namespace='/test')
def disconnect_request():
session['receive_count'] = session.get('receive_count', 0) + 1
emit('my response',
{'data': 'Disconnected!', 'count': session['receive_count']})
disconnect()
@socketio.on('connect', namespace='/test')
def test_connect():
emit('my response', {'data': 'Connected', 'count': 0})
@socketio.on('disconnect', namespace='/test')
def test_disconnect():
print('Client disconnected', request.sid)
if __name__ == '__main__':
host = '0.0.0.0'
port = 80
socketio.run(app, host=host, port=port, debug=True)
class LyrebirdMockServer(ThreadServer):
"""
模拟接口服务
使用flask在默认的9090端口启动，模拟线上接口，同时支持通过api动态修改接口数据。
"""
def __init__(self):
super().__init__()
self.conf = application.config
# TODO rm conf rom mock context
context.application.conf = application.config
self.debug = False
self.port = 9090
self._working_thread = None
self.app = Flask('MOCK',
static_folder=os.path.join(current_dir, 'static'))
self.app.jinja_env.block_start_string = '[%'
self.app.jinja_env.block_end_string = '%]'
self.app.jinja_env.variable_start_string = '[['
self.app.jinja_env.variable_end_string = ']]'
self.app.jinja_env.comment_start_string = '[#'
self.app.jinja_env.comment_end_string = '#]'
# async_mode = threading / eventlet / gevent / gevent_uwsgi
self.socket_io = SocketIO(self.app,
async_mode='threading',
log_output=False)
# 存储socket-io
context.application.socket_io = self.socket_io
# 生成过滤器实例
if self.conf:
self.port = self.conf.get('mock.port')
else:
_logger.error('Can not start mock server without config file')
raise SyntaxError('Can not start mock server without config file.'
' Default config file path = api-mock/conf.json')
# 插件初始化
plugin_manager.load()
# 加载插件界面
plugin_manager.add_view_to_blueprint(ui)
# 注册插件socket事件
plugin_manager.add_event_rules(self.socket_io)
self.app.register_blueprint(api)
self.app.register_blueprint(api_mock)
self.app.register_blueprint(ui)
@self.app.route('/')
def index():
"""
设置默认页面为UI首页
"""
return redirect(url_for('ui.index'))
@self.app.after_request
def after_request(response: Response):
"""
输出每条请求概要信息
"""
lyrebird_info = response.headers.get('lyrebird', default='')
_logger.info(
f'{response.status_code} {lyrebird_info} {request.method} {request.url[:100]}'
)
return response
def run(self):
server_ip = application.config.get('ip')
_logger.warning(f'start on http://{server_ip}:{self.port}')
report_handler.start()
self.socket_io.run(self.app,
host='0.0.0.0',
port=self.port,
debug=True,
use_reloader=False)
def stop(self):
"""
停止服务
"""
super().stop()
try:
self.socket_io.stop()
except Exception:
pass
report_handler.stop()
_logger.warning('MockServer shutdown')
from flask import Flask
from flask_socketio import SocketIO, emit
app = Flask(__name__)
socketio = SocketIO(app)
@socketio.on('message2')
def connect_handler(message):
print(message)
emit('message2', str(message), broadcast=True)
if __name__ == '__main__':
socketio.run(app, port=5000, log_output=False, debug=True)
@app.route('/sliders', methods=['GET'])
@jwt_required
@cross_origin(origin='localhost', headers=['Content-Type', 'Authorization'])
def get_sliders():
global gettime
if request.method == 'GET':
if (time.time() - gettime > 60 * 59):
client.login()
gettime = time.time()
time.sleep(2)
sheet = client.open('Slider').sheet1
data = sheet.get_all_records()
return json.dumps(data)
@celery.task
def callGeneticAlgorithm(data):
with open('example.json', 'w') as json_file:
json.dump(data, json_file)
print(data)
name = open('example.json', 'r').read()
eng.molto_it_json(name, nargout=0)
eng.quit()
return send_from_directory(static_file_dir, 'Results_extended.txt')
if __name__ == '__main__':
socket.run(app, host="0.0.0.0", threaded=True)
def pos(data):
try:
opponent = games[data['room']].players[1 - data['id']].sid
emit('posRes', {
'posX': data['posX'],
'posY': data['posY'],
'velX': data['velX'],
'velY': data['velY']
},
room=opponent)
except:
pass # Other player has allready left
@socketio.on('powerupPickup')
def powerupPickup(data):
opponent = games[data['room']].players[1 - data['id']].sid
emit('powerupPickupRes', {'tileId': data['tileId']}, room=opponent)
@socketio.on('deathStatus')
def deathStatus(data):
for player in games[data['room']].players:
if not player.sid == request.sid:
opponent = player.sid
emit('deathStatusRes', {'opponentDead': True}, room=opponent)
if __name__ == '__main__':
socketio.run(app, host="0.0.0.0", port=7676)
image = Image.open(BytesIO(base64.b64decode(data["image"])))
image = np.asarray(image) # from PIL image to numpy array
image = utils.preprocess(image) # apply preprocessing
image = np.array([image]) # model expects batch of images (4D array)
# predict the steering angle for the image
steering_angle = float(model.predict(image, batch_size=1))
throttle = 1 if speed < 20 else 0
send_control(steering_angle, throttle)
else:
socket_io.emit('manual', data={}, skip_sid=True)
def send_control(steering_angle, throttle):
socket_io.emit(
"steer",
data={
'steering_angle': steering_angle.__str__(),
'throttle': throttle.__str__()
},
skip_sid=True)
if __name__ == '__main__':
model = keras.models.load_model('model-001.h5')
model.summary()
socket_io.run(app, port=4567)
return False
except ipc.BusyError as e:
print("socket busy error: write_to_queue", e)
queue.close()
return False
except Exception as e:
print("error: ", e)
return True
if __name__ == "__main__":
import argparse
# config.BrewConfig.CONFIG_FILE = "/home/oli/dev/braubar-pi/config/config.json"
# config.BrewConfig.RECIPE_FILE = "/home/oli/dev/braubar-pi/config/recipe.json"
parser = argparse.ArgumentParser(description="BrauBar webserver at your service.")
parser.add_argument('--host', help="IP-Address to listen on. Default is 0.0.0.0", default="0.0.0.0")
parser.add_argument('-i', '--id', help="brew_id to identify the current brew process. "
"if no id is given, it shall return all brews")
args = parser.parse_args()
try:
host = args.host
brew_id = args.id
# start app in debugmode
app.debug = True
socketio.run(app, host=host)
finally:
print("good beer, see ya")
#!/usr/bin/env python
import json
from flask import Flask
from flask_socketio import SocketIO
from cofre import Cofre
with open('config.json', 'r') as config_file:
config = json.loads(config_file)
app = Flask(__name__)
app.secret_key = config['cofre_secret_key']
socketio = SocketIO(app)
socketio.on_namespace(Cofre('/cofre'))
if __name__ == '__main__':
socketio.run(app, port=8080, debug=True)
room=session['room'])
else:
emit('my response',
{'data': message['data'], 'sender': session['nick']},
room=session['room'])
@socketio.on('disconnect request', namespace='')
def disconnect_request():
session['receive_count'] = session.get('receive_count', 0) + 1
indiv_msg = 'You have disconnected.'
gr_msg = session['nick'] + ' has disconnected.'
del connected_users[session['room']][session['uid']]
emit('my response',
{'data': indiv_msg, 'bot': 'true'}, room=session['uid'])
disconnect()
emit('my response',
{'data': gr_msg, 'bot': 'true'}, room=session['room'])
render_template('index.html')
@socketio.on('connect', namespace='')
def connect():
join_room(session['uid'])
emit('my response', {'data': 'Connection successful...', 'count': 0, 'bot': 'true'})
if __name__ == '__main__':
socketio.run(app, host='0.0.0.0', port=int(os.environ.get("PORT", 33507)))
@mqtt.on_connect()
def handle_connect(client, userdata, flags, rc):
mqtt.subscribe(sub_topic)
print(":subscribe " + str(sub_topic))
@mqtt.on_message()
def handle_mqtt_message(client, userdata, message):
print(":pub on message received"+"MESSAGE: "+message)
# if message.payload=="alarmed" :
# print("alarmed signale arrived in messages turn vaariable")
# alarm=True
@app.route('/')
def hello_world():
# buttonSts = alarm
# templateData = {'button':buttonSts}
return render_temp('index.html')#,**templateData)
if __name__ == '__main__':
# client = mqtt.Client()
# #client.username_pw_set(username, password)
# client.on_connect = on_connect
# client.on_message = on_message
# client.connect("192.168.43.2",1883, 60)
# client.loop_start()
# important: Do not use reloader because this will create two Flask instances.
# Flask-MQTT only supports running with one instance
socketio.run(app, host='0.0.0.0', port=5000, use_reloader=False, debug=False)
if (data['resp'] == "Accept"):
print data['from'] + " has accepted trade offer."
else:
print "Rejected trade offer"
# {
# 'name': 'neko' (Player name)
# }
@socketio.on('leave')
def leave(data):
name = data['name']
global game
if game is not None:
game.playerLeft(name)
print name + ' has left!'
global player_names
player_names.remove(name)
leave_room(room)
emit('playerLeft', player_names, room=room)
@socketio.on('disconnect')
def disconnect():
print('Client disconnected', request.sid)
if __name__ == '__main__':
socketio.run(app, debug=True, host='0.0.0.0')
json['error'] = 'unkown operation'
io.emit('ctrl', json)
# write data back to client
def respond_data(uuid, payload):
json = {}
json['id'] = uuid
json['error'] = 0
json['payload'] = payload
io.emit('data', json)
# payload requests
@io.on('data')
def handle_data(json):
# must have valid id
if 'id' not in json or json['id'] not in terms:
json['error'] = 'invalid id'
json['payload'] = ''
io.emit('data', json)
return
# pass payload to bash session
terms[json['id']].write(json['payload'])
if __name__ == "__main__":
io.run(app, '0.0.0.0', 5000)
@app.route("/")
def home():
return render_template("home.html")
@socketio.on("skt_load_log_files")
def load_log_files():
files = os.listdir(r"C:\Users\Amit\Desktop\suraj_poc\logged_images")
socketio.emit("skt_load_file_response", {"files": files})
#take file name, search image, convert and send
@socketio.on("skt_selected_image")
def selected_image(msg):
img = cv2.imread(r"C:\Users\Amit\Desktop\suraj_poc\logged_images\\" +
msg["img_name"])
_, photoJpeg = cv2.imencode('.jpg', img)
strPhotoJpeg = b64encode(photoJpeg).decode('utf-8')
socketio.emit("skt_show_image", {"image": strPhotoJpeg})
if __name__ == "__main__":
socketio.run(app,
host="0.0.0.0",
port=5000,
use_reloader=False,
debug=True)
from flask import Flask, render_template
from flask_socketio import SocketIO
import hashlib
app = Flask(__name__)
app.config['SECRET_KEY'] = hashlib.sha256(b"AnotherChatApp")
socketio = SocketIO(app)
@app.route('/')
def sessions():
return render_template('session.html')
def messageRecived(methods=['GET', 'POST']):
print('Message Recived')
@socketio.on('my event')
def handle_my_custom_event(json, methods=['GET', 'POST']):
print('recived my event: ' + str(json))
socketio.emit('my responce', json, callback=messageRecived)
if __name__ == '__main__':
socketio.run(app, debug=True, host='0.0.0.0', port='3000')
@socketio.on('obtener arbol', namespace='/test')
def obtener_arbol():
predic = predecir_respuesta('X', prediccion_y_jugada=False)
#se envia estructura (id, jugada, valor)
nodos = nodos_x
#se envia estructura (id_source, id_target)
arcos = arcos_x
emit(
'dibujar arbol', {
'nodos': nodos,
'arcos': arcos,
'prediccion': salida,
'mi_jugada': mi_jugada(salida),
'estrategia': estrategia
})
@socketio.on('connect', namespace='/test')
def test_connect():
emit('my response', {'data': 'Connected', 'count': 0})
@socketio.on('disconnect', namespace='/test')
def test_disconnect():
print('Client disconnected', request.sid)
if __name__ == '__main__':
socketio.run(app, debug=True, port=5000)
app.logger.addHandler(logging.StreamHandler(sys.stdout))
app.logger.setLevel(logging.DEBUG)
app.secret_key = configuration_data["secret_key"]
logfile = configuration_data["logfile"]
logging.basicConfig(
level=logging.DEBUG,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
filemode='w',
filename=logfile)
ch = logging.StreamHandler(sys.stdout)
ch.setLevel(logging.INFO)
handler = RotatingFileHandler(logfile, maxBytes=10000000, backupCount=5)
handler.setLevel(logging.DEBUG)
app.logger.addHandler(handler)
log = app.logger
db_url = configuration_data["db_url"]
db = dataset.connect(db_url)
core.db = db
gmtime = time.gmtime()
start_time = "{0}:{1} UTC {2}".format(gmtime.tm_hour, gmtime.tm_min,
now.strftime("%m/%d/%Y"))
start()
log.info(":SYS:Running app")
socketio.run(app,
host=configuration_data["host"],
port=configuration_data["port"],
debug=configuration_data["debug"])
@socket.on('update_blink_pattern')
def update_blink_pattern(data):
# Set data on PUT resource /3201/0/5853 (pattern of LED blink)
logging.info('update_blink_pattern ', data)
api.set_resource_value(data['device_id'], BLINK_PATTERN_RESOURCE_PATH,
data['blink_pattern'])
@socket.on('blink')
def blink(data):
# POST to resource /3201/0/5850 (start blinking LED)
logging.info('blink: ', data)
api.set_resource_value(data['device_id'], BLINK_RESOURCE_PATH, None)
def subscription_handler(current_value, device_id, q):
while True:
new_value = q.get()
if new_value != current_value:
logging.info("Emitting new value: %s" % new_value)
socket.emit('presses', {
'device_id': device_id,
'value': new_value.decode('utf-8')
})
current_value = new_value
if __name__ == "__main__":
api.start_notifications()
socket.run(app, host='127.0.0.1', port=8002)
# This file is the entry point of our API, with the single import
# we launch the __init__.py of our module api
from flask import Flask
from config import Config
from flask_socketio import SocketIO
socketio = SocketIO(engineio_logger=True, logger=True, cors_allowed_origins='*', cors_allowed_headers='*')
def createApp(config_class=Config):
app = Flask(__name__, static_folder=None)
app.config.from_object(Config)
socketio.init_app(app)
from application.api import api_blueprint
app.register_blueprint(api_blueprint, url_prefix='/api')
from application.chat_server import chat_blueprint
app.register_blueprint(chat_blueprint, url_prefix='/chat')
return app
if __name__ == '__main__':
socketio.run(createApp, host='0.0.0.0')
@app.route("/")
def index():
return render_template('index.html')
@socketio.on('event', namespace='/raf')
def raf_message(message):
emit('message', {'data': message})
@socketio.on('broadcast_event', namespace='/raf')
def raf_message(message):
emit('message', {'data': message}, broadcast=True)
@socketio.on('connect', namespace='/raf')
def raf_connect():
emit('message', {'data': 'Connected'})
@socketio.on('disconnect', namespace='/raf')
def raf_disconnect():
print('Client disconnected')
if __name__ == "__main__":
port = int(os.environ['PORT'])
socketio.run(app, "0.0.0.0", port)
f.write(video_file)
user_path = os.path.abspath('./videos/{0}'.format(username))
emit(
"success", {
'data':
'{0}/{1}{2}.{3}'.format(username, username, video_count,
video_type)
})
video_analysis(username, video_type)
cut_size = 44
transform_test = transforms.Compose([
transforms.TenCrop(cut_size),
transforms.Lambda(lambda crops: torch.stack(
[transforms.ToTensor()(crop) for crop in crops])),
])
device = torch.device('cpu')
net = VGG('VGG19')
checkpoint = torch.load(os.path.join('FER2013_VGG19', 'PrivateTest_model.t7'),
map_location=device)
net.load_state_dict(checkpoint['net'])
net.eval()
if __name__ == '__main__':
app.debug = True
print("server start!")
socketio.run(app, host='0.0.0.0', port=8000)
from flask import Flask, render_template
from flask_socketio import SocketIO, send, emit, join_room, leave_room
app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret!'
socketio = SocketIO(app)
active_rooms = []
@socketio.on('connect')
def connect():
print("connected")
@socketio.on('message')
def on_message(message):
emit('message', message, broadcast=True, room=message["room"])
@socketio.on('connect_room')
def on_room_connect(data):
print(data)
active_rooms.append(data['room'])
join_room(data["room"])
emit('connect_room', data["room"])
if __name__ == '__main__':
socketio.run(app, host="0.0.0.0")
from flask_socketio import SocketIO from webapp import create_app flask_app = create_app() socketio = SocketIO(flask_app) socketio.run(flask_app)
# don't go crazy ... reset; ie if processor is lagging heavily, ignore the noise
distance = abs(desired_rate - self.update_rate);
if distance > MAX_SAFE_PID_DISTANCE:
# reset
_logger.debug("reset rate")
self.__init__.reset_update_rate_pid_params()
if len(payload) > 2:
socketio.emit('message', {'command': 'update', 'payload': payload})
self.last_transmitted_state = payload
socketio.start_background_task(target=self.device_loop)
if __name__ == '__main__':
# app.run(port=8888, debug=True)
# support for websockets via flask-socketio
app.network_state = NetworkState()
# from threading import Thread
# foo = Thread(target=app.network_state.device_loop, daemon=True)
# foo.start()
socketio.start_background_task(target=app.network_state.device_loop)
logging.getLogger('socketio').setLevel(logging.WARN)
logging.getLogger('engineio').setLevel(logging.WARN)
socketio.run(app, host='0.0.0.0', port=8888)
@socketio.on('update trash')
def update_trash(id):
id = id.split(';')[0]
completeness=id.split(';')[0]
response = dustbin(id,completeness)
import pdb; pdb.set_trace()
emit('update trash', str(response), broadcast=True)
def dustbin(id,completeness):
try:
import pdb;pdb.set_trace()
dustbin_object = model.dustbin_data.objects(id=id)
if len(dustbin_object) < 0:
abort(400)
dustbin_object = dustbin_object[0]
dustbin_object.completeness = completeness
dustbin_object.save()
send("hello",namespace='/chat')
data = {}
for key in dustbin_object:
data[key] = str(d[key])
return data
except Exception as e:
return e
if __name__ == '__main__':
app.host = "0.0.0.0"
app.debug = True
socketio.run(app,host="0.0.0.0")
[checks[0][1], checks[0][2]],
)
if len(nobody_else) < 1:
execute_db("update games set new = 0 where id = %s", [checks[0][2]])
@app.route("/check", methods=["GET", "POST"])
def check():
my_color = session.get("color") # TODO if not redirect to /
game_db = get_game_db() # TODO check against session.get('game', None)
if request.method == "POST": # main
hides = query_db("select hides from games where id = %s", [game_db[0][0]])
cards = map(
lambda x: x.encode("utf-8"), [request.form["card_a"], request.form["card_b"], request.form["card_c"]]
)
good = 1 if split_cards(hides[0][0]) == cards else 0
players = query_db("select color from players where game_id = %s", [game_db[0][0]])
for player_color in zip(*players)[0]:
execute_db(
"insert into checks(game_id, sender, receiver, cards, showed, good) values (%s, %s, %s, %s, %s, %s)",
[game_db[0][0], my_color, player_color, join_cards(cards), 0, good],
)
return redirect("/", code=302)
else:
return render_template("check.html", game=my_color)
if __name__ == "__main__":
# app.debug = True
socketio.run(app, host="0.0.0.0") # host='176.58.109.138', port=4242)
None
if e.error:
print("Error: ",e.error.errType, e.error.error, e.raw_data)
@socketio.on('blink')
def blink(data):
# POST to resource /3201/0/5850 (start blinking LED)
print('blink: ',data)
e = connector.postResource(data['endpointName'],'/3201/0/5850')
while not e.isDone():
None
if e.error:
print("Error: ",e.error.errType, e.error.error, e.raw_data)
# 'notifications' are routed here, handle subscriptions and update webpage
def notificationHandler(data):
global socketio
print "\r\nNotification Data Received : %s" %data['notifications']
notifications = data['notifications']
for thing in notifications:
stuff = {"endpointName":thing["ep"],"value":b64decode(thing["payload"])}
print "Emitting :",stuff
socketio.emit('presses',stuff)
if __name__ == "__main__":
connector.deleteAllSubscriptions() # remove all subscriptions, start fresh
connector.startLongPolling() # start long polling connector.mbed.com
connector.setHandler('notifications', notificationHandler) # send 'notifications' to the notificationHandler FN
socketio.run(app,host='0.0.0.0', port=8080)
new_bubble('command', command)
ui.sleep(0.005)
commands = command.split()
if commands:
program, * commands = commands
if program == 'fm':
if commands:
# check that client is operational
if fm.keys.client is None and commands[0] != 'tumblr-keys':
error_bubble('API keys were not generated properly. Regenerating keys...')
emit('need', 'fm tumblr-keys', namespace='/py')
else:
_attempt_exec(parse_fm, commands)
elif program == 'help':
_help(())
else:
error_bubble("'{}' is not a recognized command".format(program))
emit('open', namespace='/py')
@socketio.on('kill', namespace='/py')
def kill():
print('Interrupted operation')
streamer.kill = True
if __name__ == '__main__':
webbrowser.open(url='http://localhost:1989')
socketio.run(app, host='0.0.0.0', port=1989)
def ws_conn():
pass
@socketio.on('disconnect')
def ws_conn():
print('disconnect', request.sid)
@socketio.on('message')
def ws_message(message):
data = json.loads(message);
print(data)
if data['type'] == "offer":
socketio.send(json.dumps({'offer': data['offer'], 'type':data['type']}))
elif data['type'] == "answer":
socketio.send(json.dumps({'answer': data['answer'], 'type': data['type']}))
elif data['type'] == "file":
socketio.send(json.dumps({'file': data['file'], 'type': data['type']}))
else:
socketio.send(json.dumps({'candidate': data['candidate'],'type':data['type']}))
if __name__ == "__main__":
socketio.run(app, host=url)
@socketio.on("my_room_event", namespace="/trape")
def send_room_message(message):
try:
session['receive_count'] = session.get('receive_count', 0) + 1
hookAction = attacks_hook_message(message['data']['type'])
utils.Go(utils.Color['white'] + "[" + utils.Color['blueBold'] + "@" + utils.Color['white'] + "]" + " " + hookAction + utils.Color['blue'] + message['data']['message'] + utils.Color['white'] + ' in ' + utils.Color['green'] + message['room'] + utils.Color['white'])
emit('my_response', {'data': message['data'], 'count': session['receive_count']},room = message['room'])
except Exception as error:
pass
@socketio.on("disconnect_request", namespace="/trape")
def disconnect_request(d):
try:
session['receive_count'] = session.get('receive_count', 0) + 1
emit('my_response', {'data': 'Disconnected!', 'count': session['receive_count']})
utils.Go(utils.Color['white'] + "[" + utils.Color['redBold'] + "-" + utils.Color['white'] + "]" + utils.Color['red'] + " " + "A victim has closed her connection with the following id:" + " " + utils.Color['green'] + d['vId'] + utils.Color['white'])
db.sentences_victim('disconnect_victim', d['vId'], 2)
except Exception as error:
pass
@socketio.on_error("/trape")
def error_handler(e):
pass
@app.route("/" + trape.home_path)
def home():
return render_template("home.html", async_mode=socketio.async_mode)
if __name__ == 'core.sockets':
socketio.run(app, host= '0.0.0.0', port=trape.app_port, debug=False)
'threshold': 0.1,
'gpu': 1.0
}
colors = [tuple(255 * np.random.rand(3)) for _ in range(10)]
@app.route('/')
def sessions():
return render_template('index.html')
def listen():
while True:
detector.detect()
eventlet.sleep(1)
@socketio.on('connect')
def on_connection():
print("connected")
detector.tfnet = TFNet(options)
detector.capture = cv2.VideoCapture(0)
detector.capture.set(cv2.CAP_PROP_FRAME_WIDTH, 1920)
detector.capture.set(cv2.CAP_PROP_FRAME_HEIGHT, 1080)
eventlet.spawn(listen)
if __name__ == '__main__':
socketio.run(app, "127.0.0.1", 5000, debug=True)
socketio.emit('my response',
{'data': 'Falling', 'count': count, 'date': str(led_state)},
namespace='/test')
GPIO.add_event_detect(pin,GPIO.FALLING,callback = eventgpio,bouncetime = 100)
@app.route('/')
def index():
"""Renders the home page."""
return render_template(
'device.html',
title='Home Page',
year=datetime.now().year,
)
@socketio.on('my event', namespace='/test')
def test_message(message):
session['receive_count'] = session.get('receive_count', 0) + 1
emit('my response',
{'data': message['data'], 'count': session['receive_count'], 'date': str(datetime.now().time())})
@socketio.on('connect', namespace='/test')
def test_connect():
emit('my response', {'data': 'Connected', 'count': 0, 'date': str(datetime.now().time())})
if __name__ == '__main__':
socketio.run(app, host = '0.0.0.0')
from flask_socketio import SocketIO, emit, send
# Configuracion basica del servidor en Flask
app = Flask(__name__)
app.config['SECRET_KEY'] = '9f3f918414c3b8f36c904aa6085d019c'
app.debug = True
app.host = '0.0.0.0'
socketio = SocketIO(app)
# Ruta por defecto en http://127.0.0.1:5000/
@app.route("/")
def hello():
return render_template('test.html')
# SocketIO: aquí se manejan los mensajes entrantes
# y salientes del servidor, este es el socket que
# recibe las señales del archivo arduino.py
start = True
@socketio.on('message')
def handle_message(message):
print('received message: ' + message)
send(message, broadcast=True)
if __name__ == '__main__':
socketio.run(app)
def test_message(message):
session['receive_count'] = session.get('receive_count', 0) + 1
emit('my_response',
{'data': message['data'], 'count': session['receive_count']})
@socketio.on('connect', namespace='/test')
def test_connect():
global thread
if thread is None:
thread = socketio.start_background_task(target=background_thread)
emit('my_response', {'data': 'Connected', 'count': 0})
@socketio.on('add_event', namespace='/test')
def add_message():
session['receive_count'] = session.get('receive_count', 0) + 1
print("get addd")
myledon()
emit('my response',{'data': "add" , 'count': session['receive_count']})
@socketio.on('minus_event', namespace='/test')
def minus_message():
session['receive_count'] = session.get('receive_count', 0) + 1
print("get minus")
myledoff()
emit('my response',{'data': "minus" , 'count': session['receive_count']})
if __name__ == '__main__':
socketio.run(app,host='192.168.6.29', debug=False)
print('Client disconnected')
# This script is intended to run from the command-line.
if __name__ == '__main__':
# Initialize the store with its Bluemix services for the web UI
watson = WatsonEnv.get_watson_online_store()
if watson:
# If env setup succeeded, get another instance to use for slack.
# Separate instances to keep the web UI identity separate from
# the slack user.
slack_wos = WatsonEnv.get_watson_online_store()
socketio.start_background_task(slack_wos.run)
else:
# Note: Failure during Slack setup does not cause a fail. The web UI
# is running and will report an error message.
print('Slack integration is not started because of missing environment'
' variables.')
# The Bluemix port is passed in with a PORT environment variable.
# This allows Bluemix health check to work. Otherwise the default
# port for a Flask server is 5000.
port = os.environ.get("PORT") or os.environ.get("VCAP_APP_PORT") or 5000
# Run the web app.
# Use 0.0.0.0 to allow remote connections.
# Use PORT environment variable (set above) to set the port.
socketio.run(app, host='0.0.0.0', port=int(port))
@socketio.on('my room event', namespace='/test')
def send_room_message(message):
session['receive_count'] = session.get('receive_count', 0) + 1
emit('my response',
{'data': message['data'], 'count': session['receive_count']},
room=message['room'])
@socketio.on('disconnect request', namespace='/test')
def disconnect_request():
session['receive_count'] = session.get('receive_count', 0) + 1
emit('my response',
{'data': 'Disconnected!', 'count': session['receive_count']})
disconnect()
@socketio.on('connect', namespace='/test')
def test_connect():
emit('my response', {'data': 'Connected', 'count': 0})
@socketio.on('disconnect', namespace='/test')
def test_disconnect():
print('Client disconnected', request.sid)
if __name__ == '__main__':
socketio.run(app, host = '0.0.0.0', port = 5001, debug=True)
@app.route('/getparams', methods=['POST'])
def sendHandledJson():
refresh_param(SIMPLE_SPREAD, "--load", AllFile("models").get_file_list())
with open('./web/static/source/data/game_param.json') as f:
data = json.load(f)
gameName = request.form.get('gameName')
for gameParam in data['games']:
if (gameParam['name'] == gameName):
return jsonify(gameParam)
return -1
@app.route("/killall", methods=['POST'])
def kill_all_process():
print("start kill")
os.system("ps aux|grep main.py|grep -v grep|cut -c 9-15|xargs kill -9")
os.system("ps aux|grep Xvfb|grep -v grep|cut -c 9-15|xargs kill -9")
# for i in range(len(process_list)):
# p=process_list.pop()
# print(p.pid)
# # os.killpg(p.pid,signal.SIGTERM)
# # p.send_signal(signal.SIGINT)
# p.kill()
return {"pro_num": 1}
if __name__ == '__main__':
subprocess.Popen(["visdom"])
socket.run(app, debug=True)
# и произвели отключение вызвав disconnect()
# вывели на сервере сообщение, что клиент отключен
@socketio.on('disconnect request', namespace='/test1')
def disconnect_request():
session['receive_count'] = session.get('receive_count', 0) + 1
emit('Server response',
{'data': 'Disconnected!', 'count': session['receive_count']})
disconnect()
@socketio.on('disconnect', namespace='/test1')
def test_disconnect():
print('Client disconnected', request.sid)
#*********************************************************************************
# **********отправка сообщения клиенту (в его namespace test1)что сервер подключен***************************************************
@socketio.on('connect', namespace='/test1')
def test_connect():
emit('Server response', {'data': 'Server is Connected!', 'count': 0})
print("Server is connected")
# **********отправка сообщения клиенту (в его namespace test2)что сервер подключен***************************************************
@socketio.on('connect', namespace='/test2')
def test_connect():
emit('Server response', {'data': 'Server is Connected!', 'count': 0})
print("Server is connected")
if __name__ == '__main__':
socketio.run(app, debug=True)
while True:
time.sleep(2)
emit('my_response', {'data': message['data']})
# 触发事件my broadcast event：：回复所有链接（广播）
@socketio.on('my_broadcast event')
def test_message(message):
print("my_broadcast event -> " + str(message))
emit('my_response', {'data': message['data']}, broadcast=True)
##################################################################
# 自动连接和自动断开触发
@socketio.on('connect', namespace='/chat')
def test_connect():
print("连接到来")
emit('my_response', {'data': 'Connected'})
@socketio.on('disconnect', namespace='/chat')
def test_disconnect():
print("连接断开")
print('Client disconnected')
if __name__ == '__main__':
socketio.run(app, host='127.0.0.1', port=8200, debug=True)
from flask import Flask, render_template
from flask_socketio import SocketIO
app = Flask(__name__, static_url_path="", static_folder="")
app.config["SECRET_KEY"] = "dfghjkl"
socketio = SocketIO(app)
@socketio.on("message")
def handle_message(message):
print("received message: " + message)
@socketio.on("json")
def handle_json(json):
print("received json: " + str(json))
@socketio.on("my event")
def handle_my_custom_event(json):
print("Received my event")
print("received json: " + str(json))
if __name__ == "__main__":
socketio.run(app)
print("The word(s) '" + spokenText + "' have been said")
print("Command: ", command, ", Option: ", option)
socket.emit('commands', {
"spoken": spokenText,
"command": command,
"option": option
})
socket.emit(command, {"spoken": spokenText, "option": option})
if __name__ == '__main__':
username = os.getenv("USER")
password = os.getenv("PASSWORD")
port = os.getenv("PORT")
if (username == None or password == None):
print(
"No username or password found. Please set these environment variables."
)
else:
# keepAlive.start()
try:
mail = imaplib.IMAP4_SSL("imap.gmail.com", 993)
mail.login(username, password)
print("Login Successful.")
c = SiriControl(callback, mail)
c.start()
socket.run(app, debug=False, host="0.0.0.0", port=port)
except Exception as e:
print(e)
app.config['SECRET_KEY'] = 'secret!'
socketio = SocketIO(app)
@app.route('/')
def index():
return send_file('index.html')
@app.route('/Viewer/<path:path>')
def send(path):
print "send_page", path
return send_from_directory('Viewer', path)
@app.route('/Cesium/<path:path>')
def send_page(path):
print "send_page", path
return send_from_directory('Cesium', path)
@socketio.on('my event')
def test_message(message):
emit('my response', {'data': 'got it!'})
@socketio.on('chat')
def test_message(msg):
print "message:", msg
#emit('chat', {'data': 'got it!'})
emit('chat', msg)
if __name__ == '__main__':
socketio.run(app, port=80)
# Change turn
change_turn(game)
# Advancing the game
game_logic(sid)
# Else ignore
except:
print("Game does not exist or the given game id does not match")
disconnect(sid=request.sid)
@socketio.on("request::ai")
def handle_request_ai(message):
gameID = message["game"]
playerID = message["player"]
playerType = message["playerType"]
sessID = request.sid
if game_exists(gameID, playerID):
# Respond with success
set_sid(gameID, playerID, sessID)
game_logic(sessID)
else:
# Disconnect the client
print("Disconnected user due to incorrect details")
disconnect(sessID)
if __name__ == '__main__':
# Build game tree
print("\033[0;32mDone Building, starting server...\033[1;30m")
# Start the server
socketio.run(app, host='0.0.0.0')
