PyAlgoEngine 0.7.4__py3-none-any.whl

PyAlgoEngine-0.7.4.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Bolun Han
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

PyAlgoEngine-0.7.4.dist-info/METADATA

@@ -0,0 +1,27 @@
+Metadata-Version: 2.1
+Name: PyAlgoEngine
+Version: 0.7.4
+Summary: Basic algo engine
+Home-page: https://github.com/BolunHan/PyAlgoEngine
+Author: Bolun.Han
+Author-email: Bolun.Han@outlook.com
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.1
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pandas
+Requires-Dist: exchange-calendars
+Requires-Dist: PyEventEngine
+Provides-Extra: webapps
+Requires-Dist: flask; extra == "webapps"
+Requires-Dist: waitress; extra == "webapps"
+Requires-Dist: bokeh; extra == "webapps"
+
+# PyAlgoEngine
+python algo trading engine

PyAlgoEngine-0.7.4.dist-info/RECORD

@@ -0,0 +1,43 @@
+algo_engine/__init__.py,sha256=-9L0Zng2Tmu--VA4yR1iOEfQT0A_-M8EHwYP1dIUda4,1131
+algo_engine/apps/__init__.py,sha256=eoGAAMNvOufN3eY2U0U5lNqHpJ91FKS8s-wblk3fH8g,335
+algo_engine/apps/bokeh_server.py,sha256=frh53jx3XkaXcBCYMde0E65P7Ta_SwrDTcyXggan8Ms,6868
+algo_engine/apps/backtest/__init__.py,sha256=JjDJkK3B_fFWSL_Oq0MDxiUtC5F0yhMhIiCtLD8lH8s,408
+algo_engine/apps/backtest/doc_server.py,sha256=jdjIs94_ARbSCU2Sxwvd5OcWPYVQS_Vq7yMieJWCJSU,12219
+algo_engine/apps/backtest/tester.py,sha256=gdYI-8Rp8Ev_AFKRP8vGQGMPt9Ht8rujO1iM-dB9srQ,10059
+algo_engine/apps/backtest/web_app.py,sha256=_dAeHsOZ2LWalxKsCgin8VZPAyswk4OuaaJUcZrwOrA,4440
+algo_engine/apps/demo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+algo_engine/apps/demo/test.py,sha256=3Mhau6Sl5ozTjnqXGbbTxpb_mznV_JPEc5DswTkYU6A,1040
+algo_engine/backtest/__init__.py,sha256=GDWUnLzTVfYkcSDnyhMVBFh3oVyMWg9HlLmbc6GYLUM,419
+algo_engine/backtest/__main__.py,sha256=mx-OUl0n6J6zaGHSznmkoK7FkvWvLSv-oLsFJxwjeRU,1829
+algo_engine/backtest/metrics.py,sha256=7siyOY5iVFZa9Kvvx8CFwWLwFUoydp3jN8orI-r4NQ8,7546
+algo_engine/backtest/replay.py,sha256=MjIP9hgE78hi6EofabmUKb9lClKuj0CpeSB35Ej_-E0,9216
+algo_engine/backtest/sim_match.py,sha256=1GiXWreB5mbCGdVzfvWtSBAfm3FQUS6UtRocjiy1s-A,13973
+algo_engine/base/__init__.py,sha256=PJVmegsOUiTUSGNIngCR0KkgL1R4op2gBpKzBICMjFQ,2229
+algo_engine/base/console_utils.py,sha256=0KUmO8KTnNeE40oXHblNrsQR3dmd5Tw3hoFaPk-1YTw,35811
+algo_engine/base/finance_decimal.py,sha256=hDE9GfPlY1VdmdFPp3ffTINELRBEA8Gpj5XlDmp6WDs,8723
+algo_engine/base/market_buffer.py,sha256=j1BLzBHCBLepg3qlLVNxQDO1247LjqBORIVd4c0qtpY,22155
+algo_engine/base/market_utils.py,sha256=rBw8xpeDqSVhA3DJjegz2w1dP3zA2FaBuN9Abf90HQY,108316
+algo_engine/base/market_utils_nt.py,sha256=3gGr-vK75RJ4BY3Gx09isCEvbKt3qU35ZOwQqEacaEs,5894
+algo_engine/base/market_utils_posix.py,sha256=vXNTw2oydg4EFc3KmrwD9s9TBFhprpZu95-MlFkvdzY,104123
+algo_engine/base/technical_analysis.py,sha256=NbRCdCHqKoKLuyyaUmCE9q0tbUGMY41pJEhnGooaHLI,16147
+algo_engine/base/telemetrics.py,sha256=3NLvrX21WuRjm-6tfdK4Mako6-50OGpK_xmoU-RN9Y8,2617
+algo_engine/base/trade_utils.py,sha256=RK0mAvax2pJWFYWskWeenQBJt9JKD56ImhWpCL0rrIM,22676
+algo_engine/engine/__init__.py,sha256=XtSJZtXzvRrVh_ATRpxtDiIcdYMiz6iW3Rrc19lI-IA,1011
+algo_engine/engine/algo_engine.py,sha256=C-o5mCeOU7VeEekWQucs5btd6fMgDyBbyFAT3WkqlGE,32206
+algo_engine/engine/event_engine.py,sha256=KNHYtoFm76fte7WCIwQ8JXft2aGuMjEuxCy5Yezn6bM,1378
+algo_engine/engine/market_engine.py,sha256=yK4MOyzWEppHMv-j8ag2f9bm10UwefFNw_GDx6y_nZ8,11966
+algo_engine/engine/trade_engine.py,sha256=J8lv1a-HbixeJMku2UmzGkyOpD5Xvap8PCeLu-K5N5M,69557
+algo_engine/monitor/__init__.py,sha256=lNVBjbfUzy4E6mhZJTv9Je1dV0OBx8w91dDysmxJ-rc,434
+algo_engine/monitor/advanced_data_interface.py,sha256=yUZheIEThQVOL5cG2PdMrv_wGK1KZSLfVYAvYUSlpkM,8695
+algo_engine/profile/__init__.py,sha256=_8xJKF0hQU53FqoEZzy2obFREoNiPmtA9wTxbor3rUk,4268
+algo_engine/profile/cn.py,sha256=18CUQtZciN7G4BhIS0urGNbX4I5_TWGK2oCunMLpYHY,7274
+algo_engine/strategy/__init__.py,sha256=GJSGL7zAIfMccVh9a32bvjb9oGe4Cr11jzCSS4jDS3I,1835
+algo_engine/strategy/strategy_engine.py,sha256=V7OzYB-eMK2zR0XMtoEIegYmvGpHPy3_Y4kF7a0YMm0,16973
+algo_engine/utils/__init__.py,sha256=RfLDKS9c0i8gVsPeyrHB4_ICOYImdmEqUxpRzl64M7s,121
+algo_engine/utils/commit_regularizer.py,sha256=zNU2rDCGzh2bmoiktHn8VxYvpo2QUdEenuFU3E0p-qA,1775
+algo_engine/utils/data_utils.py,sha256=2RxjBNBZKpO1knYu8ZF0dnPEVgPe9XHoyfxGf7eUPV8,9286
+PyAlgoEngine-0.7.4.dist-info/LICENSE,sha256=bTmmkRlafTj1JKDkDoGfnLHD8OiuIdXaXDa35W3Ii4g,1066
+PyAlgoEngine-0.7.4.dist-info/METADATA,sha256=hw6eqlG3y9MKLUnkYE5g8UQTUnVTmnDICEXl0xhAgjI,873
+PyAlgoEngine-0.7.4.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+PyAlgoEngine-0.7.4.dist-info/top_level.txt,sha256=Pef3P5wI02TdvTt4Sn9rK06uwWy9-3oWhnC_TehQAWw,12
+PyAlgoEngine-0.7.4.dist-info/RECORD,,

PyAlgoEngine-0.7.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

PyAlgoEngine-0.7.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+algo_engine

algo_engine/__init__.py

@@ -0,0 +1,41 @@
+__version__ = "0.7.4"
+
+import logging
+import os
+import traceback
+
+from . import profile
+from .base.telemetrics import LOGGER
+
+if 'ALGO_DIR' in os.environ:
+    WORKING_DIRECTORY = os.path.realpath(os.environ['ALGO_DIR'])
+else:
+    WORKING_DIRECTORY = str(os.getcwd())
+
+
+def set_logger(logger: logging.Logger):
+    from . import base
+    from . import engine
+    from . import backtest
+    from . import strategy
+    from . import apps
+
+    base.set_logger(logger=logger)
+    engine.set_logger(logger=logger.getChild('Engine'))
+    backtest.set_logger(logger=logger.getChild('BackTest'))
+    strategy.set_logger(logger=logger.getChild('Strategy'))
+    apps.set_logger(logger=logger.getChild('Apps'))
+
+
+LOGGER.info(f'AlgoEngine version {__version__}')
+
+# import addon module
+try:
+    from . import algo_addon
+
+    LOGGER.info(f'PyAlgoEngineAddons import successful, version {algo_addon.__version__}')
+except ImportError:
+    algo_addon = None
+    LOGGER.debug(f'Install PyAlgoEngineAddons to use additional trading algos module\n{traceback.format_exc()}')
+
+__all__ = ['LOGGER', 'base', 'engine', 'backtest', 'strategy', 'algo_addon']

algo_engine/apps/__init__.py

@@ -0,0 +1,17 @@
+import logging
+
+from .. import LOGGER
+
+LOGGER = LOGGER.getChild('Apps')
+
+
+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 .backtest.tester import Tester, StrategyTester

algo_engine/apps/backtest/__init__.py

@@ -0,0 +1,20 @@
+import logging
+
+from .. import LOGGER
+
+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):
+    global LOGGER
+    LOGGER = logger
+
+    doc_server.LOGGER = LOGGER
+    web_app.LOGGER = LOGGER
+
+
+__all__ = ['CandleStick', 'StickTheme', 'WebApp', 'start_app', 'Tester']

algo_engine/apps/backtest/doc_server.py

@@ -0,0 +1,331 @@
+import datetime
+import pathlib
+from functools import partial
+from typing import TypedDict, NotRequired
+
+import pandas as pd
+
+from .. import DocServer, DocTheme
+from ...base import MarketData, TradeData, TransactionData
+from ...profile import Profile, PROFILE
+from ...utils import ts_indices
+
+
+class StickTheme(DocTheme):
+    stick_padding = 0.1
+    range_padding = 0.01
+
+    ColorStyle = TypedDict('ColorStyle', fields={'up': str, 'down': str})
+    ws_style = ColorStyle(up="green", down="red")
+    cn_style = ColorStyle(up="red", down="green")
+
+    def __init__(self, profile: Profile = PROFILE, style: ColorStyle = None):
+        self.profile = profile
+
+        if style is None:
+            if profile.profile_id == 'cn':
+                self.style = self.cn_style
+            else:
+                self.style = self.ws_style
+        else:
+            self.style = style
+
+    def stick_style(self, pct_change: float | int) -> dict:
+        style_dict = dict()
+
+        if pct_change > 0:
+            style_dict['stick_color'] = self.style['up']
+        else:
+            style_dict['stick_color'] = self.style['down']
+
+        return style_dict
+
+
+class CandleStick(DocServer):
+    class ActiveBarData(TypedDict):
+        idx: int
+        ts_start: float
+        ts_end: float
+        open_price: float
+        close_price: float
+        high_price: float
+        low_price: float
+        volume: NotRequired[float]
+
+    def __init__(self, ticker: str, start_date: datetime.date, end_date: datetime.date, profile: Profile = PROFILE, interval: float = 60., x_axis: list[float] = None, theme: DocTheme = None, **kwargs):
+        self.ticker = ticker
+        self.start_date = start_date
+        self.end_date = end_date
+        self.profile = profile
+        self.interval = interval
+        self.indices = self.ts_indices() if x_axis is None else x_axis
+
+        assert self.indices, 'Must assign x_axis to render candlesticks!'
+
+        super().__init__(
+            theme=theme,
+            max_size=kwargs.get('max_size'),
+            update_interval=kwargs.get('update_interval', 0),
+        )
+
+        self.theme = StickTheme(profile=self.profile) if self.theme is None else self.theme
+        self.timestamp: float = 0.
+        self.active_bar_data: CandleStick.ActiveBarData | None = None
+        self._data = {
+            'index': [],
+            'market_time': [],
+            'open_price': [],
+            'cs.high_price': [],
+            'cs.low_price': [],
+            'close_price': [],
+            'volume': [],
+            '_max_price': [],
+            '_min_price': [],
+            'stick_color': []
+        }
+
+    def ts_indices(self) -> list[float]:
+        """generate integer indices
+        from start date to end date, with given interval, in seconds
+        """
+
+        calendar = self.profile.trade_calendar(start_date=self.start_date, end_date=self.end_date)
+        timestamps = []
+        for market_date in calendar:
+            _ts_indices = ts_indices(
+                market_date=market_date,
+                interval=self.interval,
+                session_start=self.profile.session_start,
+                session_end=self.profile.session_end,
+                session_break=self.profile.session_break,
+                time_zone=self.profile.time_zone,
+                ts_mode='both'
+            )
+
+            timestamps.extend(_ts_indices)
+
+        return timestamps
+
+    def loc_indices(self, timestamp: float, start_idx: int = 0) -> tuple[int, float]:
+        last_idx = idx = start_idx
+
+        while idx < len(self.indices):
+            ts = self.indices[idx]
+
+            if ts > timestamp:
+                break
+
+            last_idx = idx
+            idx += 1
+
+        return last_idx, self.indices[last_idx]
+
+    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:
+                self._on_obs(timestamp=market_data.timestamp, price=market_data.market_price)
+            self.timestamp = market_data.timestamp
+        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
+
+        self.lock.release()
+
+    def _on_obs(self, timestamp: float, price: float, volume: float = 0., **kwargs):
+        open_price = kwargs.get('open_price', price)
+        high_price = kwargs.get('high_price', price)
+        low_price = kwargs.get('low_price', price)
+
+        if self.active_bar_data is None:
+            int_idx, ts_idx = self.loc_indices(timestamp=timestamp, start_idx=0)
+            if timestamp < ts_idx:
+                return
+
+            self.active_bar_data = self.ActiveBarData(
+                idx=int_idx,
+                ts_start=ts_idx,
+                ts_end=ts_idx + self.interval,
+                open_price=open_price,
+                high_price=high_price,
+                low_price=low_price,
+                close_price=price,
+                volume=volume
+            )
+        elif timestamp <= self.active_bar_data['ts_end']:
+            if 'open_price' in kwargs:
+                self.active_bar_data['open_price'] = open_price
+
+            self.active_bar_data['high_price'] = max(high_price, self.active_bar_data['high_price'])
+            self.active_bar_data['low_price'] = min(low_price, self.active_bar_data['low_price'])
+            self.active_bar_data['close_price'] = price
+
+            self.active_bar_data['volume'] += volume
+
+        if timestamp >= self.active_bar_data['ts_end']:
+            self.pipe(sequence=self.data)
+
+            for doc_id in list(self.bokeh_documents):
+                doc = self.bokeh_documents[doc_id]
+                new_data = self.bokeh_data_pipe[doc_id]
+
+                self.pipe(sequence=new_data)
+
+                if not self.update_interval:
+                    doc.add_next_tick_callback(partial(self.stream, doc_id=doc_id))
+
+            int_idx, ts_idx = self.loc_indices(timestamp=timestamp, start_idx=self.active_bar_data['idx'])
+            self.active_bar_data['idx'] = int_idx
+            self.active_bar_data['ts_start'] = ts_idx
+            self.active_bar_data['ts_end'] = ts_idx + self.interval
+            self.active_bar_data['open_price'] = price
+            self.active_bar_data['close_price'] = price
+            self.active_bar_data['high_price'] = price
+            self.active_bar_data['low_price'] = price
+            self.active_bar_data['volume'] = volume
+
+    def pipe(self, sequence: dict[str, list]):
+        sequence['index'].append(self.active_bar_data['idx'] + 0.5)  # to ensure bar rendered in the center of the interval
+        sequence['market_time'].append(datetime.datetime.fromtimestamp(self.active_bar_data['ts_start'], tz=self.profile.time_zone))
+        sequence['open_price'].append(self.active_bar_data['open_price'])
+        sequence['close_price'].append(self.active_bar_data['close_price'])
+        sequence['cs.high_price'].append(self.active_bar_data['high_price'])
+        sequence['cs.low_price'].append(self.active_bar_data['low_price'])
+        sequence['volume'].append(self.active_bar_data['volume'])
+        sequence['_max_price'].append(max(self.active_bar_data['open_price'], self.active_bar_data['close_price']))
+        sequence['_min_price'].append(min(self.active_bar_data['open_price'], self.active_bar_data['close_price']))
+        sequence['stick_color'].append(self.theme.stick_style(self.active_bar_data['close_price'] - self.active_bar_data['open_price'])['stick_color'])
+
+    def layout(self, doc_id: int):
+        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_data_source[doc_id]
+
+        tools = [
+            PanTool(dimensions="width", syncable=False),
+            WheelPanTool(dimension="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(syncable=False),
+            ResetTool(syncable=False),
+            SaveTool(syncable=False)
+        ]
+
+        tooltips = [
+            ("market_time", "@market_time{%H:%M:%S}"),
+            ("close_price", "@close_price"),
+            ("open_price", "@open_price"),
+            ("high_price", "@{cs.high_price}"),
+            ("low_price", "@{cs.low_price}"),
+        ]
+
+        plot = figure(
+            title=f"{self.ticker} Candlestick",
+            x_range=Range1d(start=0, end=len(self.indices), bounds='auto'),
+            x_axis_type="linear",
+            # sizing_mode="stretch_both",
+            min_height=80,
+            tools=tools,
+            tooltips=tooltips,
+            y_axis_location="right",
+        )
+
+        _shadows = plot.segment(
+            name='candlestick.shade',
+            x0='index',
+            x1='index',
+            y0='cs.low_price',
+            y1='cs.high_price',
+            line_width=1,
+            color="black",
+            alpha=0.8,
+            source=source
+        )
+
+        _candlestick = plot.vbar(
+            name='candlestick',
+            x='index',
+            top='_max_price',
+            bottom='_min_price',
+            width=1 - self.theme.stick_padding,
+            color='stick_color',
+            alpha=0.5,
+            source=source
+        )
+
+        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]
+
+        range_selector = figure(
+            y_range=plot.y_range,
+            min_height=20,
+            tools=[],
+            toolbar_location=None,
+            # sizing_mode="stretch_both"
+        )
+
+        range_tool = RangeTool(x_range=plot.x_range)
+        range_tool.overlay.fill_alpha = 0.5
+
+        range_selector.line('index', 'close_price', source=source)
+        range_selector.add_tools(range_tool)
+        range_selector.x_range.range_padding = self.theme.range_padding
+        range_selector.xaxis.visible = False
+        range_selector.xgrid.visible = False
+        range_selector.ygrid.visible = False
+
+        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):
+        df = pd.DataFrame(self.data).set_index(keys='market_time')
+        df = df[['open_price', 'high_price', 'low_price', 'close_price', 'volume']]
+        df.to_csv(filename)
+
+    @property
+    def data(self) -> dict[str, list]:
+        return self._data