PyAlgoEngine 0.5.0a0__tar.gz → 0.5.3__tar.gz

{PyAlgoEngine-0.5.0a0 → PyAlgoEngine-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyAlgoEngine
-Version: 0.5.0a0
+Version: 0.5.3
 Summary: Basic algo engine
 Home-page: https://github.com/BolunHan/PyAlgoEngine
 Author: Bolun.Han

{PyAlgoEngine-0.5.0a0 → PyAlgoEngine-0.5.3}/PyAlgoEngine.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyAlgoEngine
-Version: 0.5.0a0
+Version: 0.5.3
 Summary: Basic algo engine
 Home-page: https://github.com/BolunHan/PyAlgoEngine
 Author: Bolun.Han

{PyAlgoEngine-0.5.0a0 → PyAlgoEngine-0.5.3}/PyAlgoEngine.egg-info/SOURCES.txt

@@ -11,15 +11,15 @@ algo_engine/apps/__init__.py
 algo_engine/apps/bokeh_server.py
 algo_engine/apps/backtest/__init__.py
 algo_engine/apps/backtest/doc_server.py
-algo_engine/apps/backtest/metrics.py
 algo_engine/apps/backtest/tester.py
 algo_engine/apps/backtest/web_app.py
 algo_engine/apps/demo/__init__.py
 algo_engine/apps/demo/test.py
-algo_engine/back_test/__init__.py
-algo_engine/back_test/__main__.py
-algo_engine/back_test/replay.py
-algo_engine/back_test/sim_match.py
+algo_engine/backtest/__init__.py
+algo_engine/backtest/__main__.py
+algo_engine/backtest/metrics.py
+algo_engine/backtest/replay.py
+algo_engine/backtest/sim_match.py
 algo_engine/base/__init__.py
 algo_engine/base/console_utils.py
 algo_engine/base/finance_decimal.py
@@ -39,4 +39,5 @@ algo_engine/profile/cn.py
 algo_engine/strategy/__init__.py
 algo_engine/strategy/strategy_engine.py
 algo_engine/utils/__init__.py
+algo_engine/utils/commit_regularizer.py
 algo_engine/utils/data_utils.py

{PyAlgoEngine-0.5.0a0 → PyAlgoEngine-0.5.3}/algo_engine/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.5.0a"
+__version__ = "0.5.3"
 
 import logging
 import os
@@ -16,14 +16,14 @@ else:
 def set_logger(logger: logging.Logger):
     base.set_logger(logger=logger)
     engine.set_logger(logger=logger.getChild('Engine'))
-    back_test.set_logger(logger=logger.getChild('BackTest'))
+    backtest.set_logger(logger=logger.getChild('BackTest'))
     strategy.set_logger(logger=logger.getChild('Strategy'))
     apps.set_logger(logger=logger.getChild('Apps'))
 
 
 from . import base
 from . import engine
-from . import back_test
+from . import backtest
 from . import strategy
 from . import apps
 

{PyAlgoEngine-0.5.0a0 → PyAlgoEngine-0.5.3}/algo_engine/apps/__init__.py

@@ -9,8 +9,9 @@ def set_logger(logger: logging.Logger):
     global LOGGER
     LOGGER = logger
 
+    from . import backtest
     backtest.set_logger(LOGGER.getChild('Backtester'))
 
 
 from .bokeh_server import DocServer, DocTheme
-from . import backtest
+from .backtest.tester import Tester, StrategyTester

{PyAlgoEngine-0.5.0a0 → PyAlgoEngine-0.5.3}/algo_engine/apps/backtest/__init__.py

@@ -6,6 +6,7 @@ LOGGER = LOGGER.getChild('Backtester')
 
 from .doc_server import CandleStick, StickTheme
 from .web_app import WebApp, start_app
+from .tester import Tester
 
 
 def set_logger(logger: logging.Logger):
@@ -16,4 +17,4 @@ def set_logger(logger: logging.Logger):
     web_app.LOGGER = LOGGER
 
 
-__all__ = ['CandleStick', 'StickTheme', 'WebApp', 'start_app']
+__all__ = ['CandleStick', 'StickTheme', 'WebApp', 'start_app', 'Tester']

{PyAlgoEngine-0.5.0a0 → PyAlgoEngine-0.5.3}/algo_engine/apps/backtest/doc_server.py

@@ -1,13 +1,9 @@
 import datetime
 import pathlib
 from functools import partial
-from threading import Lock
-from typing import overload, TypedDict, NotRequired
+from typing import TypedDict, NotRequired
 
 import pandas as pd
-from bokeh.models import PanTool, WheelPanTool, WheelZoomTool, BoxZoomTool, ResetTool, ExamineTool, SaveTool, CrosshairTool, HoverTool, Toolbar
-from bokeh.models import RangeTool, Range1d
-from bokeh.plotting import figure, gridplot
 
 from .. import DocServer, DocTheme
 from ...base import MarketData, TradeData, TransactionData
@@ -124,24 +120,15 @@ class CandleStick(DocServer):
 
         return last_idx, self.indices[last_idx]
 
-    @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):
-        ...
-
     def update(self, **kwargs):
         self.lock.acquire()
 
         if 'market_data' in kwargs:
             market_data: MarketData = kwargs['market_data']
 
+            if market_data.ticker != self.ticker:
+                return
+
             if isinstance(market_data, (TradeData, TransactionData)):
                 self._on_obs(timestamp=market_data.timestamp, price=market_data.price, volume=market_data.volume)
             else:
@@ -150,11 +137,16 @@ class CandleStick(DocServer):
         else:
             kwargs = kwargs.copy()
             timestamp = kwargs.pop('timestamp', self.timestamp)
+            ticker = kwargs.pop('ticker')
             price = kwargs.pop('market_price', kwargs.pop('close_price'))
             volume = kwargs.pop('volume', 0)
 
+            assert ticker is not None, 'Must assign a ticker for update function!'
             assert price is not None, f'Must assign a market_price or close_price for {self.__class__} update function!'
 
+            if ticker != self.ticker:
+                return
+
             self._on_obs(timestamp=timestamp, price=price, volume=volume, **kwargs)
             self.timestamp = timestamp
 
@@ -228,20 +220,24 @@ class CandleStick(DocServer):
         self._register_candlestick(doc_id=doc_id)
 
     def _register_candlestick(self, doc_id: int):
+        from bokeh.models import PanTool, WheelPanTool, WheelZoomTool, BoxZoomTool, ResetTool, ExamineTool, SaveTool, CrosshairTool, HoverTool, RangeTool, Range1d
+        from bokeh.plotting import figure, gridplot
+
         doc = self.bokeh_documents[doc_id]
         source = self.bokeh_source[doc_id]
 
         tools = [
             PanTool(dimensions="width", syncable=False),
             WheelPanTool(dimension="width", syncable=False),
-            BoxZoomTool(dimensions="width", syncable=False),
+            BoxZoomTool(dimensions="auto", syncable=False),
             WheelZoomTool(dimensions="width", syncable=False),
             CrosshairTool(dimensions="both", syncable=False),
             HoverTool(mode='vline', syncable=False, formatters={'@market_time': 'datetime'}),
-            ExamineTool(),
-            ResetTool(),
-            SaveTool()
+            ExamineTool(syncable=False),
+            ResetTool(syncable=False),
+            SaveTool(syncable=False)
         ]
+
         tooltips = [
             ("market_time", "@market_time{%H:%M:%S}"),
             ("close_price", "@close_price"),
@@ -254,7 +250,7 @@ class CandleStick(DocServer):
             title=f"{self.ticker} Candlestick",
             x_range=Range1d(start=0, end=len(self.indices), bounds='auto'),
             x_axis_type="linear",
-            sizing_mode="stretch_both",
+            # sizing_mode="stretch_both",
             min_height=80,
             tools=tools,
             tooltips=tooltips,
@@ -287,16 +283,13 @@ class CandleStick(DocServer):
         plot.xaxis.major_label_overrides = {i: datetime.datetime.fromtimestamp(ts, tz=self.profile.time_zone).strftime('%Y-%m-%d %H:%M:%S') for i, ts in enumerate(self.indices)}
         plot.xaxis.ticker.min_interval = 1.
         tools[5].renderers = [_candlestick]
-        plot.toolbar.autohide = True
-        plot.toolbar.active_drag = tools[0]
-        plot.toolbar.active_scroll = tools[3]
 
         range_selector = figure(
             y_range=plot.y_range,
             min_height=20,
             tools=[],
             toolbar_location=None,
-            sizing_mode="stretch_both"
+            # sizing_mode="stretch_both"
         )
 
         range_tool = RangeTool(x_range=plot.x_range)
@@ -309,8 +302,23 @@ class CandleStick(DocServer):
         range_selector.xgrid.visible = False
         range_selector.ygrid.visible = False
 
-        root = gridplot(children=[[plot], [range_selector]], sizing_mode="stretch_both")
+        root = gridplot(
+            children=[
+                [plot],
+                [range_selector]
+            ],
+            sizing_mode="stretch_both",
+            merge_tools=True,
+            toolbar_options={
+                'autohide': True,
+                'active_drag': tools[0],
+                'active_scroll': tools[3]
+            },
+        )
         root.rows = ['80%', '20%']
+        root.width_policy = 'max'
+        root.height_policy = 'max'
+
         doc.add_root(root)
 
     def to_csv(self, filename: str | pathlib.Path):

PyAlgoEngine-0.5.3/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')

PyAlgoEngine-0.5.3/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(),
+    )