-
Notifications
You must be signed in to change notification settings - Fork 8
/
quant.py
132 lines (102 loc) · 4.1 KB
/
quant.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
import asyncio
import logging
import os
import signal
import uvloop
from dotenv import load_dotenv
from core.models.exchange import ExchangeType
from core.models.strategy import StrategyType
from exchange import ExchangeFactory, WSFactory
from executor import OrderExecutorActorFactory
from feed import FeedActorFactory
from infrastructure.config import ConfigService
from infrastructure.event_dispatcher.event_dispatcher import EventDispatcher
from infrastructure.logger import configure_logging
from infrastructure.shutdown import GracefulShutdown
from optimization import StrategyOptimizerFactory
from portfolio import Portfolio
from position import PositionActorFactory, PositionFactory
from position.risk.break_even import PositionRiskBreakEvenStrategy
from position.size.fixed import PositionFixedSizeStrategy
from position.take_profit.risk_reward import PositionRiskRewardTakeProfitStrategy
from risk import RiskActorFactory
from service import EnvironmentSecretService, SignalService, WasmFileService
from sor import SmartRouter
from strategy import SignalActorFactory
from strategy.generator import StrategyGeneratorFactory
from system.backtest import BacktestSystem
from system.context import SystemContext
from system.trading import TradingSystem
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
load_dotenv()
REGIME = os.getenv("REGIME")
LOG_DIR = os.getenv("LOG_DIR")
LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO").upper()
WASM_FOLDER = os.getenv("WASM_FOLDER")
configure_logging(LOG_LEVEL)
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
graceful_shutdown = GracefulShutdown()
signal.signal(signal.SIGTERM, graceful_shutdown.exit)
async def main():
logging.info("Initializing...")
config_service = ConfigService()
config_service.load(config_path=f"config.{REGIME}.ini")
config = {"bus": {"num_workers": os.cpu_count()}, "store": {"base_dir": LOG_DIR}}
config_service.update(config)
event_bus = EventDispatcher(config_service)
exchange_factory = ExchangeFactory(EnvironmentSecretService())
ws_factory = WSFactory(EnvironmentSecretService())
Portfolio(config_service)
SmartRouter(exchange_factory, config_service)
position_factory = PositionFactory(
PositionFixedSizeStrategy(),
PositionRiskBreakEvenStrategy(config_service),
PositionRiskRewardTakeProfitStrategy(config_service),
)
signal_actor_factory = SignalActorFactory(
SignalService(WasmFileService(WASM_FOLDER))
)
position_actor_factory = PositionActorFactory(position_factory, config_service)
risk_actor_factory = RiskActorFactory(config_service)
executor_actor_factory = OrderExecutorActorFactory()
feed_actor_factory = FeedActorFactory(exchange_factory, ws_factory, config_service)
trend_context = SystemContext(
signal_actor_factory,
position_actor_factory,
risk_actor_factory,
executor_actor_factory,
feed_actor_factory,
StrategyGeneratorFactory(config_service),
StrategyOptimizerFactory(config_service),
strategy_type=StrategyType.TREND,
exchange_type=ExchangeType.BYBIT,
config_service=config_service,
)
trend_system_a = BacktestSystem(trend_context)
trading_system = TradingSystem(
signal_actor_factory,
position_actor_factory,
risk_actor_factory,
executor_actor_factory,
feed_actor_factory,
config_service,
exchange_type=ExchangeType.BYBIT,
)
trend_system_a_task = asyncio.create_task(trend_system_a.start())
trading_system_task = asyncio.create_task(trading_system.start())
shutdown_task = asyncio.create_task(graceful_shutdown.wait_for_exit_signal())
try:
logging.info("Started")
await asyncio.gather(*[trend_system_a_task, shutdown_task])
finally:
logging.info("Closing...")
shutdown_task.cancel()
trend_system_a_task.cancel()
trading_system_task.cancel()
trading_system.stop()
await event_bus.stop()
await event_bus.wait()
logging.info("Finished.")
with asyncio.Runner() as runner:
runner.run(main())