PyAlgoEngine 0.12.0.post3__cp313-cp313-win_amd64.whl

algo_engine/base/finance_decimal.py

@@ -0,0 +1,258 @@
+import math
+import numbers
+import operator
+
+__all__ = ['FinancialDecimal']
+
+from typing import Self
+
+TICK_SIZE = 100
+
+
+class FinancialDecimal(float):
+    __slots__ = ('_k', '_tick')
+
+    # We're immutable, so use __new__ not __init__
+    def __new__(cls, value: numbers.Real | str = 0., /, k: int = None, tick: int = None):
+        if tick is not None and type(tick) is not int:
+            raise TypeError(f'tick of {cls} must be a integer.')
+        elif tick is None:
+            tick = TICK_SIZE
+        elif tick <= 0:
+            raise ValueError(f'tick of {cls} must be a positive integer.')
+
+        if k is not None and type(k) is not int:
+            raise TypeError(f'k of {cls} must be a integer.')
+        elif k is None:
+            if type(value) is int:
+                k = value * tick
+            elif isinstance(value, numbers.Real):
+                k = round(value * tick)
+            elif isinstance(value, (str, bytes)):
+                k = round(float(value) * tick)
+            else:
+                raise TypeError(f'value of the {cls} must be a float-convertable.')
+
+        self = super(FinancialDecimal, cls).__new__(cls, k / tick)
+
+        self._k = k
+        self._tick = tick
+        return self
+
+    def __repr__(self):
+        return f'{self.__class__.__name__}({self._k}, {self._tick})'
+
+    def __str__(self):
+        if self._tick == 1:
+            return str(self._k)
+        else:
+            digits = math.ceil(math.log10(self._tick))
+            return format(float(self), f'.{digits}f')
+
+    def __reduce__(self):
+        return self.__class__, (self._k, self._tick)
+
+    def __copy__(self):
+        # for a float, the copy method should return a different object / memory location. In fact, this method should not even be implemented!
+        # however the Fraction, as an immutable, use the same object / memory location, as clone.
+        # this method uses float-style implementation
+        return self.__class__(self._k, self._tick)
+
+    def __deepcopy__(self, memo):
+        return self.__class__(self._k, self._tick)
+
+    @classmethod
+    def from_float(cls, f: float, tick=None):
+        if isinstance(f, numbers.Integral):
+            return cls(int(f), tick=tick)
+        elif not isinstance(f, float):
+            raise TypeError(f"{cls.__name__}.from_float() only takes floats, not {f!r} ({type(f).__name__})")
+
+        return cls(f, tick=tick)
+
+    def as_integer_ratio(self) -> tuple[int, int]:
+        return self._k, self._tick
+
+    def __add__(self, other: int | float | numbers.Real):
+        if isinstance(other, int):
+            return self.__class__(k=self._k + other * self._tick, tick=self._tick)
+        elif isinstance(other, self.__class__) and self._tick == other._tick:
+            return self.__class__(k=self._k + other._k, tick=self._tick)
+        elif isinstance(other, float):
+            return self.__class__(k=round(self._k + float.__mul__(other, self._tick)), tick=self._tick)
+        else:
+            return float.__add__(self, other)
+
+    def __radd__(self, other: int | float | numbers.Real):
+        if isinstance(other, numbers.Real):
+            return self.__add__(other)
+        else:
+            return other.__add__(float(self))
+
+    def __sub__(self, other: int | float | numbers.Real):
+        if isinstance(other, int):
+            return self.__class__(k=self._k - other * self._tick, tick=self._tick)
+        elif isinstance(other, self.__class__) and self._tick == other._tick:
+            return self.__class__(k=self._k - other._k, tick=self._tick)
+        elif isinstance(other, float):
+            return self.__class__(k=round(self._k - float.__mul__(other, self._tick)), tick=self._tick)
+        else:
+            return float.__sub__(self, other)
+
+    def __rsub__(self, other: int | float | numbers.Real):
+        if isinstance(other, numbers.Real):
+            return FinancialDecimal(other, tick=self._tick).__sub__(self)
+        else:
+            return float.__sub__(other, self)
+
+    def __mul__(self, other: int | float | numbers.Real):
+        if isinstance(other, int):
+            return self.__class__(k=self._k * other, tick=self._tick)
+        elif isinstance(other, float):
+            return self.__class__(k=round(self._k * float(other)), tick=self._tick)
+        else:
+            return float.__mul__(self, other)
+
+    def __rmul__(self, other: int | float | numbers.Real):
+        if isinstance(other, numbers.Real):
+            return self.__mul__(other)
+        else:
+            return other.__mul__(float(self))
+
+    def __truediv__(self, other: int | float | numbers.Real):
+        if isinstance(other, numbers.Real):
+            return self.__class__(k=round(self._k / float(other)), tick=self._tick)
+        else:
+            float.__truediv__(self, other)
+
+    def __rtruediv__(self, other: int | float | Self):
+        if isinstance(other, numbers.Real):
+            return self.__class__(k=round(float(other) / float(self) * self._tick), tick=self._tick)
+        else:
+            float.__truediv__(other, self)
+
+    def __floordiv__(self, other: int | float | Self):
+        if isinstance(other, (int, self.__class__)):
+            return (self._k * other.denominator) // (self._tick * other.numerator)
+        else:
+            return float.__floordiv__(self, other)
+
+    def __rdivmod__(self, other):
+        return divmod(other, float(self))
+
+    def __pow__(self, other: int | float | Self, __mod: None = None):
+        if isinstance(other, numbers.Real):
+            return self.__class__(k=round(float(self) ** float(other) * self._tick), tick=self._tick)
+        else:
+            return float.__pow__(self, other, __mod)
+
+    def __pos__(self):
+        return FinancialDecimal(k=self._k, tick=self._tick)
+
+    def __neg__(self):
+        return FinancialDecimal(k=-self._k, tick=self._tick)
+
+    def __abs__(self):
+        return FinancialDecimal(k=abs(self._k), tick=self._tick)
+
+    def _richcmp(self, other, op):
+        # convert other to a Rational instance where reasonable.
+        if isinstance(other, (numbers.Rational, self.__class__)):
+            return op(self._k * other.denominator, self._tick * other.numerator)
+        if isinstance(other, float):
+            if math.isnan(other) or math.isinf(other):
+                return op(0.0, other)
+            else:
+                return op(self, FinancialDecimal(other, tick=self._tick))
+        else:
+            return NotImplemented
+
+    def __eq__(self, other):
+        return self._richcmp(other, operator.eq)
+
+    def __lt__(self, other):
+        """a < b"""
+        return self._richcmp(other, operator.lt)
+
+    def __gt__(self, other):
+        """a > b"""
+        return self._richcmp(other, operator.gt)
+
+    def __le__(self, other):
+        """a <= b"""
+        return self._richcmp(other, operator.le)
+
+    def __ge__(self, other):
+        """a >= b"""
+        return self._richcmp(other, operator.ge)
+
+    def __bool__(self):
+        return bool(self._k)
+
+    @property
+    def k(self):
+        return self._k
+
+    @property
+    def numerator(self):
+        return self._k
+
+    @property
+    def tick(self):
+        return self._tick
+
+    @property
+    def denominator(self):
+        return self._tick
+
+
+def main():
+    fd_0 = FinancialDecimal(math.pi, tick=10000)
+    print(f'fd_0 => {fd_0}')
+    print(f'fd_0:.3f => {fd_0:.3f}')
+
+    # i = 2
+    for i in [2, math.e]:
+        print(f'fd_0 + {i} => {fd_0 + i}')
+        print(f'{i} + fd_0 => {i + fd_0}')
+
+        print(f'fd_0 - {i} => {fd_0 - i}')
+        print(f'{i} - fd_0 => {i - fd_0}')
+
+        print(f'fd_0 * {i} => {fd_0 * i}')
+        print(f'{i} * fd_0 => {i * fd_0}')
+
+        print(f'fd_0 / {i} => {fd_0 / i}')
+        print(f'{i} / fd_0 => {i / fd_0}')
+
+        print(f'fd_0 ** {i} => {fd_0 ** i}')
+        print(f'{i} ** fd_0 => {i ** fd_0}')
+
+        print(f'fd_0 // {i} => {fd_0 // i}')
+        print(f'{i} // fd_0 => {i // fd_0}')
+
+        print(f'fd_0 % {i} => {fd_0 % i}')
+        print(f'{i} % fd_0 => {i % fd_0}')
+
+        print(f'fd_0 __divmod__ {i} => {fd_0.__divmod__(i)}')
+        print(f'{i} __divmod__ fd_0 => {divmod(i, fd_0)}')
+
+    print(f'fd_0 == math.pi => {fd_0 == math.pi}')
+    print(f'fd_0 == 2 => {fd_0 == 2}')
+    print(f'fd_0 == math.e => {fd_0 == math.e}')
+
+    print(f'fd_0 >= math.pi => {fd_0 >= math.pi}')
+    print(f'fd_0 >= 2 => {fd_0 >= 2}')
+    print(f'fd_0 >= math.e => {fd_0 >= math.e}')
+
+    print(f'fd_0 <= math.pi => {fd_0 <= math.pi}')
+    print(f'fd_0 <= 2 => {fd_0 <= 2}')
+    print(f'fd_0 <= math.e => {fd_0 <= math.e}')
+
+    print(f'math.pi == fd_0  => {math.pi == fd_0}')
+    print(f'2 == fd_0=> {2 == fd_0}')
+    print(f'math.e == fd_0 => {math.e == fd_0}')
+
+
+if __name__ == '__main__':
+    main()

algo_engine/base/telemetrics.py

@@ -0,0 +1,104 @@
+import logging
+import sys
+import time
+
+LOGGER: logging.Logger | None = None
+LOG_LEVEL = logging.INFO
+
+
+class ColoredFormatter(logging.Formatter):
+    """Logging Formatter to add colors and count warning / errors"""
+
+    def __init__(self, fmt=None, datefmt=None, style='{', validate=True):
+        self.format_str = '[{asctime} {name} - {threadName} - {module}:{lineno} - {levelname}] {message}' if fmt is None else fmt
+        self.date_fmt = '%Y-%m-%d %H:%M:%S' if datefmt is None else datefmt
+        self.style = style
+
+        super().__init__(fmt=fmt, datefmt=datefmt, style=style, validate=validate)
+
+    def _get_format(self, level: int, select=False):
+        bold_red = f"\33[31;1;3;4{';7' if select else ''}m"
+        red = f"\33[31;1{';7' if select else ''}m"
+        green = f"\33[32;1{';7' if select else ''}m"
+        yellow = f"\33[33;1{';7' if select else ''}m"
+        blue = f"\33[34;1{';7' if select else ''}m"
+        reset = "\33[0m"
+
+        if level <= logging.NOTSET:
+            fmt = self.format_str
+        elif level <= logging.DEBUG:
+            fmt = blue + self.format_str + reset
+        elif level <= logging.INFO:
+            fmt = green + self.format_str + reset
+        elif level <= logging.WARNING:
+            fmt = yellow + self.format_str + reset
+        elif level <= logging.ERROR:
+            fmt = red + self.format_str + reset
+        else:
+            fmt = bold_red + self.format_str + reset
+
+        return fmt
+
+    def format(self, record):
+        log_fmt = self._get_format(level=record.levelno)
+        formatter = logging.Formatter(log_fmt, datefmt=self.date_fmt, style=self.style)
+        return formatter.format(record)
+
+
+class DuplicateWarningFilter(logging.Filter):
+    """Filter that lets each WARNING message pass only once per handler."""
+
+    def __init__(self, name: str = ''):
+        super().__init__(name=name)
+        self._seen_warnings: set[str] = set()
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        if record.levelno != logging.WARNING:
+            return True
+
+        message = record.getMessage()
+        if message in self._seen_warnings:
+            return False
+
+        self._seen_warnings.add(message)
+        return True
+
+
+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
+        stream_handler: logging.StreamHandler | None = None
+        for handler in LOGGER.handlers:
+            # noinspection PyUnresolvedReferences
+            if isinstance(handler, logging.StreamHandler) and handler.stream == stream_io:
+                have_handler = True
+                stream_handler = handler
+                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)
+            stream_handler = logger_ch
+
+        if stream_handler is not None and not any(isinstance(flt, DuplicateWarningFilter) for flt in stream_handler.filters):
+            stream_handler.addFilter(DuplicateWarningFilter())
+
+    assert LOGGER is not None
+    return LOGGER
+
+
+_ = get_logger()

algo_engine/engine/__infra__.pxd

@@ -0,0 +1,10 @@
+from .c_market_engine cimport MDS, MonitorManager, MarketDataService
+
+# Involving TopicSet is not necessary, and will causes conflict with quark.collections.c_allocator and quark.collections.c_bytemap
+# Should only cimport directly when necessary
+from .c_event_engine cimport TopicSet, EVENT_ENGINE
+
+__all__ = [
+    'MDS', 'MonitorManager', 'MarketDataService',
+    'TopicSet', 'EVENT_ENGINE'
+]

algo_engine/engine/__init__.pxd

@@ -0,0 +1,10 @@
+from .c_market_engine cimport MDS, MonitorManager, MarketDataService
+
+# Involving TopicSet is not necessary, and will causes conflict with quark.collections.c_allocator and quark.collections.c_bytemap
+# Should only cimport directly when necessary
+from .c_event_engine cimport TopicSet, EVENT_ENGINE
+
+__all__ = [
+    'MDS', 'MonitorManager', 'MarketDataService',
+    'TopicSet', 'EVENT_ENGINE'
+]

algo_engine/engine/__init__.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import logging
+
+from .. import LOGGER
+
+LOGGER = LOGGER.getChild('Engine')
+
+
+def set_logger(logger: logging.Logger):
+    global LOGGER
+    LOGGER = logger
+
+    algo_engine.LOGGER = logger.getChild('AlgoEngine')
+    c_event_engine.EVENT_ENGINE.logger = logger.getChild('EventEngine')
+    c_market_engine.LOGGER = logger.getChild('MarketEngine')
+    trade_engine.LOGGER = logger.getChild('TradeEngine')
+
+
+class Singleton(type):
+    _instances = {}
+
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
+        return cls._instances[cls]
+
+
+from .c_event_engine import EVENT_ENGINE, TOPIC, TopicSet
+from .c_market_engine import MDS, MarketDataService, MarketDataMonitor, MonitorManager
+from .algo_engine import AlgoTemplate, ALGO_ENGINE, ALGO_REGISTRY
+from .trade_engine import DirectMarketAccess, Balance, PositionManagementService, Inventory, RiskProfile
+
+__all__ = [
+    'LOGGER',
+    'EVENT_ENGINE', 'TOPIC', 'TopicSet',
+    'AlgoTemplate', 'ALGO_ENGINE', 'ALGO_REGISTRY',
+    'MDS', 'MarketDataService', 'MarketDataMonitor', 'MonitorManager', 'Singleton',
+    'DirectMarketAccess', 'Balance', 'PositionManagementService', 'Inventory', 'RiskProfile'
+]