onesecondtrader 0.40.0__py3-none-any.whl → 0.41.0__py3-none-any.whl

onesecondtrader/dashboard/registry.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import enum
+
+from onesecondtrader.core.strategies import StrategyBase
+from onesecondtrader.core.brokers import BrokerBase
+from onesecondtrader.core.datafeeds import DatafeedBase
+from onesecondtrader.core.models import ParamSpec
+
+
+def _get_subclasses(base: type) -> dict[str, type]:
+    result = {}
+    for cls in base.__subclasses__():
+        if not cls.__name__.startswith("_"):
+            result[cls.__name__] = cls
+        result.update(_get_subclasses(cls))
+    return result
+
+
+def get_strategies() -> dict[str, type[StrategyBase]]:
+    return _get_subclasses(StrategyBase)
+
+
+def get_brokers() -> dict[str, type[BrokerBase]]:
+    return _get_subclasses(BrokerBase)
+
+
+def get_datafeeds() -> dict[str, type[DatafeedBase]]:
+    return _get_subclasses(DatafeedBase)
+
+
+def get_param_schema(params: dict[str, ParamSpec]) -> list[dict]:
+    schema = []
+    for name, spec in params.items():
+        param_info = {
+            "name": name,
+            "default": _serialize_value(spec.default),
+            "type": _get_type_name(spec.default),
+        }
+        if spec.min is not None:
+            param_info["min"] = spec.min
+        if spec.max is not None:
+            param_info["max"] = spec.max
+        if spec.step is not None:
+            param_info["step"] = spec.step
+        choices = spec.resolved_choices
+        if choices is not None:
+            param_info["choices"] = [_serialize_value(c) for c in choices]  # type: ignore[assignment]
+        schema.append(param_info)
+    return schema
+
+
+def _serialize_value(value) -> str | int | float | bool:
+    if isinstance(value, enum.Enum):
+        return value.name
+    return value
+
+
+def _get_type_name(value) -> str:
+    if isinstance(value, enum.Enum):
+        return "enum"
+    if isinstance(value, bool):
+        return "bool"
+    if isinstance(value, int):
+        return "int"
+    if isinstance(value, float):
+        return "float"
+    if isinstance(value, str):
+        return "str"
+    return "unknown"
+
+
+def get_strategy_schema(name: str) -> dict | None:
+    cls = get_strategies().get(name)
+    if cls is None:
+        return None
+    return {
+        "name": name,
+        "parameters": get_param_schema(getattr(cls, "parameters", {})),
+    }
+
+
+def get_broker_schema(name: str) -> dict | None:
+    cls = get_brokers().get(name)
+    if cls is None:
+        return None
+    return {
+        "name": name,
+        "parameters": get_param_schema(getattr(cls, "parameters", {})),
+    }
+
+
+def get_datafeed_schema(name: str) -> dict | None:
+    cls = get_datafeeds().get(name)
+    if cls is None:
+        return None
+    return {
+        "name": name,
+        "parameters": get_param_schema(getattr(cls, "parameters", {})),
+    }

onesecondtrader/orchestrator/__init__.py

@@ -0,0 +1,7 @@
+__all__ = [
+    "Orchestrator",
+    "RunRecorder",
+]
+
+from .orchestrator import Orchestrator
+from .recorder import RunRecorder

onesecondtrader/orchestrator/orchestrator.py

@@ -0,0 +1,105 @@
+import dotenv
+import pandas as pd
+
+from onesecondtrader.core.brokers import BrokerBase
+from onesecondtrader.core.datafeeds import DatafeedBase
+from onesecondtrader.core.messaging import EventBus
+from onesecondtrader.core.strategies import StrategyBase
+from .recorder import RunRecorder
+
+
+class Orchestrator:
+    db_path: str = "runs.db"
+    mode: str = "backtest"
+
+    def __init__(
+        self,
+        strategies: list[type[StrategyBase]],
+        broker: type[BrokerBase],
+        datafeed: type[DatafeedBase],
+    ) -> None:
+        dotenv.load_dotenv()
+        self._strategy_classes = strategies
+        self._broker_class = broker
+        self._datafeed_class = datafeed
+        self._event_bus: EventBus | None = None
+        self._strategies: list[StrategyBase] = []
+        self._broker: BrokerBase | None = None
+        self._datafeed: DatafeedBase | None = None
+        self._recorder: RunRecorder | None = None
+
+    def run(self) -> None:
+        run_id = self._generate_run_id()
+        symbols = self._collect_symbols()
+        bar_period = self._get_bar_period()
+
+        self._event_bus = EventBus()
+
+        self._recorder = self._create_recorder(run_id, symbols, bar_period)
+        self._broker = self._broker_class(self._event_bus)
+        self._strategies = [s(self._event_bus) for s in self._strategy_classes]
+        self._datafeed = self._datafeed_class(self._event_bus)
+
+        try:
+            self._broker.connect()
+            self._datafeed.connect()
+            self._subscribe_symbols()
+            self._datafeed.wait_until_complete()
+            self._event_bus.wait_until_system_idle()
+        finally:
+            self._shutdown()
+
+    def _generate_run_id(self) -> str:
+        timestamp = pd.Timestamp.now(tz="UTC").strftime("%Y-%m-%d_%H-%M-%S")
+        strategy_names = "_".join(s.__name__ for s in self._strategy_classes)
+        return f"{timestamp}_{strategy_names}"
+
+    def _collect_symbols(self) -> list[str]:
+        symbols = []
+        for strategy_class in self._strategy_classes:
+            symbols.extend(strategy_class.symbols)
+        return list(set(symbols))
+
+    def _get_bar_period(self) -> str | None:
+        if not self._strategy_classes:
+            return None
+        params = self._strategy_classes[0].parameters
+        if "bar_period" not in params:
+            return None
+        default = params["bar_period"].default
+        if hasattr(default, "name"):
+            return default.name  # type: ignore[no-any-return]
+        return None
+
+    def _create_recorder(
+        self, run_id: str, symbols: list[str], bar_period: str | None
+    ) -> RunRecorder:
+        class ConfiguredRecorder(RunRecorder):
+            db_path = self.db_path
+
+        assert self._event_bus is not None
+        return ConfiguredRecorder(
+            event_bus=self._event_bus,
+            run_id=run_id,
+            strategy="_".join(s.name for s in self._strategy_classes),
+            mode=self.mode,
+            symbols=symbols,
+            bar_period=bar_period,
+        )
+
+    def _subscribe_symbols(self) -> None:
+        assert self._datafeed is not None
+        for strategy_class in self._strategy_classes:
+            bar_period = strategy_class.parameters["bar_period"].default
+            for symbol in strategy_class.symbols:
+                self._datafeed.subscribe(symbol, bar_period)  # type: ignore[arg-type]
+
+    def _shutdown(self) -> None:
+        if self._datafeed:
+            self._datafeed.disconnect()
+        if self._broker:
+            self._broker.disconnect()
+        for strategy in self._strategies:
+            strategy.shutdown()
+        if self._recorder:
+            self._recorder.shutdown()

onesecondtrader/orchestrator/recorder.py

@@ -0,0 +1,196 @@
+import json
+import pathlib
+import sqlite3
+
+import pandas as pd
+
+from onesecondtrader.core import events
+from onesecondtrader.core.messaging import EventBus, Subscriber
+
+
+class RunRecorder(Subscriber):
+    db_path: str = "runs.db"
+
+    def __init__(
+        self,
+        event_bus: EventBus,
+        run_id: str,
+        strategy: str,
+        mode: str,
+        symbols: list[str] | None = None,
+        bar_period: str | None = None,
+    ) -> None:
+        self._run_id = run_id
+        self._strategy = strategy
+        self._mode = mode
+        self._symbols = symbols or []
+        self._bar_period = bar_period
+        self._conn = self._init_db()
+        self._insert_run()
+        super().__init__(event_bus)
+        self._subscribe(
+            events.BarProcessed,
+            events.OrderSubmission,
+            events.OrderModification,
+            events.OrderCancellation,
+            events.OrderSubmissionAccepted,
+            events.OrderSubmissionRejected,
+            events.OrderModificationAccepted,
+            events.OrderModificationRejected,
+            events.OrderCancellationAccepted,
+            events.OrderCancellationRejected,
+            events.OrderFilled,
+            events.OrderExpired,
+        )
+
+    def _init_db(self) -> sqlite3.Connection:
+        schema_path = pathlib.Path(__file__).parent / "schema.sql"
+        conn = sqlite3.connect(self.db_path, check_same_thread=False)
+        conn.execute("PRAGMA journal_mode=WAL")
+        conn.execute("PRAGMA foreign_keys=ON")
+        conn.executescript(schema_path.read_text())
+        return conn
+
+    def _insert_run(self) -> None:
+        self._conn.execute(
+            """
+            INSERT INTO runs (run_id, strategy, symbols, bar_period, mode, status, created_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                self._run_id,
+                self._strategy,
+                json.dumps(self._symbols) if self._symbols else None,
+                self._bar_period,
+                self._mode,
+                "running",
+                pd.Timestamp.now(tz="UTC").isoformat(),
+            ),
+        )
+        self._conn.commit()
+
+    def _on_event(self, event: events.EventBase) -> None:
+        match event:
+            case events.BarProcessed():
+                self._record_bar(event)
+            case events.OrderSubmission():
+                self._record_order_request(event, "submission")
+            case events.OrderModification():
+                self._record_order_request(event, "modification")
+            case events.OrderCancellation():
+                self._record_order_request(event, "cancellation")
+            case events.OrderFilled():
+                self._record_fill(event)
+            case events.OrderSubmissionAccepted():
+                self._record_order_response(event, "submission_accepted")
+            case events.OrderSubmissionRejected():
+                self._record_order_response(event, "submission_rejected")
+            case events.OrderModificationAccepted():
+                self._record_order_response(event, "modification_accepted")
+            case events.OrderModificationRejected():
+                self._record_order_response(event, "modification_rejected")
+            case events.OrderCancellationAccepted():
+                self._record_order_response(event, "cancellation_accepted")
+            case events.OrderCancellationRejected():
+                self._record_order_response(event, "cancellation_rejected")
+            case events.OrderExpired():
+                self._record_order_response(event, "expired")
+
+    def _record_bar(self, event: events.BarProcessed) -> None:
+        self._conn.execute(
+            """
+            INSERT INTO bars (run_id, ts_event, symbol, bar_period, open, high, low, close, volume, indicators)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                self._run_id,
+                event.ts_event.isoformat(),
+                event.symbol,
+                event.bar_period.value,
+                event.open,
+                event.high,
+                event.low,
+                event.close,
+                event.volume,
+                json.dumps(event.indicators) if event.indicators else None,
+            ),
+        )
+        self._conn.commit()
+
+    def _record_order_request(
+        self, event: events.BrokerRequestEvent, request_type: str
+    ) -> None:
+        order_type = getattr(event, "order_type", None)
+        side = getattr(event, "side", None)
+        self._conn.execute(
+            """
+            INSERT INTO order_requests (run_id, ts_event, request_type, order_id, symbol, order_type, side, quantity, limit_price, stop_price)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                self._run_id,
+                event.ts_event.isoformat(),
+                request_type,
+                str(event.system_order_id),
+                getattr(event, "symbol", None),
+                order_type.value if order_type else None,
+                side.value if side else None,
+                getattr(event, "quantity", None),
+                getattr(event, "limit_price", None),
+                getattr(event, "stop_price", None),
+            ),
+        )
+        self._conn.commit()
+
+    def _record_order_response(
+        self, event: events.BrokerResponseEvent, response_type: str
+    ) -> None:
+        self._conn.execute(
+            """
+            INSERT INTO order_responses (run_id, ts_event, ts_broker, response_type, order_id, broker_order_id, reason)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                self._run_id,
+                event.ts_event.isoformat(),
+                event.ts_broker.isoformat(),
+                response_type,
+                str(event.associated_order_id),
+                getattr(event, "broker_order_id", None),
+                getattr(event, "reason", None),
+            ),
+        )
+        self._conn.commit()
+
+    def _record_fill(self, event: events.OrderFilled) -> None:
+        self._conn.execute(
+            """
+            INSERT INTO fills (run_id, ts_event, ts_broker, fill_id, order_id, broker_fill_id, symbol, side, quantity, price, commission, exchange)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                self._run_id,
+                event.ts_event.isoformat(),
+                event.ts_broker.isoformat(),
+                str(event.fill_id),
+                str(event.associated_order_id),
+                event.broker_fill_id,
+                event.symbol,
+                event.side.value,
+                event.quantity_filled,
+                event.fill_price,
+                event.commission,
+                event.exchange,
+            ),
+        )
+        self._conn.commit()
+
+    def _cleanup(self) -> None:
+        self._conn.execute(
+            """
+            UPDATE runs SET status = ?, completed_at = ? WHERE run_id = ?
+            """,
+            ("completed", pd.Timestamp.now(tz="UTC").isoformat(), self._run_id),
+        )
+        self._conn.commit()
+        self._conn.close()

onesecondtrader/orchestrator/schema.sql

@@ -0,0 +1,208 @@
+-- Run Recorder Database Schema (runs.db)
+--
+-- A single database file storing all strategy runs. This schema captures the
+-- complete lifecycle of each run including metadata, processed bars with
+-- indicator values, order requests, broker responses, and fill executions.
+--
+-- The database uses WAL (Write-Ahead Logging) mode for concurrent read/write
+-- access, allowing the dashboard to read while a strategy is actively writing.
+--
+-- All tables reference `run_id` to associate records with their parent run.
+-- This enables efficient querying within a run and across multiple runs.
+--
+-- Tables:
+--
+-- | Table | Description |
+-- |-------|-------------|
+-- | `runs` | Run metadata including strategy name, symbols, status, and timestamps. |
+-- | `bars` | Processed OHLCV bars with computed indicator values. |
+-- | `order_requests` | Order requests from strategy to broker: submissions, modifications, cancellations. |
+-- | `order_responses` | Broker responses: acceptances, rejections, expirations. |
+-- | `fills` | Executed fills with price, quantity, commission, and exchange information. |
+
+
+-- Run metadata capturing the configuration and status of strategy executions.
+--
+-- Each row represents a single strategy run. The table stores the initial
+-- configuration used to start the run as well as runtime status that is updated
+-- when the run completes or is interrupted.
+--
+-- | Field | Type | Constraints | Description |
+-- |-------|------|-------------|-------------|
+-- | `run_id` | TEXT | PRIMARY KEY | Unique identifier for this run, typically formatted as `YYYY-MM-DD_HH-MM-SS_StrategyName` |
+-- | `strategy` | TEXT | NOT NULL | Name of the strategy class that was executed |
+-- | `symbols` | TEXT | | JSON array of symbols traded during this run (e.g., `["AAPL", "MSFT"]`) |
+-- | `bar_period` | TEXT | | Bar period used by the strategy (e.g., `SECOND`, `MINUTE`, `HOUR`, `DAY`) |
+-- | `mode` | TEXT | NOT NULL | Execution mode: `backtest` for historical simulation or `live` for real-time trading |
+-- | `status` | TEXT | NOT NULL | Current run status: `running`, `completed`, or `interrupted` |
+-- | `created_at` | TEXT | NOT NULL | ISO 8601 timestamp when the run was started |
+-- | `completed_at` | TEXT | | ISO 8601 timestamp when the run finished (NULL if still running or interrupted) |
+
+CREATE TABLE IF NOT EXISTS runs (
+    run_id TEXT PRIMARY KEY,
+    strategy TEXT NOT NULL,
+    symbols TEXT,
+    bar_period TEXT,
+    mode TEXT NOT NULL,
+    status TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    completed_at TEXT
+);
+
+
+-- Processed OHLCV bars with indicator values computed by the strategy.
+--
+-- Each row represents a single bar that was processed by the strategy. The bar
+-- data comes from `BarProcessed` events which include both the raw OHLCV values
+-- and any indicator values computed by the strategy's indicators.
+--
+-- Indicator values are stored as a JSON object where keys are indicator names
+-- prefixed with their plot position (e.g., `{"00_SMA_20": 150.5, "01_RSI": 65.2}`).
+--
+-- | Field | Type | Constraints | Description |
+-- |-------|------|-------------|-------------|
+-- | `id` | INTEGER | PRIMARY KEY | Auto-incrementing unique identifier for this bar record |
+-- | `run_id` | TEXT | NOT NULL, FK | Reference to the parent run in the `runs` table |
+-- | `ts_event` | TEXT | NOT NULL | ISO 8601 timestamp of the bar's closing time |
+-- | `symbol` | TEXT | NOT NULL | Trading symbol (e.g., `AAPL`, `ESH5`) |
+-- | `bar_period` | TEXT | NOT NULL | Bar aggregation period: `SECOND`, `MINUTE`, `HOUR`, or `DAY` |
+-- | `open` | REAL | NOT NULL | Opening price of the bar |
+-- | `high` | REAL | NOT NULL | Highest price during the bar |
+-- | `low` | REAL | NOT NULL | Lowest price during the bar |
+-- | `close` | REAL | NOT NULL | Closing price of the bar |
+-- | `volume` | INTEGER | | Trading volume during the bar (NULL if not available) |
+-- | `indicators` | TEXT | | JSON object of indicator name-value pairs computed for this bar |
+
+CREATE TABLE IF NOT EXISTS bars (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
+    ts_event TEXT NOT NULL,
+    symbol TEXT NOT NULL,
+    bar_period TEXT NOT NULL,
+    open REAL NOT NULL,
+    high REAL NOT NULL,
+    low REAL NOT NULL,
+    close REAL NOT NULL,
+    volume INTEGER,
+    indicators TEXT
+);
+
+
+-- Order requests sent from the strategy to the broker.
+--
+-- Each row represents a request event initiated by the strategy. This includes
+-- new order submissions, modifications to existing orders, and cancellation
+-- requests. These are the "outbound" events from the strategy's perspective.
+--
+-- | Field | Type | Constraints | Description |
+-- |-------|------|-------------|-------------|
+-- | `id` | INTEGER | PRIMARY KEY | Auto-incrementing unique identifier for this request record |
+-- | `run_id` | TEXT | NOT NULL, FK | Reference to the parent run in the `runs` table |
+-- | `ts_event` | TEXT | NOT NULL | ISO 8601 timestamp when the request was sent |
+-- | `request_type` | TEXT | NOT NULL | Request type: `submission`, `modification`, or `cancellation` |
+-- | `order_id` | TEXT | NOT NULL | System-assigned UUID for this order |
+-- | `symbol` | TEXT | NOT NULL | Trading symbol |
+-- | `order_type` | TEXT | | Order type: `MARKET`, `LIMIT`, `STOP`, `STOP_LIMIT` (submission only) |
+-- | `side` | TEXT | | Order side: `BUY` or `SELL` (submission only) |
+-- | `quantity` | REAL | | Order quantity (submission and modification) |
+-- | `limit_price` | REAL | | Limit price for LIMIT and STOP_LIMIT orders |
+-- | `stop_price` | REAL | | Stop trigger price for STOP and STOP_LIMIT orders |
+
+CREATE TABLE IF NOT EXISTS order_requests (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
+    ts_event TEXT NOT NULL,
+    request_type TEXT NOT NULL,
+    order_id TEXT NOT NULL,
+    symbol TEXT NOT NULL,
+    order_type TEXT,
+    side TEXT,
+    quantity REAL,
+    limit_price REAL,
+    stop_price REAL
+);
+
+
+-- Broker responses to order requests.
+--
+-- Each row represents a response event from the broker. This includes acceptances,
+-- rejections, and expirations. These are the "inbound" events from the broker's
+-- perspective. Fills are stored separately in the `fills` table.
+--
+-- | Field | Type | Constraints | Description |
+-- |-------|------|-------------|-------------|
+-- | `id` | INTEGER | PRIMARY KEY | Auto-incrementing unique identifier for this response record |
+-- | `run_id` | TEXT | NOT NULL, FK | Reference to the parent run in the `runs` table |
+-- | `ts_event` | TEXT | NOT NULL | ISO 8601 timestamp when the response was received |
+-- | `ts_broker` | TEXT | NOT NULL | ISO 8601 timestamp when the broker processed the request |
+-- | `response_type` | TEXT | NOT NULL | Response type: `submission_accepted`, `submission_rejected`, `modification_accepted`, `modification_rejected`, `cancellation_accepted`, `cancellation_rejected`, `expired` |
+-- | `order_id` | TEXT | NOT NULL | System-assigned UUID of the associated order |
+-- | `broker_order_id` | TEXT | | Broker-assigned order identifier (on acceptance) |
+-- | `reason` | TEXT | | Rejection reason (on rejection) |
+
+CREATE TABLE IF NOT EXISTS order_responses (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
+    ts_event TEXT NOT NULL,
+    ts_broker TEXT NOT NULL,
+    response_type TEXT NOT NULL,
+    order_id TEXT NOT NULL,
+    broker_order_id TEXT,
+    reason TEXT
+);
+
+
+-- Fill executions recording completed trades.
+--
+-- Each row represents a single fill event where an order was partially or fully
+-- executed. An order may have multiple fills if it is executed in parts. Fills
+-- are separated from other broker responses due to their distinct structure and
+-- importance for P&L calculations.
+--
+-- | Field | Type | Constraints | Description |
+-- |-------|------|-------------|-------------|
+-- | `id` | INTEGER | PRIMARY KEY | Auto-incrementing unique identifier for this fill record |
+-- | `run_id` | TEXT | NOT NULL, FK | Reference to the parent run in the `runs` table |
+-- | `ts_event` | TEXT | NOT NULL | ISO 8601 timestamp when the fill event was received |
+-- | `ts_broker` | TEXT | NOT NULL | ISO 8601 timestamp when the broker executed the fill |
+-- | `fill_id` | TEXT | NOT NULL | System-assigned UUID for this specific fill |
+-- | `order_id` | TEXT | NOT NULL | System-assigned UUID of the order that was filled |
+-- | `broker_fill_id` | TEXT | | Broker-assigned fill identifier |
+-- | `symbol` | TEXT | NOT NULL | Trading symbol that was filled |
+-- | `side` | TEXT | NOT NULL | Fill side: `BUY` or `SELL` |
+-- | `quantity` | REAL | NOT NULL | Number of units filled |
+-- | `price` | REAL | NOT NULL | Execution price |
+-- | `commission` | REAL | | Commission charged for this fill |
+-- | `exchange` | TEXT | | Exchange or venue where the fill occurred |
+
+CREATE TABLE IF NOT EXISTS fills (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    run_id TEXT NOT NULL REFERENCES runs(run_id) ON DELETE CASCADE,
+    ts_event TEXT NOT NULL,
+    ts_broker TEXT NOT NULL,
+    fill_id TEXT NOT NULL,
+    order_id TEXT NOT NULL,
+    broker_fill_id TEXT,
+    symbol TEXT NOT NULL,
+    side TEXT NOT NULL,
+    quantity REAL NOT NULL,
+    price REAL NOT NULL,
+    commission REAL,
+    exchange TEXT
+);
+
+
+-- Indexes for efficient querying by run, timestamp, and order relationships.
+
+CREATE INDEX IF NOT EXISTS idx_bars_run_id ON bars(run_id);
+CREATE INDEX IF NOT EXISTS idx_bars_run_ts ON bars(run_id, ts_event);
+CREATE INDEX IF NOT EXISTS idx_bars_run_symbol ON bars(run_id, symbol);
+CREATE INDEX IF NOT EXISTS idx_order_requests_run_id ON order_requests(run_id);
+CREATE INDEX IF NOT EXISTS idx_order_requests_run_ts ON order_requests(run_id, ts_event);
+CREATE INDEX IF NOT EXISTS idx_order_requests_order_id ON order_requests(order_id);
+CREATE INDEX IF NOT EXISTS idx_order_responses_run_id ON order_responses(run_id);
+CREATE INDEX IF NOT EXISTS idx_order_responses_run_ts ON order_responses(run_id, ts_event);
+CREATE INDEX IF NOT EXISTS idx_order_responses_order_id ON order_responses(order_id);
+CREATE INDEX IF NOT EXISTS idx_fills_run_id ON fills(run_id);
+CREATE INDEX IF NOT EXISTS idx_fills_run_ts ON fills(run_id, ts_event);
+CREATE INDEX IF NOT EXISTS idx_fills_order_id ON fills(order_id);

onesecondtrader/secmaster/schema.sql

@@ -690,3 +690,51 @@ CREATE TABLE symbology (
     end_date TEXT NOT NULL,
     PRIMARY KEY (symbol, instrument_id, start_date)
 );
+
+-- Precomputed database metadata for fast dashboard queries.
+--
+-- This table stores aggregate statistics about the database contents that would
+-- otherwise require expensive COUNT(*) queries on large tables. Stats are updated
+-- after each data ingestion operation.
+--
+-- | Field | Type | Constraints | Description |
+-- |-------|------|-------------|-------------|
+-- | `key` | TEXT | PRIMARY KEY | The name of the statistic (e.g., 'symbol_count', 'ohlcv_record_count') |
+-- | `value` | TEXT | NOT NULL | The value of the statistic, stored as text for flexibility |
+CREATE TABLE meta (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+);
+
+-- Precomputed per-symbol coverage statistics for fast search queries.
+--
+-- This table stores aggregate statistics for each symbol/rtype combination,
+-- eliminating the need for expensive JOIN and GROUP BY queries on the large
+-- ohlcv table during symbol search. Stats are updated after each data ingestion.
+--
+-- | Field | Type | Constraints | Description |
+-- |-------|------|-------------|-------------|
+-- | `symbol` | TEXT | NOT NULL, PK | The ticker symbol |
+-- | `rtype` | INTEGER | NOT NULL, PK | The bar duration type (32=1s, 33=1m, 34=1h, 35=1d) |
+-- | `min_ts` | INTEGER | NOT NULL | The earliest timestamp for this symbol/rtype |
+-- | `max_ts` | INTEGER | NOT NULL | The latest timestamp for this symbol/rtype |
+-- | `record_count` | INTEGER | NOT NULL | Total number of records for this symbol/rtype |
+CREATE TABLE symbol_coverage (
+    symbol TEXT NOT NULL,
+    rtype INTEGER NOT NULL,
+    min_ts INTEGER NOT NULL,
+    max_ts INTEGER NOT NULL,
+    record_count INTEGER NOT NULL,
+    PRIMARY KEY (symbol, rtype)
+);
+
+-- User-defined symbol presets for quick selection in the dashboard.
+--
+-- | Field | Type | Constraints | Description |
+-- |-------|------|-------------|-------------|
+-- | `name` | TEXT | PRIMARY KEY | Unique name for the preset (e.g., 'Tech Stocks', 'My Watchlist') |
+-- | `symbols` | TEXT | NOT NULL | JSON array of symbol strings (e.g., '["AAPL", "GOOGL", "MSFT"]') |
+CREATE TABLE symbol_presets (
+    name TEXT PRIMARY KEY,
+    symbols TEXT NOT NULL
+);