intelligent-trading-bot/service/server.py

import os
import sys
import math, time
from datetime import datetime
from decimal import *
import click

import asyncio

from apscheduler.schedulers.asyncio import AsyncIOScheduler

from service.App import *
from common.utils import *
from service.collector import *
from service.analyzer import *
from service.notifier import *
from service.trader import *

import logging

log = logging.getLogger('server')


#
# Main procedure
#

async def main_task():
    """This task will be executed regularly according to the schedule"""
    res = await main_collector_task()
    if res:
        return res

    # TODO: Validation
    #last_kline_ts = App.analyzer.get_last_kline_ts(symbol)
    #if last_kline_ts + 60_000 != startTime:
    #    log.error(f"Problem during analysis. Last kline end ts {last_kline_ts + 60_000} not equal to start of current interval {startTime}.")

    # Generate signals (derived features, predictions)
    try:
        analyze_task = await App.loop.run_in_executor(None, App.analyzer.analyze)
    except Exception as e:
        print(f"Error while analyzing data: {e}")
        return
    # Signal is stored in App.signal

    if "notify" in App.config["actions"]:
        notify_task = App.loop.create_task(notify_telegram())

    # Now we have a list of signals and can make trade decisions using trading logic and trade
    if "trade" in App.config["actions"]:
        trade_task = App.loop.create_task(main_trader_task())

    return


@click.command()
@click.option('--config_file', '-c', type=click.Path(), default='', help='Configuration file name')
def start_server(config_file):

    load_config(config_file)

    symbol = App.config["symbol"]

    print(f"Initializing server. Trade pair: {symbol}. ")

    #getcontext().prec = 8

    #
    # Validation
    #

    #
    # Connect to the server and update/initialize the system state
    #
    App.client = Client(api_key=App.config["api_key"], api_secret=App.config["api_secret"])

    App.analyzer = Analyzer(App.config)

    App.loop = asyncio.get_event_loop()

    # Do one time server check and state update
    try:
        App.loop.run_until_complete(data_provider_health_check())
    except Exception as e:
        print(f"Problems during health check (connectivity, server etc.) {e}")

    if data_provider_problems_exist():
        print(f"Problems during health check (connectivity, server etc.)")
        return

    print(f"Finished health check (connection, server status etc.)")

    # Do one time data load (cold start)
    try:
        App.loop.run_until_complete(sync_data_collector_task())
        # First call may take a while because of big batch and hence we make second call into to get the (possible) newest klines not received by the first call
        App.loop.run_until_complete(sync_data_collector_task())
    except Exception as e:
        print(f"Problems during initial data collection. {e}")

    if data_provider_problems_exist():
        print(f"Problems during initial data collection.")
        return

    print(f"Finished initial data collection.")

    # Initialize trade status (account, balances, orders etc.)
    if "trade" in App.config["actions"]:
        try:
            App.loop.run_until_complete(update_trade_status())
        except Exception as e:
            print(f"Problems trade status sync. {e}")

        if data_provider_problems_exist():
            print(f"Problems trade status sync.")
            return

        print(f"Finished trade status sync (account, balances etc.)")
        print(f"Balance: {App.config['base_asset']} = {str(App.base_quantity)}")
        print(f"Balance: {App.config['quote_asset']} = {str(App.quote_quantity)}")

    #
    # Register scheduler
    #

    App.sched = AsyncIOScheduler()
    # logging.getLogger('apscheduler.executors.default').setLevel(logging.WARNING)
    logging.getLogger('apscheduler').setLevel(logging.WARNING)

    App.sched.add_job(
        main_task,
        trigger='cron',
        # second='*/30',
        minute='*',
        id='main_task'
    )

    App.sched.start()  # Start scheduler (essentially, start the thread)

    print(f"Scheduler started.")

    #
    # Start event loop
    #
    try:
        App.loop.run_forever()  # Blocking. Run until stop() is called
    except KeyboardInterrupt:
        print(f"KeyboardInterrupt.")
    finally:
        App.loop.close()
        print(f"Event loop closed.")
        App.sched.shutdown()
        print(f"Scheduler shutdown.")

    return 0


if __name__ == "__main__":
    start_server()