log = logging.getLogger("artemis") log.setLevel(logging.DEBUG) # create a file handler handler = logging.FileHandler("/tmp/server.log") handler.setLevel(logging.DEBUG) # create a logging format formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s") handler.setFormatter(formatter) # add the handlers to the logger log.addHandler(handler) wz_log = logging.getLogger("werkzeug") wz_log.setLevel(logging.ERROR) async_mode = "threading" sio = socketio.Server(logger=False, async_mode=async_mode) app = Flask(__name__) app.wsgi_app = socketio.Middleware(sio, app.wsgi_app) app.config["SECRET_KEY"] = "secret!" clients = set() hostname = "" thread = None @sio.on("connect") def artemis_connect(sid, environ): log.info("connect {}".format(sid)) clients.add(sid)
import eventlet import socketio sio = socketio.Server(cors_allowed_origins='*') app = socketio.WSGIApp(sio, static_files={ '/': {'content_type': 'text/html', 'filename': './index.html'} }) @sio.event def connect(sid, environ): print('connect ', sid) @sio.on('motor_command') def motor_command(sid, data): print('message ', data) delta = 0 direction = data['direction'] value = data['value'] if direction == 'left': delta -= int(value) elif direction == 'right': delta += int(value) print(f'motor_command: {direction} value: {value} delta: {delta}') @sio.on('generator_type_of_signal') def type_of_signal(sid, data): print('message ', data) type_of_signal = data['typeofSignal']
from django.utils import timezone # from engineio.payload import Payload # Payload.max_decode_packets = 500 # from django.shortcuts import render # [LIVE STREAMING]: Async mode & thread. # Set async_mode to 'threading', 'eventlet', 'gevent' or 'gevent_uwsgi' to # force a mode else, the best mode is selected automatically from what's # installed - Reference: https://github.com/miguelgrinberg/python-socketio/blob/master/examples/server/wsgi/django_example/socketio_app/views.py. async_mode = None # Asynchronous mode. sio = socketio.Server(async_mode=async_mode) thread = None def index(request): if request.user.is_authenticated: return render( request, "qr_bar_decoder/index.html", ) else: return HttpResponseRedirect(f"{reverse('login')}?next={reverse('qr_bar_decoder:index')}") @sio.event def connect(sid, environment): # "Infinite loops prevents the client connections.
file.setFormatter(formatter) logger.addHandler(file) try: config = Config() secret_key = config.read("secret_key") if not secret_key: secret_key = "".join( random.choice(string.ascii_uppercase + string.digits) for _ in range(16)) config.write("secret_key", secret_key) app.secret_key = secret_key Storage().init() sockets = socketio.Server() app.wsgi_app = socketio.Middleware(sockets, app.wsgi_app) sockets.register_namespace(Backend()) if __name__ == "__main__": if not app.debug: def open_in_browser(): logging.info("Application is starting...") url = "http://127.0.0.1:" + str(port) while True: try: request.urlopen(url=url) break except Exception:
import socketio from flask import Flask import eventlet import eventlet.wsgi from io import BytesIO import base64 from PIL import Image from keras.models import load_model import numpy as np import matplotlib.pyplot as plt import training_utils as TU server = socketio.Server() app = Flask(__name__) @server.on('connect') def connect(sid, environ): print('connect ', sid) send_control(0,0) def send_control(steering_angle, throttle): server.emit("steer", data={'steering_angle': steering_angle.__str__(), 'throttle': throttle.__str__()}, skip_sid=True) MAX_SPEED = 25 MIN_SPEED = 10 @server.on('telemetry') def telemetry(sid, data):
import logging import socketio from flask import Flask sio = socketio.Server(async_mode='eventlet', logging=logging.NullHandler) app = Flask(__name__) # client asks for data @sio.on('remote:send_request') def remote_control(sid, command): if not 'account' in command: return False bot_name = command.pop('account') event = 'bot:process_request:{}'.format(bot_name) sio.emit(event, data=command) # sending bot response to client @sio.on('bot:send_reply') def request_reply(sid, response): event = response.pop('command') account = response['account'] event = "{}:{}".format(event, account) sio.emit(event, response) @sio.on('bot:broadcast') def bot_broadcast(sid, env): event = env['event']
def init_app(self, app, **kwargs): if app is not None: if not hasattr(app, 'extensions'): app.extensions = {} # pragma: no cover app.extensions['socketio'] = self self.server_options.update(kwargs) self.manage_session = self.server_options.pop('manage_session', self.manage_session) if 'client_manager' not in self.server_options: url = self.server_options.pop('message_queue', None) channel = self.server_options.pop('channel', 'flask-socketio') write_only = app is None if url: if url.startswith(('redis://', "rediss://")): queue_class = socketio.RedisManager elif url.startswith(('kafka://')): queue_class = socketio.KafkaManager elif url.startswith('zmq'): queue_class = socketio.ZmqManager else: queue_class = socketio.KombuManager queue = queue_class(url, channel=channel, write_only=write_only) self.server_options['client_manager'] = queue if 'json' in self.server_options and \ self.server_options['json'] == flask_json: # flask's json module is tricky to use because its output # changes when it is invoked inside or outside the app context # so here to prevent any ambiguities we replace it with wrappers # that ensure that the app context is always present class FlaskSafeJSON(object): @staticmethod def dumps(*args, **kwargs): with app.app_context(): return flask_json.dumps(*args, **kwargs) @staticmethod def loads(*args, **kwargs): with app.app_context(): return flask_json.loads(*args, **kwargs) self.server_options['json'] = FlaskSafeJSON resource = self.server_options.pop('path', None) or \ self.server_options.pop('resource', None) or 'socket.io' if resource.startswith('/'): resource = resource[1:] if os.environ.get('FLASK_RUN_FROM_CLI'): if self.server_options.get('async_mode') is None: self.server_options['async_mode'] = 'threading' self.server = socketio.Server(**self.server_options) self.async_mode = self.server.async_mode for handler in self.handlers: self.server.on(handler[0], handler[1], namespace=handler[2]) for namespace_handler in self.namespace_handlers: self.server.register_namespace(namespace_handler) if app is not None: # here we attach the SocketIO middlware to the SocketIO object so # it can be referenced later if debug middleware needs to be # inserted self.sockio_mw = _SocketIOMiddleware(self.server, app, socketio_path=resource) app.wsgi_app = self.sockio_mw
eventlet.monkey_patch() elif async_mode == 'gevent': from gevent import monkey monkey.patch_all() import time from threading import Thread from flask import Flask, render_template import socketio # impor the tasks (celery) import tasks # set up the db manager to get the message from the RabbitMQ (AMQP) mgr = socketio.KombuManager('amqp://') sio = socketio.Server(client_manager=mgr, logger=True, async_mode=async_mode) app = Flask(__name__) app.wsgi_app = socketio.Middleware(sio, app.wsgi_app) app.config['SECRET_KEY'] = 'secret!' app.config['DEBUG'] = True app.debug = True thread = None def background_thread(): """Example of how to send server generated events to clients.""" count = 0 while True: time.sleep(10) count += 1 sio.emit('my response', {'data': 'Server generated event'},
import socketio from flask import Flask import json from functions import * from threading import Thread, Lock import time import shutil import math from aiohttp import web import asyncio from test_model import create_label_to_class_map, create_data_dir_result_label_map from facenet import facenet UPLOAD_FOLDER = './uploads' sio = socketio.Server(async_mode='threading') app = Flask(__name__) app.wsgi_app = socketio.WSGIApp(sio, app.wsgi_app) data_dir = 'dataset' model_path = 'models/20180402-114759.pb' batch_size = 90 image_size = 160 classifier_filename = 'models/' + sorted( filter(lambda x: 'clf' in x, os.listdir('models')))[-1] mutex = Lock() if os.path.isdir('tmp'): shutil.rmtree('tmp') os.mkdir('tmp')
import os import socketio os.environ.setdefault("DJANGO_SETTINGS_MODULE", "ahome.settings") manager = socketio.RedisManager('') sio = socketio.Server(client_manager=manager)
import eventlet import classes_pb2 import datetime import pymongo import json, ast from pymongo import MongoClient from protobuf_to_dict import protobuf_to_dict from bson import json_util # Mongo init mongoClient = MongoClient('localhost', 27017) db = mongoClient['MDsensorsDB'] # Socket init sio = socketio.Server( async_mode='eventlet', ping_timeout=10, ping_interval=2 ) # this will give us 10 seconds +- 2 precision in the disconnect. changing these value will be reflected to the client too. app = socketio.WSGIApp(sio) # Data Structure session_map = dict() last_received_data = dict( ) # ['sid' : timestamp, 'sid': timestamp] store the timestamp of the last sensor received by this sid # Functions @sio.event def connect(sid, environ): headers = environ['headers_raw'] session_map[sid] = dict() for key, value in headers:
def __init__( self, task_planner: TaskPlanner, datetime_factory: DateTimeFactory, candle_storage_plugins: CandleStoragePlugins, order_storage_plugins: OrderStoragePlugins, market_plugins: MarketPlugins, strategy_plugins: StrategyPlugins, strategy_run_storage: StrategyRunStorage, portfolio_snapshot_storage_plugins: PortfolioSnapshotStoragePlugins ): super().__init__() self._market_plugins = market_plugins self._task_planner = task_planner self._portfolio_snapshot_storage_plugins = portfolio_snapshot_storage_plugins socket = socketio.Server(async_mode='threading') @socket.on('connect') def connect(sid, environ): logger.info('Socket %s connected ', sid) @socket.on(EVENT_PING_REQUEST) def ping_request(sid, data): logger.info('RECEIVED: {}, {}'.format(EVENT_PING_REQUEST, data)) data['response_timestamp'] = datetime_factory.now().timestamp() socket.emit(EVENT_PING_RESPONSE, data) @socket.on(SOCKET_EVENT_GET_BALANCE) def balances(sid, data): logger.info('RECEIVED: {}, {}'.format(SOCKET_EVENT_GET_BALANCE, data)) if 'market_name' not in data: return 'ERROR', { 'message': 'Missing "market_name" field in request.' } if 'market_plugin_name' not in data: return 'ERROR', { 'message': 'Missing "market_plugin_name" field in request.' } market_plugin = self._market_plugins.get_plugin( data['market_plugin_name']) market = market_plugin.get_market(data['market_name'], datetime_factory, {}) return 'OK', serialize_balances(market.get_balances()) @socket.on(EVENT_GET_CANDLES) def candles(sid, data): logger.info('RECEIVED: {}, {}'.format(EVENT_GET_CANDLES, data)) if 'candle_storage' not in data: return 'ERROR', { 'message': 'Missing "candle_storage" field in request.' } candle_storage = candle_storage_plugins.get_candle_storage( data['candle_storage']) result_candles = candle_storage.find_by( data['market'], deserialize_pair(data['pair']), deserialize_datetime_interval(data['interval']), candle_size=deserialize_candle_size(data['candle_size'])) return 'OK', serialize_candles(result_candles) @socket.on(EVENT_GET_MARKET_PLUGINS) def market_plugins(sid, data): logger.info('RECEIVED: {}, {}'.format(EVENT_GET_MARKET_PLUGINS, data)) result = [] for plugin in self._market_plugins.get_available_market_plugins(): result.append({ 'name': plugin.get_name(), }) return 'OK', result @socket.on(EVENT_GET_MARKETS) def markets(sid, data): logger.info('RECEIVED: {}, {}'.format(EVENT_GET_MARKETS, data)) plugin = self._market_plugins.get_plugin( data['market_plugin_name']) result = [] for market_name in plugin.get_available_markets(): market_class = plugin.get_market_class(market_name) result.append({ 'name': market_name, 'configuration_structure': market_class.get_configuration_structure(), }) return 'OK', result @socket.on(EVENT_GET_PAIRS) def pairs(sid, data): logger.info('RECEIVED: {}, {}'.format(EVENT_GET_PAIRS, data)) if 'market_name' not in data: return 'ERROR', { 'message': 'Missing "market_name" field in request.' } if 'market_plugin_name' not in data: return 'ERROR', { 'message': 'Missing "market_plugin_name" field in request.' } market_plugin = self._market_plugins.get_plugin( data['market_plugin_name']) market = market_plugin.get_market(data['market_name'], datetime_factory, {}) return 'OK', list( map( lambda pair: { 'key': serialize_pair(pair), 'name': pair.base_currency + '-' + pair.market_currency }, market.get_all_tradable_pairs())) @socket.on(EVENT_GET_CANDLE_STORAGES) def candle_storages(sid, data): logger.info('RECEIVED: {}, {}'.format(EVENT_GET_CANDLE_STORAGES, data)) return 'OK', list( map(lambda storage_name: {'name': storage_name}, candle_storage_plugins.get_available_candle_storages())) @socket.on(EVENT_GET_ORDER_STORAGES) def order_storages(sid, data): logger.info('RECEIVED: {}, {}'.format(EVENT_GET_ORDER_STORAGES, data)) return 'OK', list( map(lambda storage_name: {'name': storage_name}, order_storage_plugins.get_available_order_storages())) @socket.on(EVENT_GET_STRATEGIES) def strategies(sid, data): logger.info('RECEIVED: {}, {}'.format(EVENT_GET_STRATEGIES, data)) result = [] for market_name in strategy_plugins.get_available_strategies(): strategy_class = strategy_plugins.get_strategy_class( market_name) result.append({ 'name': market_name, 'configuration_structure': strategy_class.get_configuration_structure(), }) return 'OK', result @socket.on(EVENT_GET_ORDERS) def orders(sid, data): logger.info('RECEIVED: {}, {}'.format(EVENT_GET_ORDERS, data)) if 'order_storage' not in data: return 'ERROR', { 'message': 'Missing "order_storage" field in request.' } order_storage = order_storage_plugins.get_order_storage( data['order_storage']) strategy_run_id = data[ 'strategy_run_id'] if 'strategy_run_id' in data else None result_orders = order_storage.find_by( data['market'], deserialize_pair(data['pair']), interval=deserialize_datetime_interval(data['interval']), strategy_run_id=strategy_run_id) result_data = serialize_orders(result_orders) if strategy_run_id is not None: # Todo: Make this configurable, see https://github.com/Achse/coinrat/issues/47 portfolio_snapshot_storage = self._portfolio_snapshot_storage_plugins \ .get_portfolio_snapshot_storage('influx_db') snapshots = portfolio_snapshot_storage.get_for_strategy_run( strategy_run_id) for row in result_data: row['portfolio_snapshot'] = serialize_portfolio_snapshot( snapshots[row[ORDER_FIELD_ORDER_ID]]) return 'OK', result_data @socket.on(EVENT_GET_STRATEGY_RUNS) def strategy_runs(sid, data): logger.info('RECEIVED: {}, {}'.format(EVENT_GET_STRATEGY_RUNS, data)) return 'OK', serialize_strategy_runs( strategy_run_storage.find_by()) @socket.on(EVENT_CLEAR_ORDERS) def clear_orders(sid, data): logger.info('RECEIVED: {}, {}'.format(EVENT_CLEAR_ORDERS, data)) if 'order_storage' not in data: return 'ERROR', { 'message': 'Missing "order_storage" field in request.' } order_storage = order_storage_plugins.get_order_storage( data['order_storage']) order_storage.delete_by(data['market'], deserialize_pair(data['pair']), interval=deserialize_datetime_interval( data['interval'])) return 'OK' @socket.on(EVENT_RUN_REPLY) def reply(sid, data): logger.info('Received Strategy REPLAY request: ' + json.dumps(data)) self._task_planner.plan_replay_strategy(data) return 'OK' @socket.on('disconnect') def disconnect(sid): logger.info('Socket %s disconnect ', sid) self._socket = socket
from rest_framework.exceptions import NotFound from rest_framework.response import Response from rest_framework.generics import GenericAPIView from rest_framework.permissions import IsAuthenticated from config import settings from users.models import User from users.serializers import UserSerializer, LoginSerializer from users.permissions import IsCurrentOrReadOnly static_files = { '/static': './drf-yasg', } async_mode = None basedir = Path(__file__).resolve().parent sio = socketio.Server(async_mode='eventlet', static_files=static_files) def index(_request): return HttpResponse(open(basedir.joinpath('static/index.html'))) @sio.event def connect(sid, environ): print("connect ", sid) class CreateUserView(GenericAPIView): serializer_class = UserSerializer permission_classes = (IsAuthenticated, )
def __init__(self, config, mongo): self.app = Flask(__name__) self.app.config['yada_config'] = config self.app.config['yada_mongo'] = mongo self.app.debug = True self.app.secret_key = '23ljk2l9a08sd7f09as87df09as87df3k4j' CORS(self.app, supports_credentials=True) endpoints.BaseGraphView.get_base_graph = self.get_base_graph self.app.add_url_rule( '/transaction', view_func=endpoints.TransactionView.as_view('transaction'), methods=['GET', 'POST']) self.app.add_url_rule('/get-graph-info', view_func=endpoints.GraphView.as_view('graph'), methods=['GET', 'POST']) self.app.add_url_rule( '/get-graph-sent-friend-requests', view_func=endpoints.GraphSentFriendRequestsView.as_view( 'graphsentfriendrequests'), methods=['GET', 'POST']) self.app.add_url_rule( '/get-graph-friend-requests', view_func=endpoints.GraphFriendRequestsView.as_view( 'graphfriendrequests'), methods=['GET', 'POST']) self.app.add_url_rule( '/get-graph-friends', view_func=endpoints.GraphFriendsView.as_view('graphfriends'), methods=['GET', 'POST']) self.app.add_url_rule( '/get-graph-posts', view_func=endpoints.GraphPostsView.as_view('graphposts'), methods=['GET', 'POST']) self.app.add_url_rule( '/get-graph-messages', view_func=endpoints.GraphMessagesView.as_view('graphmessages'), methods=['GET', 'POST']) self.app.add_url_rule('/get-graph-new-messages', view_func=endpoints.GraphNewMessagesView.as_view( 'graphnewmessages'), methods=['GET', 'POST']) self.app.add_url_rule( '/get-graph-comments', view_func=endpoints.GraphCommentsView.as_view('get-comments'), methods=['POST']) self.app.add_url_rule( '/get-graph-reacts', view_func=endpoints.GraphReactsView.as_view('get-reacts'), methods=['POST']) self.app.add_url_rule( '/get-graph-wallet', view_func=endpoints.RidWalletView.as_view('get-wallet')) self.app.add_url_rule('/wallet', view_func=endpoints.WalletView.as_view('wallet')) self.app.add_url_rule('/faucet', view_func=endpoints.FaucetView.as_view('faucet')) self.app.add_url_rule( '/pool', view_func=endpoints.MiningPoolView.as_view('pool')) self.app.add_url_rule( '/pool-submit', view_func=endpoints.MiningPoolSubmitView.as_view('poolsubmit'), methods=['GET', 'POST']) self.app.add_url_rule( '/pool-explorer', view_func=endpoints.MiningPoolExplorerView.as_view( 'pool-explorer')) self.app.add_url_rule( '/get-block', view_func=endpoints.GetBlockByHashView.as_view('get-block'), methods=['GET']) self.app.add_url_rule( '/getblockheight', view_func=endpoints.GetBlockHeightView.as_view('get-block-height')) self.app.add_url_rule( '/newtransaction', view_func=endpoints.NewTransactionView.as_view('new-transaction'), methods=['POST']) self.app.add_url_rule( '/newblock', view_func=endpoints.NewBlockView.as_view('new-block'), methods=['POST']) self.app.add_url_rule( '/get-blocks', view_func=endpoints.GetBlocksView.as_view('get-blocks-range')) self.app.add_url_rule( '/create-raw-transaction', view_func=endpoints.CreateRawTransactionView.as_view( 'create-raw-transaction'), methods=['POST']) self.app.add_url_rule( '/sign-raw-transaction', view_func=endpoints.SignRawTransactionView.as_view( 'sign-raw-transaction'), methods=['POST']) self.app.add_url_rule( '/generate-wallet', view_func=endpoints.GenerateWalletView.as_view('generate-wallet')) self.app.add_url_rule( '/generate-child-wallet', view_func=endpoints.GenerateChildWalletView.as_view( 'generate-child-wallet'), methods=['POST']) self.app.add_url_rule( '/explorer-search', view_func=endpoints.ExplorerSearchView.as_view('explorer-search')) self.app.add_url_rule( '/get-latest-block', view_func=endpoints.GetLatestBlockView.as_view('get-latest-block')) self.app.add_url_rule( '/register', view_func=endpoints.RegisterView.as_view('register')) self.app.add_url_rule( '/create-relationship', view_func=endpoints.CreateRelationshipView.as_view( 'create-relationship'), methods=['POST']) self.app.add_url_rule('/post-fastgraph-transaction', view_func=endpoints.PostFastGraphView.as_view( 'post-fastgraph-transaction'), methods=['POST']) self.app.add_url_rule( '/yada_config.json', view_func=endpoints.GetYadaConfigView.as_view('yada-config')) self.app.add_url_rule( '/login', view_func=endpoints.GetSiginCodeView.as_view('login')) self.app.add_url_rule('/', view_func=endpoints.HomeView.as_view('home')) self.app.add_url_rule('/search', view_func=endpoints.SearchView.as_view('search')) self.app.add_url_rule('/react', view_func=endpoints.ReactView.as_view('react'), methods=['POST']) self.app.add_url_rule( '/comment-react', view_func=endpoints.CommentReactView.as_view('comment-react'), methods=['POST']) self.app.add_url_rule('/get-comment-reacts', view_func=endpoints.GetCommentReactsView.as_view( 'get-comment-reacts'), methods=['POST']) self.app.add_url_rule( '/get-comment-reacts-detail', view_func=endpoints.GetCommentReactsDetailView.as_view( 'get-comment-reacts-detail'), methods=['POST']) self.app.add_url_rule( '/comment', view_func=endpoints.CommentView.as_view('comment'), methods=['POST']) sio = socketio.Server(async_mode='gevent') sio.register_namespace(endpoints.BlockchainSocketServer('/chat')) socketio.Middleware(sio, self.app)
import eventlet import socketio from arduino import MIS_Arduino from threading import Lock from time import sleep import json # create the arduino object and lock arduino = MIS_Arduino("/dev/ttyACM0", 11520) lockduino = Lock() # creates the socket.IO and relative server sio = socketio.Server(async_mode='eventlet') app = socketio.WSGIApp(sio) def send_reading(): ' helper function to keep sending data over the socket.io ' while True: if arduino.sent == False: with lockduino: msg = arduino.state_dict() sio.emit("status", msg, to=sid) #print("SENT: ", msg) eventlet.sleep(0) # connection event @sio.event def connect(sid, environ):
#Runs on Python 2.7 #On raspberry pi , install pip first from the python-dev apt package . http://raspberry.io/wiki/how-to-get-python-on-your-raspberrypi/ #Install Dependencies: #sudo pip install python-socketio flask eventlet flask-cors flask-sslify flask-login pyserial future async_mode = 'eventlet' import time, json, random, string, pickle from flask import Flask, render_template import socketio sio = socketio.Server(logger=True, async_mode=async_mode) app = Flask(__name__) app.wsgi_app = socketio.Middleware(sio, app.wsgi_app) app.config['SECRET_KEY'] = '3Eu7r{w4zBt>ktx?$LgXVgVs7m;*86yX,j2mz7M8>JMzi$2MC;' file_thread = None resetter_thread = None values = { 'max_depth': 135, 'stroke_length': 15, 'min_delay': 0.5, 'max_delay': 0.5, 'max_speed': 8, 'min_speed': 8, 'speed_step': 5, 'on_off': 0, 'go_zero': 0, 'go_min': 0, 'go_max': 0, 'mode': 0,
def create_app(script_info=None): engineio_logger = logging.getLogger("EngineIO") socketio_logger = logging.getLogger("SocketioIO") engineio_logger.setLevel(logging.WARNING) socketio_logger.setLevel(logging.WARNING) socketIO = socketio.Server(ping_timeout=600, logger=socketio_logger, engineio_logger=engineio_logger) # instantiate the app app = Flask(__name__) app.wsgi_app = socketio.WSGIApp(socketIO, app.wsgi_app) # WebSocket app.config['SECRET_KEY'] = 'secret!' # workflow instance with tasks stack flow = Workflow() # worker manager/explorer hr = Recruit(flow, socketIO) hr.status() # Front-end clients front_clients = [] # ---------------------------------------- HTTP @app.route('/') def index(): return jsonify({ 'index': 'Please stand by!', 'workers': str(hr.workers), "results": hr.result, 'stack': hr.flow.get_stack(), 'front-end': front_clients }), 200 # -------------------------------------- EVENTS # #------------- Main-node events ------------------ # @socketIO.on('ping', namespace='/main_node') def main_ping(self, *params): print("\tReceived ping from main node. Arguments:", params) socketIO.emit("ping_response", hr.workers, namespace='/main_node') @socketIO.on('add_tasks', namespace='/main_node') def add_tasks_event(self, tasks): if len(tasks) > 0: print('Received new tasks: %s' % len(tasks)) try: id_list, task_list = task_parser(tasks) for item in task_list: hr.new_task(item) socketIO.emit('task_accepted', id_list, namespace='/main_node') except Exception as error: logging.error( "ERROR '%s' in parsing received task, nothing will be added to task stack. " % error) logging.error("Received task: " % tasks) socketIO.emit("wrong_task_structure", tasks, namespace='/main_node') @socketIO.on('terminate_tasks', namespace='/main_node') def terminate_tasks_event(self, ids): print("Terminating tasks: %s" % str(ids)) for task_id in ids: socketIO.emit("terminate", task_id, namespace="/worker_management") #------------- Workers management events ------------------ # # Checking if worker confirm a task @socketIO.on('assign', namespace='/worker_management') def task_confirm(sid, data): hr.task_confirm(data) # Listen to the results from the worker @socketIO.on('result', namespace='/worker_management') def handle_result(sid, json): temp_id = hr.analysis_res(json) if temp_id is not None: socketIO.emit('task_results', json, namespace='/main_node') @socketIO.on('register_worker', namespace='/worker_management') def register(sid): hr.workers.append(sid) print('Worker ' + sid + ' has been registered at Worker Service') socketIO.emit('reg_response', namespace='/worker_management', room=sid) return 'Server confirmed registration' @socketIO.on('unregister_worker', namespace='/worker_management') def unregister(sid): hr.workers.remove(sid) # ------------ General events -------------------- # # managing array with curent workers @socketIO.on('connect') def connected(sid, environ): print(sid + ' has been connected to Worker Service') @socketIO.on('disconnect') def disconnect(sid): print(sid + 'has been disconnected from Worker Service') if (hr.workers.__contains__(sid)): hr.workers.remove(sid) @socketIO.on('ping') def ping_pong(sid, data): print(' Ping from: ' + str(sid)) socketIO.emit("ping") return socketIO, app
def drive_sim_car(model, path_images_save, set_speed): """ Function wrapper to make script callable. Inputs ---------- model: Keras sequential model Keras model object path_images_save: str Path specifying where recorded images should be saved. set_speed: int Initial speed value for the simulator. Outputs ------- N/A """ sio = socketio.Server() class SimplePIController: def __init__(self, Kp, Ki): self.Kp = Kp self.Ki = Ki self.set_point = 0. self.error = 0. self.integral = 0. def set_desired(self, desired): self.set_point = desired def update(self, measurement): # proportional error self.error = self.set_point - measurement # integral error self.integral += self.error return self.Kp * self.error + self.Ki * self.integral @sio.on('telemetry') def telemetry(sid, data): if data: # The current steering angle of the car steering_angle = data["steering_angle"] # The current throttle of the car throttle = data["throttle"] # The current speed of the car speed = data["speed"] # The current image from the center camera of the car imgString = data["image"] image = Image.open(BytesIO(base64.b64decode(imgString))) image_array = np.asarray(image) # Prepare image for use by a model image_array = prepare_image(image_array) steering_angle = float( model.predict(image_array[None, :, :, :], batch_size=1)) throttle = controller.update(float(speed)) # Slow down on hard turns. if abs(steering_angle) >= 0.55: throttle = 0.1 print(steering_angle, throttle) send_control(steering_angle, throttle) # save frame if path_images_save != '': timestamp = datetime.utcnow().strftime( '%Y_%m_%d_%H_%M_%S_%f')[:-3] image_filename = path_join(path_images_save, timestamp) image.save('{}.jpg'.format(image_filename)) else: # NOTE: DON'T EDIT THIS. sio.emit('manual', data={}, skip_sid=True) @sio.on('connect') def connect(sid, environ): print("connect ", sid) send_control(0, 0) def send_control(steering_angle, throttle): sio.emit("steer", data={ 'steering_angle': steering_angle.__str__(), 'throttle': throttle.__str__() }, skip_sid=True) app = Flask(__name__) controller = SimplePIController(0.1, 0.002) controller.set_desired(set_speed) # Wrap Flask application with engineio's middleware app = socketio.Middleware(sio, app) # Deploy as an eventlet WSGI server eventlet.wsgi.server(eventlet.listen(('', 4567)), app)
import time import numpy as np import gc from .hdanalysis.modules import * from .hdanalysis.core import * #### for file upload #### from werkzeug.utils import secure_filename app = Flask(__name__, static_folder='../js/static') #mgr = socketio.RedisManager('redis://') sio = socketio.Server(ping_timeout=12000, ping_interval=12000, cors_allowed_origins='*') #, client_manager=mgr) fApp = socketio.Middleware(sio, app) registry = ModuleUIRegistry(sio) UPLOAD_FOLDER = "upload" ALLOWED_EXTENSIONS = set(['txt', 'csv', 'db', 'rearray', 'pts']) app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER layoutConfig = None class nddav: processes = {}
#!/usr/bin/env python import eventlet eventlet.monkey_patch(socket=True, select=True, time=True) import eventlet.wsgi import socketio import time from flask import Flask, render_template from bridge import Bridge from conf import conf sio = socketio.Server(pingInterval=1000000, pingTimeout=1000000) app = Flask(__name__) msgs = [] dbw_enable = False @sio.on('connect') def connect(sid, environ): print("connect ", sid) def send(topic, data): msgs.append((topic, data)) #sio.emit(topic, data=json.dumps(data), skip_sid=True) bridge = Bridge(conf, send)
session = Session() noip_config = session.query(Option).filter_by(name="network", section="dyndns").first() if noip_config: noip_config = json.loads(noip_config.value) if noip_config and noip_config.get("restrict_host", False) and noip_config.get("hostname", None): allowed_origins = f"https://{noip_config['hostname']}" else: allowed_origins = "*" if len(allowed_origins) == 1: allowed_origins = allowed_origins[0] sio = socketio.Server(async_mode="threading", cors_allowed_origins=allowed_origins) logger = logging.getLogger(LOG_SOCKETIO) logging.getLogger("werkzeug").setLevel(logging.DEBUG) def start_socketio(): logger.info("Server CORS allowed on '%s'", allowed_origins) app = Flask(__name__) # wrap Flask application with socketio's middleware app.wsgi_app = socketio.WSGIApp(sio, app.wsgi_app) # start on a thread to avoid blocking the main thread (health check) Thread(target=app.run, kwargs={ "threaded": True, "debug": False, # avoid starting application twice in development
from flask import Flask import socketio import eventlet import json import reverse_geocode from countryinfo import CountryInfo with open('server_config.json') as json_data_file: data_server = json.load(json_data_file) SERVER = data_server.get('server') APP = Flask(__name__) SIO = socketio.Server() @SIO.on('connect') def on_connect(sid, data): print('user connected ' + sid) @SIO.on('handleLatLng') def on_handleLatLng(sid, data): coordinates = (data.get('lat'), data.get('lng')), location_info = reverse_geocode.search(coordinates)[0] country = location_info.get('country') try: country_info = CountryInfo(country).info() except: country_info = 'Unknow Country' SIO.emit('country_info', {
#!/usr/bin/env python from gevent import pywsgi from geventwebsocket.handler import WebSocketHandler import socketio import time from bridge import Bridge from conf import conf sio = socketio.Server(async_mode='gevent') msgs = [] dbw_enable = False @sio.on('connect') def connect(sid, environ): print("connect ", sid) def send(topic, data): sio.emit(topic, data=data, skip_sid=True) bridge = Bridge(conf, send) @sio.on('telemetry') def telemetry(sid, data): global dbw_enable if data["dbw_enable"] != dbw_enable: dbw_enable = data["dbw_enable"] bridge.publish_dbw_status(dbw_enable)
from django.core.management.base import BaseCommand import socketio import eventlet from django.core.exceptions import ObjectDoesNotExist import threading from main.models import UserProfile, UserConnection eventlet.monkey_patch() mgr = socketio.RedisManager('redis://localhost:6379/0') sio = socketio.Server(cors_allowed_origins='*', async_mode='eventlet', client_manager=mgr) app = socketio.WSGIApp(sio) def add_user_task(sid, data): try: user = UserProfile.objects.get(login=data['login']) except ObjectDoesNotExist: print('No user') user = UserProfile() user.login = data['login'] user.save() con = UserConnection() con.user = user con.sid = sid con.save() UserConnection.check_online(user) def remove_connection_task(sid):
import engineio import eventlet import json from pomodoro import * # app = Flask(__name__) # app.config['SECRET_KEY'] = 'secret!' # app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 0 # Client that connects to the main server that serves all players client = socketio.Client() client.connect("http://localhost:3000") # Server that opens the connection to the JS display interface server = socketio.Server(logger=True) server_app = socketio.WSGIApp(server, static_files={ '/': {'content_type': 'text/html', 'filename': 'index.html'}, '/static/assets/stylesheets/milligram.min.css': { 'content_type': 'text/css', 'filename': 'static/assets/stylesheets/milligram.min.css', }, '/static/assets/stylesheets/normalize.css': { 'content_type': 'text/css', 'filename': 'static/assets/stylesheets/normalize.css', }, '/static/assets/stylesheets/style.css': { 'content_type': 'text/css', 'filename': 'static/assets/stylesheets/style.css', }, '/static/client.js': {
import socketio import eventlet import multiprocessing as mp from .dection import * sio = socketio.Server(cors_allowed_origins="http://localhost:8080") app = socketio.WSGIApp(sio) from .events import * def start_server(): eventlet.wsgi.server(eventlet.listen(("", 5000)), app) def run(): processes = [ mp.Process(target=start_server), mp.Process(target=connect_to_server) ] [p.start() for p in processes] [p.join() for p in processes]
def blueprint(self, on_new_message): sio = socketio.Server() socketio_webhook = WebappBlueprint(sio, self.socketio_path, "socketio_webhook", __name__) @socketio_webhook.route("/", methods=["GET"]) def health(): """A simple check to see if the service is running.""" return jsonify({"status": "ok"}) @socketio_webhook.route("/export", methods=["GET"]) def export(): """Endpoint exposing an export to retrieve all stored conversations.""" attachment_filename = "conversations_{}.zip".format( datetime.datetime.now().strftime("%Y%m%d%H%M%S")) zip_filename = self.conversation_logger_manager.export() return send_file(zip_filename, mimetype="application/zip", attachment_filename=attachment_filename, as_attachment=True) @sio.on("connect", namespace=self.namespace) def connect(sid, environ): logger.debug("User {} connected to socketio endpoint.".format(sid)) @sio.on("disconnect", namespace=self.namespace) def disconnect(sid): logger.debug("User {} disconnected from socketio endpoint." "".format(sid)) @sio.on(self.user_message_evt, namespace=self.namespace) def handle_message(sid, data): """Called whenever the socket receives a message from the user.""" participant_id = data["participant_id"] user_text = data["message"] message_id = data["message_id"] # Creates an instance of the conversational logger and logs message conversation_logger = self.conversation_logger_manager.create(sid, participant_id) conversation_logger.user_sent_message(user_text) language_errors = [] lt_response = None try: # Extract entities from the message nlu_response = self.nlu_api.parse(user_text) nlu_entities = nlu_response["entities"] # Check if text contains error lt_response = self.languagetool_api.check(user_text) # Ignore hesitation errors and errors that are entities lt_response.ignore_hesitation_errors() lt_response.ignore_entity_errors(nlu_entities, ["name"]) language_errors = lt_response.errors_to_dict() except (TypeError, ValueError): logger.debug("Error occurred using LanguageTool") output_channel = WebappOutput( sio, self.bot_message_evt, conversation_logger, language_errors) if len(language_errors) > 0: # Send found errors to the client output_channel.send_language_errors( sid, message_id, language_errors) if lt_response != None and lt_response.error_ratio() >= 0.25: # Circumvent the chatbot if the ratio is to high output_channel.send_text_message( sid, "I am afraid I have trouble understanding. Please could you rephrase?") else: # No error found, pass user message to bot message = UserMessage( user_text, output_channel, sid, input_channel=self.name()) on_new_message(message) return socketio_webhook
import socketio # 由于不启动flask服务测试,就直接把数据拿过来用了 RABBITMQ = 'amqp://*****:*****@localhost:5672/toutiao' # 创建socketIO.manager对象,以便socketIO从中间件提取数据 # mgr = socketio.KombuManager(current_app.config['RABBITMQ']) mgr = socketio.KombuManager(RABBITMQ) # 创建socketIO对象 # async_mode 告知socketio 服务器使用eventlet 协程服务器来托管运行 sio = socketio.Server(async_mode='eventlet', client_manager=mgr) app = socketio.Middleware(sio)
# -*- coding: utf-8 -*- import os, cv2, socketio, base64, shutil, eventlet.wsgi import numpy as np from keras.models import load_model from flask import Flask from PIL import Image from io import BytesIO from datetime import datetime from keras.preprocessing.image import array_to_img # socketio sio = socketio.Server() # ------图像预处理------------- # 除去顶部的天空和底部的汽车正面 def crop(image): return image[60:-25, :, :] # 调整图像大小 def resize(image): return cv2.resize(image, (IMAGE_WIDTH, IMAGE_HEIGHT), cv2.INTER_AREA) # 转换RGB为YUV格式 def rgb2yuv(image): return cv2.cvtColor(image, cv2.COLOR_RGB2YUV)
""" import numpy as np import argparse import socketio import eventlet import base64 from keras.models import load_model from flask import Flask from PIL import Image from io import BytesIO from helper import preprocess socket = socketio.Server() app = Flask(__name__) model = None max_speed = 16 min_speed = 6 speed_limit = max_speed @socket.on('connect') def connect(sid, environ): print('connected: ', sid) send_control(0, 0)