PyAlgoEngine 0.8.0a16__tar.gz → 0.8.0.post2__tar.gz

{pyalgoengine-0.8.0a16 → pyalgoengine-0.8.0.post2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAlgoEngine
-Version: 0.8.0a16
+Version: 0.8.0.post2
 Summary: Basic algo engine
 Home-page: https://github.com/BolunHan/PyAlgoEngine
 Author: Bolun.Han

{pyalgoengine-0.8.0a16 → pyalgoengine-0.8.0.post2}/PyAlgoEngine.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAlgoEngine
-Version: 0.8.0a16
+Version: 0.8.0.post2
 Summary: Basic algo engine
 Home-page: https://github.com/BolunHan/PyAlgoEngine
 Author: Bolun.Han

{pyalgoengine-0.8.0a16 → pyalgoengine-0.8.0.post2}/PyAlgoEngine.egg-info/SOURCES.txt

@@ -37,6 +37,7 @@ algo_engine/base/technical_analysis.py
 algo_engine/base/telemetrics.py
 algo_engine/base/tick.pyi
 algo_engine/base/trade_utils.pyi
+algo_engine/base/trade_utils_native.py
 algo_engine/base/transaction.pyi
 algo_engine/engine/__init__.py
 algo_engine/engine/algo_engine.py

{pyalgoengine-0.8.0a16 → pyalgoengine-0.8.0.post2}/algo_engine/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.8.0.alpha16"
+__version__ = "0.8.0.post2"
 
 import logging
 import os

{pyalgoengine-0.8.0a16 → pyalgoengine-0.8.0.post2}/algo_engine/apps/backtest/tester.py

@@ -8,7 +8,7 @@ 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 ...backtest import SimMatch, ProgressReplay
 from ...base import MarketData, TradeReport, TradeInstruction
 from ...profile import Profile, PROFILE
 
@@ -109,17 +109,18 @@ class Tester(object, metaclass=abc.ABCMeta):
         pass
 
     def run(self, **kwargs):
-        replay = ProgressiveReplay(
+        replay = ProgressReplay(
             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),
         )
 
+        for ticker in self.subscription:
+            replay.add_subscription(ticker, dtype='TickData')
+            replay.add_subscription(ticker, dtype='TradeData')
+
         _start_ts = time.time()
 
         for market_data in replay:
@@ -222,17 +223,18 @@ class StrategyTester(Tester):
         if not self.event_engine.active:
             self.event_engine.start()
 
-        replay = ProgressiveReplay(
+        replay = ProgressReplay(
             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),
         )
 
+        for ticker in self.subscription:
+            replay.add_subscription(ticker, dtype='TickData')
+            replay.add_subscription(ticker, dtype='TradeData')
+
         _start_ts = time.time()
 
         for market_data in replay:

pyalgoengine-0.8.0.post2/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']

{pyalgoengine-0.8.0a16 → pyalgoengine-0.8.0.post2}/algo_engine/backtest/replay.py

@@ -1,16 +1,97 @@
 import abc
 import datetime
+import enum
 import inspect
+import logging
 import operator
 import warnings
 from collections.abc import Sequence, Mapping, Iterable, Callable
-from typing import Literal, Protocol, runtime_checkable, get_type_hints
+from typing import Literal, Protocol, runtime_checkable, get_type_hints, Self
 
 from . import LOGGER
 from ..base import MarketData, DataType, MarketDataBuffer
 
 LOGGER = LOGGER.getChild('Replay')
-__all__ = ['MarketDateCallable', 'MarketDataLoader', 'MarketDataBulkLoader', 'Replay', 'SimpleReplay', 'ProgressReplay', 'ProgressiveReplay']
+__all__ = ['PyDataScope', 'MarketDateCallable', 'MarketDataLoader', 'MarketDataBulkLoader', 'Replay', 'SimpleReplay', 'ProgressReplay', 'ProgressiveReplay']
+
+
+class PyDataScope(enum.Flag):
+    SCOPE_TRANSACTION = enum.auto()
+    SCOPE_ORDER = enum.auto()
+    SCOPE_TICK = enum.auto()
+    SCOPE_TICK_LITE = enum.auto()
+
+    SCOPE_ALL = SCOPE_TRANSACTION | SCOPE_ORDER | SCOPE_TICK
+
+    @classmethod
+    def _missing_(cls, value: Literal['TickData', 'TickDataLite', 'OrderData', 'TransactionData']):
+        if isinstance(value, int):
+            return super()._missing_(value)
+
+        if isinstance(value, str):
+            dtypes = value.split(',')
+        elif isinstance(value, Iterable):
+            dtypes = value
+        else:
+            raise TypeError(value)
+
+        _ = PyDataScope(0)
+        for dtype in dtypes:
+            _ = _.from_str(dtype)
+        return _
+
+    @classmethod
+    def get_dtype(cls, dtype: DataType | str) -> str | Literal['TickData', 'TickDataLite', 'OrderData', 'TransactionData']:
+        match dtype:
+            case 'TickData' | 'TickDataLite' | 'OrderData' | 'TransactionData':
+                return str(dtype)
+            case 'TradeData':  # handle the alias
+                return 'TransactionData'
+            case DataType.DTYPE_TICK | DataType.DTYPE_ORDER | DataType.DTYPE_TRANSACTION:
+                return DataType(dtype).name.removeprefix('DTYPE_').capitalize() + 'Data'
+            case DataType.DTYPE_TICK_LITE:
+                return 'Data'.join(_.capitalize() for _ in DataType(dtype).name.removeprefix('DTYPE_').split('_'))
+            case _:
+                raise ValueError(f'Invalid dtype {dtype}, expect str or int.')
+
+    def __iter__(self):
+        return iter(self.to_dtype())
+
+    def to_dtype(self) -> list[DataType]:
+        scope = list(super().__iter__())
+        scope_dtype = set()
+
+        for dtype in scope:
+
+            if dtype is PyDataScope.SCOPE_TRANSACTION:
+                scope_dtype.add(DataType.DTYPE_TRANSACTION)
+            elif dtype is PyDataScope.SCOPE_ORDER:
+                scope_dtype.add(DataType.DTYPE_ORDER)
+            elif dtype is PyDataScope.SCOPE_TICK_LITE:
+                scope_dtype.add(DataType.DTYPE_TICK_LITE)
+            elif dtype is PyDataScope.SCOPE_TICK:
+                scope_dtype.add(DataType.DTYPE_TICK)
+
+        return list(scope_dtype)
+
+    def to_int(self) -> list[int]:
+        return [int(_) for _ in self.to_dtype()]
+
+    def to_str(self) -> list[str]:
+        return [self.get_dtype(_) for _ in self.to_dtype()]
+
+    def from_str(self, dtype: Literal['TickData', 'TickDataLite', 'OrderData', 'TransactionData']) -> Self:
+        match dtype:
+            case 'TickData':
+                return self | self.SCOPE_TICK
+            case 'TickDataLite':
+                return self | self.SCOPE_TICK_LITE
+            case 'OrderData':
+                return self | self.SCOPE_ORDER
+            case 'TransactionData' | 'TradeData':
+                return self | self.SCOPE_TRANSACTION
+            case _:
+                raise ValueError(f'Invalid str {dtype}.')
 
 
 @runtime_checkable
@@ -27,7 +108,7 @@ class MarketDataLoader(Protocol):
 
 @runtime_checkable
 class MarketDataBulkLoader(Protocol):
-    def __call__(self, market_date: datetime.date, tickers: Sequence[str], dtypes: Sequence[str | DataType]) -> Sequence[MarketData] | Mapping[float, MarketData] | MarketDataBuffer:
+    def __call__(self, market_date: datetime.date, tickers: Sequence[str], dtypes: Sequence[str | DataType] | PyDataScope) -> Sequence[MarketData] | Mapping[float, MarketData] | MarketDataBuffer:
         pass
 
 
@@ -40,13 +121,16 @@ def check_protocol_signature(func: Callable, protocol: type) -> bool:
 
     proto_params = list(proto_sig.parameters.values())[1:]  # Skip 'self'
     func_params = list(func_sig.parameters.values())
+    enable_keywords = False
 
     # Check for *args (VAR_POSITIONAL) — not allowed
     for p in func_params:
         if p.kind == inspect.Parameter.VAR_POSITIONAL:
             raise TypeError(f"{func.__name__} uses *args, which is not allowed")
+        elif p.kind == inspect.Parameter.VAR_KEYWORD:
+            enable_keywords = True
 
-    # Check number of required positional args (not counting **kwargs)
+    # Extract positional args (POSITIONAL_ONLY or POSITIONAL_OR_KEYWORD)
     proto_arg_names = [p.name for p in proto_params if p.kind in (
         inspect.Parameter.POSITIONAL_ONLY,
         inspect.Parameter.POSITIONAL_OR_KEYWORD
@@ -57,8 +141,13 @@ def check_protocol_signature(func: Callable, protocol: type) -> bool:
         inspect.Parameter.POSITIONAL_OR_KEYWORD
     )]
 
-    if proto_arg_names != func_arg_names:
-        raise TypeError(f"{func.__name__} argument names {func_arg_names} do not match protocol {proto_arg_names}")
+    # Check if required positional args match (ignore **kwargs)
+    if not enable_keywords and sorted(proto_arg_names) != sorted(func_arg_names):
+        warnings.warn(
+            f"{func} argument names {func_arg_names} do not match protocol {proto_arg_names}",
+            stacklevel=2
+        )
+        return False
 
     # Type hint comparison (warn if mismatched, but allow)
     proto_hints = get_type_hints(protocol.__call__)
@@ -104,32 +193,26 @@ class Replay(object, metaclass=abc.ABCMeta):
         if eod is not None:
             self.add_eod(eod)
 
-    def add_bod(self, func: MarketDateCallable):
-        self.bod.append(func)
-
-    def add_eod(self, func: MarketDateCallable):
-        self.eod.append(func)
+    def add_bod(self, func: MarketDateCallable, priority: int = None) -> None:
+        if priority is None:
+            self.bod.append(func)
+        else:
+            self.bod.insert(priority, func)
 
-    @classmethod
-    def get_dtype(cls, dtype: DataType | str) -> str | Literal['TickData', 'TickDataLite', 'OrderData', 'TransactionData']:
-        match dtype:
-            case 'TickData' | 'TickDataLite' | 'OrderData' | 'TransactionData':
-                return str(dtype)
-            case DataType.DTYPE_TICK | DataType.DTYPE_ORDER | DataType.DTYPE_TRANSACTION:
-                return DataType(dtype).name.removeprefix('DTYPE_').capitalize() + 'Data'
-            case DataType.DTYPE_TICK_LITE:
-                return 'Data'.join(_.capitalize() for _ in DataType(dtype).name.removeprefix('DTYPE_').split('_'))
-            case _:
-                raise ValueError(f'Invalid dtype {dtype}, expect str or int.')
+    def add_eod(self, func: MarketDateCallable, priority: int = None):
+        if priority is None:
+            self.eod.append(func)
+        else:
+            self.eod.insert(priority, func)
 
     def add_subscription(self, ticker: str, dtype: DataType | str):
-        dtype = self.get_dtype(dtype)
+        dtype = PyDataScope.get_dtype(dtype)
         topic = f'{ticker}.{dtype}'
 
         self.subscription[topic] = (ticker, dtype)
 
     def remove_subscription(self, ticker: str, dtype: DataType | str):
-        dtype = self.get_dtype(dtype)
+        dtype = PyDataScope.get_dtype(dtype)
         topic = f'{ticker}.{dtype}'
 
         try:
@@ -162,7 +245,7 @@ class SimpleReplay(Replay):
 
     def __iter__(self):
         self._calendar = self.calendar or [self.start_date + datetime.timedelta(days=i) for i in range((self.end_date - self.start_date).days + 1)]
-        self._market_date = self.market_date or sorted(_ for _ in self._calendar if _ >= self.market_date)[0]
+        self._market_date = sorted(_ for _ in self._calendar if _ >= self.market_date)[0]
         self._status = {market_date: 'skipped' if market_date < self.market_date else 'idle' for market_date in self._calendar}
         self._idx_buffer = 0
         self._idx_date = sum([1 for _ in self._calendar if _ < self.market_date])
@@ -208,7 +291,9 @@ class SimpleReplay(Replay):
         return f'{self.__class__.__name__}{{id={id(self)}, from={self.start_date}, to={self.end_date}}}'
 
     def _bulk_load_protocol(self):
+        LOGGER.info(f'{self} loading {self._market_date} {(', '.join(self.dtypes)) if self.dtypes else 'data'} for {len(self.tickers)} tickers...')
         buffer = self.loader(market_date=self._market_date, tickers=self.tickers, dtypes=self.dtypes)
+        LOGGER.info(f'{self} sorting {self._market_date} data...')
         buffer.sort()
 
         if isinstance(buffer, MarketDataBuffer):
@@ -220,11 +305,12 @@ class SimpleReplay(Replay):
         elif isinstance(buffer, Mapping):
             self._buffer = iter(buffer.values())
             self._buffer_size = len(buffer)
+        LOGGER.info(f'{self} {self._market_date} total {self._buffer_size:,} items loaded.')
 
     def _individual_load_protocol(self):
         buffer = []
         for topic, (_ticker, _dtype) in self.subscription.items():
-            LOGGER.info(f'{self} loading {self._market_date} {_ticker} {_dtype}')
+            LOGGER.info(f'{self} loading {self._market_date} {_ticker} {_dtype}...')
             data = self.loader(market_date=self._market_date, ticker=_ticker, dtype=_dtype)
             if isinstance(data, Mapping):
                 buffer.extend(list(data.values()))
@@ -232,14 +318,16 @@ class SimpleReplay(Replay):
                 buffer.extend(data)
             else:
                 raise TypeError(f'The loader {self.loader} returned {type(data)}. Expect a sequence or mapping of MarketData')
+        LOGGER.info(f'{self} sorting {self._market_date} data...')
         buffer.sort(key=operator.attrgetter('timestamp', 'ticker', '_dtype'))
         self._buffer = iter(buffer)
         self._buffer_size = len(buffer)
+        LOGGER.info(f'{self} {self._market_date} total {self._buffer_size:,} items loaded.')
 
     def _safe_load(self):
         if self.loader is None:
             assert hasattr(self, '_buffer') and isinstance(self._buffer, Iterable), f'Without assigning a data loader, the _buffer of {self.__class__.__name__} should be set in bod process.'
-            return
+            return None
 
         is_bulk_loader = check_protocol_signature(self.loader, MarketDataBulkLoader)
         is_individual_loader = check_protocol_signature(self.loader, MarketDataLoader)
@@ -266,7 +354,7 @@ class SimpleReplay(Replay):
         if not hasattr(self, '_buffer'):
             raise RuntimeError(f'{self.__class__.__name__} not started yet.')
 
-        return (self._idx_date + (self._idx_buffer / self._buffer_size - 1)) / len(self._calendar)
+        return (self._idx_date + self._idx_buffer / self._buffer_size) / len(self._calendar)
 
     @property
     def tickers(self) -> list[str]:
@@ -300,7 +388,7 @@ class ProgressReplay(SimpleReplay):
             calendar: Sequence[datetime.date] = None,
             bod: MarketDateCallable = None,
             eod: MarketDateCallable = None,
-            **tqdm_kwargs
+            **pbar_config
     ):
         super().__init__(
             loader=loader,
@@ -312,42 +400,134 @@ class ProgressReplay(SimpleReplay):
             eod=eod
         )
 
-        self._tqdm_kwargs = {
-            'total': 1,
-            'unit_scale': True,
-            'unit': 'percent',
-            'mininterval': 0.1,
-            'miniters': 0.001,
-            **tqdm_kwargs
+        self.pbar_config = {
+            'backend': pbar_config.pop('backend', 'tqdm'),  # tqdm or native
+            'config': pbar_config,
         }
-        self.add_bod(self._update_progress_bar)
+        self._pbar = None
+        self.add_bod(self._update_pbar_prefix, priority=0)
+
+    def _init_pbar(self):
+        pbar_backend = self.pbar_config['backend']
+        match pbar_backend:
+            case 'tqdm':
+                from tqdm.auto import tqdm
+                from tqdm.std import tqdm as tqdm_std
+                from tqdm.contrib.logging import _TqdmLoggingHandler, _get_first_found_console_logging_handler, _is_console_logging_handler
+
+                tqdm_secondary_config = {
+                    'total': 1,
+                    'unit_scale': True,
+                    'unit': 'percent',
+                    'mininterval': 0.1,
+                    'miniters': 0.001,
+                    **self.pbar_config['config'],
+                }
+                self._pbar_secondary = tqdm(**tqdm_secondary_config)
+
+                tqdm_config = {
+                    'total': 1,
+                    'unit_scale': True,
+                    'unit': 'percent',
+                    'mininterval': 0.1,
+                    'miniters': 0.001,
+                    **self.pbar_config['config'],
+                }
+                self._pbar = tqdm(**tqdm_config)
+
+                self._update_pbar_progress = self._update_tqdm_progress
+                self.pbar_config['loggers'] = loggers = [LOGGER.root] + [_ for _ in LOGGER.root.manager.loggerDict.values() if isinstance(_, logging.Logger) and _.handlers]
+                self.pbar_config['original_handlers_list'] = [logger.handlers for logger in loggers]
+                for logger in loggers:
+                    tqdm_handler = _TqdmLoggingHandler(tqdm_std)
+                    orig_handler = _get_first_found_console_logging_handler(logger.handlers)
+                    if orig_handler is not None:
+                        tqdm_handler.setFormatter(orig_handler.formatter)
+                        tqdm_handler.stream = orig_handler.stream
+                    logger.handlers = [handler for handler in logger.handlers if not _is_console_logging_handler(handler)] + [tqdm_handler]
+            case 'native':
+                from ..base import Progress
+
+                progress_config = dict(
+                    tasks=1,
+                    tick_size=0.001,
+                    **self.pbar_config['config'],
+                )
+
+                self._pbar = Progress(**progress_config)
+                self._update_pbar_progress = self._update_native_progress
+            case _:
+                raise NotImplementedError(f'Invalid pbar backend {pbar_backend}')
+
+    def _update_pbar_prefix(self, market_date: datetime.date):
+        pbar_backend = self.pbar_config['backend']
+        match pbar_backend:
+            case 'tqdm':
+                prompt = f'Progress Total ({self._idx_date + 1} / {len(self._calendar)})'
+                prompt_secondary = f'Progress [{market_date:%Y-%m-%d}]'
+                prompt_length = max(len(prompt), len(prompt_secondary))
+                self._pbar.set_description(prompt.ljust(prompt_length))
+                self._pbar.refresh()
+                self._pbar_secondary.n = 0
+                self._pbar_secondary.set_description(prompt_secondary.ljust(prompt_length))
+                self._pbar_secondary.refresh()
+            case 'native':
+                self._pbar.prompt = f'Replay {market_date:%Y-%m-%d} ({self._idx_date + 1} / {len(self._calendar)}):'
+                self._pbar.output()
+            case _:
+                raise NotImplementedError(f'Invalid pbar backend {pbar_backend}')
+
+    def _close_pbar(self):
+        pbar_backend = self.pbar_config['backend']
+        match pbar_backend:
+            case 'tqdm':
+                for logger, original_handlers in zip(self.pbar_config['loggers'], self.pbar_config['original_handlers_list']):
+                    logger.handlers = original_handlers
+
+                self._pbar_secondary.n = 1
+                # self._pbar_secondary.refresh()
+                self._pbar_secondary.close()
+                self._pbar_secondary = None
+
+                self._pbar.n = 1
+                # self._pbar.refresh()
+                self._pbar.close()
+                self._pbar = None
+            case 'native':
+                self._pbar.done_tasks = 1
+                self._pbar.output()
+            case _:
+                raise NotImplementedError(f'Invalid pbar backend {pbar_backend}')
+
+    def _update_tqdm_progress(self):
+        self._pbar.n = self.progress
+        self._pbar.update(0)
+
+        self._pbar_secondary.n = self._idx_buffer / self._buffer_size
+        self._pbar_secondary.update(0)
+
+    def _update_native_progress(self):
+        self._pbar.done_tasks = self.progress
+
+        if (not self._pbar.tick_size) \
+                or self._pbar.progress >= self._pbar.tick_size + self._pbar.last_output \
+                or self._pbar.is_done:
+            self._pbar.output()
 
     def __iter__(self):
-        from tqdm.auto import tqdm
-        self._pbar = tqdm(**self._tqdm_kwargs)
-        iterator = super().__iter__()
+        self._init_pbar()
+        return super().__iter__()
 
+    def __next__(self) -> MarketData:
         try:
-            while True:
-                try:
-                    result = next(iterator)
-                    if self._pbar:
-                        self._pbar.update(self.progress)
-                    yield result
-                except StopIteration:
-                    break
-        finally:
+            result = super().__next__()
             if self._pbar is not None:
-                self._pbar.close()
-                self._pbar = None
-
-    def __next__(self) -> MarketData:
-        raise RuntimeError("MarketDataBufferReplay should be used as an iterator context")
-
-    def _update_progress_bar(self, market_date: datetime.date):
-        if self._pbar:
-            self._pbar.set_description(f'Replay {market_date:%Y-%m-%d} ({self._idx_date + 1} / {len(self._calendar)})')
-            self._pbar.refresh()
+                self._update_pbar_progress()
+            return result
+        except StopIteration:
+            if self._pbar is not None:
+                self._close_pbar()
+            raise
 
 
 class ProgressiveReplay(SimpleReplay):
@@ -378,7 +558,7 @@ class ProgressiveReplay(SimpleReplay):
             eod: MarketDateCallable = None,
             **progress_config
     ) -> None:
-        warnings.deprecated('User ProgressReplay instead!')
+        warnings.warn('User ProgressReplay instead!', DeprecationWarning, stacklevel=2)
         self.loader = loader
         super().__init__(loader=loader, market_date=market_date, start_date=start_date, end_date=end_date, calendar=calendar, bod=bod, eod=eod)
 
@@ -410,6 +590,8 @@ class ProgressiveReplay(SimpleReplay):
             tasks=1,
             **progress_config
         )
+        self._pbar = None
+        self.add_bod(self._update_progress_bar, priority=0)
 
     def __iter__(self):
         from ..base import Progress
@@ -419,16 +601,17 @@ class ProgressiveReplay(SimpleReplay):
     def __next__(self) -> MarketData:
         try:
             result = super().__next__()
-            self._pbar.done_tasks = self.progress
+            if self._pbar:
+                self._pbar.done_tasks = self.progress
 
-            if (not self._pbar.tick_size) \
-                    or self._pbar.progress >= self._pbar.tick_size + self._pbar.last_output \
-                    or self._pbar.is_done:
-                self._pbar.output()
+                if (not self._pbar.tick_size) \
+                        or self._pbar.progress >= self._pbar.tick_size + self._pbar.last_output \
+                        or self._pbar.is_done:
+                    self._pbar.output()
 
             return result
         except StopIteration:
-            if not self._pbar.is_done:
+            if self._pbar is not None and not self._pbar.is_done:
                 self.progress.done_tasks = 1
                 self._pbar.output()
             raise

{pyalgoengine-0.8.0a16 → pyalgoengine-0.8.0.post2}/algo_engine/base/__init__.py

@@ -5,6 +5,8 @@ import pathlib
 from .telemetrics import LOGGER
 from ..profile import PROFILE
 
+USE_CYTHON = True
+
 
 def set_logger(logger: logging.Logger):
     global LOGGER
@@ -15,6 +17,9 @@ def set_logger(logger: logging.Logger):
 
 
 def check_cython_module(cython_module) -> bool:
+    if not USE_CYTHON:
+        return False
+
     for name in cython_module:
         cython_ext = '.pyd' if os.name == 'nt' else '.so'
         for file in pathlib.Path(__file__).parent.glob(f'*{cython_ext}'):

{pyalgoengine-0.8.0a16 → pyalgoengine-0.8.0.post2}/algo_engine/base/market_data.pyi

@@ -19,6 +19,9 @@ class MarketData:
 
     def __init__(self, ticker: str, timestamp: float, **kwargs: Any) -> None: ...
 
+    def update(self, name: str, value: Any) -> None:
+        ...
+
     @classmethod
     def buffer_size(cls) -> int: ...
 

{pyalgoengine-0.8.0a16 → pyalgoengine-0.8.0.post2}/algo_engine/base/market_data_buffer.pyi

@@ -31,7 +31,7 @@ class MarketDataBuffer:
 
     def to_bytes(self) -> bytes: ...
 
-    def update(self, dtype: int, **kwargs: dict[str, Any]) -> None: ...
+    def update(self, dtype: int, **kwargs: Any) -> None: ...
 
     def __getitem__(self, idx: int) -> MarketData | TransactionData | OrderData | TickDataLite | TickData | BarData: ...
 
@@ -79,6 +79,10 @@ class MarketDataConcurrentBuffer:
             capacity: int = ...
     ) -> None: ...
 
+    def get_head(self, worker_id: int) -> int: ...
+
+    def min_head(self) -> int: ...
+
     def is_empty(self, worker_id: int) -> bool: ...
 
     def is_empty_all(self) -> bool: ...
@@ -89,4 +93,10 @@ class MarketDataConcurrentBuffer:
 
     def get(self, idx: int) -> MarketData | TransactionData | OrderData | TickDataLite | TickData | BarData: ...
 
-    def listen(self, worker_id: int, timeout: float = ...) -> MarketData | TransactionData | OrderData | TickDataLite | TickData | BarData: ...
+    def listen(self, worker_id: int, block: bool = True, timeout: float = ...) -> MarketData | TransactionData | OrderData | TickDataLite | TickData | BarData: ...
+
+    @property
+    def head(self) -> list[int]: ...
+
+    @property
+    def tail(self) -> int: ...