onesecondtrader 0.53.0__tar.gz → 0.54.0__tar.gz

{onesecondtrader-0.53.0 → onesecondtrader-0.54.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onesecondtrader
-Version: 0.53.0
+Version: 0.54.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.53.0 → onesecondtrader-0.54.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "onesecondtrader"
-version = "0.53.0"
+version = "0.54.0"
 description = "The Trading Infrastructure Toolkit for Python. Research, simulate, and deploy algorithmic trading strategies — all in one place."
 authors = [
     {name = "Nils P. Kujath",email = "63961429+NilsKujath@users.noreply.github.com"}

onesecondtrader-0.54.0/src/onesecondtrader/datafeeds/__init__.py

@@ -0,0 +1,11 @@
+"""
+Provides data feed components for ingesting market data into the system.
+"""
+
+from .base import DatafeedBase
+from .simulated import SimulatedDatafeed
+
+__all__ = [
+    "DatafeedBase",
+    "SimulatedDatafeed",
+]

onesecondtrader-0.54.0/src/onesecondtrader/datafeeds/base.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import abc
+
+from onesecondtrader import events, messaging, models
+
+
+class DatafeedBase(abc.ABC):
+    """
+    Abstract base class for market data feed implementations.
+
+    A data feed is responsible for connecting to an external data source, managing symbol and bar-period subscriptions, and publishing market data events onto the system event bus.
+
+    Concrete subclasses implement the mechanics of connectivity, subscription handling, and lifecycle management for a specific data source.
+    """
+
+    def __init__(self, event_bus: messaging.EventBus) -> None:
+        """
+        Initialize the data feed with an event bus.
+
+        parameters:
+            event_bus:
+                Event bus used to publish market data events produced by this data feed.
+        """
+        self._event_bus = event_bus
+
+    def _publish(self, event: events.EventBase) -> None:
+        """
+        Publish a market data event to the event bus.
+
+        This method is intended for use by subclasses to forward incoming data from the external source into the internal event-driven system.
+
+        parameters:
+            event:
+                Event instance to be published.
+        """
+        self._event_bus.publish(event)
+
+    @abc.abstractmethod
+    def connect(self) -> None:
+        """
+        Establish a connection to the underlying data source.
+
+        Implementations should perform any required setup, authentication, or resource allocation needed before subscriptions can be registered.
+        """
+        pass
+
+    @abc.abstractmethod
+    def disconnect(self) -> None:
+        """
+        Terminate the connection to the underlying data source.
+
+        Implementations should release resources and ensure that no further events are published after disconnection.
+        """
+        pass
+
+    @abc.abstractmethod
+    def subscribe(self, symbols: list[str], bar_period: models.BarPeriod) -> None:
+        """
+        Subscribe to market data for one or more symbols at a given bar period.
+
+        parameters:
+            symbols:
+                Instrument symbols to subscribe to, interpreted according to the conventions of the underlying data source.
+            bar_period:
+                Bar aggregation period specifying the granularity of market data.
+        """
+        pass
+
+    @abc.abstractmethod
+    def unsubscribe(self, symbols: list[str], bar_period: models.BarPeriod) -> None:
+        """
+        Cancel existing subscriptions for one or more symbols at a given bar period.
+
+        parameters:
+            symbols:
+                Instrument symbols for which subscriptions should be removed.
+            bar_period:
+                Bar aggregation period associated with the subscriptions.
+        """
+        pass
+
+    def wait_until_complete(self) -> None:
+        """
+        Block until the data feed has completed all pending work.
+
+        This method may be overridden by subclasses that perform asynchronous ingestion or background processing.
+        The default implementation does nothing.
+        """
+        pass

onesecondtrader-0.54.0/src/onesecondtrader/datafeeds/simulated.py

@@ -0,0 +1,209 @@
+from __future__ import annotations
+
+import itertools
+import os
+import sqlite3
+import threading
+
+from onesecondtrader import events, messaging, models
+from onesecondtrader.datafeeds.base import DatafeedBase
+
+_RTYPE_MAP = {
+    models.BarPeriod.SECOND: 32,
+    models.BarPeriod.MINUTE: 33,
+    models.BarPeriod.HOUR: 34,
+    models.BarPeriod.DAY: 35,
+}
+
+_RTYPE_TO_BAR_PERIOD = {v: k for k, v in _RTYPE_MAP.items()}
+
+
+class SimulatedDatafeed(DatafeedBase):
+    """
+    Simulated market data feed backed by a secmaster SQLite database.
+
+    This datafeed replays historical OHLCV bars from a secmaster database, resolving symbols
+    via time-bounded symbology mappings. Bars are delivered in timestamp order, with all bars
+    sharing the same timestamp published before calling `wait_until_system_idle`.
+
+    Subclasses must set `publisher_name`, `dataset`, and `symbol_type` as class attributes to
+    scope the feed to a specific data source. The database must contain publishers with numeric
+    `source_instrument_id` values; symbol-only publishers (e.g., yfinance) are not supported.
+    """
+
+    db_path: str = ""
+    publisher_name: str = ""
+    dataset: str = ""
+    symbol_type: str = ""
+    price_scale: float = 1e9
+    start_ts: int | None = None
+    end_ts: int | None = None
+
+    def __init__(self, event_bus: messaging.EventBus) -> None:
+        """
+        Parameters:
+            event_bus:
+                Event bus used to publish bar events and synchronize with subscribers.
+        """
+        super().__init__(event_bus)
+        self._db_path = self.db_path or os.environ.get(
+            "SECMASTER_DB_PATH", "secmaster.db"
+        )
+        if not self.publisher_name:
+            raise ValueError("publisher_name is required")
+        if not self.dataset:
+            raise ValueError("dataset is required")
+        if not self.symbol_type:
+            raise ValueError("symbol_type is required")
+        self._subscriptions: set[tuple[str, models.BarPeriod]] = set()
+        self._subscriptions_lock = threading.Lock()
+        self._connection: sqlite3.Connection | None = None
+        self._thread: threading.Thread | None = None
+        self._stop_event = threading.Event()
+        self._publisher_id: int | None = None
+
+    def connect(self) -> None:
+        """
+        Open a connection to the secmaster database and resolve the publisher.
+
+        If already connected, this method returns immediately.
+        """
+        if self._connection:
+            return
+        self._connection = sqlite3.connect(self._db_path, check_same_thread=False)
+        self._connection.execute("PRAGMA foreign_keys = ON")
+        self._connection.execute("PRAGMA journal_mode = WAL")
+        row = self._connection.execute(
+            "SELECT publisher_id FROM publishers WHERE name = ? AND dataset = ?",
+            (self.publisher_name, self.dataset),
+        ).fetchone()
+        if row is None:
+            raise ValueError(
+                f"Publisher not found: {self.publisher_name}/{self.dataset}"
+            )
+        self._publisher_id = row[0]
+
+    def disconnect(self) -> None:
+        """
+        Close the database connection and stop any active streaming.
+
+        If not connected, this method returns immediately.
+        """
+        if not self._connection:
+            return
+        self._stop_event.set()
+        if self._thread and self._thread.is_alive():
+            self._thread.join()
+        self._connection.close()
+        self._connection = None
+        self._publisher_id = None
+
+    def subscribe(self, symbols: list[str], bar_period: models.BarPeriod) -> None:
+        """
+        Register symbols for bar delivery at the specified period.
+
+        Parameters:
+            symbols:
+                List of ticker symbols to subscribe.
+            bar_period:
+                Bar aggregation period for the subscription.
+        """
+        with self._subscriptions_lock:
+            self._subscriptions.update((s, bar_period) for s in symbols)
+
+    def unsubscribe(self, symbols: list[str], bar_period: models.BarPeriod) -> None:
+        """
+        Remove symbols from bar delivery at the specified period.
+
+        Parameters:
+            symbols:
+                List of ticker symbols to unsubscribe.
+            bar_period:
+                Bar aggregation period for the subscription.
+        """
+        with self._subscriptions_lock:
+            self._subscriptions.difference_update((s, bar_period) for s in symbols)
+
+    def wait_until_complete(self) -> None:
+        """
+        Stream all subscribed bars and block until delivery is complete.
+
+        Bars are published in timestamp order. After each timestamp batch, the method
+        waits for all event bus subscribers to become idle before proceeding.
+        """
+        with self._subscriptions_lock:
+            has_subscriptions = bool(self._subscriptions)
+        if not has_subscriptions:
+            return
+        if self._thread is None or not self._thread.is_alive():
+            self._stop_event.clear()
+            self._thread = threading.Thread(
+                target=self._stream,
+                name=self.__class__.__name__,
+                daemon=False,
+            )
+            self._thread.start()
+        self._thread.join()
+
+    def _stream(self) -> None:
+        if not self._connection or self._publisher_id is None:
+            return
+
+        with self._subscriptions_lock:
+            subscriptions = list(self._subscriptions)
+        if not subscriptions:
+            return
+
+        symbols = list({symbol for symbol, _ in subscriptions})
+        rtypes = list({_RTYPE_MAP[bp] for _, bp in subscriptions})
+        subscription_set = {(symbol, _RTYPE_MAP[bp]) for symbol, bp in subscriptions}
+
+        params: list = [self._publisher_id, self.symbol_type]
+        params.extend(symbols)
+        params.extend(rtypes)
+        if self.start_ts is not None:
+            params.append(self.start_ts)
+        if self.end_ts is not None:
+            params.append(self.end_ts)
+
+        query = f"""
+            SELECT s.symbol, o.rtype, o.ts_event, o.open, o.high, o.low, o.close, o.volume
+            FROM ohlcv o
+            JOIN instruments i ON i.instrument_id = o.instrument_id
+            JOIN symbology s
+              ON s.publisher_ref = i.publisher_ref
+             AND s.source_instrument_id = i.source_instrument_id
+             AND date(o.ts_event / 1000000000, 'unixepoch') >= s.start_date
+             AND date(o.ts_event / 1000000000, 'unixepoch') <= s.end_date
+            WHERE i.publisher_ref = ?
+              AND s.symbol_type = ?
+              AND s.symbol IN ({",".join("?" * len(symbols))})
+              AND o.rtype IN ({",".join("?" * len(rtypes))})
+              {"AND o.ts_event >= ?" if self.start_ts is not None else ""}
+              {"AND o.ts_event <= ?" if self.end_ts is not None else ""}
+            ORDER BY o.ts_event, s.symbol
+        """
+
+        rows = self._connection.execute(query, params)
+
+        def to_bar(row):
+            symbol, rtype, ts_event, open_, high, low, close, volume = row
+            if (symbol, rtype) not in subscription_set:
+                return None
+            return events.market.BarReceived(
+                ts_event_ns=ts_event,
+                symbol=symbol,
+                bar_period=_RTYPE_TO_BAR_PERIOD[rtype],
+                open=open_ / self.price_scale,
+                high=high / self.price_scale,
+                low=low / self.price_scale,
+                close=close / self.price_scale,
+                volume=volume,
+            )
+
+        for _, group in itertools.groupby(rows, key=lambda r: r[2]):
+            if self._stop_event.is_set():
+                return
+            for bar in filter(None, map(to_bar, group)):
+                self._publish(bar)
+            self._event_bus.wait_until_system_idle()

{onesecondtrader-0.53.0 → onesecondtrader-0.54.0}/src/onesecondtrader/secmaster/utils.py

@@ -559,6 +559,8 @@ def _ingest_symbology(
             batch,
         )
 
+    _validate_no_overlapping_symbology(con, publisher_id, symbol_type)
+
     logger.info(
         "Completed symbology ingest from %s (%d mappings)", json_path.name, count
     )
@@ -566,6 +568,37 @@ def _ingest_symbology(
     return count
 
 
+def _validate_no_overlapping_symbology(
+    con: sqlite3.Connection,
+    publisher_id: int,
+    symbol_type: str,
+) -> None:
+    query = """
+        WITH ordered AS (
+            SELECT
+                symbol,
+                start_date,
+                end_date,
+                LEAD(start_date) OVER (
+                    PARTITION BY symbol ORDER BY start_date
+                ) AS next_start
+            FROM symbology
+            WHERE publisher_ref = ? AND symbol_type = ?
+        )
+        SELECT symbol, start_date, end_date, next_start
+        FROM ordered
+        WHERE next_start IS NOT NULL AND end_date > next_start
+        LIMIT 1
+    """
+    row = con.execute(query, (publisher_id, symbol_type)).fetchone()
+    if row:
+        symbol, start, end, next_start = row
+        raise ValueError(
+            f"Overlapping symbology detected for symbol={symbol!r}: "
+            f"segment [{start}, {end}] overlaps with next segment starting {next_start}"
+        )
+
+
 def _enable_bulk_loading(con: sqlite3.Connection) -> None:
     con.execute("PRAGMA journal_mode = WAL")
     con.execute("PRAGMA synchronous = NORMAL")