PyAlgoEngine 0.3.13__tar.gz → 0.4.0__tar.gz

{pyalgoengine-0.3.13/PyAlgoEngine.egg-info → pyalgoengine-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyAlgoEngine
-Version: 0.3.13
+Version: 0.4.0
 Summary: Basic algo engine
 Home-page: https://github.com/BolunHan/PyAlgoEngine
 Author: Bolun.Han
@@ -8,15 +8,17 @@ 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.8
+Requires-Python: >=3.1
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: pandas
 Requires-Dist: exchange_calendars
-Requires-Dist: PyQuantKit
-Requires-Dist: PyEventEngine
+Requires-Dist: PyQuantKit>=0.3.0
+Requires-Dist: PyEventEngine>=0.3.0.post3
 
 # PyAlgoEngine
 python algo trading engine

{pyalgoengine-0.3.13 → pyalgoengine-0.4.0/PyAlgoEngine.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyAlgoEngine
-Version: 0.3.13
+Version: 0.4.0
 Summary: Basic algo engine
 Home-page: https://github.com/BolunHan/PyAlgoEngine
 Author: Bolun.Han
@@ -8,15 +8,17 @@ 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.8
+Requires-Python: >=3.1
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
 Requires-Dist: pandas
 Requires-Dist: exchange_calendars
-Requires-Dist: PyQuantKit
-Requires-Dist: PyEventEngine
+Requires-Dist: PyQuantKit>=0.3.0
+Requires-Dist: PyEventEngine>=0.3.0.post3
 
 # PyAlgoEngine
 python algo trading engine

pyalgoengine-0.4.0/PyAlgoEngine.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+LICENSE
+README.md
+setup.py
+PyAlgoEngine.egg-info/PKG-INFO
+PyAlgoEngine.egg-info/SOURCES.txt
+PyAlgoEngine.egg-info/dependency_links.txt
+PyAlgoEngine.egg-info/requires.txt
+PyAlgoEngine.egg-info/top_level.txt
+algo_engine/__init__.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/engine/__init__.py
+algo_engine/engine/algo_engine.py
+algo_engine/engine/event_engine.py
+algo_engine/engine/market_engine.py
+algo_engine/engine/trade_engine.py
+algo_engine/monitor/__init__.py
+algo_engine/monitor/advanced_data_interface.py
+algo_engine/profile/__init__.py
+algo_engine/profile/cn.py
+algo_engine/strategie/__init__.py
+algo_engine/strategie/strategy_engine.py

pyalgoengine-0.4.0/PyAlgoEngine.egg-info/requires.txt

@@ -0,0 +1,5 @@
+numpy
+pandas
+exchange_calendars
+PyQuantKit>=0.3.0
+PyEventEngine>=0.3.0.post3

pyalgoengine-0.4.0/PyAlgoEngine.egg-info/top_level.txt

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

pyalgoengine-0.4.0/algo_engine/__init__.py

@@ -0,0 +1,74 @@
+__version__ = "0.4.0"
+
+import logging
+import os
+import sys
+import time
+import traceback
+
+from PyQuantKit import ColoredFormatter
+
+LOGGER: logging.Logger | None = None
+LOG_LEVEL = logging.INFO
+
+if 'ALGO_DIR' in os.environ:
+    WORKING_DIRECTORY = os.path.realpath(os.environ['ALGO_DIR'])
+else:
+    WORKING_DIRECTORY = str(os.getcwd())
+
+
+def get_logger(**kwargs) -> logging.Logger:
+    level = kwargs.get('level', LOG_LEVEL)
+    stream_io = kwargs.get('stream_io', sys.stdout)
+    formatter = kwargs.get('formatter', ColoredFormatter())
+    global LOGGER
+
+    if LOGGER is not None:
+        return LOGGER
+
+    LOGGER = logging.getLogger('PyAlgoEngine')
+    LOGGER.setLevel(level)
+    logging.Formatter.converter = time.gmtime
+
+    if stream_io:
+        have_handler = False
+        for handler in LOGGER.handlers:
+            # noinspection PyUnresolvedReferences
+            if type(handler) == logging.StreamHandler and handler.stream == stream_io:
+                have_handler = True
+                break
+
+        if not have_handler:
+            logger_ch = logging.StreamHandler(stream=stream_io)
+            logger_ch.setLevel(level=level)
+            logger_ch.setFormatter(fmt=formatter)
+            LOGGER.addHandler(logger_ch)
+
+    return LOGGER
+
+
+def set_logger(logger: logging.Logger):
+    global LOGGER
+    LOGGER = logger
+
+    engine.LOGGER = LOGGER.getChild('Engine')
+    back_test.LOGGER = LOGGER.getChild('BackTest')
+    strategie.LOGGER = LOGGER.getChild('Strategies')
+
+
+_ = get_logger()
+
+from . import engine
+from . import back_test
+from . import profile
+from . import strategie
+
+engine.LOGGER.info(f'AlgoEngine version {__version__}')
+
+# import addon module
+try:
+    from . import EngineAddon
+
+    engine.LOGGER.info(f'AlgoEngine_Addons import successful, version {EngineAddon.__version__}')
+except ImportError:
+    engine.LOGGER.debug(f'Install AlgoEngine_Addons to use Statistics module\n{traceback.format_exc()}')

pyalgoengine-0.4.0/algo_engine/back_test/__init__.py

@@ -0,0 +1,8 @@
+from .. import LOGGER
+
+LOGGER = LOGGER.getChild('BackTest')
+
+from .replay import Replay, SimpleReplay, ProgressiveReplay
+from .sim_match import SimMatch
+
+__all__ = ['Replay', 'SimpleReplay', 'ProgressiveReplay', 'SimMatch']

pyalgoengine-0.3.13/AlgoEngine/Strategies/BackTest.py → pyalgoengine-0.4.0/algo_engine/back_test/__main__.py

@@ -1,15 +1,14 @@
-from __future__ import annotations
+__package__ = 'algo_engine.back_test'
 
 import datetime
+from typing import Callable
 
 import EventEngine
 
-from . import EventDMA
-from ._StrategyEngine import StrategyEngine
-from ..Engine import LOGGER, TOPIC, MarketDataService, Balance, RiskProfile, PositionManagementService
-from ..Engine.AlgoEngine import AlgoRegistry, AlgoEngine
-
-LOGGER = LOGGER.getChild('BackTest')
+from ..engine import TOPIC, MarketDataService, Balance, RiskProfile, PositionManagementService
+from ..engine.algo_engine import AlgoRegistry, AlgoEngine
+from ..strategie import EventDMA
+from ..strategie.strategy_engine import StrategyEngine
 
 
 def test_stop(code=0):
@@ -19,7 +18,7 @@ def test_stop(code=0):
     # `os._exit(code)`
 
 
-def test_start(start_date: datetime.date, end_date: datetime.date, data_loader: callable, **kwargs):
+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,

pyalgoengine-0.4.0/algo_engine/back_test/replay.py

@@ -0,0 +1,257 @@
+import abc
+import datetime
+import inspect
+from typing import Iterable
+
+from PyQuantKit import Progress, TickData, TransactionData, TradeData, OrderBook
+
+from . import LOGGER
+
+
+class Replay(object, metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def __next__(self): ...
+
+    @abc.abstractmethod
+    def __iter__(self): ...
+
+
+class SimpleReplay(Replay):
+    def __init__(self, **kwargs):
+        self.eod = kwargs.pop('eod', None)
+        self.bod = kwargs.pop('bod', None)
+
+        self.replay_task = []
+        self.task_progress = 0
+        self.task_date = None
+        self.progress = Progress(tasks=1, **kwargs)
+
+    def load(self, data):
+        if isinstance(data, dict):
+            self.replay_task.extend(list(data.values()))
+        else:
+            self.replay_task.extend(data)
+
+    def reset(self):
+        self.replay_task.clear()
+        self.task_progress = 0
+        self.task_date = None
+        self.progress.reset()
+
+    def next_task(self):
+        if self.task_progress < len(self.replay_task):
+            market_data = self.replay_task[self.task_progress]
+            market_time = market_data.market_time
+
+            if isinstance(market_time, datetime.datetime):
+                market_date = market_time.date()
+            else:
+                market_date = market_time
+
+            if market_date != self.task_date:
+                if callable(self.eod) and self.task_date:
+                    self.eod(self.task_date)
+
+                self.task_date = market_date
+                self.progress.prompt = f'Replay {market_date:%Y-%m-%d}:'
+
+                if callable(self.bod):
+                    self.bod(market_date)
+
+            self.progress.done_tasks = self.task_progress / len(self.replay_task)
+
+            if (not self.progress.tick_size) or self.progress.progress >= self.progress.tick_size + self.progress.last_output:
+                self.progress.output()
+
+            self.task_progress += 1
+        else:
+            raise StopIteration()
+
+        return market_data
+
+    def __next__(self):
+        try:
+            return self.next_task()
+        except StopIteration:
+            if not self.progress.is_done:
+                self.progress.done_tasks = 1
+                self.progress.output()
+
+            self.reset()
+            raise StopIteration()
+
+    def __iter__(self):
+        return self
+
+
+class ProgressiveReplay(Replay):
+    """
+    progressively loading and replaying market data
+
+    requires arguments
+    loader: a data loading function. Expect loader = Callable(market_date: datetime.date, ticker: str, dtype: str| type) -> dict[any, MarketData]
+    start_date & end_date: the given replay period
+    or calendar: the given replay calendar.
+
+    accepts kwargs:
+    ticker / tickers: the given symbols to replay, expect a str| list[str]
+    dtype / dtypes: the given dtype(s) of symbol to replay, expect a str | type, list[str | type]. default = all, which is (TradeData, TickData, OrderBook)
+    subscription / subscribe: the given ticker-dtype pair to replay, expect a list[dict[str, str | type]]
+    """
+
+    def __init__(
+            self,
+            loader,
+            **kwargs
+    ):
+        self.loader = loader
+        self.start_date: datetime.date | None = kwargs.pop('start_date', None)
+        self.end_date: datetime.date | None = kwargs.pop('end_date', None)
+        self.calendar: list[datetime.date] | None = kwargs.pop('calendar', None)
+
+        self.eod = kwargs.pop('eod', None)
+        self.bod = kwargs.pop('bod', None)
+
+        self.replay_subscription = {}
+        self.replay_calendar = []
+        self.replay_task = []
+
+        self.date_progress = 0
+        self.task_progress = 0
+        self.progress = Progress(tasks=1, **kwargs)
+
+        tickers: list[str] = kwargs.pop('ticker', kwargs.pop('tickers', []))
+        dtypes: list[str | type] = kwargs.pop('dtype', kwargs.pop('dtypes', [TradeData, TransactionData, OrderBook, TickData]))
+
+        if not all([arg_name in inspect.getfullargspec(loader).args for arg_name in ['market_date', 'ticker', 'dtype']]):
+            raise TypeError('loader function has 3 requires args, market_date, ticker and dtype.')
+
+        if isinstance(tickers, str):
+            tickers = [tickers]
+        elif isinstance(tickers, Iterable):
+            tickers = list(tickers)
+        else:
+            raise TypeError(f'Invalid ticker {tickers}, expect str or list[str]')
+
+        if isinstance(dtypes, str) or inspect.isclass(dtypes):
+            dtypes = [dtypes]
+        elif isinstance(dtypes, Iterable):
+            dtypes = list(dtypes)
+        else:
+            raise TypeError(f'Invalid dtype {dtypes}, expect str or list[str]')
+
+        for ticker in tickers:
+            for dtype in dtypes:
+                self.add_subscription(ticker=ticker, dtype=dtype)
+
+        subscription = kwargs.pop('subscription', kwargs.pop('subscribe', []))
+
+        if isinstance(subscription, dict):
+            subscription = [subscription]
+
+        for sub in subscription:
+            self.add_subscription(**sub)
+
+        self.reset()
+
+    def add_subscription(self, ticker: str, dtype: type | str):
+        if isinstance(dtype, str):
+            pass
+        elif inspect.isclass(dtype):
+            dtype = dtype.__name__
+        else:
+            raise ValueError(f'Invalid dtype {dtype}, expect str or class.')
+
+        topic = f'{ticker}.{dtype}'
+        self.replay_subscription[topic] = (ticker, dtype)
+
+    def remove_subscription(self, ticker: str, dtype: type | str):
+        if isinstance(dtype, str):
+            pass
+        else:
+            dtype = dtype.__name__
+
+        topic = f'{ticker}.{dtype}'
+        self.replay_subscription.pop(topic, None)
+
+    def reset(self):
+        if self.calendar is None:
+            self.replay_calendar = [self.start_date + datetime.timedelta(days=i) for i in range((self.end_date - self.start_date).days + 1)]
+        else:
+            self.replay_calendar = self.calendar
+
+        self.task_progress = 0
+        self.date_progress = sum([1 for _ in self.replay_calendar if _ < self.start_date])
+        self.progress.reset()
+
+        if self.date_progress:
+            self.progress.done_tasks = self.date_progress / len(self.replay_calendar)
+
+    def next_trade_day(self):
+        if self.date_progress < len(self.replay_calendar):
+            market_date = self.replay_calendar[self.date_progress]
+            self.progress.prompt = f'Replay {market_date:%Y-%m-%d} ({self.date_progress + 1} / {len(self.replay_calendar)}):'
+            for topic in self.replay_subscription:
+                ticker, dtype = self.replay_subscription[topic]
+                LOGGER.info(f'{self} loading {market_date} {ticker} {dtype}')
+                data = self.loader(market_date=market_date, ticker=ticker, dtype=dtype)
+
+                if isinstance(data, dict):
+                    self.replay_task.extend(list(data.values()))
+                elif isinstance(data, (list, tuple)):
+                    self.replay_task.extend(data)
+
+            self.date_progress += 1
+        else:
+            raise StopIteration()
+
+        self.replay_task.sort(key=lambda x: x.market_time)
+
+    def next_task(self):
+        if self.task_progress < len(self.replay_task):
+            data = self.replay_task[self.task_progress]
+            self.task_progress += 1
+        else:
+            if self.eod is not None and self.date_progress and (self.date_progress >= len(self.replay_calendar) or self.replay_calendar[self.date_progress] > self.start_date):
+                self.eod(market_date=self.replay_calendar[self.date_progress - 1], replay=self)
+
+            self.replay_task.clear()
+            self.task_progress = 0
+
+            if self.bod is not None and self.date_progress < len(self.replay_calendar):
+                self.bod(market_date=self.replay_calendar[self.date_progress], replay=self)
+
+            self.next_trade_day()
+
+            data = self.next_task()
+
+        if self.replay_task and self.replay_calendar:
+            current_progress = (self.date_progress - 1 + (self.task_progress / len(self.replay_task))) / len(self.replay_calendar)
+            self.progress.done_tasks = current_progress
+        else:
+            self.progress.done_tasks = 1
+
+        if (not self.progress.tick_size) \
+                or self.progress.progress >= self.progress.tick_size + self.progress.last_output \
+                or self.progress.is_done:
+            self.progress.output()
+
+        return data
+
+    def __next__(self):
+        try:
+            return self.next_task()
+        except StopIteration:
+            if not self.progress.is_done:
+                self.progress.done_tasks = 1
+                self.progress.output()
+
+            self.reset()
+            raise StopIteration()
+
+    def __iter__(self):
+        self.reset()
+        return self
+
+    def __repr__(self):
+        return f'{self.__class__.__name__}{{id={id(self)}, from={self.start_date}, to={self.end_date}}}'