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)