onesecondtrader 0.18.0__py3-none-any.whl → 0.20.0__py3-none-any.whl

onesecondtrader/core.py

@@ -5,6 +5,7 @@ Core module containing the backbone of OneSecondTrader's event-driven architectu
 import abc
 import dataclasses
 import enum
+import logging
 import pandas as pd
 import queue
 import threading
@@ -13,6 +14,13 @@ import uuid
 from collections import defaultdict
 
 
+logging.basicConfig(
+    level=logging.DEBUG,
+    format="%(asctime)s - %(levelname)s - %(threadName)s - %(message)s",
+)
+logger = logging.getLogger("onesecondtrader")
+
+
 class Models:
     """
     Namespace for all models.
@@ -34,12 +42,41 @@ class Models:
         STOP = enum.auto()
         STOP_LIMIT = enum.auto()
 
+    class OrderRejectionReason(enum.Enum):
+        INSUFFICIENT_FUNDS = enum.auto()
+        MARKET_CLOSED = enum.auto()
+        UNKNOWN = enum.auto()
+
+    class CancelRejectionReason(enum.Enum):
+        ORDER_ALREADY_FILLED = enum.auto()
+        ORDER_ALREADY_CANCELLED = enum.auto()
+        ORDER_PENDING_EXECUTION = enum.auto()
+        MARKET_CLOSED = enum.auto()
+        UNKNOWN = enum.auto()
+
+    class ModifyRejectionReason(enum.Enum):
+        ORDER_ALREADY_FILLED = enum.auto()
+        ORDER_ALREADY_CANCELLED = enum.auto()
+        ORDER_PENDING_EXECUTION = enum.auto()
+        ORDER_NOT_FOUND = enum.auto()
+        INVALID_PRICE = enum.auto()
+        INVALID_QUANTITY = enum.auto()
+        MARKET_CLOSED = enum.auto()
+        UNKNOWN = enum.auto()
+
+    class TimeInForce(enum.Enum):
+        GTC = enum.auto()
+        DAY = enum.auto()
+        IOC = enum.auto()
+        FOK = enum.auto()
+
 
 class Events:
     """
     Namespace for all events.
     """
 
+    # BASE EVENT
     @dataclasses.dataclass(kw_only=True, frozen=True)
     class BaseEvent:
         ts_event: pd.Timestamp = dataclasses.field(
@@ -48,12 +85,20 @@ class Events:
 
     # SYSTEM EVENTS
     @dataclasses.dataclass(kw_only=True, frozen=True)
-    class SystemShutdown(BaseEvent):
+    class SystemEvent(BaseEvent):
+        pass
+
+    @dataclasses.dataclass(kw_only=True, frozen=True)
+    class SystemShutdown(SystemEvent):
         pass
 
     # MARKET EVENTS
     @dataclasses.dataclass(kw_only=True, frozen=True)
-    class IncomingBar(BaseEvent):
+    class MarketEvent(BaseEvent):
+        pass
+
+    @dataclasses.dataclass(kw_only=True, frozen=True)
+    class IncomingBar(MarketEvent):
         ts_event: pd.Timestamp
         symbol: str
         record_type: Models.RecordType
@@ -63,29 +108,83 @@ class Events:
         close: float
         volume: int | None = None
 
-    # BROKER REQUEST EVENTS
+    # BROKER REQUESTS EVENTS
     @dataclasses.dataclass(kw_only=True, frozen=True)
-    class Order(BaseEvent):
-        order_id: uuid.UUID = dataclasses.field(default_factory=lambda: uuid.uuid4())
+    class BrokerRequestEvent(BaseEvent):
+        pass
+
+    @dataclasses.dataclass(kw_only=True, frozen=True)
+    class SubmitOrder(BrokerRequestEvent):
+        order_id: uuid.UUID = dataclasses.field(default_factory=uuid.uuid4)
         symbol: str
         order_type: Models.OrderType
         side: Models.OrderSide
         quantity: float
         limit_price: float | None = None
         stop_price: float | None = None
+        time_in_force: Models.TimeInForce = Models.TimeInForce.GTC
+
+    @dataclasses.dataclass(kw_only=True, frozen=True)
+    class ModifyOrder(BrokerRequestEvent):
+        order_id: uuid.UUID
+        quantity: float | None = None
+        limit_price: float | None = None
+        stop_price: float | None = None
+
+    @dataclasses.dataclass(kw_only=True, frozen=True)
+    class CancelOrder(BrokerRequestEvent):
+        order_id: uuid.UUID
 
     # BROKER RESPONSE EVENTS
     @dataclasses.dataclass(kw_only=True, frozen=True)
-    class Fill(BaseEvent):
+    class BrokerResponseEvent(BaseEvent):
+        ts_broker: pd.Timestamp
+
+    @dataclasses.dataclass(kw_only=True, frozen=True)
+    class OrderSubmitted(BrokerResponseEvent):
+        order_id: uuid.UUID
+        broker_order_id: str | None = None
+
+    @dataclasses.dataclass(kw_only=True, frozen=True)
+    class OrderModified(BrokerResponseEvent):
+        order_id: uuid.UUID
+        broker_order_id: str | None = None
+
+    @dataclasses.dataclass(kw_only=True, frozen=True)
+    class Fill(BrokerResponseEvent):
         fill_id: uuid.UUID = dataclasses.field(default_factory=uuid.uuid4)
         broker_fill_id: str | None = None
         associated_order_id: uuid.UUID
+        symbol: str
         side: Models.OrderSide
         quantity_filled: float
         fill_price: float
         commission: float
         exchange: str = "SIMULATED"
 
+    @dataclasses.dataclass(kw_only=True, frozen=True)
+    class OrderRejected(BrokerResponseEvent):
+        order_id: uuid.UUID
+        reason: Models.OrderRejectionReason
+
+    @dataclasses.dataclass(kw_only=True, frozen=True)
+    class OrderCancelled(BrokerResponseEvent):
+        order_id: uuid.UUID
+
+    @dataclasses.dataclass(kw_only=True, frozen=True)
+    class OrderExpired(BrokerResponseEvent):
+        order_id: uuid.UUID
+
+    @dataclasses.dataclass(kw_only=True, frozen=True)
+    class CancelRejected(BrokerResponseEvent):
+        order_id: uuid.UUID
+        reason: Models.CancelRejectionReason
+
+    @dataclasses.dataclass(kw_only=True, frozen=True)
+    class ModifyRejected(BrokerResponseEvent):
+        order_id: uuid.UUID
+        reason: Models.ModifyRejectionReason
+
 
 class BaseConsumer(abc.ABC):
     """
@@ -94,7 +193,9 @@ class BaseConsumer(abc.ABC):
 
     def __init__(self) -> None:
         self._queue: queue.Queue[Events.BaseEvent] = queue.Queue()
-        self._thread = threading.Thread(target=self._consume, daemon=True)
+        self._thread = threading.Thread(
+            target=self._consume, name=self.__class__.__name__, daemon=True
+        )
         self._thread.start()
 
     @abc.abstractmethod

onesecondtrader/datafeeds.py

@@ -0,0 +1,172 @@
+import abc
+import pandas as pd
+import threading
+
+from pathlib import Path
+from onesecondtrader.core import Events, Models, event_bus, logger
+
+
+class DatafeedBase(abc.ABC):
+    """
+    Base class for all datafeeds.
+    """
+
+    def __init__(self) -> None:
+        self._is_connected: bool = False
+        self._watched_symbols: set[tuple[str, Models.RecordType]] = set()
+        self._lock: threading.Lock = threading.Lock()
+
+    @abc.abstractmethod
+    def watch(self, symbols: list[tuple[str, Models.RecordType]]) -> bool:
+        pass
+
+    @abc.abstractmethod
+    def unwatch(self, symbols: list[str]) -> None:
+        pass
+
+
+class SimulatedDatafeedCSV(DatafeedBase):
+    """
+    CSV-based simulated datafeed for backtesting.
+    """
+
+    csv_path: str | Path = ""
+    artificial_delay: float = 0.0
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._stop_event = threading.Event()
+        self._streaming_thread: threading.Thread | None = None
+        self._data_iterator: pd.io.parsers.readers.TextFileReader | None = None
+        self._connected_path: str | Path = ""
+
+    def watch(self, symbols: list[tuple[str, Models.RecordType]]) -> bool:
+        with self._lock:
+            if not self._is_connected:
+                try:
+                    self._data_iterator = pd.read_csv(
+                        Path(self.csv_path),
+                        usecols=[
+                            "ts_event",
+                            "rtype",
+                            "open",
+                            "high",
+                            "low",
+                            "close",
+                            "volume",
+                            "symbol",
+                        ],
+                        dtype={
+                            "ts_event": int,
+                            "rtype": int,
+                            "open": int,
+                            "high": int,
+                            "low": int,
+                            "close": int,
+                            "volume": int,
+                            "symbol": str,
+                        },
+                        chunksize=1,
+                    )
+                    self._is_connected = True
+                    self._connected_path = self.csv_path
+                    logger.info(
+                        f"{self.__class__.__name__} connected to {self.csv_path}"
+                    )
+                except Exception as e:
+                    logger.error(f"{self.__class__.__name__} failed to connect: {e}")
+                    self._data_iterator = None
+                    self._is_connected = False
+                    return False
+            elif self._connected_path != self.csv_path:
+                logger.warning(
+                    "csv_path changed while connected; unwatch all symbols first"
+                )
+
+            self._watched_symbols.update(symbols)
+            formatted = ", ".join(f"{s} ({r.name})" for s, r in symbols)
+            logger.info(f"{self.__class__.__name__} watching {formatted}")
+
+            if not self._streaming_thread or not self._streaming_thread.is_alive():
+                self._stop_event.clear()
+                self._streaming_thread = threading.Thread(
+                    target=self._stream, name="CSVDatafeedStreaming", daemon=False
+                )
+                self._streaming_thread.start()
+
+        return True
+
+    def unwatch(self, symbols: list[str]) -> None:
+        thread_to_join = None
+        with self._lock:
+            symbols_set = set(symbols)
+            self._watched_symbols.difference_update(
+                {
+                    (symbol, rtype)
+                    for (symbol, rtype) in self._watched_symbols
+                    if symbol in symbols_set
+                }
+            )
+            logger.info(f"{self.__class__.__name__} unwatched {', '.join(symbols)}")
+            if not self._watched_symbols:
+                self._stop_event.set()
+                thread_to_join = self._streaming_thread
+                self._streaming_thread = None
+
+        if thread_to_join and thread_to_join.is_alive():
+            thread_to_join.join(timeout=5.0)
+            if thread_to_join.is_alive():
+                logger.warning("Streaming thread did not terminate within timeout")
+            else:
+                logger.info(f"{self.__class__.__name__} disconnected")
+
+    def _stream(self) -> None:
+        if self._data_iterator is None:
+            logger.error("_stream called with no data iterator")
+            return
+        should_delay = self.artificial_delay > 0
+        delay_time = self.artificial_delay
+        while not self._stop_event.is_set():
+            try:
+                chunk = next(self._data_iterator)
+                row = chunk.iloc[0]
+
+                symbol = row["symbol"]
+                record_type = Models.RecordType(row["rtype"])
+                symbol_key = (symbol, record_type)
+
+                with self._lock:
+                    if symbol_key not in self._watched_symbols:
+                        continue
+
+                bar_event = Events.IncomingBar(
+                    ts_event=pd.Timestamp(row["ts_event"], unit="ns", tz="UTC"),
+                    symbol=symbol,
+                    record_type=record_type,
+                    open=row["open"] / 1e9,
+                    high=row["high"] / 1e9,
+                    low=row["low"] / 1e9,
+                    close=row["close"] / 1e9,
+                    volume=row["volume"],
+                )
+
+                event_bus.publish(bar_event)
+
+                if should_delay and self._stop_event.wait(delay_time):
+                    break
+            except StopIteration:
+                logger.info("CSV datafeed reached end of file")
+                break
+            except Exception as e:
+                logger.error(f"CSV datafeed error reading data: {e}")
+                break
+
+        with self._lock:
+            self._data_iterator = None
+            self._is_connected = False
+
+
+simulated_datafeed_csv = SimulatedDatafeedCSV()
+"""
+Global instance of SimulatedDatafeedCSV.
+"""

{onesecondtrader-0.18.0.dist-info → onesecondtrader-0.20.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onesecondtrader
-Version: 0.18.0
+Version: 0.20.0
 Summary: The Trading Infrastructure Toolkit for Python. Research, simulate, and deploy algorithmic trading strategies — all in one place.
 License-File: LICENSE
 Author: Nils P. Kujath

onesecondtrader-0.20.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+onesecondtrader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+onesecondtrader/core.py,sha256=UH8nVc_tZX-xHEaCp1YCyMeHDOtQTbP6sr8a9bqwSyw,7115
+onesecondtrader/datafeeds.py,sha256=KXK2duFRFPo7KuNbG7AqIu-LGXtuuDj20aTOGBE4Cm4,6103
+onesecondtrader/indicators.py,sha256=wGn-5v8L1gepMP45KcVrEo-f2ReOCD3r8lva9aEIUnY,3199
+onesecondtrader-0.20.0.dist-info/METADATA,sha256=6FN1iee59eZiuQz1Y8NsY4EeOhayXxx6xGsmKt3UdOg,9682
+onesecondtrader-0.20.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+onesecondtrader-0.20.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+onesecondtrader-0.20.0.dist-info/RECORD,,

onesecondtrader-0.18.0.dist-info/RECORD

@@ -1,7 +0,0 @@
-onesecondtrader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-onesecondtrader/core.py,sha256=uMy2eYLtzfSPC_99kjft7L3DL4SRi1ZBnnSYyd_XrIo,3921
-onesecondtrader/indicators.py,sha256=wGn-5v8L1gepMP45KcVrEo-f2ReOCD3r8lva9aEIUnY,3199
-onesecondtrader-0.18.0.dist-info/METADATA,sha256=48Xk2OPiF57MkcpqFnyAG328SWljqyTEO5XmFS0VDrI,9682
-onesecondtrader-0.18.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-onesecondtrader-0.18.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-onesecondtrader-0.18.0.dist-info/RECORD,,