async def shutdown(background_tasks: BackgroundTasks,
authorization: Optional[str] = Header(None)):
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
background_tasks.add_task(jh.terminate_app)
return JSONResponse({'message': 'Shutting down...'})
async def websocket_endpoint(websocket: WebSocket, token: str = Query(...)):
from jesse.services.multiprocessing import process_manager
from jesse.services.env import ENV_VALUES
if not authenticator.is_valid_token(token):
return
await websocket.accept()
queue = Queue()
ch, = await async_redis.psubscribe(f"{ENV_VALUES['APP_PORT']}:channel:*")
async def echo(q):
while True:
msg = await q.get()
msg = json.loads(msg)
msg['id'] = process_manager.get_client_id(msg['id'])
await websocket.send_json(msg)
async def reader(channel, q):
async for ch, message in channel.iter():
# modify id and set the one that the font-end knows
await q.put(message)
asyncio.get_running_loop().create_task(reader(ch, queue))
asyncio.get_running_loop().create_task(echo(queue))
try:
while True:
# just so WebSocketDisconnect would be raised on connection close
await websocket.receive_text()
except WebSocketDisconnect:
await async_redis.punsubscribe(f"{ENV_VALUES['APP_PORT']}:channel:*")
print('Websocket disconnected')
def live(
request_json: LiveRequestJson,
authorization: Optional[str] = Header(None)
) -> JSONResponse:
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse import validate_cwd
# dev_mode is used only by developers so it doesn't have to be a supported parameter
dev_mode: bool = False
validate_cwd()
# execute live session
from jesse_live import live_mode
from jesse.services.multiprocessing import process_manager
trading_mode = 'livetrade' if request_json.paper_mode is False else 'papertrade'
process_manager.add_task(
live_mode.run,
f'{trading_mode}-' + str(request_json.id),
request_json.debug_mode,
dev_mode,
request_json.config,
request_json.routes,
request_json.extra_routes,
trading_mode,
)
mode = 'live' if request_json.paper_mode is False else 'paper'
return JSONResponse({'message': f"Started {mode} trading..."},
status_code=202)
async def terminate_all(authorization: Optional[str] = Header(None)):
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.services.multiprocessing import process_manager
process_manager.flush()
return JSONResponse({'message': 'terminating all tasks...'})
def make_strategy(
json_request: NewStrategyRequestJson,
authorization: Optional[str] = Header(None)
) -> JSONResponse:
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.services import strategy_maker
return strategy_maker.generate(json_request.name)
def feedback(
json_request: FeedbackRequestJson,
authorization: Optional[str] = Header(None)
) -> JSONResponse:
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.services import jesse_trade
return jesse_trade.feedback(json_request.description, json_request.email)
def download_optimization_log(token: str = Query(...)):
"""
Optimization logs don't have have session ID
"""
if not authenticator.is_valid_token(token):
return authenticator.unauthorized_response()
from jesse.modes import data_provider
return data_provider.download_file('optimize', 'log')
def update_config(json_request: ConfigRequestJson,
authorization: Optional[str] = Header(None)):
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.modes.data_provider import update_config as uc
uc(json_request.current_config)
return JSONResponse({'message': 'Updated configurations successfully'},
status_code=200)
def general_info(authorization: Optional[str] = Header(None)) -> JSONResponse:
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.modes import data_provider
try:
data = data_provider.get_general_info(has_live=HAS_LIVE_TRADE_PLUGIN)
except Exception as e:
return JSONResponse({'error': str(e)}, status_code=500)
return JSONResponse(data, status_code=200)
def get_config(json_request: ConfigRequestJson,
authorization: Optional[str] = Header(None)):
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.modes.data_provider import get_config as gc
return JSONResponse(
{
'data': gc(json_request.current_config,
has_live=HAS_LIVE_TRADE_PLUGIN)
},
status_code=200)
def download(mode: str,
file_type: str,
session_id: str,
token: str = Query(...)):
"""
Log files require session_id because there is one log per each session. Except for the optimize mode
"""
if not authenticator.is_valid_token(token):
return authenticator.unauthorized_response()
from jesse.modes import data_provider
return data_provider.download_file(mode, file_type, session_id)
def report_exception(
json_request: ReportExceptionRequestJson,
authorization: Optional[str] = Header(None)
) -> JSONResponse:
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.services import jesse_trade
return jesse_trade.report_exception(json_request.description,
json_request.traceback,
json_request.mode,
json_request.attach_logs,
json_request.session_id,
json_request.email,
has_live=HAS_LIVE_TRADE_PLUGIN)
def cancel_backtest(request_json: CancelRequestJson,
authorization: Optional[str] = Header(None)):
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.services.multiprocessing import process_manager
process_manager.cancel_process('backtest-' + request_json.id)
return JSONResponse(
{
'message':
f'Backtest process with ID of {request_json.id} was requested for termination'
},
status_code=202)
def get_orders(
json_request: GetOrdersRequestJson,
authorization: Optional[str] = Header(None)
) -> JSONResponse:
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse_live.services.data_provider import get_orders as go
arr = go(json_request.session_id)
return JSONResponse({
'id': json_request.id,
'data': arr
},
status_code=200)
def cancel_backtest(request_json: LiveCancelRequestJson,
authorization: Optional[str] = Header(None)):
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.services.multiprocessing import process_manager
trading_mode = 'livetrade' if request_json.paper_mode is False else 'papertrade'
process_manager.cancel_process(f'{trading_mode}-' + request_json.id)
return JSONResponse(
{
'message':
f'Live process with ID of {request_json.id} terminated.'
},
status_code=200)
def import_candles(
request_json: ImportCandlesRequestJson,
authorization: Optional[str] = Header(None)
) -> JSONResponse:
from jesse.services.multiprocessing import process_manager
validate_cwd()
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.modes import import_candles_mode
process_manager.add_task(import_candles_mode.run,
'candles-' + str(request_json.id),
request_json.exchange, request_json.symbol,
request_json.start_date, True)
return JSONResponse({'message': 'Started importing candles...'},
status_code=202)
def get_candles(
json_request: GetCandlesRequestJson,
authorization: Optional[str] = Header(None)
) -> JSONResponse:
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse import validate_cwd
validate_cwd()
from jesse.modes.data_provider import get_candles as gc
arr = gc(json_request.exchange, json_request.symbol,
json_request.timeframe)
return JSONResponse({
'id': json_request.id,
'data': arr
},
status_code=200)
def backtest(request_json: BacktestRequestJson,
authorization: Optional[str] = Header(None)):
from jesse.services.multiprocessing import process_manager
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
validate_cwd()
from jesse.modes.backtest_mode import run as run_backtest
process_manager.add_task(run_backtest, 'backtest-' + str(request_json.id),
request_json.debug_mode, request_json.config,
request_json.routes, request_json.extra_routes,
request_json.start_date, request_json.finish_date,
None, request_json.export_chart,
request_json.export_tradingview,
request_json.export_full_reports,
request_json.export_csv, request_json.export_json)
return JSONResponse({'message': 'Started backtesting...'}, status_code=202)
async def optimization(request_json: OptimizationRequestJson,
authorization: Optional[str] = Header(None)):
if not authenticator.is_valid_token(authorization):
return authenticator.unauthorized_response()
from jesse.services.multiprocessing import process_manager
validate_cwd()
from jesse.modes.optimize_mode import run as run_optimization
process_manager.add_task(run_optimization,
'optimize-' + str(request_json.id),
request_json.debug_mode, request_json.config,
request_json.routes, request_json.extra_routes,
request_json.start_date, request_json.finish_date,
request_json.optimal_total,
request_json.export_csv, request_json.export_json)
# optimize_mode(start_date, finish_date, optimal_total, cpu, csv, json)
return JSONResponse({'message': 'Started optimization...'},
status_code=202)