PyAlgoEngine 0.7.4__py3-none-any.whl

algo_engine/apps/backtest/tester.py

@@ -0,0 +1,254 @@
+import abc
+import datetime
+import time
+from typing import Literal
+
+import numpy as np
+
+from algo_engine.backtest.metrics import TradeMetrics
+from . import LOGGER
+from .web_app import WebApp
+from ...backtest import SimMatch, ProgressiveReplay
+from ...base import MarketData, TradeReport, TradeInstruction
+from ...profile import Profile, PROFILE
+
+
+class Tester(object, metaclass=abc.ABCMeta):
+    def __init__(
+            self,
+            start_date: datetime.date,
+            end_date: datetime.date,
+            dtype: list[str] = None,
+            profile: Profile = None,
+            **kwargs
+    ):
+        self.start_date = start_date
+        self.end_date = end_date
+        self.dtype = ['TickData', 'TradeData'] if dtype is None else dtype
+        self.profile = PROFILE if profile is None else profile
+
+        self.timestamp = 0.
+        self.last_price = {}
+        self.subscription = set()
+        self.web_app = WebApp(start_date=start_date, end_date=end_date, **kwargs)
+        self.metrics: dict[str, TradeMetrics] = {}
+        self.sim_match: dict[str, SimMatch] = {}
+
+    def register_ticker(self, ticker: str, **kwargs):
+        self.subscription.add(ticker)
+
+        self.metrics[ticker] = TradeMetrics()
+
+        self.web_app.register(ticker=ticker, **kwargs)
+
+        sim_match = self.sim_match[ticker] = SimMatch(
+            ticker=ticker,
+            instant_fill=kwargs.get('instant_fill', True)
+        )
+
+        # to add callback function to sim_match, use following codes.
+        # sim_match.on_order = self.on_order
+        # sim_match.on_report = self.on_report
+
+    def unregister_ticker(self, ticker: str, **kwargs):
+        self.subscription.remove(ticker)
+
+        self.metrics.pop(ticker)
+
+        # the web app does not provide an unregister method, however, this is not a requirement
+
+        sim_match = self.sim_match.pop(ticker)
+        sim_match.unregister()
+
+    def _launch_order(self, ticker: str, volume: float, limit_price: float):
+        order = TradeInstruction(ticker=ticker, side=np.sign(volume), volume=abs(float), timestamp=self.timestamp)
+        self.sim_match[ticker].launch_order(order=order)
+
+    def buy(self, ticker: str, volume: float = None, limit_price: float = None):
+        if volume is None:
+            trade_metrics = self.metrics[ticker]
+            exposure = trade_metrics.exposure
+            volume = -exposure if exposure < 0 else 1
+
+        if limit_price is None:
+            limit_price = self.last_price[ticker]
+
+        self._launch_order(ticker=ticker, volume=volume, limit_price=limit_price)
+
+    def sell(self, ticker: str, volume: float = None, limit_price: float = None):
+        if volume is None:
+            trade_metrics = self.metrics[ticker]
+            exposure = trade_metrics.exposure
+            volume = -exposure if exposure > 0 else -1
+
+        if limit_price is None:
+            limit_price = self.last_price[ticker]
+
+        self._launch_order(ticker=ticker, volume=volume, limit_price=limit_price)
+
+    @abc.abstractmethod
+    def load_data(self, ticker: str, market_date: datetime.date, dtype: Literal['TickData', 'TradeData', 'TransactionData', 'OrderBook']) -> list[MarketData]:
+        ...
+
+    @abc.abstractmethod
+    def on_market_data(self, market_data: MarketData, **kwargs):
+        ...
+
+    @abc.abstractmethod
+    def on_report(self, report: TradeReport, **kwargs):
+        ...
+
+    @abc.abstractmethod
+    def on_order(self, order: TradeInstruction, **kwargs):
+        ...
+
+    def bod(self, market_date: datetime.date, **kwargs):
+        pass
+
+    def eod(self, market_date: datetime.date, **kwargs):
+        pass
+
+    def run(self, **kwargs):
+        replay = ProgressiveReplay(
+            loader=self.load_data,
+            tickers=list(self.subscription),
+            dtype=['TickData', 'TradeData'],
+            start_date=self.start_date,
+            end_date=self.end_date,
+            bod=self.bod,
+            eod=self.eod,
+            tick_size=kwargs.get('progress_tick_size', 0.001),
+        )
+
+        _start_ts = time.time()
+
+        for market_data in replay:
+            self.on_market_data(market_data=market_data)
+            self.sim_match[market_data.ticker](market_data=market_data)
+            self.web_app.update(market_data=market_data)
+
+            self.timestamp = market_data.timestamp
+            self.last_price[market_data.ticker] = market_data.market_price
+
+        LOGGER.info(f'All done! time_cost: {time.time() - _start_ts:,.3}s')
+
+
+class StrategyTester(Tester):
+    from ...strategy.strategy_engine import StrategyEngine
+
+    def __init__(self, start_date: datetime.date, end_date: datetime.date, data_loader, strategy: StrategyEngine, **kwargs):
+        self.data_loader = data_loader
+        self.strategy = strategy
+        self.event_engine = self.strategy.event_engine
+        self.topic_set = self.strategy.topic_set
+        self.multi_threading = kwargs.get('multi_threading', False)
+        self.lock = self.strategy.lock
+
+        super().__init__(
+            start_date=start_date,
+            end_date=end_date,
+            dtype=kwargs.pop('dtype', ['TickData', 'TradeData']),
+            profile=kwargs.pop('profile', PROFILE),
+            event_engine=strategy.event_engine,
+            topic_set=strategy.topic_set,
+            multi_threading=kwargs.pop('multi_threading', False),
+            **kwargs
+        )
+
+    def register_ticker(self, ticker: str, **kwargs):
+        super().register_ticker(ticker=ticker, **kwargs)
+
+        for ticker, sim_match in self.sim_match.items():
+            sim_match.register(event_engine=self.event_engine, topic_set=self.topic_set)
+
+    def register(self):
+        self.event_engine.register_handler(topic=self.topic_set.realtime, handler=self.strategy.mds.on_market_data)
+        self.event_engine.register_handler(topic=self.topic_set.realtime, handler=self.strategy.position_tracker.on_market_data)
+        self.event_engine.register_handler(topic=self.topic_set.realtime, handler=self.on_market_data)
+
+        self.event_engine.register_handler(topic=self.topic_set.on_order, handler=self.strategy.balance.on_order)
+        self.event_engine.register_handler(topic=self.topic_set.on_order, handler=self.on_order)
+        self.event_engine.register_handler(topic=self.topic_set.on_report, handler=self.strategy.balance.on_report)
+        self.event_engine.register_handler(topic=self.topic_set.on_report, handler=self.on_report)
+
+    def initialize_position_management(self):
+        for ticker in self.subscription:
+            risk_profile = self.strategy.position_tracker.dma.risk_profile
+
+            risk_profile.set_rule(ticker=ticker, key='max_trade_long', value=np.inf)
+            risk_profile.set_rule(ticker=ticker, key='max_trade_short', value=np.inf)
+            risk_profile.set_rule(ticker=ticker, key='max_exposure_long', value=np.inf)
+            risk_profile.set_rule(ticker=ticker, key='max_exposure_short', value=np.inf)
+
+    def load_data(self, ticker: str, market_date: datetime.date, dtype: Literal['TickData', 'TradeData', 'TransactionData', 'OrderBook']) -> list[MarketData]:
+        return self.data_loader(ticker=ticker, market_date=market_date, dtype=dtype)
+
+    def bod(self, market_date: datetime.date, **kwargs):
+        super().bod(market_date=market_date, **kwargs)
+        self.bod(market_date=market_date, **kwargs)
+
+    def eod(self, market_date: datetime.date, **kwargs):
+        super().bod(market_date=market_date, **kwargs)
+        self.bod(market_date=market_date, **kwargs)
+
+    def on_market_data(self, market_data: MarketData, **kwargs):
+        self.strategy.__call__(market_data=market_data, **kwargs)
+
+        if self.lock.locked():
+            self.lock.release()
+
+    def on_report(self, report: TradeReport, **kwargs):
+        self.strategy.on_report(report=report, **kwargs)
+
+    def on_order(self, order: TradeInstruction, **kwargs):
+        self.strategy.on_order(order=order, **kwargs)
+
+    def _launch_order(self, ticker: str, volume: float, limit_price: float):
+        self.strategy.open_pos(ticker=ticker, volume=abs(volume), trade_side=np.sign(volume))
+
+    def buy(self, ticker: str, volume: float = None, limit_price: float = None):
+        if ticker not in self.subscription:
+            raise ValueError(f'{ticker} not subscribed for trading!')
+
+        super().buy(ticker=ticker, volume=volume, limit_price=limit_price)
+
+    def sell(self, ticker: str, volume: float = None, limit_price: float = None):
+        if ticker not in self.subscription:
+            raise ValueError(f'{ticker} not subscribed for trading!')
+
+        super().sell(ticker=ticker, volume=volume, limit_price=limit_price)
+
+    def run(self, **kwargs):
+        if not self.event_engine.active:
+            self.event_engine.start()
+
+        replay = ProgressiveReplay(
+            loader=self.load_data,
+            tickers=list(self.subscription),
+            dtype=['TickData', 'TradeData'],
+            start_date=self.start_date,
+            end_date=self.end_date,
+            bod=self.bod,
+            eod=self.eod,
+            tick_size=kwargs.get('progress_tick_size', 0.001),
+        )
+
+        _start_ts = time.time()
+
+        for market_data in replay:
+            if self.multi_threading:
+                self.lock.acquire()
+                self.event_engine.put(topic=self.topic_set.push(market_data=market_data), market_data=market_data)
+            else:
+                self.strategy.mds.on_market_data(market_data=market_data)
+                self.strategy.position_tracker.on_market_data(market_data=market_data)
+                self.strategy.on_market_data(market_data=market_data)
+
+                if market_data.ticker in self.subscription:
+                    self.sim_match[market_data.ticker](market_data=market_data)
+                    self.web_app.update(market_data=market_data)
+
+            self.timestamp = market_data.timestamp
+            self.last_price[market_data.ticker] = market_data.market_price
+
+        LOGGER.info(f'All done! time_cost: {time.time() - _start_ts:,.3}s')

algo_engine/apps/backtest/web_app.py

@@ -0,0 +1,127 @@
+import argparse
+import datetime
+import pathlib
+from threading import Thread
+
+from .doc_server import CandleStick
+from .. import LOGGER
+from ..bokeh_server import DocManager, DocServer
+from ...profile import Profile, PROFILE
+
+
+class WebApp(object):
+    def __init__(self, start_date: datetime.date, end_date: datetime.date, name: str = 'WebApp.Backtest', address: str = '0.0.0.0', port: int = 8080, profile: Profile = None, **kwargs):
+        from flask import Flask
+        self.start_date = start_date
+        self.end_date = end_date
+        self.name = name
+        self.root_dir = pathlib.Path(__file__).parent
+        self.profile = PROFILE if profile is None else profile
+        self.host = address
+        self.port = port
+
+        self.flask = Flask(
+            import_name=self.name,
+            template_folder=self.root_dir.joinpath('templates'),
+            static_folder=self.root_dir.joinpath('static')
+        )
+        self.doc_manager = DocManager(host='localhost', port=port)
+        self.dashboard: dict[str, dict[str, DocServer]] = {}
+
+    def update(self, **kwargs):
+        for doc_server in self.doc_manager.doc_server.values():
+            doc_server.update(**kwargs)
+
+    def register(self, ticker: str, **kwargs):
+        if ticker in self.dashboard:
+            raise ValueError(f'Ticker {ticker} already registered.')
+
+        dashboard = self.dashboard[ticker] = {}
+        candlestick = dashboard[f'candlesticks'] = CandleStick(ticker=ticker, start_date=self.start_date, end_date=self.end_date, **kwargs)
+
+        self.doc_manager.register(url=f'/candlesticks/{ticker}', doc_server=candlestick)
+
+    def render_index(self):
+        from flask import render_template
+
+        dashboard_url = {ticker: f'{self.url}/{ticker}' for ticker in self.dashboard}
+
+        html = render_template(
+            'index.html',
+            title=f'PyAlgoEngine.Backtest.App',
+            data=dashboard_url
+        )
+
+        return html
+
+    def render_dashboard(self, ticker: str):
+        from flask import render_template
+        from bokeh.embed import server_document
+
+        dashboard = self.dashboard[ticker]
+        bokeh_scripts = {}
+
+        for name, doc_server in dashboard.items():
+            url = self.doc_manager.doc_url[doc_server]
+            doc_script = server_document(url=f'http://{self.doc_manager.bokeh_host}:{self.doc_manager.bokeh_port}{url}')
+            bokeh_scripts[name] = doc_script
+
+        html = render_template(
+            'dash.html',
+            ticker=ticker,
+            framework="flask",
+            **bokeh_scripts
+        )
+        return html
+
+    def serve(self, blocking: bool = True):
+        from waitress import serve
+
+        LOGGER.info(f'starting {self} service...')
+
+        self.doc_manager.start()
+        self.flask.route(rule='/', methods=["GET"])(self.render_index)
+
+        for ticker in self.dashboard:
+            def renderer():
+                return self.render_dashboard(ticker=ticker)
+
+            self.flask.route(rule=f'/{ticker}', methods=["GET"])(renderer)
+
+        if blocking:
+            return serve(app=self.flask, host=self.host, port=self.port)
+
+        t = Thread(target=serve, kwargs=dict(app=self.flask, host=self.host, port=self.port))
+        t.start()
+
+        # a monkey patch to resolve flask double logging issues
+        for hdl in (logger := self.flask.logger).handlers:
+            logger.removeHandler(hdl)
+
+        for hdl in (logger := LOGGER.root).handlers:
+            logger.removeHandler(hdl)
+
+    @property
+    def url(self) -> str:
+        if self.host == '0.0.0.0':
+            return f'http://localhost:{self.port}/'
+        else:
+            return f'http://{self.host}:{self.port}/'
+
+
+def start_app(start_date: datetime.date, end_date: datetime.date, blocking: bool = True, **kwargs):
+    web_app = WebApp(start_date=start_date, end_date=end_date, **kwargs)
+    web_app.serve(blocking=blocking)
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='Start Backtest.App')
+    parser.add_argument('--start_date', type=str, required=True, help='Start date in YYYY-MM-DD format')
+    parser.add_argument('--end_date', type=str, required=True, help='End date in YYYY-MM-DD format')
+
+    args = parser.parse_args()
+
+    start_app(
+        start_date=datetime.datetime.strptime(args.start_date, '%Y-%m-%d').date(),
+        end_date=datetime.datetime.strptime(args.end_date, '%Y-%m-%d').date(),
+    )

algo_engine/apps/bokeh_server.py

@@ -0,0 +1,205 @@
+import abc
+import uuid
+from copy import deepcopy
+from functools import partial
+from threading import Thread, Lock
+from typing import overload
+
+from . import LOGGER
+from ..base import MarketData
+
+
+class DocTheme(object, metaclass=abc.ABCMeta):
+    pass
+
+
+class DocServer(object, metaclass=abc.ABCMeta):
+    def __init__(self, theme: DocTheme = None, max_size: int = None, update_interval: float = 0., lock: Lock = None, **kwargs):
+        from bokeh.document import Document
+        from bokeh.models import ColumnDataSource
+
+        self.theme: DocTheme = theme
+        self.max_size: int = max_size
+        self.update_interval: float = update_interval
+        self.lock = Lock() if lock is None else lock
+
+        self.bokeh_documents: dict[int, Document] = {}
+        # self.bokeh_source: dict[int, ColumnDataSource] = {}
+        self.bokeh_data_pipe: dict[int, dict[str, list[...]]] = {}
+        self.bokeh_data_patch: dict[int, dict[str, list[tuple[int, ...]]]] = {}
+        self.bokeh_data_source: dict[int, ColumnDataSource] = {}
+
+    def __str__(self):
+        return f'<{self.__class__.__name__}>(id={id(self.__class__)})'
+
+    def __call__(self, doc):
+        self.register_document(doc=doc)
+
+    def __hash__(self):
+        return id(self)
+
+    @overload
+    def update(self, timestamp: float, market_price: float, **kwargs):
+        ...
+
+    @overload
+    def update(self, timestamp: float, open_price: float, close_price: float, high_price: float, low_price: float, **kwargs):
+        ...
+
+    @overload
+    def update(self, market_data: MarketData, **kwargs):
+        ...
+
+    @abc.abstractmethod
+    def update(self, **kwargs):
+        ...
+
+    @abc.abstractmethod
+    def layout(self, doc_id: int):
+        ...
+
+    def stream(self, doc_id: int = None):
+        if doc_id is None:
+            for doc_id in list(self.bokeh_documents):
+                self.stream(doc_id=doc_id)
+            return
+
+        # doc = self.bokeh_documents[doc_id]
+        data_pipe = self.bokeh_data_pipe[doc_id]
+        source = self.bokeh_data_source[doc_id]
+
+        source.stream(new_data=deepcopy(data_pipe), rollover=self.max_size)
+        for key, seq in data_pipe.items():
+            seq.clear()
+
+        LOGGER.debug(f'{self.__class__} <stream> updated!')
+
+    def patch(self, doc_id: int = None):
+        if doc_id is None:
+            for doc_id in list(self.bokeh_documents):
+                self.patch(doc_id=doc_id)
+            return
+
+        # doc = self.bokeh_documents[doc_id]
+        data_patch = self.bokeh_data_patch[doc_id]
+        source = self.bokeh_data_source[doc_id]
+
+        source.patch(patches=deepcopy(data_patch))
+        for key, seq in data_patch.items():
+            seq.clear()
+
+        LOGGER.debug(f'{self.__class__} <patch> updated!')
+
+    def register_document(self, doc):
+        from bokeh.models import ColumnDataSource
+
+        self.lock.acquire()
+
+        doc_id = uuid.uuid4().int
+
+        data = deepcopy(self.data)
+        self.bokeh_documents[doc_id] = doc
+        self.bokeh_data_pipe[doc_id] = {key: [] for key in data}
+        self.bokeh_data_patch[doc_id] = {key: [] for key in data}
+        self.bokeh_data_source[doc_id] = ColumnDataSource(data=data)
+
+        self.layout(doc_id=doc_id)
+
+        if self.update_interval:
+            doc.add_periodic_callback(callback=partial(self.stream, doc_id=doc_id), period_milliseconds=int(self.update_interval * 1000))
+            doc.add_periodic_callback(callback=partial(self.patch, doc_id=doc_id), period_milliseconds=int(self.update_interval * 1000))
+
+        doc.on_session_destroyed(partial(self._unregister_document, doc_id=doc_id))
+
+        LOGGER.info(f'{self} registered Bokeh document id = {doc_id}!')
+        self.lock.release()
+
+    def _unregister_document(self, session_context, doc_id: int):
+        self.lock.acquire()
+        LOGGER.info(f'Session {doc_id} disconnected!')
+
+        self.bokeh_documents.pop(doc_id)
+        self.bokeh_data_pipe.pop(doc_id)
+        self.bokeh_data_patch.pop(doc_id)
+        self.bokeh_data_source.pop(doc_id)
+        self.lock.release()
+
+    @property
+    @abc.abstractmethod
+    def data(self) -> dict[str, list]:
+        """
+        the data used to provide initial values for new bokeh.ColumnDataSource.
+        """
+        ...
+
+
+class DocManager(object):
+    def __init__(self, host: str = 'localhost', port: int = 21543, **kwargs):
+        self.host = host
+        self.port = port
+
+        self.bokeh_host = kwargs.get('bokeh_host', 'localhost')
+        self.bokeh_port = kwargs.get('bokeh_port', 5006)
+        self.bokeh_check_unused_sessions = kwargs.get('bokeh_check_unused_sessions', 1)
+
+        self.doc_server: dict[str, DocServer] = {}
+        self.doc_url: dict[DocServer, str] = {}
+        self.bokeh_thread = Thread(target=self.serve_bokeh, daemon=True)
+
+    def __getitem__(self, url: str):
+        return self.doc_server.__getitem__(url)
+
+    def __setitem__(self, url: str, doc_server: DocServer):
+        return self.register(url=url, doc_server=doc_server)
+
+    def __contains__(self, url: str):
+        return self.doc_server.__contains__(url)
+
+    def register(self, url: str, doc_server: DocServer):
+        if url in self.doc_server:
+            LOGGER.warning(f'{url} already registered! Existed doc_server {self.doc_server[url]} overridden!')
+
+        self.doc_server[url] = doc_server
+        self.doc_url[doc_server] = url
+        return doc_server
+
+    def serve_bokeh(self):
+        from bokeh.server.server import Server
+        import psutil
+        import socket
+
+        # Get all network interfaces and their IP addresses
+        addrs = psutil.net_if_addrs()
+        websocket_origin = [
+            f"{self.host}:{self.port}"
+        ]
+
+        for interface, addr_info in addrs.items():
+            for addr in addr_info:
+                if addr.family == socket.AF_INET:  # Filter only IPv4 addresses
+                    LOGGER.info(f"Binding network interface: {interface}, IP Address: {addr.address}")
+                    websocket_origin.append(f"{addr.address}:{self.port}")
+
+        server = Server(
+            applications=self.doc_server,
+            address=self.bokeh_host,
+            port=self.bokeh_port,
+            check_unused_sessions_milliseconds=(self.bokeh_check_unused_sessions * 1000),
+            allow_websocket_origin=[f"{self.bokeh_host}:{self.bokeh_port}"] + websocket_origin,
+            # num_procs=1
+        )
+
+        LOGGER.info(
+            f'bokeh service started at {self.bokeh_host}:{self.bokeh_port}!\n' +
+            '\n'.join([f'http://{self.bokeh_host}:{self.bokeh_port}{url} => {app}' for url, app in self.doc_server.items()])
+        )
+
+        server.start()
+
+        # for url in applications:
+        #     server.io_loop.add_callback(server.show, url)
+
+        server.io_loop.start()
+
+    def start(self):
+        self.bokeh_thread.start()

algo_engine/apps/demo/test.py

@@ -0,0 +1,39 @@
+import datetime
+import time
+
+from algo_engine.apps.backtest import WebApp, LOGGER
+from algo_engine.base import Progress
+from algo_engine.profile import PROFILE_CN
+from algo_engine.utils import fake_data
+
+
+def main():
+    PROFILE_CN.override_profile()
+    ticker = '000016.SH'
+    market_date = datetime.date.today()
+
+    data_set = fake_data(market_date=market_date)
+    web_app = WebApp(start_date=market_date, end_date=market_date)
+    LOGGER.info(f'{len(data_set)} fake data generated for {ticker} {market_date}.')
+
+    web_app.register(ticker=ticker)
+    web_app.serve(blocking=False)
+
+    LOGGER.info(f'web app started at {web_app.url}')
+
+    for ts, row in Progress(list(data_set.iterrows())):
+        web_app.update(
+            timestamp=ts,
+            ticker=ticker,
+            open_price=row['open_price'],
+            close_price=row['close_price'],
+            high_price=row['high_price'],
+            low_price=row['low_price'],
+        )
+        time.sleep(0.05)
+
+
+if __name__ == '__main__':
+    main()
+
+    # sys.exit(-1)

algo_engine/backtest/__init__.py

@@ -0,0 +1,19 @@
+import logging
+
+from .. import LOGGER
+
+LOGGER = LOGGER.getChild('BackTest')
+
+
+def set_logger(logger: logging.Logger):
+    global LOGGER
+    LOGGER = logger
+
+    replay.LOGGER = LOGGER.getChild('Replay')
+    sim_match.LOGGER = LOGGER.getChild('SimMatch')
+
+
+from .replay import Replay, SimpleReplay, ProgressiveReplay
+from .sim_match import SimMatch
+
+__all__ = ['Replay', 'SimpleReplay', 'ProgressiveReplay', 'SimMatch']

algo_engine/backtest/__main__.py

@@ -0,0 +1,51 @@
+__package__ = 'algo_engine.backtest'
+
+import datetime
+from collections.abc import Callable
+
+import event_engine
+
+from ..engine import TOPIC, MarketDataService, Balance, RiskProfile, PositionManagementService
+from ..engine.algo_engine import AlgoRegistry, AlgoEngine
+from ..strategy import EventDMA
+from ..strategy.strategy_engine import StrategyEngine
+
+
+def test_stop(code=0):
+    EVENT_ENGINE.stop()
+    # noinspection PyUnresolvedReferences, PyProtectedMember
+    # `import os`
+    # `os._exit(code)`
+
+
+def test_start(start_date: datetime.date, end_date: datetime.date, data_loader: Callable, **kwargs):
+    EVENT_ENGINE.start()
+    STRATEGY_ENGINE.back_test(
+        start_date=start_date,
+        end_date=end_date,
+        data_loader=data_loader,
+        **kwargs
+    )
+
+
+# in backtest, the global objects is newly inited to separate from production
+EVENT_ENGINE = event_engine.EventEngine()
+MDS = MarketDataService()
+ALGO_REGISTRY = AlgoRegistry()
+ALGO_ENGINE = AlgoEngine(mds=MDS, registry=ALGO_REGISTRY)
+
+BALANCE = Balance()
+RISK_PROFILE = RiskProfile(mds=MDS, balance=BALANCE)
+DMA = EventDMA(event_engine=EVENT_ENGINE, mds=MDS, risk_profile=RISK_PROFILE)
+POSITION_TRACKER = PositionManagementService(dma=DMA, algo_engine=ALGO_ENGINE)
+STRATEGY_ENGINE = StrategyEngine(event_engine=EVENT_ENGINE, position_tracker=POSITION_TRACKER)
+BALANCE.add(strategy=STRATEGY_ENGINE, position_tracker=POSITION_TRACKER)
+
+EVENT_ENGINE.register_handler(topic=TOPIC.realtime, handler=MDS.on_market_data)
+EVENT_ENGINE.register_handler(topic=TOPIC.on_report, handler=BALANCE.on_report)
+EVENT_ENGINE.register_handler(topic=TOPIC.on_order, handler=BALANCE.on_order)
+STRATEGY_ENGINE.register()
+
+MDS.synthetic_orderbook = True
+
+__all__ = ['BALANCE', 'RISK_PROFILE', 'DMA', 'POSITION_TRACKER', 'STRATEGY_ENGINE', 'BALANCE', 'EVENT_ENGINE', 'MDS']