global time_of_birth
time_of_birth = datetime.now()
print("----Time Reset")
@socketio.on('log_score')
def log_score(message):
global time_of_birth
global last_score
data = json.loads(message)
# if last_score <= int(data['score']):
# time_of_birth = datetime.now()
# last_score = int(data['score'])
logtime = datetime.now()
time_alive = str(logtime - time_of_birth)
export((str(logtime), data["score"], data["rank"], data["total_players"],
data["max_lobby_score"], time_alive + "\n"))
@socketio.on('disconnect')
def test_disconnect():
print('Client disconnected')
global output_file
output_file.close()
output_file = open(output_file_path, "a")
if __name__ == '__main__':
socketio.run(app, host="localhost", port=8080, debug=True)
print("Started App")
game_code = GameCode.generate()
# r.hmset(gamecode)
# print(r.hmget(gamecode))
response = {"gamecode":game_code}
# qs = post_data.split(",")
r.hset(gamecode, mapping={'currentQ': 0, 'teams': {}})
return jsonify(response)
@socketio.on('join-session')
def handle_join(username,team_number,game_code):
join_room(gamecode)
socketio.emit('participant-joined', username, team_number, room=game_code)
replace = r.get(game_code)
replace["teams"][team_number] = 0
r.set(game_code, mapping=replace)
@socketio.on('answer')
def handle_answer(answer, team_no, q_no, game_id, username, game_code):
socketio.emit('answer-submitted', answer, team_no, q_no, game_id, username, room=game_code)
@socketio.on('question')
def change_question(game_id, new_question_no, question_text):
socketio.emit('new-question', new_question_no, question_text, room=game_id)
replace = r.get(game_id)
r['currentQ'] = new_question_no
r.set(game_id, mapping=replace)
if __name__ == "__main__":
socketio.run(app, host="0.0.0.0")
@sio.on('classify', namespace='/ocr')
def classify(message):
rand_image = np.random.random((1, img_size, img_size, 1))
rand_image = np.tile(rand_image, (1, 1, 1, 3))
with graph.as_default():
probs = model.predict(rand_image)
emit('classify_response', {'data': probs[0].tolist()})
@sio.on('connect', namespace='/ocr')
def connect():
emit('connect_response', {'data': 'Connected'})
@sio.on('disconnect', namespace='/ocr')
def disconnect():
print('Client disconnected')
if __name__ == '__main__':
graph = tf.get_default_graph()
# wrap Flask application with engineio's middleware
app = socketio.Middleware(sio, app)
# deploy as an eventlet WSGI server
eventlet.wsgi.server(eventlet.listen(('', 5000)), app)
socketio.run(app, debug=False)
def __init__(self, port, player):
self.player = player
interface_path = os.path.dirname(os.path.realpath(__file__))
www_path = os.path.join(interface_path, 'http2')
app = Flask(__name__, template_folder=www_path)
app.config['SECRET_KEY'] = 'secret!'
socketio = SocketIO(app, async_mode='eventlet')
#
# FLASK Routing
#
@app.route('/')
def index():
# return render_template('index.html', async_mode=socketio.async_mode)
return send_from_directory(www_path, 'index.html')
@app.route('/upload', methods=['POST'])
def files_upload():
if 'file' not in request.files:
return 'No file provided', 404
file = request.files['file']
if file.filename == '':
return 'No filename provided', 404
if file and self.player.validExt(file.filename):
filename = secure_filename(file.filename)
file.save(os.path.join(self.player.basepath[0], filename))
fileslist_message()
return 'ok'
return 'No valid file provided', 404
@app.route('/<path:path>')
def send_static(path):
return send_from_directory(www_path, path)
#
# SOCKETIO Routing
#
def background_thread():
while True:
socketio.emit('status', self.player.status()
) # {'msg': 'yo', 'timestamp': time.gmtime()}
socketio.sleep(0.1)
def settings_send(arg):
socketio.emit('settings', arg)
def playlist_send(arg=None):
socketio.emit('playlist', arg)
self.player.on(['settings-update'], settings_send)
self.player.on(['playlist-update'], playlist_send)
@socketio.on('connect')
def client_connect():
socketio.emit('settings', self.player.settings())
socketio.emit('name', self.player.name)
global thread
with thread_lock:
if thread is None:
thread = socketio.start_background_task(
target=background_thread)
@socketio.on('play')
def play_message(message=None):
if message and 'path' in message:
self.player.play(message['path'])
elif message and 'index' in message:
self.player.play(int(message['index']))
else:
self.player.play()
@socketio.on('stop')
def stop_message():
self.player.stop()
@socketio.on('clear')
def clear_message():
self.player.clear()
@socketio.on('add')
def add_message(path):
self.player.add(path)
@socketio.on('remove')
def rm_message(index):
self.player.remove(index)
@socketio.on('pause')
def pause_message():
self.player.pause()
@socketio.on('resume')
def resume_message():
self.player.resume()
@socketio.on('next')
def next_message():
self.player.next()
@socketio.on('prev')
def prev_message():
self.player.prev()
@socketio.on('loop')
def loop_message(mode=None):
doLoop = 1
if mode:
if mode == 'all':
doLoop = 2
elif mode == 'one':
doLoop = 1
else:
doLoop = 0
self.player.loop(doLoop)
@socketio.on('unloop')
def unloop_message():
self.player.loop(0)
@socketio.on('volume')
def volume_message(message=None):
if message:
self.player.volume(int(message))
@socketio.on('mute')
def mute_message():
self.player.mute(True)
@socketio.on('unmute')
def unmute_message():
self.player.mute(False)
@socketio.on('autoplay')
def mute_message():
self.player.autoplay(True)
@socketio.on('notautoplay')
def unmute_message():
self.player.autoplay(False)
@socketio.on('reboot')
def reboot_message():
os.system('reboot')
@socketio.on('pan')
def pan_message(message=None):
if message and len(message) == 2:
self.player.pan([int(message[0]), int(message[1])])
@socketio.on('flip')
def flip_message():
self.player.flip(True)
@socketio.on('unflip')
def unflip_message():
self.player.flip(False)
@socketio.on('status')
def status_message():
pass
@socketio.on('ping')
def ping_message():
socketio.send('pong')
@socketio.on('event')
def event_message(message=None):
if message['event']:
if message['data']:
self.player.trigger(message['event'], message['data'])
else:
self.player.trigger(message['event'])
@socketio.on('fileslist')
def fileslist_message():
def path_to_dict(path):
d = {'text': os.path.basename(path), 'path': path}
if os.path.isdir(path):
d['nodes'] = [
path_to_dict(os.path.join(path, x))
for x in sorted(os.listdir(path))
]
d['backColor'] = "#EEE"
d['selectable'] = False
else:
d['selectable'] = True
d['text'] += ' <div class="media-edit float-right">'
d['text'] += ' <span class="badge badge-success" onClick="playlistAdd(\'' + path + '\'); event.stopPropagation();"> <i class="fas fa-plus"></i> </span>'
# d['text'] += ' <span class="badge badge-danger ml-2"><i class="far fa-trash-alt"></i> </span>';
d['text'] += ' </div>'
return d
liste = []
for bp in self.player.basepath:
liste.append(path_to_dict(bp))
if len(liste) > 0 and 'nodes' in liste[0]:
socketio.emit('files', liste)
else:
socketio.emit('files', None)
@socketio.on('filesdelete')
def filesdelete_message(message=None):
# print ('delete', message)
if message:
for e in message:
e = e.replace('/..', '')
for basepath in self.player.basepath:
if e.startswith(basepath):
os.remove(e)
fileslist_message()
@socketio.on('connect', namespace='/test')
def test_connect():
pass
@socketio.on('disconnect', namespace='/test')
def test_disconnect():
print('Client disconnected', request.sid)
# prepare sub-thread
self.server_thread = threading.Thread(
target=lambda: socketio.run(app, host='0.0.0.0', port=port))
self.server_thread.daemon = True
from flask_socketio import send, emit
from flask_restful import Resource, Api
import sys
sys.path.append("..")
sio = socketio.Client()
app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret!'
socketio = SocketIO(app, cors_allowed_origins="*")
@socketio.on('response')
def handle_response(response):
print("Handle Response called")
emit('message', response)
@socketio.on('message')
def handle_message(message):
try:
emit('message', "Spinning up Magnum Infrastructure..")
except Exception as e:
print(e)
emit('message', "Sorry I am not trained to do that yet...")
if __name__ == '__main__':
socketio.run(app, host='0.0.0.0')
#!/usr/bin/env python
# -*- coding: utf-8 -*-
if __name__ == '__main__':
from {{cookiecutter.project_name}}.application import socketio
from {{cookiecutter.project_name}}.application import app
socketio.run(app, host='0.0.0.0', port=8000)
app = Flask(__name__)
app.config['SECRET KEY'] = 'secret'
socketio = SocketIO(app)
@app.route('/', methods=['POST', 'GET'])
def index():
return render_template('index2.html')
@socketio.on('message')
def another_event(data):
print('LOS DATOS SON', data)
emit('message', data, broadcast=True)
@socketio.on('enviarGrados')
def grados(msg):
print('el mensaje es', msg)
emit('grados', msg, broadcast=True)
@socketio.on('posicionHome')
def home():
print('llegando a home')
emit('home', 'home', broadcast=True)
if __name__ == '__main__':
socketio.run(app, host='172.31.83.234', port=8080, debug=True)
)
# print(game)
return jsonify({
'status': 'OK',
'message': 'Task Added!',
})
@app.route('/detectpattern', methods=['POST'])
def detectPattern():
if request.method == 'POST':
url = request.json.get('pattern_url', None)
b64 = request.json.get('image_b64', None)
match = compareImage(url, b64)
return jsonify({
"status": 'OK',
"message": 'Compared!',
"match": match,
})
@socketio.on('connect') #authentication?
def connect_handler():
print('SOCKETIO Connected. SessionID:' + request.sid)
@socketio.on('disconnect')
def disconnect_handler():
print('SOCKETIO Disconnected.')
if __name__ == '__main__':
# app.run(debug='True', host='0.0.0.0')
socketio.run(app, debug='True', host='0.0.0.0')
@app.route('/ls-program', methods=['GET'])
def ls_program():
run_process(['ls'], None, True)
return "done", 200
@app.route('/terminal', methods=['GET'])
def terminal():
return render_template('terminal_test.html')
@app.route('/upload', methods=['GET', 'POST'])
def upload_file():
if request.method == 'POST':
f = request.files['file']
filename = secure_filename(f.filename)
f.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
return "Upload Successful"
return render_template('/upload.html')
if __name__ == '__main__':
# global socketio
if not os.path.exists(app.config['UPLOAD_FOLDER']):
os.makedirs(app.config['UPLOAD_FOLDER'])
socketio = SocketIO(app, async_mode="threading")
socketio.run(app, debug=True, use_reloader=False)
# app.run()
def __init__(self, regieinterface, port):
self.regieinterface = regieinterface
interface_path = os.path.dirname(os.path.realpath(__file__))
localRegie = os.path.isdir(REGIE_PATH)
if localRegie:
www_path = os.path.join(REGIE_PATH, 'web')
else:
www_path = os.path.join(interface_path, 'regie')
app = Flask(__name__, template_folder=www_path)
app.config['SECRET_KEY'] = 'secret!'
socketio = SocketIO(app, cors_allowed_origins="*")
#
# FLASK Routing
#
@app.route('/')
def index():
# self.regieinterface.log('requesting index')
return send_from_directory(www_path, 'index.html')
@app.route('/<path:path>')
def send_static(path):
# self.regieinterface.log('requesting '+path)
return send_from_directory(www_path, path)
#
# SOCKETIO Routing
#
self.sendBuffer = queue.Queue()
def background_thread():
while True:
try:
task = self.sendBuffer.get_nowait()
if len(task) > 1: socketio.emit(task[0], task[1])
else: socketio.emit(task[0], None)
self.sendBuffer.task_done()
except queue.Empty:
socketio.sleep(0.1)
@self.regieinterface.hplayer.on('files.dirlist-updated')
def filetree_send(ev, *args):
self.sendBuffer.put(('data', {
'fileTree':
self.regieinterface.hplayer.files()
}))
@self.regieinterface.hplayer.on('*.peer.*')
def peer_send(ev, *args):
args[0].update({'type': ev.split('.')[-1]})
self.sendBuffer.put(('dispo', args[0]))
# !!! TODO: stop zyre monitoring when every client are disconnected
@socketio.on('connect')
def client_connect():
self.regieinterface.log('New Remote Regie connected')
@socketio.on('save')
def save(data):
try:
json.loads(data)
with open(
os.path.join(self.regieinterface._datapath,
'project.json'), 'w') as file:
file.write(data)
except:
e = str(sys.exc_info()[0])
self.regieinterface.log('fail to save project: ' + e + ' ' +
data)
@socketio.on('init')
def init(data):
# send project
emit('data', self.projectData())
# Start update broadcaster
global thread
with thread_lock:
if thread is None:
thread = socketio.start_background_task(
target=background_thread)
@socketio.on('register')
def register(data):
# enable peer monitoring
self.regieinterface.emit('peers.getlink')
self.regieinterface.emit('peers.subscribe', ['status', 'settings'])
@socketio.on('event')
def event(data):
self.regieinterface.emit('peers.triggers', data, 374)
# prepare sub-thread
self.server_thread = threading.Thread(
target=lambda: socketio.run(app, host='0.0.0.0', port=port))
self.server_thread.daemon = True
# watchdog project.json
self.watcher()
#!/usr/bin/python3
import socketio
from app import create_app, db, socketio
from config import DevelopmentConfig
# Remove Config when deploying.
app = create_app(DevelopmentConfig)
@app.shell_context_processor
def make_shell_context():
return {
'db': db,
}
if __name__ == '__main__':
socketio.run(app)
socketio.emit('data9', data, broadcast=True)
if datapoints["type"] == "Reference10":
socketio.emit('data10', data, broadcast=True)
socketio.sleep(2)
def graph():
try:
file_list = [
'test1.txt', 'test2.txt', 'test3.txt', 'test4.txt', 'test5.txt',
'test6.txt', 'test7.txt', 'test8.txt', 'test9.txt', 'test10.txt'
]
tailing(
'/home/chetan/Desktop/Work/gdfShikha/finalGaph/graph/src/datafiles/',
*file_list)
except ValueError:
pass
@socketio.on('connect')
def test_connect():
print('Client connected')
socketio.start_background_task(graph)
if __name__ == ("__main__"):
# socketio.run(app,host="192.168.1.62", port=5002)
socketio.run(app, host="192.168.43.188", port=8002)
from flask.app import Flask
# from flask_cors import cross_origin, CORS
from flask_socketio import SocketIO, emit, send
import socketio
# import socketio
import eventlet
from os import path
filedir = (path.dirname(path.realpath(__file__)))
from random import randint
if __name__ == "__main__":
from sys import argv
# init
app = Flask(__name__)
app.config['SECRET_KEY'] = 'jrieoy'
socketio = SocketIO(app)
@socketio.on('connection')
def handleConnection():
print("connection established")
socketio.emit('connection', broadcast=True)
socketio.run(app, port=randint(1000, 9000))
else:
emitMyRegisteration = None
for line in lines:
data=json.loads(line)
if data["type"] == "SyntheticValue":
label=data["data"]["timestamp"][11:]
y=data["data"]["PNL"]
list=[label,y]
#print(list)
socketio.emit('data1',list, broadcast=True)
if data["type"] == "SyntheticRatio":
label=data["data"]["timestamp"][11:]
y=data["data"]["PNL"]
list=[label,y]
#print(list)
socketio.emit('data2',list, broadcast=True)
socketio.sleep(20)
@socketio.on('connect')
def test_connect():
print('Client connected')
socketio.start_background_task(graph)
print("Thread Started")
if __name__ == ("__main__"):
# socketio.run(app,host="192.168.1.62", port=5002)
socketio.run(app,host="192.168.0.101", port=5000)
def __init__(self, http2interface, port):
self.http2interface = http2interface
interface_path = os.path.dirname(os.path.realpath(__file__))
www_path = os.path.join(interface_path, 'http2')
app = Flask(__name__, template_folder=www_path)
app.config['SECRET_KEY'] = 'secret!'
socketio = SocketIO(app)
#
# FLASK Routing
#
@app.route('/')
def index():
# return render_template('index.html', async_mode=socketio.async_mode)
return send_from_directory(www_path, 'index.html')
@app.route('/simple')
def simple():
return send_from_directory(www_path, 'simple.html')
@app.route('/upload', methods=['POST'])
def files_upload():
if 'file' not in request.files:
return 'No file provided', 404
file = request.files['file']
if file.filename == '':
return 'No filename provided', 404
if file and self.http2interface.hplayer.validExt(file.filename):
filename = secure_filename(file.filename)
filepath = os.path.join(
self.http2interface.hplayer.basepath[0], filename)
if os.path.exists(filepath):
prefix, ext = os.path.splitext(filepath)
filepath = prefix + '-' + ext
file.save(filepath)
try:
im = Image.load(filepath)
im.verify(
) #I perform also verify, don't know if he sees other types o defects
im.close() #reload is necessary in my case
im = Image.open(filepath)
im.thumbnail((1920, 1080), Image.ANTIALIAS)
im.save(filepath)
except IOError:
print("cannot resize", filepath)
except:
pass
fileslist_message()
self.http2interface.hplayer.add(filepath)
return 'ok'
return 'No valid file provided', 404
@app.route('/<path:path>')
def send_static(path):
return send_from_directory(www_path, path)
#
# SOCKETIO Routing
#
self.sendSettings = None
self.sendPlaylist = None
def background_thread():
while True:
socketio.emit(
'status',
self.http2interface.hplayer.players()
[0].status()) # {'msg': 'yo', 'timestamp': time.gmtime()}
if self.sendSettings is not None:
socketio.emit('settings', self.sendSettings)
self.sendSettings = None
if self.sendPlaylist is not None:
socketio.emit('playlist', self.sendPlaylist)
self.sendPlaylist = None
socketio.sleep(0.1)
@self.http2interface.hplayer.on('settings.updated')
def settings_send(ev, *args):
self.sendSettings = args[0]
@self.http2interface.hplayer.on('playlist.updated')
def playlist_send(ev, *args):
self.sendPlaylist = args[0]
@socketio.on('connect')
def client_connect():
socketio.emit('settings', self.http2interface.hplayer.settings())
socketio.emit('playlist', self.http2interface.hplayer.playlist())
socketio.emit('name', self.http2interface.hplayer.name())
global thread
with thread_lock:
if thread is None:
thread = socketio.start_background_task(
target=background_thread)
# @socketio.on('autoplay')
# def mute_message():
# self.player.autoplay(True)
# @socketio.on('audiomode')
# def audiomode_message(message=None):
# self.player.audiomode(message)
@socketio.on('reboot')
def reboot_message():
os.system('reboot')
@socketio.on('restart')
def restart_message():
self.http2interface.emit('hardreset')
@socketio.on('ping')
def ping_message():
socketio.send('pong')
@socketio.on('event')
def event_message(message=None):
if message['event']:
if 'data' in message:
self.http2interface.emit(message['event'], message['data'])
else:
self.http2interface.emit(message['event'])
@socketio.on('fileslist')
def fileslist_message():
def path_to_dict(path):
if os.path.basename(path).startswith('.'):
return None
d = {'text': os.path.basename(path), 'path': path}
if os.path.isdir(path):
n = filter(None, [
path_to_dict(os.path.join(path, x))
for x in sorted(os.listdir(path))
])
d['nodes'] = [x for x in n if x is not None]
d['backColor'] = "#EEE"
d['selectable'] = False
else:
d['selectable'] = True
d['text'] += ' <div class="media-edit float-right">'
d['text'] += ' <span class="badge badge-success" onClick="playlistAdd(\'' + path + '\'); event.stopPropagation();"> <i class="fas fa-plus"></i> </span>'
# d['text'] += ' <span class="badge badge-danger ml-2"><i class="far fa-trash-alt"></i> </span>';
d['text'] += ' </div>'
return d
liste = []
for bp in self.http2interface.hplayer.files.root_paths:
br = path_to_dict(bp)
if br is not None:
# print(br)
liste.append(br)
if len(liste) > 0 and 'nodes' in liste[0]:
socketio.emit('files', liste)
else:
socketio.emit('files', None)
@socketio.on('filesdelete')
def filesdelete_message(message=None):
# print ('delete', message)
if message:
for e in message:
e = e.replace('/..', '')
for basepath in self.http2interface.hplayer.files.root_paths:
if e.startswith(basepath):
os.remove(e)
fileslist_message()
@socketio.on('connect', namespace='/test')
def test_connect():
pass
@socketio.on('disconnect', namespace='/test')
def test_disconnect():
print('Client disconnected', request.sid)
# prepare sub-thread
self.server_thread = threading.Thread(
target=lambda: socketio.run(app, host='0.0.0.0', port=port))
self.server_thread.daemon = True
### Draw Lanes ###
### Display orig img with overlay and stuff ###
for row in reversed(range(0, img.shape[0], 2)):
for col in range(int(left_best_fit_function(row)),
int(right_best_fit_function(row)), 2):
orig_img_row = int(row / scale_down_factor)
orig_img_col = int(col / scale_down_factor)
if orig_img_col >= orig_img.shape[1] or orig_img_col < 0:
continue
orig_img[orig_img_row][orig_img_col] = (0, 255, 0)
cv.imshow("input", orig_img)
cv.imshow("output", img)
### Save Images For Deep Learning ###
cv.imwrite(
"trainingImages/{}-{}.png".format(image_increment, center_offset),
img_to_save)
if cv.waitKey(1) & 0xFF == ord('q'):
return
if __name__ == '__main__':
socketio.run(app, host="0.0.0.0", port=8080)
cap.release()
cv.destroyAllWindows()
data['room']))
leave_room(data['room'])
socketio.emit('leave_room_announcement', data, room=data['room'])
# Routes for Twilio API
@app.route("/inbound_sms", methods=['GET', 'POST'])
def inbound_sms():
response = MessagingResponse()
# Grab information from incoming SMS message
inbound_message = request.form['Body']
from_number = request.form['From']
to_number = request.form['To']
# Store the above information in a data object to pass on
data = {
'username': from_number,
'room': from_number,
'message': inbound_message
}
# Emits a received message using the above data object to the room number
socketio.emit('receive_message', data, room=from_number)
return 'message sent'
if __name__ == '__main__':
socketio.run(app, debug=True)
def main(params):
socketio.run(app, host='0.0.0.0', debug=True)
