PyAlgoEngine 0.7.4__py3-none-any.whl

algo_engine/monitor/__init__.py

@@ -0,0 +1,15 @@
+from ..engine import MDS
+from ..engine.market_engine import MarketDataMonitor as Monitor
+
+
+def add_synthetic_orderbook():
+    # init synthetic orderbook monitor
+    monitor = SyntheticOrderBookMonitor(mds=MDS)
+    MDS.add_monitor(monitor=monitor)
+    # override current orderbook
+    MDS._order_book = monitor.order_book
+
+
+from .advanced_data_interface import *
+
+__all__ = ['Monitor', 'SyntheticOrderBookMonitor', 'MinuteBarMonitor']

algo_engine/monitor/advanced_data_interface.py

@@ -0,0 +1,239 @@
+import datetime
+import json
+import pickle
+from multiprocessing import shared_memory
+from typing import Self
+
+from . import Monitor
+from ..base import TradeData, OrderBook, MarketData, BarData, TransactionData
+
+
+class SyntheticOrderBookMonitor(Monitor):
+
+    def __init__(self, **kwargs):
+
+        super().__init__(
+            name=kwargs.pop('name', 'Monitor.SyntheticOrderBook'),
+            monitor_id=kwargs.pop('monitor_id', None)
+        )
+
+        self.order_book: dict[str, OrderBook] = {}
+
+    def __call__(self, market_data: MarketData, **kwargs):
+        if isinstance(market_data, TradeData):
+            self.on_trade_data(trade_data=market_data)
+
+    def on_trade_data(self, trade_data: TradeData):
+        ticker = trade_data.ticker
+
+        if order_book := self.order_book.get(ticker):
+            if order_book.market_time <= trade_data.market_time:
+                side = trade_data.side
+                price = trade_data.price
+                book = order_book.ask if side.sign > 0 else order_book.bid
+                listed_volume = book.at_price(price).volume if price in book else 0.
+                traded_volume = trade_data.volume
+                book.update(price=price, volume=max(0, listed_volume - traded_volume))
+
+    def on_transaction_data(self, transaction_data: TransactionData):
+        pass
+
+    def to_json(self, fmt='str', **kwargs) -> str | dict:
+        data_dict = dict(
+            name=self.name,
+            monitor_id=self.monitor_id,
+            order_book={k: v.to_json(fmt='dict') for k, v in self.order_book.items()},
+        )
+
+        if fmt == 'dict':
+            return data_dict
+        elif fmt == 'str':
+            return json.dumps(data_dict, **kwargs)
+        else:
+            raise ValueError(f'Invalid format {fmt}, except "dict" or "str".')
+
+    @classmethod
+    def from_json(cls, json_message: str | bytes | bytearray | dict) -> Self:
+        if isinstance(json_message, dict):
+            json_dict = json_message
+        else:
+            json_dict = json.loads(json_message)
+
+        self = cls(
+            name=json_dict['name'],
+            monitor_id=json_dict['monitor_id'],
+            keep_order_log=json_dict['keep_order_log']
+        )
+
+        self.order_book = {k: MarketData.from_json(v) for k, v in json_dict['order_book'].items()}
+        return self
+
+    def from_shm(self, name: str = None) -> None:
+        if name is None:
+            name = f'{self.monitor_id}.json'
+
+        shm = shared_memory.SharedMemory(name=name)
+        json_dict = pickle.loads(bytes(shm.buf))
+
+        self.clear()
+
+        self.order_book.update({k: MarketData.from_json(v) for k, v in json_dict['order_book'].items()})
+
+    def clear(self) -> None:
+        self.order_book.clear()
+
+    @property
+    def value(self) -> dict[str, OrderBook]:
+        return self.order_book
+
+
+class MinuteBarMonitor(Monitor):
+
+    def __init__(self, interval: float = 60., **kwargs):
+        self.interval = interval
+
+        super().__init__(
+            name=kwargs.pop('name', 'Monitor.MinuteBarMonitor'),
+            monitor_id=kwargs.pop('monitor_id', None)
+        )
+
+        self._minute_bar_data: dict[str, BarData] = {}
+        self._last_bar_data: dict[str, BarData] = {}
+
+    def __call__(self, market_data: MarketData, **kwargs):
+        self._update_last_bar(market_data=market_data, interval=self.interval)
+        # self._update_active_bar(market_data=market_data, interval=self.interval)
+
+    def _update_last_bar(self, market_data: MarketData, interval: float):
+        ticker = market_data.ticker
+        market_price = market_data.market_price
+        market_time = market_data.market_time
+        timestamp = market_data.timestamp
+
+        if ticker not in self._minute_bar_data or market_time >= self._minute_bar_data[ticker].bar_end_time:
+            # update bar_data
+            if ticker in self._minute_bar_data:
+                self._last_bar_data[ticker] = self._minute_bar_data[ticker]
+
+            bar_data = self._minute_bar_data[ticker] = BarData(
+                ticker=ticker,
+                timestamp=int(timestamp // interval + 1) * interval,
+                start_timestamp=int(timestamp // interval) * interval,
+                bar_span=datetime.timedelta(seconds=interval),
+                high_price=market_price,
+                low_price=market_price,
+                open_price=market_price,
+                close_price=market_price,
+                volume=0.,
+                notional=0.,
+                trade_count=0
+            )
+        else:
+            bar_data = self._minute_bar_data[ticker]
+
+        if isinstance(market_data, TradeData):
+            bar_data['volume'] += market_data.volume
+            bar_data['notional'] += market_data.notional
+            bar_data['trade_count'] += 1
+
+        bar_data['close_price'] = market_price
+        bar_data['high_price'] = max(bar_data.high_price, market_price)
+        bar_data['low_price'] = min(bar_data.low_price, market_price)
+
+    def _update_active_bar(self, market_data: MarketData, interval: float):
+        ticker = market_data.ticker
+        market_price = market_data.market_price
+        market_time = market_data.market_time
+        timestamp = market_data.timestamp
+
+        if ticker not in self._minute_bar_data or market_time >= self._minute_bar_data[ticker].bar_end_time:
+            bar_data = self._minute_bar_data[ticker] = BarData(
+                ticker=ticker,
+                start_timestamp=timestamp - interval,
+                timestamp=timestamp,
+                bar_span=datetime.timedelta(seconds=interval),
+                high_price=market_price,
+                low_price=market_price,
+                open_price=market_price,
+                close_price=market_price,
+                volume=0.,
+                notional=0.,
+                trade_count=0
+            )
+            bar_data.history = []
+
+        else:
+            bar_data = self._minute_bar_data[ticker]
+
+        history: list[TradeData] = getattr(bar_data, 'history')
+        bar_data['start_timestamp'] = timestamp - interval
+
+        if isinstance(market_data, TradeData):
+            history.append(market_data)
+
+        while True:
+            if history[0].market_time >= bar_data.bar_start_time:
+                break
+            else:
+                history.pop(0)
+
+        bar_data['volume'] = sum([_.volume for _ in history])
+        bar_data['notional'] = sum([_.notional for _ in history])
+        bar_data['trade_count'] = len([_.notional for _ in history])
+        bar_data['close_price'] = market_price
+        bar_data['open_price'] = history[0].market_price
+        bar_data['high_price'] = max([_.market_price for _ in history])
+        bar_data['low_price'] = min([_.market_price for _ in history])
+
+    def to_json(self, fmt='str', **kwargs) -> str | dict:
+        data_dict = dict(
+            name=self.name,
+            monitor_id=self.monitor_id,
+            interval=self.interval,
+            minute_bar_data={k: v.to_json(fmt='dict') for k, v in self._minute_bar_data.items()},
+            last_bar_data={k: v.to_json(fmt='dict') for k, v in self._last_bar_data.items()},
+        )
+
+        if fmt == 'dict':
+            return data_dict
+        elif fmt == 'str':
+            return json.dumps(data_dict, **kwargs)
+        else:
+            raise ValueError(f'Invalid format {fmt}, except "dict" or "str".')
+
+    @classmethod
+    def from_json(cls, json_message: str | bytes | bytearray | dict) -> Self:
+        if isinstance(json_message, dict):
+            json_dict = json_message
+        else:
+            json_dict = json.loads(json_message)
+
+        self = cls(
+            name=json_dict['name'],
+            monitor_id=json_dict['monitor_id'],
+            interval=json_dict['interval'],
+        )
+
+        self._minute_bar_data = {k: MarketData.from_json(v) for k, v in json_dict['minute_bar_data'].items()}
+        self._last_bar_data = {k: MarketData.from_json(v) for k, v in json_dict['last_bar_data'].items()}
+        return self
+
+    def from_shm(self, name: str = None) -> None:
+        if name is None:
+            name = f'{self.monitor_id}.json'
+
+        shm = shared_memory.SharedMemory(name=name)
+        json_dict = pickle.loads(bytes(shm.buf))
+
+        self.clear()
+
+        self._minute_bar_data.update({k: MarketData.from_json(v) for k, v in json_dict['minute_bar_data'].items()})
+        self._last_bar_data.update({k: MarketData.from_json(v) for k, v in json_dict['last_bar_data'].items()})
+
+    def clear(self) -> None:
+        self._minute_bar_data.clear()
+        self._last_bar_data.clear()
+
+    @property
+    def value(self) -> dict[str, BarData]:
+        return self._last_bar_data

algo_engine/profile/__init__.py

@@ -0,0 +1,121 @@
+import abc
+import datetime
+from typing import Self
+
+
+class Profile(object, metaclass=abc.ABCMeta):
+    def __init__(
+            self,
+            profile_id: str,
+            session_start: datetime.time | None = None,
+            session_end: datetime.time | None = None,
+            session_break: list[tuple[datetime.time, datetime.time]] = None
+    ):
+        self.profile_id = profile_id
+        self.session_start = session_start
+        self.session_end = session_end
+        self.session_break = [] if session_break is None else session_break
+
+        self.time_zone = None
+
+    def __repr__(self):
+        return f'<Profile {self.profile_id}>({id(self)})'
+
+    def override_profile(self, profile: Self = None) -> Self:
+        if profile is None:
+            profile = PROFILE
+
+        profile.profile_id = self.profile_id
+        profile.session_start = self.session_start
+        profile.session_end = self.session_end
+
+        if profile.session_break is None or self.session_break is None:
+            profile.session_break = self.session_break
+        else:
+            profile.session_break.clear()
+            profile.session_break.extend(self.session_break)
+
+        profile.trade_time_between = self.trade_time_between
+        profile.is_market_session = self.is_market_session
+        profile.trade_calendar = self.trade_calendar
+
+        return profile
+
+    @abc.abstractmethod
+    def trade_time_between(self, start_time: datetime.datetime | float, end_time: datetime.datetime | float, **kwargs) -> datetime.timedelta:
+        ...
+
+    @abc.abstractmethod
+    def is_market_session(self, timestamp: float | int | datetime.datetime, **kwargs) -> bool:
+        ...
+
+    @abc.abstractmethod
+    def trade_calendar(self, start_date: datetime.date, end_date: datetime.date, **kwargs) -> list[datetime.date]:
+        ...
+
+    @property
+    def range_break(self) -> list[dict]:
+        """
+        an range break designed for plotly.
+        """
+        range_break = []
+
+        if not self.session_break:
+            return range_break
+
+        # Convert session_break to range_break format
+        for start, end in self.session_break:
+            start_hour = start.hour + start.minute / 60
+            end_hour = end.hour + end.minute / 60
+            range_break.append(dict(bounds=[start_hour, end_hour], pattern="hour"))
+
+        # Add the additional fixed non-trading periods
+        if self.session_start is not None and self.session_start != datetime.time.min:
+            range_break.append(
+                dict(bounds=[0, self.session_start.hour + self.session_start.minute / 60], pattern="hour"),
+            )
+
+        if self.session_end is not None and self.session_end != datetime.time.max:
+            range_break.append(
+                dict(bounds=[self.session_end.hour + self.session_end.minute / 60, 24], pattern="hour"),
+            )
+
+        return range_break
+
+
+class DefaultProfile(Profile):
+    def __init__(self):
+        super().__init__(
+            profile_id='non-stop',
+            session_start=datetime.time.min,
+            session_end=None,
+            session_break=None
+        )
+
+    def trade_time_between(self, start_time: datetime.datetime | float, end_time: datetime.datetime | float, **kwargs) -> datetime.timedelta:
+        if start_time is not None and isinstance(start_time, (float, int)):
+            start_time = datetime.datetime.fromtimestamp(start_time, tz=self.time_zone)
+
+        if end_time is not None and isinstance(end_time, (float, int)):
+            end_time = datetime.datetime.fromtimestamp(end_time, tz=self.time_zone)
+
+        if start_time is None or end_time is None:
+            return datetime.timedelta(seconds=0)
+
+        if start_time > end_time:
+            return datetime.timedelta(seconds=0)
+
+        return end_time - start_time
+
+    def is_market_session(self, timestamp: float | int | datetime.datetime, **kwargs) -> bool:
+        return True
+
+    def trade_calendar(self, start_date: datetime.date, end_date: datetime.date, **kwargs) -> list[datetime.date]:
+        return [start_date + datetime.timedelta(days=i) for i in range((end_date - start_date).days + 1)]
+
+
+from .cn import PROFILE_CN
+
+PROFILE = DefaultProfile()
+
+__all__ = ['Profile', 'PROFILE', 'PROFILE_CN']

algo_engine/profile/cn.py

@@ -0,0 +1,175 @@
+import datetime
+import functools
+
+from . import Profile
+
+
+class ProfileCN(Profile):
+    def __init__(self):
+        super().__init__(
+            profile_id='cn',
+            session_start=datetime.time(9, 30),
+            session_end=datetime.time(15, 0),
+            session_break=[(datetime.time(11, 30), datetime.time(13, 0))]
+        )
+
+        self.cn_trade_calendar_cache = {}
+
+    def override_profile(self, profile: Profile = None):
+        profile = super().override_profile(profile=profile)
+
+        setattr(profile, 'cn_trade_calendar_cache', self.cn_trade_calendar_cache)
+
+    @functools.lru_cache
+    def trade_calendar(self, start_date: datetime.date, end_date: datetime.date, **kwargs) -> list[datetime.date]:
+        import pandas as pd
+        import exchange_calendars
+
+        market = kwargs.get('market', 'XSHG')
+        tz = kwargs.get('tz', 'UTC')
+
+        if market in self.cn_trade_calendar_cache:
+            trade_calendar = self.cn_trade_calendar_cache[market]
+        else:
+            trade_calendar = self.cn_trade_calendar_cache[market] = exchange_calendars.get_calendar(market)
+
+        calendar = trade_calendar.sessions_in_range(start_date, end_date)
+
+        # noinspection PyTypeChecker
+        result = list(pd.to_datetime(calendar).date)
+
+        return result
+
+    @functools.lru_cache
+    def is_trade_day(self, market_date: datetime.date, market='XSHG', tz='UTC') -> bool:
+        if market in self.cn_trade_calendar_cache:
+            trade_calendar = self.cn_trade_calendar_cache[market]
+        else:
+            import exchange_calendars
+            trade_calendar = self.cn_trade_calendar_cache[market] = exchange_calendars.get_calendar(market)
+
+        return trade_calendar.is_session(market_date)
+
+    def trade_days_between(self, start_date: datetime.date, end_date: datetime.date = datetime.date.today(), **kwargs) -> int:
+        """
+        Returns the number of trade days between the given date, which is the pre-open of the start_date to the pre-open of the end_date.
+        :param start_date: the given trade date
+        :param end_date: the given trade date
+        :return: integer number of days
+        """
+        assert start_date <= end_date, "The end date must not before the start date"
+
+        if start_date == end_date:
+            offset = 0
+        else:
+            market_date_list = self.trade_calendar(start_date=start_date, end_date=end_date, **kwargs)
+            if not market_date_list:
+                offset = 0
+            else:
+                last_trade_date = market_date_list[-1]
+                offset = len(market_date_list)
+
+                if last_trade_date == end_date:
+                    offset -= 1
+
+        return offset
+
+    @classmethod
+    def time_to_seconds(cls, t: datetime.time):
+        return (t.hour * 60 + t.minute) * 60 + t.second + t.microsecond / 1000
+
+    def trade_time_between(self, start_time: datetime.datetime | datetime.time | float | int, end_time: datetime.datetime | datetime.time | float | int, fmt='timedelta', **kwargs):
+        if start_time is None or end_time is None:
+            if fmt == 'timestamp':
+                return 0.
+            elif fmt == 'timedelta':
+                return datetime.timedelta(0)
+            else:
+                raise NotImplementedError(f'Invalid fmt {fmt}, should be "timestamp" or "timedelta"')
+
+        session_start = kwargs.pop('session_start', self.session_start)
+        session_break = kwargs.pop('session_break', self.session_break)
+        session_end = kwargs.pop('session_end', self.session_end)
+        session_length_0 = datetime.timedelta(seconds=self.time_to_seconds(session_break[0]) - self.time_to_seconds(session_start))
+        session_length_1 = datetime.timedelta(seconds=self.time_to_seconds(session_end) - self.time_to_seconds(session_break[1]))
+        session_length = session_length_0 + session_length_1
+        implied_date = datetime.date.today()
+
+        if isinstance(start_time, (float, int)):
+            start_time = datetime.datetime.fromtimestamp(start_time, tz=self.time_zone)
+            implied_date = start_time.date()
+
+        if isinstance(end_time, (float, int)):
+            end_time = datetime.datetime.fromtimestamp(end_time, tz=self.time_zone)
+            implied_date = end_time.date()
+
+        if isinstance(start_time, datetime.time):
+            start_time = datetime.datetime.combine(implied_date, start_time)
+
+        if isinstance(end_time, datetime.time):
+            end_time = datetime.datetime.combine(implied_date, end_time)
+
+        offset = datetime.timedelta()
+
+        market_time = start_time.time()
+
+        # calculate the timespan from start_time to session_end
+        if market_time <= session_start:
+            offset += session_length
+        elif session_start < market_time <= session_break[0]:
+            offset += datetime.datetime.combine(start_time.date(), session_break[0]) - start_time
+            offset += session_length_1
+        elif session_break[0] < market_time <= session_break[1]:
+            offset += session_length_1
+        elif session_break[1] < market_time <= session_end:
+            offset += datetime.datetime.combine(start_time.date(), session_end) - start_time
+        else:
+            offset += datetime.timedelta(0)
+
+        offset -= session_length
+
+        market_time = end_time.time()
+
+        # calculate the timespan from session_start to end_time
+        if market_time <= session_start:
+            offset += datetime.timedelta(0)
+        elif session_start < market_time <= session_break[0]:
+            offset += end_time - datetime.datetime.combine(end_time.date(), session_start)
+        elif session_break[0] < market_time <= session_break[1]:
+            offset += session_length_0
+        elif session_break[1] < market_time <= session_end:
+            offset += end_time - datetime.datetime.combine(end_time.date(), session_break[1])
+            offset += session_length_0
+        else:
+            offset += session_length
+
+        # calculate market_date difference
+        if start_time.date() != end_time.date():
+            offset += session_length * self.trade_days_between(start_date=start_time.date(), end_date=end_time.date(), **kwargs)
+
+        if fmt == 'timestamp':
+            return offset.total_seconds()
+        elif fmt == 'timedelta':
+            return offset
+        else:
+            raise NotImplementedError(f'Invalid fmt {fmt}, should be "timestamp" or "timedelta"')
+
+    def is_market_session(self, timestamp: float | int | datetime.datetime, **kwargs) -> bool:
+        if isinstance(timestamp, (float, int)):
+            market_time = datetime.datetime.fromtimestamp(timestamp, tz=self.time_zone).time()
+        elif isinstance(timestamp, datetime.datetime):
+            market_time = timestamp.time()
+        elif isinstance(timestamp, datetime.time):
+            market_time = timestamp
+        else:
+            raise TypeError(f'Expect timestamp to be a float, int or datetime, got {type(timestamp)}!')
+
+        if (market_time < datetime.time(9, 30)
+                or datetime.time(11, 30) < market_time < datetime.time(13, 0)
+                or datetime.time(15, 0) < market_time):
+            return False
+
+        return True
+
+
+PROFILE_CN = ProfileCN()

algo_engine/strategy/__init__.py

@@ -0,0 +1,44 @@
+import logging
+from threading import Lock
+
+from .. import LOGGER
+from ..base import TradeInstruction
+from ..engine import EVENT_ENGINE, TOPIC, MDS, MarketDataService, Balance, Inventory, DirectMarketAccess, RiskProfile, PositionManagementService
+
+LOGGER = LOGGER.getChild('Strategy')
+
+from .strategy_engine import StrategyEngine
+
+
+class EventDMA(DirectMarketAccess):
+    def __init__(self, mds: MarketDataService, risk_profile: RiskProfile, event_engine=None, cool_down: float = None):
+        self.event_engine = EVENT_ENGINE if event_engine is None else event_engine
+        super().__init__(mds=mds, risk_profile=risk_profile, cool_down=cool_down)
+
+    def _launch_order_handler(self, order: TradeInstruction, **kwargs):
+        self.event_engine.put(topic=TOPIC.launch_order(ticker=order.ticker), order=order, **kwargs)
+
+    def _cancel_order_handler(self, order: TradeInstruction, **kwargs):
+        self.event_engine.put(topic=TOPIC.cancel_order(ticker=order.ticker), order_id=order.order_id, **kwargs)
+
+    def _reject_order_handler(self, order: TradeInstruction, **kwargs):
+        raise NotImplementedError()
+
+
+def set_logger(logger: logging.Logger):
+    global LOGGER
+    LOGGER = logger
+
+    strategy_engine.LOGGER = logger.getChild('Strategy')
+
+
+REPLAY_LOCK = Lock()
+INVENTORY = Inventory()
+BALANCE = Balance(inventory=INVENTORY)  # need to be registered
+RISK_PROFILE = RiskProfile(mds=MDS, balance=BALANCE)
+DMA = EventDMA(mds=MDS, risk_profile=RISK_PROFILE)
+POSITION_TRACKER = PositionManagementService(dma=DMA)
+STRATEGY_ENGINE = StrategyEngine(event_engine=EVENT_ENGINE, position_tracker=POSITION_TRACKER)  # need to be registered, also register MDS
+BALANCE.add(strategy=STRATEGY_ENGINE, position_tracker=POSITION_TRACKER)
+
+__all__ = ['INVENTORY', 'BALANCE', 'RISK_PROFILE', 'DMA', 'POSITION_TRACKER', 'STRATEGY_ENGINE']