PyAlgoEngine 0.12.3__cp315-cp315-win_amd64.whl

algo_engine/__infra__.pxd

@@ -0,0 +1,3 @@
+from .base cimport *
+from .engine cimport *
+from .exchange_profile cimport *

algo_engine/__init__.pxd

@@ -0,0 +1,3 @@
+from .base cimport *
+from .engine cimport *
+from .exchange_profile cimport *

algo_engine/__init__.py

@@ -0,0 +1,107 @@
+__version__ = "0.12.3"
+
+import functools
+import logging
+import os
+import pathlib
+import traceback
+from collections.abc import Mapping
+
+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())
+
+from . import base
+from . import exchange_profile
+from . import engine
+from . import backtest
+from . import strategy
+from . import apps
+from . import monitor
+from . import utils
+
+
+def set_logger(logger: logging.Logger):
+    from . import base
+    from . import exchange_profile
+    from . import engine
+    from . import backtest
+    from . import strategy
+    from . import apps
+
+    base.set_logger(logger=logger)
+    exchange_profile.set_logger(logger=logger.getChild('ExchangeProfile'))
+    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()}')
+
+
+def _format_config_view(config: Mapping, indent: int = 0) -> str:
+    """Render a (possibly nested) config view as indented bullet lines."""
+    lines = []
+    for key, value in config.items():
+        if isinstance(value, Mapping):
+            lines.append(f"{'  ' * indent}- {key}:")
+            lines.append(_format_config_view(value, indent + 1))
+        else:
+            lines.append(f"{'  ' * indent}- {key}: {value}")
+    return "\n".join(lines)
+
+
+@functools.cache
+def get_include() -> list[str]:
+    import os
+    from .base import CONFIG
+
+    res_dir = pathlib.Path(__file__).parent
+    LOGGER.info(
+        f'Building with <PyAlgoEngine> version: "{__version__}", resource directory: "{res_dir}", '
+        f"config:\n{_format_config_view(CONFIG)}"
+    )
+
+    scr_dir = [
+        os.path.realpath(res_dir),
+        os.path.realpath(res_dir / 'base'),
+        os.path.realpath(res_dir / 'base' / 'c_market_data'),
+        os.path.realpath(res_dir / 'exchange_profile'),
+        os.path.realpath(res_dir / 'engine'),
+    ]
+
+    # Auto-generated unified include root (mirrors every C header under
+    # algo_engine/include/algo_engine/...). Populated by setup.py's
+    # collect_headers step; expose it to downstream builds when present.
+    include_root = os.path.realpath(res_dir / 'includes')
+    if os.path.isdir(include_root):
+        scr_dir.append(include_root)
+
+    import cbase
+    dep_dir = cbase.get_include()
+
+    import event_engine
+    dep_dir += event_engine.get_include()
+
+    return scr_dir + dep_dir
+
+
+__all__ = [
+    'apps', 'backtest', 'base', 'engine', 'exchange_profile', 'monitor', 'profile', 'strategy', 'utils',
+    'algo_addon',
+    'get_include',
+    'LOGGER'
+]

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,328 @@
+import datetime
+import pathlib
+from functools import partial
+from typing import NotRequired, TypedDict
+
+import pandas as pd
+
+from algo_engine.apps import DocServer, DocTheme
+from algo_engine.base import MarketData, TradeData, TransactionData
+from algo_engine.exchange_profile import PROFILE
+from algo_engine.utils import ts_indices
+
+
+class StickTheme(DocTheme):
+    stick_padding = 0.1
+    range_padding = 0.01
+
+    ColorStyle = TypedDict('ColorStyle', {'up': str, 'down': str})
+    ws_style = ColorStyle(up="green", down="red")
+    cn_style = ColorStyle(up="red", down="green")
+
+    def __init__(self, style: ColorStyle = None):
+        if style is None:
+            if PROFILE.profile_id in ['CN_STOCK']:
+                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, 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.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() 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 = 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=PROFILE.session_start.to_pytime(),
+                session_end=PROFILE.session_end.to_pytime(),
+                session_break=[(session_break.break_start.to_pytime(), session_break.break_end.to_pytime()) for session_break in PROFILE.session_breaks],
+                time_zone=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(PROFILE.timestamp_to_datetime(self.active_bar_data['ts_start']))
+        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: PROFILE.timestamp_to_datetime(ts).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

algo_engine/apps/backtest/static/styles/dash.css

@@ -0,0 +1,48 @@
+/* styles.css */
+html, body {
+    height: 100%;
+    width: 100%;
+    margin: 0;
+    padding: 0;
+    background-color: #121212;
+    color: #e0e0e0;
+    font-family: Arial, sans-serif;
+}
+
+.container {
+    display: flex;
+    flex-direction: column;
+    height: 100%;
+    width: 100%;
+}
+
+.header {
+    flex: 0 1 auto;
+    text-align: center;
+    padding: 10px;
+    background-color: #1f1f1f;
+}
+
+.header h1 {
+    margin: 0;
+    color: #e0e0e0;
+}
+
+.content {
+}
+
+.content.candlesticks {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    width: 100%;
+    height: 100%;
+}
+
+.content.candlesticks > div {
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    width: 100%;
+    height: 100%;
+}

algo_engine/apps/backtest/templates/dash.html

@@ -0,0 +1,20 @@
+<!doctype html>
+
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <title>Dashboard {{ ticker }}</title>
+    <link rel="stylesheet" type="text/css" href="{{ url_for('static',filename='styles/dash.css') }}">
+</head>
+
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>Backtest App for {{ ticker }}</h1>
+        </div>
+        <div class="content candlesticks">
+            {{ candlesticks|safe }}
+        </div>
+    </div>
+</body>
+</html>

algo_engine/apps/backtest/templates/index.html

@@ -0,0 +1,40 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{{ title }}</title>
+    <style>
+        table {
+            width: 50%;
+            margin: auto;
+            border-collapse: collapse;
+        }
+
+        th, td {
+            border: 1px solid black;
+            padding: 8px;
+            text-align: left;
+        }
+
+        th {
+            background-color: #f2f2f2;
+        }
+    </style>
+</head>
+<body>
+<h2 style="text-align: center;">Backtest Dashboard Urls</h2>
+<table>
+    <tr>
+        <th>Ticker</th>
+        <th>Dashboard Urls</th>
+    </tr>
+    {% for key, value in data.items() %}
+    <tr>
+        <td>{{ key }}</td>
+        <td><a href="{{ value }}">{{ value }}</a></td>
+    </tr>
+    {% endfor %}
+</table>
+</body>
+</html>