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

onesecondtrader/__init__.py

@@ -1,4 +1,5 @@
 __all__ = [
+    "ActionType",
     "BarPeriod",
     "BarProcessed",
     "BarReceived",
@@ -18,6 +19,7 @@ __all__ = [
     "OrderSide",
     "OrderSubmission",
     "OrderType",
+    "ParamSpec",
     "SimulatedBroker",
     "SimulatedDatafeed",
     "SimpleMovingAverage",
@@ -46,11 +48,13 @@ from onesecondtrader.core.indicators import (
     Volume,
 )
 from onesecondtrader.core.models import (
+    ActionType,
     BarPeriod,
     FillRecord,
     InputSource,
     OrderRecord,
     OrderSide,
     OrderType,
+    ParamSpec,
 )
 from onesecondtrader.core.strategies import SMACrossover, StrategyBase

onesecondtrader/connectors/datafeeds/simulated.py

@@ -21,6 +21,8 @@ _PRICE_SCALE = 1e9
 
 class SimulatedDatafeed(DatafeedBase):
     db_path: str = ""
+    start_ts: int | None = None
+    end_ts: int | None = None
 
     def __init__(self, event_bus: messaging.EventBus) -> None:
         super().__init__(event_bus)
@@ -51,9 +53,14 @@ class SimulatedDatafeed(DatafeedBase):
         self._connected = False
 
     def subscribe(self, symbol: str, bar_period: models.BarPeriod) -> None:
-        if (symbol, bar_period) in self._subscriptions:
-            return
         self._subscriptions.add((symbol, bar_period))
+
+    def unsubscribe(self, symbol: str, bar_period: models.BarPeriod) -> None:
+        self._subscriptions.discard((symbol, bar_period))
+
+    def wait_until_complete(self) -> None:
+        if not self._subscriptions:
+            return
         if self._thread is None or not self._thread.is_alive():
             self._stop_event.clear()
             self._thread = threading.Thread(
@@ -62,9 +69,7 @@ class SimulatedDatafeed(DatafeedBase):
                 daemon=False,
             )
             self._thread.start()
-
-    def unsubscribe(self, symbol: str, bar_period: models.BarPeriod) -> None:
-        self._subscriptions.discard((symbol, bar_period))
+        self._thread.join()
 
     def _stream(self) -> None:
         if not self._connection:
@@ -83,26 +88,40 @@ class SimulatedDatafeed(DatafeedBase):
 
         cursor = self._connection.cursor()
 
-        instrument_ids = self._resolve_instrument_ids(cursor, symbols)
-        if not instrument_ids:
+        symbology_map = self._load_symbology(cursor, symbols)
+        if not symbology_map:
             return
 
-        instrument_to_symbol = {v: k for k, v in instrument_ids.items()}
-        id_list = list(instrument_ids.values())
+        all_instrument_ids = set()
+        for entries in symbology_map.values():
+            for entry in entries:
+                all_instrument_ids.add(entry["instrument_id"])
+
+        id_list = list(all_instrument_ids)
         rtype_list = list(set(rtype_by_symbol.values()))
 
         placeholders_ids = ",".join("?" * len(id_list))
         placeholders_rtypes = ",".join("?" * len(rtype_list))
 
+        date_filter = ""
+        params = id_list + rtype_list
+        if self.start_ts is not None:
+            date_filter += " AND ts_event >= ?"
+            params.append(self.start_ts)
+        if self.end_ts is not None:
+            date_filter += " AND ts_event <= ?"
+            params.append(self.end_ts)
+
         query = f"""
             SELECT instrument_id, rtype, ts_event, open, high, low, close, volume
             FROM ohlcv
             WHERE instrument_id IN ({placeholders_ids})
               AND rtype IN ({placeholders_rtypes})
+              {date_filter}
             ORDER BY ts_event
         """
 
-        cursor.execute(query, id_list + rtype_list)
+        cursor.execute(query, params)
 
         while True:
             if self._stop_event.is_set():
@@ -113,7 +132,10 @@ class SimulatedDatafeed(DatafeedBase):
                 break
 
             instrument_id, rtype, ts_event, open_, high, low, close, volume = row
-            symbol = instrument_to_symbol.get(instrument_id)
+
+            symbol = self._resolve_symbol_for_bar(
+                symbology_map, instrument_id, ts_event
+            )
             if symbol is None:
                 continue
 
@@ -137,16 +159,40 @@ class SimulatedDatafeed(DatafeedBase):
             )
             self._event_bus.wait_until_system_idle()
 
-    def _resolve_instrument_ids(
+    def _load_symbology(
         self, cursor: sqlite3.Cursor, symbols: list[str]
-    ) -> dict[str, int]:
+    ) -> dict[str, list[dict]]:
         placeholders = ",".join("?" * len(symbols))
         query = f"""
-            SELECT symbol, instrument_id
+            SELECT symbol, instrument_id, start_date, end_date
             FROM symbology
             WHERE symbol IN ({placeholders})
-            GROUP BY symbol
-            HAVING start_date = MAX(start_date)
+            ORDER BY symbol, start_date
         """
         cursor.execute(query, symbols)
-        return {row[0]: row[1] for row in cursor.fetchall()}
+
+        result: dict[str, list[dict]] = {}
+        for row in cursor.fetchall():
+            symbol, instrument_id, start_date, end_date = row
+            start_ns = int(pd.Timestamp(start_date, tz="UTC").value)
+            end_ns = int(pd.Timestamp(end_date, tz="UTC").value)
+            if symbol not in result:
+                result[symbol] = []
+            result[symbol].append(
+                {
+                    "instrument_id": instrument_id,
+                    "start_ns": start_ns,
+                    "end_ns": end_ns,
+                }
+            )
+        return result
+
+    def _resolve_symbol_for_bar(
+        self, symbology_map: dict[str, list[dict]], instrument_id: int, ts_event: int
+    ) -> str | None:
+        for symbol, entries in symbology_map.items():
+            for entry in entries:
+                if entry["instrument_id"] == instrument_id:
+                    if entry["start_ns"] <= ts_event < entry["end_ns"]:
+                        return symbol
+        return None

onesecondtrader/core/datafeeds/base.py

@@ -27,3 +27,6 @@ class DatafeedBase(abc.ABC):
     @abc.abstractmethod
     def unsubscribe(self, symbol: str, bar_period: models.BarPeriod) -> None:
         pass
+
+    def wait_until_complete(self) -> None:
+        pass

onesecondtrader/core/events/requests.py

@@ -16,6 +16,8 @@ class OrderSubmission(bases.BrokerRequestEvent):
     quantity: float
     limit_price: float | None = None
     stop_price: float | None = None
+    action: models.orders.ActionType | None = None
+    signal: str | None = None
 
 
 @dataclasses.dataclass(kw_only=True, frozen=True)

onesecondtrader/core/models/__init__.py

@@ -1,12 +1,15 @@
 __all__ = [
+    "ActionType",
     "BarPeriod",
     "InputSource",
     "OrderSide",
     "OrderType",
     "OrderRecord",
     "FillRecord",
+    "ParamSpec",
 ]
 
 from .data import BarPeriod, InputSource
-from .orders import OrderSide, OrderType
+from .orders import ActionType, OrderSide, OrderType
 from .records import OrderRecord, FillRecord
+from .params import ParamSpec

onesecondtrader/core/models/orders.py

@@ -13,3 +13,15 @@ class OrderType(enum.Enum):
 class OrderSide(enum.Enum):
     BUY = enum.auto()
     SELL = enum.auto()
+
+
+class ActionType(enum.Enum):
+    ENTRY = enum.auto()
+    ENTRY_LONG = enum.auto()
+    ENTRY_SHORT = enum.auto()
+    EXIT = enum.auto()
+    EXIT_LONG = enum.auto()
+    EXIT_SHORT = enum.auto()
+    ADD = enum.auto()
+    REDUCE = enum.auto()
+    REVERSE = enum.auto()

onesecondtrader/core/models/params.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+import dataclasses
+import enum
+
+
+@dataclasses.dataclass
+class ParamSpec:
+    default: int | float | str | bool | enum.Enum
+    min: int | float | None = None
+    max: int | float | None = None
+    step: int | float | None = None
+    choices: list | None = None
+
+    @property
+    def resolved_choices(self) -> list | None:
+        if self.choices is not None:
+            return self.choices
+        if isinstance(self.default, enum.Enum):
+            return list(type(self.default))
+        return None

onesecondtrader/core/models/records.py

@@ -17,6 +17,8 @@ class OrderRecord:
     quantity: float
     limit_price: float | None = None
     stop_price: float | None = None
+    action: orders.ActionType | None = None
+    signal: str | None = None
     filled_quantity: float = 0.0
 
 

onesecondtrader/core/strategies/base.py

@@ -10,11 +10,17 @@ from onesecondtrader.core import events, indicators, messaging, models
 
 
 class StrategyBase(messaging.Subscriber, abc.ABC):
+    name: str = ""
     symbols: list[str] = []
-    bar_period: models.BarPeriod = models.BarPeriod.SECOND
+    parameters: dict[str, models.ParamSpec] = {}
 
-    def __init__(self, event_bus: messaging.EventBus) -> None:
+    def __init__(self, event_bus: messaging.EventBus, **overrides) -> None:
         super().__init__(event_bus)
+
+        for name, spec in self.parameters.items():
+            value = overrides.get(name, spec.default)
+            setattr(self, name, value)
+
         self._subscribe(
             events.BarReceived,
             events.OrderSubmissionAccepted,
@@ -70,8 +76,9 @@ class StrategyBase(messaging.Subscriber, abc.ABC):
         quantity: float,
         limit_price: float | None = None,
         stop_price: float | None = None,
+        action: models.ActionType | None = None,
+        signal: str | None = None,
     ) -> uuid.UUID:
-        # Uses bar timestamp for backtest compatibility; ts_created tracks real wall-clock time
         order_id = uuid.uuid4()
 
         event = events.OrderSubmission(
@@ -83,6 +90,8 @@ class StrategyBase(messaging.Subscriber, abc.ABC):
             quantity=quantity,
             limit_price=limit_price,
             stop_price=stop_price,
+            action=action,
+            signal=signal,
         )
 
         order = models.OrderRecord(
@@ -93,6 +102,8 @@ class StrategyBase(messaging.Subscriber, abc.ABC):
             quantity=quantity,
             limit_price=limit_price,
             stop_price=stop_price,
+            action=action,
+            signal=signal,
         )
 
         self._submitted_orders[order_id] = order
@@ -131,6 +142,8 @@ class StrategyBase(messaging.Subscriber, abc.ABC):
             stop_price=(
                 stop_price if stop_price is not None else original_order.stop_price
             ),
+            action=original_order.action,
+            signal=original_order.signal,
             filled_quantity=original_order.filled_quantity,
         )
 
@@ -179,7 +192,7 @@ class StrategyBase(messaging.Subscriber, abc.ABC):
     def _on_bar_received(self, event: events.BarReceived) -> None:
         if event.symbol not in self.symbols:
             return
-        if event.bar_period != self.bar_period:
+        if event.bar_period != self.bar_period:  # type: ignore[attr-defined]
             return
 
         self._current_symbol = event.symbol

onesecondtrader/core/strategies/examples.py

@@ -3,16 +3,20 @@ from .base import StrategyBase
 
 
 class SMACrossover(StrategyBase):
-    fast_period: int = 20
-    slow_period: int = 100
-    quantity: float = 1.0
+    name = "SMA Crossover"
+    parameters = {
+        "bar_period": models.ParamSpec(default=models.BarPeriod.SECOND),
+        "fast_period": models.ParamSpec(default=20, min=5, max=100, step=1),
+        "slow_period": models.ParamSpec(default=100, min=10, max=500, step=1),
+        "quantity": models.ParamSpec(default=1.0, min=0.1, max=100.0, step=0.1),
+    }
 
     def setup(self) -> None:
         self.fast_sma = self.add_indicator(
-            indicators.SimpleMovingAverage(period=self.fast_period)
+            indicators.SimpleMovingAverage(period=self.fast_period)  # type: ignore[attr-defined]
         )
         self.slow_sma = self.add_indicator(
-            indicators.SimpleMovingAverage(period=self.slow_period)
+            indicators.SimpleMovingAverage(period=self.slow_period)  # type: ignore[attr-defined]
         )
 
     def on_bar(self, event: events.BarReceived) -> None:
@@ -22,7 +26,11 @@ class SMACrossover(StrategyBase):
             and self.position <= 0
         ):
             self.submit_order(
-                models.OrderType.MARKET, models.OrderSide.BUY, self.quantity
+                models.OrderType.MARKET,
+                models.OrderSide.BUY,
+                self.quantity,  # type: ignore[attr-defined]
+                action=models.ActionType.ENTRY,
+                signal="sma_crossover_up",
             )
 
         if (
@@ -31,5 +39,9 @@ class SMACrossover(StrategyBase):
             and self.position >= 0
         ):
             self.submit_order(
-                models.OrderType.MARKET, models.OrderSide.SELL, self.quantity
+                models.OrderType.MARKET,
+                models.OrderSide.SELL,
+                self.quantity,  # type: ignore[attr-defined]
+                action=models.ActionType.EXIT,
+                signal="sma_crossover_down",
             )

onesecondtrader/dashboard/__init__.py

@@ -0,0 +1,3 @@
+__all__ = ["app"]
+
+from .app import app