PyAlgoEngine 0.3.11.post1__tar.gz → 0.3.12.post3__tar.gz

{PyAlgoEngine-0.3.11.post1 → PyAlgoEngine-0.3.12.post3}/AlgoEngine/Engine/MarketEngine.py

@@ -1,18 +1,19 @@
-from __future__ import annotations
-
 import abc
 import datetime
 import functools
-import threading
+import inspect
+import json
+import pickle
 import uuid
 from collections import defaultdict
-from typing import Iterable
+from multiprocessing import shared_memory
+from typing import Iterable, Self
 
 from PyQuantKit import TickData, TradeData, OrderBook, MarketData, Progress, TransactionSide, BarData, TransactionData
 
 from . import LOGGER
 
-__all__ = ['MDS', 'MarketDataService', 'MarketDataMonitor', 'SyntheticOrderBookMonitor', 'MinuteBarMonitor', 'Profile', 'ProgressiveReplay', 'SimpleReplay', 'Replay']
+__all__ = ['MDS', 'MarketDataService', 'MarketDataMonitor', 'MonitorManager', 'SyntheticOrderBookMonitor', 'MinuteBarMonitor', 'Profile', 'ProgressiveReplay', 'SimpleReplay', 'Replay']
 LOGGER = LOGGER.getChild('MarketEngine')
 
 
@@ -32,41 +33,139 @@ class MarketDataMonitor(object, metaclass=abc.ABCMeta):
     The implemented monitor should be initialized and use `MDS.add_monitor(monitor)` to attach onto the engine
     """
 
-    def __init__(self, name: str, monitor_id: str = None, mds: MarketDataService = None):
-        self.name = name
-        self.monitor_id = uuid.uuid4().hex if monitor_id is None else monitor_id
-        self.mds = MDS if mds is None else mds
-        self.enabled = True
+    def __init__(self, name: str, monitor_id: str = None):
+        self.name: str = name
+        self.monitor_id: str = uuid.uuid4().hex if monitor_id is None else monitor_id
+        self.enabled: bool = True
 
     @abc.abstractmethod
-    def __call__(self, market_data: MarketData, **kwargs): ...
+    def __call__(self, market_data: MarketData, **kwargs):
+        ...
+
+    def __reduce__(self):
+        return self.__class__.from_json, (self.to_json(),)
 
     @abc.abstractmethod
-    def clear(self) -> None: ...
+    def to_json(self, fmt='str') -> dict | str:
+        ...
+
+    @classmethod
+    @abc.abstractmethod
+    def from_json(cls, json_message: str | bytes | bytearray | dict) -> Self:
+        ...
+
+    def to_shm(self, name: str = None) -> str:
+        """
+        Put the data of the monitor into python shared memory.
+        This function is designed to facilitate multiprocessing.
+        Some monitor is not advised to be handled concurrently,
+        In which case, raise a NotImplementedError.
+
+        The function is expected to put all data into a sharable list,
+        and return the name of the list, which can be set by the given name.
+        Default name = self.monitor_id
+
+        Note that this method HAVE NO LOCK, use with caution.
+        """
+        if name is None:
+            name = f'{self.monitor_id}.json'
+
+        data = pickle.dumps(self.to_json(fmt='dict'))
+        size = len(data)
+
+        try:
+            shm = shared_memory.SharedMemory(name=name)
+
+            if shm.size != size:
+                shm.close()
+                shm.unlink()
+                shm = shared_memory.SharedMemory(create=True, size=size, name=name)
+        except FileNotFoundError as _:
+            shm = shared_memory.SharedMemory(create=True, size=size, name=name)
+
+        shm.buf[:size] = data
+        shm.close()
+        return name
+
+    @classmethod
+    def from_shm(cls, monitor_id: str):
+        """
+        retrieve the data and update the monitor from shared memory.
+        This function is designed to facilitate multiprocessing.
+        """
+        return
 
-    @property
     @abc.abstractmethod
-    def value(self) -> dict[str, float] | float: ...
+    def clear(self) -> None:
+        ...
 
     @property
     @abc.abstractmethod
-    def is_ready(self) -> bool: ...
+    def value(self) -> dict[str, float] | float:
+        ...
+
+    @property
+    def is_ready(self) -> bool:
+        return True
+
+
+class MonitorManager(object):
+    """
+    manage market data monitor
+
+    state codes for the manager
+    0: idle
+    1: working
+    -1: terminating
+    """
+
+    def __init__(self):
+        self.monitor: dict[str, MarketDataMonitor] = {}
+
+    def __call__(self, market_data: MarketData):
+        for monitor_id in self.monitor:
+            self._work(monitor_id=monitor_id, market_data=market_data)
+
+    def add_monitor(self, monitor: MarketDataMonitor):
+        self.monitor[monitor.monitor_id] = monitor
+
+    def pop_monitor(self, monitor_id: str) -> MarketDataMonitor:
+        return self.monitor.pop(monitor_id)
+
+    def _work(self, monitor_id: str, market_data: MarketData):
+        monitor = self.monitor.get(monitor_id)
+        if monitor is not None and monitor.enabled:
+            monitor.__call__(market_data)
+
+    def start(self):
+        pass
+
+    def stop(self):
+        pass
+
+    def clear(self):
+        self.monitor.clear()
+
+    @property
+    def values(self) -> dict[str, float]:
+        values = {}
+
+        for monitor in self.monitor.values():
+            values.update(monitor.value)
+
+        return values
 
 
 class SyntheticOrderBookMonitor(MarketDataMonitor):
-    def __init__(self, keep_order_log: bool = False, **kwargs):
-        self.keep_order_log = keep_order_log
+
+    def __init__(self, **kwargs):
 
         super().__init__(
             name=kwargs.pop('name', 'Monitor.SyntheticOrderBook'),
-            monitor_id=kwargs.pop('monitor_id', None),
-            mds=kwargs.pop('mds', None),
+            monitor_id=kwargs.pop('monitor_id', None)
         )
 
-        self._is_ready = True
-        self._value = {}
-        self.order_book = {}
-        self.order_log = {}
+        self.order_book: dict[str, OrderBook] = {}
 
     def __call__(self, market_data: MarketData, **kwargs):
         if isinstance(market_data, TradeData):
@@ -77,55 +176,59 @@ class SyntheticOrderBookMonitor(MarketDataMonitor):
 
         if order_book := self.order_book.get(ticker):
             if order_book.market_time <= trade_data.market_time:
-                side: TransactionSide = trade_data.side
+                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_entry(price=price, volume=max(0, listed_volume - traded_volume))
-
-        if self.keep_order_log:
-            self._update_order_log(trade_data=trade_data)
+                book.update(price=price, volume=max(0, listed_volume - traded_volume))
 
     def on_transaction_data(self, transaction_data: TransactionData):
         pass
 
-    def _update_order_log(self, trade_data: TradeData):
-        side: TransactionSide = trade_data.side
-        price = trade_data.price
-        traded_volume = trade_data.volume
-
-        for order_id in list(self.order_log):
-            order_log = self.order_log.get(order_id)
-
-            if order_log is None:
-                continue
-
-            if side.sign > 0:
-                if order_log.side.sign < 0:
-                    if price == order_log.price:
-                        order_log.volume -= traded_volume
-                    elif price > order_log.price:
-                        order_log.volume = 0.
-                else:
-                    if price <= order_log.price:
-                        order_log.volume = 0.
-            elif side.sign < 0:
-                if order_log.side.sign > 0:
-                    if price == order_log.price:
-                        order_log.volume -= traded_volume
-                    elif price < order_log.price:
-                        order_log.volume = 0.
-                else:
-                    if price >= order_log.price:
-                        order_log.volume = 0.
-
-            if order_log.volume <= 0:
-                self.order_log.pop(order_id)
+    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()},
+        )
 
-    @property
-    def is_ready(self) -> bool:
-        return self._is_ready
+        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]:
@@ -133,21 +236,18 @@ class SyntheticOrderBookMonitor(MarketDataMonitor):
 
 
 class MinuteBarMonitor(MarketDataMonitor):
+
     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),
-            mds=kwargs.pop('mds', None),
+            monitor_id=kwargs.pop('monitor_id', None)
         )
 
         self._minute_bar_data: dict[str, BarData] = {}
         self._last_bar_data: dict[str, BarData] = {}
 
-        self._is_ready = True
-        self._value = {}
-
     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)
@@ -156,6 +256,7 @@ class MinuteBarMonitor(MarketDataMonitor):
         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
@@ -164,7 +265,8 @@ class MinuteBarMonitor(MarketDataMonitor):
 
             bar_data = self._minute_bar_data[ticker] = BarData(
                 ticker=ticker,
-                bar_start_time=datetime.datetime.fromtimestamp(self.mds.timestamp // interval * interval),
+                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,
@@ -178,23 +280,25 @@ class MinuteBarMonitor(MarketDataMonitor):
             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['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)
+        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 = MarketData.market_time
+        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,
-                bar_start_time=datetime.datetime.fromtimestamp(self.mds.timestamp - interval),
+                start_timestamp=timestamp - interval,
+                timestamp=timestamp,
                 bar_span=datetime.timedelta(seconds=interval),
                 high_price=market_price,
                 low_price=market_price,
@@ -210,7 +314,7 @@ class MinuteBarMonitor(MarketDataMonitor):
             bar_data = self._minute_bar_data[ticker]
 
         history: list[TradeData] = getattr(bar_data, 'history')
-        bar_data.bar_start_time = datetime.datetime.fromtimestamp(self.mds.timestamp - interval)
+        bar_data['start_timestamp'] = timestamp - interval
 
         if isinstance(market_data, TradeData):
             history.append(market_data)
@@ -221,17 +325,62 @@ class MinuteBarMonitor(MarketDataMonitor):
             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])
+        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()},
+        )
 
-    @property
-    def is_ready(self) -> bool:
-        return self._is_ready
+        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]:
@@ -469,8 +618,7 @@ class MarketDataService(object):
         self._tick_data: dict[str, TickData] = {}
         self._trade_data: dict[str, TradeData] = {}
         self._monitor: dict[str, MarketDataMonitor] = {}
-
-        self.lock = threading.Lock()
+        self._monitor_manager = MonitorManager()
 
         if self.synthetic_orderbook:
             # init synthetic orderbook monitor
@@ -484,24 +632,30 @@ class MarketDataService(object):
             self.on_market_data(market_data=kwargs['market_data'])
 
     def __getitem__(self, monitor_id: str) -> MarketDataMonitor:
-        return self._monitor[monitor_id]
+        return self.monitor[monitor_id]
 
     def add_monitor(self, monitor: MarketDataMonitor):
-        self._monitor[monitor.monitor_id] = monitor
+        self.monitor[monitor.monitor_id] = monitor
+        self.monitor_manager.add_monitor(monitor)
 
     def pop_monitor(self, monitor: MarketDataMonitor = None, monitor_id: str = None, monitor_name: str = None):
         if monitor_id is not None:
-            return self._monitor.pop(monitor_id)
+            pass
         elif monitor_name is not None:
-            for _ in list(self._monitor.values()):
+            for _ in list(self.monitor.values()):
                 if _.name == monitor_name:
-                    return self._monitor.pop(_.monitor_id)
+                    monitor_id = _.monitor_id
+            if monitor is None:
+                LOGGER.error(f'monitor_name {monitor_name} not registered.')
         elif monitor is not None:
-            return self._monitor.pop(monitor.monitor_id)
+            monitor_id = monitor.monitor_id
         else:
             LOGGER.error('must assign a monitor, or monitor_id, or monitor_name to pop.')
             return None
 
+        self.monitor.pop(monitor_id)
+        self.monitor_manager.pop_monitor(monitor_id)
+
     def init_cn_override(self):
         self.profile = CN_Profile()
 
@@ -520,7 +674,7 @@ class MarketDataService(object):
             LOGGER.info(f'MDS confirmed {ticker} TickData subscribed!')
 
         self._tick_data[ticker] = tick_data
-        self._order_book[ticker] = tick_data.order_book
+        # self._order_book[ticker] = tick_data.order_book
 
     def _on_order_book(self, order_book):
         ticker = order_book.ticker
@@ -531,7 +685,6 @@ class MarketDataService(object):
         self._order_book[ticker] = order_book
 
     def on_market_data(self, market_data: MarketData):
-        self.lock.acquire()
         ticker = market_data.ticker
         market_time = market_data.market_time
         timestamp = market_data.timestamp
@@ -551,18 +704,7 @@ class MarketDataService(object):
         elif isinstance(market_data, OrderBook):
             self._on_order_book(order_book=market_data)
 
-        for monitor_id in self._monitor:
-            monitor = self._monitor.get(monitor_id)
-
-            if monitor is None:
-                continue
-
-            if not monitor.enabled:
-                continue
-
-            monitor.__call__(market_data)
-
-        self.lock.release()
+        self.monitor_manager.__call__(market_data=market_data)
 
     def get_order_book(self, ticker: str) -> OrderBook | None:
         return self._order_book.get(ticker, None)
@@ -590,7 +732,7 @@ class MarketDataService(object):
             else:
                 raise ValueError(f'Invalid side {side}')
 
-            queued_volume = book.loc(prior=prior, posterior=posterior)
+            queued_volume = book.loc_volume(p0=prior, p1=posterior)
         return queued_volume
 
     def trade_time_between(self, start_time: datetime.datetime | float, end_time: datetime.datetime | float, **kwargs) -> datetime.timedelta:
@@ -600,28 +742,23 @@ class MarketDataService(object):
         return self.profile.in_trade_session(market_time=market_time)
 
     def clear(self):
-        self.lock.acquire()
         # self._market_price.clear()
         # self._market_time = None
         # self._timestamp = None
 
         self._market_history.clear()
         self._order_book.clear()
-        self._monitor.clear()
-        self.lock.release()
+        self.monitor.clear()
+        self.monitor_manager.clear()
 
     @property
     def market_price(self) -> dict[str, float]:
-        self.lock.acquire()
         result = self._market_price
-        self.lock.release()
         return result
 
     @property
     def market_history(self) -> dict[str, dict[datetime.datetime, float]]:
-        self.lock.acquire()
         result = self._market_history
-        self.lock.release()
         return result
 
     @property
@@ -663,6 +800,23 @@ class MarketDataService(object):
     def session_break(self) -> tuple[datetime.time, datetime.time] | None:
         return self.profile.session_break
 
+    @property
+    def monitor(self) -> dict[str, MarketDataMonitor]:
+        return self._monitor
+
+    @property
+    def monitor_manager(self) -> MonitorManager:
+        return self._monitor_manager
+
+    @monitor_manager.setter
+    def monitor_manager(self, manager: MonitorManager):
+        self._monitor_manager.clear()
+
+        self._monitor_manager = manager
+
+        for monitor in self.monitor.values():
+            self._monitor_manager.add_monitor(monitor=monitor)
+
 
 class Replay(object, metaclass=abc.ABCMeta):
     @abc.abstractmethod
@@ -779,15 +933,22 @@ class ProgressiveReplay(Replay):
         tickers: list[str] = kwargs.pop('ticker', kwargs.pop('tickers', []))
         dtypes: list[str | type] = kwargs.pop('dtype', kwargs.pop('dtypes', [TradeData, OrderBook, TickData]))
 
-        if isinstance(tickers, Iterable):
+        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:
-            tickers = [tickers]
+            raise TypeError(f'Invalid ticker {tickers}, expect str or list[str]')
 
-        if isinstance(dtypes, Iterable):
+        if isinstance(dtypes, str) or inspect.isclass(dtypes):
+            dtypes = [dtypes]
+        elif isinstance(dtypes, Iterable):
             dtypes = list(dtypes)
         else:
-            dtypes = [dtypes]
+            raise TypeError(f'Invalid dtype {dtypes}, expect str or list[str]')
 
         for ticker in tickers:
             for dtype in dtypes:
@@ -795,7 +956,7 @@ class ProgressiveReplay(Replay):
 
         subscription = kwargs.pop('subscription', kwargs.pop('subscribe', []))
 
-        if not isinstance(subscription, list):
+        if isinstance(subscription, dict):
             subscription = [subscription]
 
         for sub in subscription:
@@ -806,8 +967,10 @@ class ProgressiveReplay(Replay):
     def add_subscription(self, ticker: str, dtype: type | str):
         if isinstance(dtype, str):
             pass
-        else:
+        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)

{PyAlgoEngine-0.3.11.post1 → PyAlgoEngine-0.3.12.post3}/AlgoEngine/Engine/TradeEngine.py

@@ -2000,7 +2000,7 @@ class SimMatch(object):
         self.market_time = datetime.datetime.min
 
     def __call__(self, **kwargs):
-        order = kwargs.pop('order', None)
+        order: TradeInstruction = kwargs.pop('order', None)
         market_data = kwargs.pop('market_data', None)
 
         if order is not None:
@@ -2084,7 +2084,7 @@ class SimMatch(object):
                 if order.side.sign > 0:
                     # match order based on worst offer
                     if order.limit_price is None:
-                        self._match(order=order, match_price=market_data.VWAP)
+                        self._match(order=order, match_price=market_data.vwap)
                     elif market_data.high_price < order.limit_price:
                         self._match(order=order, match_price=market_data.high_price)
                     # match order based on limit price
@@ -2096,7 +2096,7 @@ class SimMatch(object):
                 elif order.side.sign < 0:
                     # match order based on worst offer
                     if order.limit_price is None:
-                        self._match(order=order, match_price=market_data.VWAP)
+                        self._match(order=order, match_price=market_data.vwap)
                     elif market_data.low_price > order.limit_price:
                         self._match(order=order, match_price=market_data.low_price)
                     # match order based on limit price

{PyAlgoEngine-0.3.11.post1 → PyAlgoEngine-0.3.12.post3}/AlgoEngine/Engine/__init__.py

@@ -92,10 +92,10 @@ _ = get_logger()
 
 from .EventEngine import EVENT_ENGINE, TOPIC
 from .AlgoEngine import AlgoTemplate, ALGO_ENGINE, ALGO_REGISTRY
-from .MarketEngine import MDS, MarketDataService, MarketDataMonitor, SyntheticOrderBookMonitor, MinuteBarMonitor, ProgressiveReplay, SimpleReplay, Replay
+from .MarketEngine import MDS, MarketDataService, MarketDataMonitor, MonitorManager, SyntheticOrderBookMonitor, MinuteBarMonitor, ProgressiveReplay, SimpleReplay, Replay
 from .TradeEngine import DirectMarketAccess, Balance, PositionManagementService, Inventory, RiskProfile, SimMatch
 
 __all__ = ['set_logger', 'LOGGER', 'EVENT_ENGINE', 'TOPIC',
            'AlgoTemplate', 'ALGO_ENGINE', 'ALGO_REGISTRY',
-           'MDS', 'MarketDataService', 'MarketDataMonitor', 'SyntheticOrderBookMonitor', 'MinuteBarMonitor', 'ProgressiveReplay', 'SimpleReplay', 'Replay',
+           'MDS', 'MarketDataService', 'MarketDataMonitor', 'MonitorManager', 'SyntheticOrderBookMonitor', 'MinuteBarMonitor', 'ProgressiveReplay', 'SimpleReplay', 'Replay',
            'DirectMarketAccess', 'Balance', 'PositionManagementService', 'Inventory', 'RiskProfile', 'SimMatch']

{PyAlgoEngine-0.3.11.post1 → PyAlgoEngine-0.3.12.post3}/AlgoEngine/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.3.11.post1"
+__version__ = "0.3.12.post3"
 
 import traceback
 

{PyAlgoEngine-0.3.11.post1 → PyAlgoEngine-0.3.12.post3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyAlgoEngine
-Version: 0.3.11.post1
+Version: 0.3.12.post3
 Summary: Basic algo engine
 Home-page: https://github.com/BolunHan/PyAlgoEngine
 Author: Bolun.Han

{PyAlgoEngine-0.3.11.post1 → PyAlgoEngine-0.3.12.post3}/PyAlgoEngine.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PyAlgoEngine
-Version: 0.3.11.post1
+Version: 0.3.12.post3
 Summary: Basic algo engine
 Home-page: https://github.com/BolunHan/PyAlgoEngine
 Author: Bolun.Han