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)
