PyAlgoEngine 0.12.3__cp315-cp315-win_amd64.whl

algo_engine/apps/sim_input/window.py

@@ -0,0 +1,162 @@
+__package__ = 'algo_engine.apps.sim_input'
+
+import ctypes
+import dataclasses
+import enum
+import os
+from typing import Literal
+
+from . import LOGGER
+
+LOGGER.getChild('Window')
+
+# Define necessary Windows API functions and constants
+user32 = ctypes.windll.user32
+kernel32 = ctypes.windll.kernel32
+psapi = ctypes.windll.psapi
+
+# Define constants for access rights
+PROCESS_QUERY_INFORMATION = 0x0400
+PROCESS_VM_READ = 0x0010
+
+# Define necessary Windows API function prototypes
+WNDENUMPROC = ctypes.WINFUNCTYPE(ctypes.c_bool, ctypes.c_int, ctypes.POINTER(ctypes.c_int))
+
+
+@dataclasses.dataclass(frozen=True)
+class WindowInfo:
+    window_name: str
+    pid: int
+    hwnd: int
+    executable_name: str
+    executable_path: str
+
+
+class WindowState(enum.IntEnum):
+    SW_SHOWNORMAL = 1  # Show the window normally
+    SW_SHOWMINIMIZED = 2  # Minimize the window
+    SW_SHOWMAXIMIZED = 3  # Maximize the window
+    SW_SHOWNOACTIVATE = 4  # Show the window without activating it
+    SW_SHOW = 5  # Show the window and bring it to the foreground
+
+
+# Function to get PID from window handle
+def get_pid(hwnd):
+    pid = ctypes.c_ulong()
+    user32.GetWindowThreadProcessId(hwnd, ctypes.byref(pid))
+    return pid.value
+
+
+# Function to retrieve the executable path and name of a process
+def get_executable_info(pid):
+    # Open the process to get information
+    h_process = kernel32.OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, False, pid)
+    if not h_process:
+        return None, None
+
+    # Buffer to hold the path
+    path_buffer = ctypes.create_unicode_buffer(1024)
+
+    # Get the full executable path using GetModuleFileNameEx
+    if psapi.GetModuleFileNameExW(h_process, 0, path_buffer, ctypes.byref(ctypes.c_ulong(1024))):
+        executable_path = path_buffer.value
+        executable_name = os.path.basename(executable_path)
+    else:
+        executable_path = None
+        executable_name = None
+
+    # Close the process handle
+    kernel32.CloseHandle(h_process)
+
+    return executable_name, executable_path
+
+
+# Function to check if a window is visible (including minimized)
+def is_window_visible(hwnd):
+    return user32.IsWindowVisible(hwnd)
+
+
+# Function to enumerate windows
+def get_windows() -> list[WindowInfo]:
+    windows = []
+
+    def enum_windows_proc(hwnd, _):
+        # Only include visible windows
+        if not is_window_visible(hwnd):
+            return True
+
+        # Get window title (for name)
+        length = user32.GetWindowTextLengthW(hwnd)
+        if length > 0:
+            buffer = ctypes.create_unicode_buffer(length + 1)
+            user32.GetWindowTextW(hwnd, buffer, length + 1)
+            window_name = buffer.value
+        else:
+            window_name = "Untitled"
+
+        # Get the PID for the window
+        pid = get_pid(hwnd)
+
+        # Get executable name and path
+        executable_name, executable_path = get_executable_info(pid)
+
+        # Append to the windows list as a tuple (window_name, pid, hwnd, executable_name, executable_path)
+        windows.append(WindowInfo(window_name=window_name, pid=pid, hwnd=hwnd, executable_name=executable_name, executable_path=executable_path))
+        return True
+
+    # Enumerate all windows (including child windows)
+    user32.EnumWindows(WNDENUMPROC(enum_windows_proc), 0)
+
+    return windows
+
+
+def find_window(name: str = None, executable: str = None) -> list[WindowInfo]:
+    windows = get_windows()
+    matched = []
+
+    for window in windows:
+        if name is not None and name.lower() not in window.name.lower():
+            continue
+
+        if executable is not None and executable.lower() not in window.executable_name.lower():
+            continue
+
+        matched.append(window)
+
+    return matched
+
+
+# Function to set the window action (top, maximize, minimize)
+def set_window(window_info: WindowInfo, action: Literal['top', 'maximize', 'minimize', 'max', 'min']):
+    hwnd = window_info.hwnd
+
+    match action:
+        case "top":
+            # Bring the window to the front (top)
+            user32.ShowWindow(hwnd, WindowState.SW_SHOWNORMAL)
+            user32.SetForegroundWindow(hwnd)
+        case "maximize" | 'max':
+            # Maximize the window
+            user32.ShowWindow(hwnd, WindowState.SW_SHOWMAXIMIZED)
+        case "minimize" | 'min':
+            # Minimize the window
+            user32.ShowWindow(hwnd, WindowState.SW_SHOWMINIMIZED)
+        case _:
+            raise ValueError(f"Unknown action: {action}")
+
+
+def main():
+    # Example usage
+    windows = get_windows()
+    for _ in windows:
+        LOGGER.debug(_)
+
+    firefox = find_window(executable="firefox")[0]
+    LOGGER.info(firefox)
+
+    set_window(window_info=firefox, action='top')
+    set_window(window_info=firefox, action='maximize')
+
+
+if __name__ == "__main__":
+    main()

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 PyDataScope, MarketDateCallable, MarketDataLoader, MarketDataBulkLoader, Replay, SimpleReplay, ProgressReplay
+from .sim_match import SimMatch
+
+__all__ = ['PyDataScope', 'MarketDateCallable', 'MarketDataLoader', 'MarketDataBulkLoader', 'Replay', 'SimpleReplay', 'ProgressReplay', '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']

algo_engine/backtest/metrics.py

@@ -0,0 +1,179 @@
+import uuid
+
+import numpy as np
+import pandas as pd
+
+
+class TradeMetrics(object):
+    def __init__(self):
+        self.trades = {}
+        self.trade_batch = []
+
+        self.exposure = 0.
+        self.total_pnl = 0.
+        self.total_cash_flow = 0.
+
+        self.current_pnl = 0.
+        self.current_cash_flow = 0.
+        self.current_trade_batch = {'cash_flow': 0., 'pnl': 0., 'turnover': 0., 'trades': []}
+        self.market_price = None
+
+    def update(self, market_price: float):
+        self.market_price = market_price
+        self.total_pnl = self.exposure * market_price + self.total_cash_flow
+        self.current_pnl = self.exposure * market_price + self.current_cash_flow
+        self.current_trade_batch['pnl'] = self.exposure * market_price + self.current_trade_batch['cash_flow']
+
+    def add_trades(self, side: int, price: float, timestamp: float, volume: float = None, trade_id: int | str = None):
+        assert side in {1, -1}, f"trade side must in {1, -1}, got {side}."
+        assert volume is None or volume >= 0, "volume must be positive."
+
+        if volume is None:
+            if self.exposure * side < 0:
+                volume = abs(self.exposure)
+            elif self.exposure * side > 0:
+                volume = 0.
+            else:
+                volume = 1.
+
+        if trade_id is None:
+            trade_id = uuid.uuid4().int
+        elif trade_id in self.trades:
+            return
+
+        # split the trades
+        if (target_exposure := self.exposure + volume * side) * self.exposure < 0:
+            self.add_trades(side=side, volume=abs(self.exposure), price=price, timestamp=timestamp, trade_id=f'{trade_id}.0')
+            volume = volume - abs(self.exposure)
+            trade_id = f'{trade_id}.1'
+
+        self.exposure += volume * side
+        self.total_cash_flow -= volume * side * price
+        self.total_pnl = self.exposure * price + self.total_cash_flow
+        self.current_cash_flow -= volume * side * price
+        self.current_pnl = self.exposure * price + self.current_cash_flow
+        self.market_price = price
+
+        self.trades[trade_id] = trade_log = dict(
+            side=side,
+            volume=volume,
+            timestamp=timestamp,
+            price=price,
+            exposure=self.exposure,
+            cash_flow=self.current_cash_flow,
+            pnl=self.current_pnl
+        )
+
+        if 'init_side' not in self.current_trade_batch:
+            self.current_trade_batch['init_side'] = side
+
+        self.current_trade_batch['cash_flow'] -= volume * side * price
+        self.current_trade_batch['pnl'] = self.exposure * price + self.current_trade_batch['cash_flow']
+        self.current_trade_batch['turnover'] += abs(volume) * price
+        self.current_trade_batch['trades'].append(trade_log)
+
+        if not self.exposure:
+            self.trade_batch.append(self.current_trade_batch)
+            self.current_trade_batch = {'cash_flow': 0., 'pnl': 0., 'turnover': 0., 'trades': []}
+            self.current_pnl = self.current_cash_flow = 0.
+
+    def add_trades_batch(self, trade_logs: pd.DataFrame):
+        for timestamp, row in trade_logs.iterrows():  # type: float, dict
+            side = row['side']
+            price = row['current_price']
+            volume = row['signal']
+            self.add_trades(side=side, volume=volume, price=price, timestamp=timestamp)
+
+    def clear(self):
+        self.trades.clear()
+        self.trade_batch.clear()
+
+        self.exposure = 0.
+        self.total_pnl = 0.
+        self.total_cash_flow = 0.
+
+        self.current_pnl = 0.
+        self.current_cash_flow = 0.
+        self.current_trade_batch = {'cash_flow': 0., 'pnl': 0., 'turnover': 0., 'trades': []}
+        self.market_price = None
+
+    @property
+    def summary(self):
+        info_dict = dict(
+            total_gain=0.,
+            total_loss=0.,
+            trade_count=0,
+            win_count=0,
+            lose_count=0,
+            turnover=0.,
+        )
+
+        for trade_batch in self.trade_batch:
+            if trade_batch['pnl'] > 0:
+                info_dict['total_gain'] += trade_batch['pnl']
+                info_dict['trade_count'] += 1
+                info_dict['win_count'] += 1
+                info_dict['turnover'] += trade_batch['turnover']
+            else:
+                info_dict['total_loss'] += trade_batch['pnl']
+                info_dict['trade_count'] += 1
+                info_dict['lose_count'] += 1
+                info_dict['turnover'] += trade_batch['turnover']
+
+        info_dict['win_rate'] = info_dict['win_count'] / info_dict['trade_count'] if info_dict['trade_count'] else 0.
+        info_dict['average_gain'] = info_dict['total_gain'] / info_dict['win_count'] / self.market_price if info_dict['win_count'] else 0.
+        info_dict['average_loss'] = info_dict['total_loss'] / info_dict['lose_count'] / self.market_price if info_dict['lose_count'] else 0.
+        info_dict['gain_loss_ratio'] = -info_dict['average_gain'] / info_dict['average_loss'] if info_dict['average_loss'] else 1.
+        info_dict['long_avg_pnl'] = np.average([_['pnl'] for _ in long_trades]) / self.market_price if (long_trades := [_ for _ in self.trade_batch if _['init_side'] == 1]) else np.nan
+        info_dict['short_avg_pnl'] = np.average([_['pnl'] for _ in short_trades]) / self.market_price if (short_trades := [_ for _ in self.trade_batch if _['init_side'] == -1]) else np.nan
+        info_dict['ttl_pnl.no_leverage'] = np.sum([trade_batch['pnl'] for trade_batch in self.trade_batch])
+        info_dict['net_pnl.optimistic'] = info_dict['ttl_pnl.no_leverage'] - (0.00034 + 0.000023) / 2 * info_dict['turnover']
+
+        return info_dict
+
+    @property
+    def info(self):
+        trade_info = []
+        trade_index = []
+        for batch_id, trade_batch in enumerate(self.trade_batch):
+            for trade_id, trade_dict in enumerate(trade_batch['trades']):
+                trade_info.append(
+                    dict(
+                        timestamp=trade_dict['timestamp'],
+                        side=trade_dict['side'],
+                        volume=trade_dict['volume'],
+                        price=trade_dict['price'],
+                        exposure=trade_dict['exposure'],
+                        pnl=trade_dict['pnl']
+                    )
+                )
+                trade_index.append((f'batch.{batch_id}', f'trade.{trade_id}'))
+
+        df = pd.DataFrame(trade_info, index=trade_index)
+        return df
+
+    def to_string(self) -> str:
+        metric_info = self.summary
+
+        fmt_dict = {
+            'total_gain': f'{metric_info["total_gain"]:,.3f}',
+            'total_loss': f'{metric_info["total_loss"]:,.3f}',
+            'trade_count': f'{metric_info["trade_count"]:,}',
+            'win_count': f'{metric_info["win_count"]:,}',
+            'lose_count': f'{metric_info["lose_count"]:,}',
+            'turnover': f'{metric_info["turnover"]:,.3f}',
+            'win_rate': f'{metric_info["win_rate"]:.2%}',
+            'average_gain': f'{metric_info["average_gain"]:,.4%}',
+            'average_loss': f'{metric_info["average_loss"]:,.4%}',
+            'long_avg_pnl': f'{metric_info["long_avg_pnl"]:,.4%}',
+            'short_avg_pnl': f'{metric_info["short_avg_pnl"]:,.4%}',
+            'gain_loss_ratio': f'{metric_info["gain_loss_ratio"]:,.3%}'
+        }
+
+        info_str = (f'Trade Metrics Report:'
+                    f'\n'
+                    f'{pd.Series(fmt_dict).to_string()}'
+                    f'\n'
+                    f'{self.info.to_string()}')
+
+        return info_str