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

onesecondtrader/core/events/market.py

@@ -1,22 +0,0 @@
-from __future__ import annotations
-
-import dataclasses
-
-from onesecondtrader.core import models
-from . import bases
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class BarReceived(bases.MarketEvent):
-    symbol: str
-    bar_period: models.data.BarPeriod
-    open: float
-    high: float
-    low: float
-    close: float
-    volume: int | None = None
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class BarProcessed(BarReceived):
-    indicators: dict[str, float] = dataclasses.field(default_factory=dict)

onesecondtrader/core/events/requests.py

@@ -1,33 +0,0 @@
-from __future__ import annotations
-
-import dataclasses
-import uuid
-
-from onesecondtrader.core import models
-from . import bases
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class OrderSubmission(bases.BrokerRequestEvent):
-    system_order_id: uuid.UUID = dataclasses.field(default_factory=uuid.uuid4)
-    symbol: str
-    order_type: models.orders.OrderType
-    side: models.orders.OrderSide
-    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)
-class OrderCancellation(bases.BrokerRequestEvent):
-    symbol: str
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class OrderModification(bases.BrokerRequestEvent):
-    symbol: str
-    quantity: float | None = None
-    limit_price: float | None = None
-    stop_price: float | None = None

onesecondtrader/core/events/responses.py

@@ -1,54 +0,0 @@
-from __future__ import annotations
-
-import dataclasses
-import uuid
-
-from onesecondtrader.core import models
-from . import bases
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class OrderSubmissionAccepted(bases.BrokerResponseEvent):
-    broker_order_id: str | None = None
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class OrderSubmissionRejected(bases.BrokerResponseEvent):
-    reason: str | None = None
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class OrderModificationAccepted(bases.BrokerResponseEvent):
-    broker_order_id: str | None = None
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class OrderModificationRejected(bases.BrokerResponseEvent):
-    reason: str | None = None
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class OrderCancellationAccepted(bases.BrokerResponseEvent):
-    pass
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class OrderCancellationRejected(bases.BrokerResponseEvent):
-    reason: str | None = None
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class OrderFilled(bases.BrokerResponseEvent):
-    fill_id: uuid.UUID = dataclasses.field(default_factory=uuid.uuid4)
-    broker_fill_id: str | None = None
-    symbol: str
-    side: models.orders.OrderSide
-    quantity_filled: float
-    fill_price: float
-    commission: float
-    exchange: str = "SIMULATED"
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class OrderExpired(bases.BrokerResponseEvent):
-    pass

onesecondtrader/core/indicators/__init__.py

@@ -1,13 +0,0 @@
-__all__ = [
-    "Indicator",
-    "Open",
-    "High",
-    "Low",
-    "Close",
-    "Volume",
-    "SimpleMovingAverage",
-]
-
-from .base import Indicator
-from .bar import Open, High, Low, Close, Volume
-from .averages import SimpleMovingAverage

onesecondtrader/core/indicators/averages.py

@@ -1,56 +0,0 @@
-from __future__ import annotations
-
-import collections
-
-import numpy as np
-
-from onesecondtrader.core import events, models
-from .base import Indicator
-
-
-class SimpleMovingAverage(Indicator):
-    def __init__(
-        self,
-        period: int = 200,
-        max_history: int = 100,
-        input_source: models.InputSource = models.InputSource.CLOSE,
-        plot_at: int = 0,
-    ) -> None:
-        super().__init__(max_history=max_history, plot_at=plot_at)
-        self.period: int = max(1, int(period))
-        self.input_source: models.InputSource = input_source
-        self._window: dict[str, collections.deque[float]] = {}
-
-    @property
-    def name(self) -> str:
-        return f"SMA_{self.period}_{self.input_source.name}"
-
-    def _compute_indicator(self, incoming_bar: events.BarReceived) -> float:
-        symbol = incoming_bar.symbol
-        if symbol not in self._window:
-            self._window[symbol] = collections.deque(maxlen=self.period)
-        window = self._window[symbol]
-        value = self._extract_input(incoming_bar)
-        window.append(value)
-        if len(window) < self.period:
-            return np.nan
-        return sum(window) / self.period
-
-    def _extract_input(self, incoming_bar: events.BarReceived) -> float:
-        match self.input_source:
-            case models.InputSource.OPEN:
-                return incoming_bar.open
-            case models.InputSource.HIGH:
-                return incoming_bar.high
-            case models.InputSource.LOW:
-                return incoming_bar.low
-            case models.InputSource.CLOSE:
-                return incoming_bar.close
-            case models.InputSource.VOLUME:
-                return (
-                    float(incoming_bar.volume)
-                    if incoming_bar.volume is not None
-                    else np.nan
-                )
-            case _:
-                return incoming_bar.close

onesecondtrader/core/indicators/bar.py

@@ -1,47 +0,0 @@
-from onesecondtrader.core import events
-from .base import Indicator
-
-
-class Open(Indicator):
-    @property
-    def name(self) -> str:
-        return "OPEN"
-
-    def _compute_indicator(self, incoming_bar: events.BarReceived) -> float:
-        return incoming_bar.open
-
-
-class High(Indicator):
-    @property
-    def name(self) -> str:
-        return "HIGH"
-
-    def _compute_indicator(self, incoming_bar: events.BarReceived) -> float:
-        return incoming_bar.high
-
-
-class Low(Indicator):
-    @property
-    def name(self) -> str:
-        return "LOW"
-
-    def _compute_indicator(self, incoming_bar: events.BarReceived) -> float:
-        return incoming_bar.low
-
-
-class Close(Indicator):
-    @property
-    def name(self) -> str:
-        return "CLOSE"
-
-    def _compute_indicator(self, incoming_bar: events.BarReceived) -> float:
-        return incoming_bar.close
-
-
-class Volume(Indicator):
-    @property
-    def name(self) -> str:
-        return "VOLUME"
-
-    def _compute_indicator(self, incoming_bar: events.BarReceived) -> float:
-        return float(incoming_bar.volume) if incoming_bar.volume is not None else 0.0

onesecondtrader/core/indicators/base.py

@@ -1,60 +0,0 @@
-from __future__ import annotations
-
-import abc
-import collections
-import threading
-
-import numpy as np
-
-from onesecondtrader.core import events
-
-
-class Indicator(abc.ABC):
-    def __init__(self, max_history: int = 100, plot_at: int = 99) -> None:
-        self._lock = threading.Lock()
-        self._max_history = max(1, int(max_history))
-        self._current_symbol: str = ""
-        self._history_data: dict[str, collections.deque[float]] = {}
-        self._plot_at = plot_at
-
-    @property
-    @abc.abstractmethod
-    def name(self) -> str:
-        pass
-
-    @abc.abstractmethod
-    def _compute_indicator(self, incoming_bar: events.BarReceived) -> float:
-        pass
-
-    def update(self, incoming_bar: events.BarReceived) -> None:
-        symbol = incoming_bar.symbol
-        self._current_symbol = symbol
-        value = self._compute_indicator(incoming_bar)
-        with self._lock:
-            if symbol not in self._history_data:
-                self._history_data[symbol] = collections.deque(maxlen=self._max_history)
-            self._history_data[symbol].append(value)
-
-    @property
-    def latest(self) -> float:
-        with self._lock:
-            h = self._history_data.get(self._current_symbol, collections.deque())
-            return h[-1] if h else np.nan
-
-    @property
-    def history(self) -> collections.deque[float]:
-        with self._lock:
-            h = self._history_data.get(self._current_symbol, collections.deque())
-            return collections.deque(h, maxlen=self._max_history)
-
-    def __getitem__(self, index: int) -> float:
-        # Returns np.nan on out-of-bounds access. Since np.nan comparisons always
-        # return False, strategies can skip explicit length checks.
-        try:
-            return self.history[index]
-        except IndexError:
-            return np.nan
-
-    @property
-    def plot_at(self) -> int:
-        return self._plot_at

onesecondtrader/core/messaging/__init__.py

@@ -1,7 +0,0 @@
-__all__ = [
-    "EventBus",
-    "Subscriber",
-]
-
-from .eventbus import EventBus
-from .subscriber import Subscriber

onesecondtrader/core/messaging/eventbus.py

@@ -1,47 +0,0 @@
-from __future__ import annotations
-
-import collections
-import threading
-import typing
-
-from onesecondtrader.core import events
-
-if typing.TYPE_CHECKING:
-    from .subscriber import Subscriber
-
-
-class EventBus:
-    def __init__(self) -> None:
-        self._per_event_subscriptions: collections.defaultdict[
-            type[events.bases.EventBase], set[Subscriber]
-        ] = collections.defaultdict(set)
-        self._subscribers: set[Subscriber] = set()
-        self._lock: threading.Lock = threading.Lock()
-
-    def subscribe(
-        self,
-        subscriber: Subscriber,
-        event_type: type[events.bases.EventBase],
-    ) -> None:
-        with self._lock:
-            self._subscribers.add(subscriber)
-            self._per_event_subscriptions[event_type].add(subscriber)
-
-    def unsubscribe(self, subscriber: Subscriber) -> None:
-        with self._lock:
-            for set_of_event_subscribers in self._per_event_subscriptions.values():
-                set_of_event_subscribers.discard(subscriber)
-            self._subscribers.discard(subscriber)
-
-    def publish(self, event: events.bases.EventBase) -> None:
-        # Intentionally matches exact event types only, not parent classes
-        with self._lock:
-            subscribers = self._per_event_subscriptions[type(event)].copy()
-        for subscriber in subscribers:
-            subscriber.receive(event)
-
-    def wait_until_system_idle(self) -> None:
-        with self._lock:
-            subscribers = self._subscribers.copy()
-        for subscriber in subscribers:
-            subscriber.wait_until_idle()

onesecondtrader/core/messaging/subscriber.py

@@ -1,69 +0,0 @@
-import abc
-import queue
-import threading
-
-from onesecondtrader.core import events
-from .eventbus import EventBus
-
-
-class Subscriber(abc.ABC):
-    def __init__(self, event_bus: EventBus) -> None:
-        self._event_bus = event_bus
-        self._queue: queue.Queue[events.bases.EventBase | None] = queue.Queue()
-        self._running: threading.Event = threading.Event()
-        self._running.set()
-        self._thread = threading.Thread(
-            target=self._event_loop, name=self.__class__.__name__
-        )
-        self._thread.start()
-
-    def receive(self, event: events.bases.EventBase) -> None:
-        if self._running.is_set():
-            self._queue.put(event)
-
-    def wait_until_idle(self) -> None:
-        if not self._running.is_set():
-            return
-        self._queue.join()
-
-    def shutdown(self) -> None:
-        if not self._running.is_set():
-            return
-        self._event_bus.unsubscribe(self)
-        self._running.clear()
-        self._queue.put(None)
-        if threading.current_thread() is not self._thread:
-            self._thread.join()
-
-    def _subscribe(self, *event_types: type[events.bases.EventBase]) -> None:
-        for event_type in event_types:
-            self._event_bus.subscribe(self, event_type)
-
-    def _publish(self, event: events.bases.EventBase) -> None:
-        self._event_bus.publish(event)
-
-    def _event_loop(self) -> None:
-        while True:
-            event = self._queue.get()
-            if event is None:
-                self._queue.task_done()
-                break
-            try:
-                self._on_event(event)
-            except Exception as exc:
-                self._on_exception(exc)
-            finally:
-                self._queue.task_done()
-        self._cleanup()
-
-    def _on_exception(self, exc: Exception) -> None:
-        # Override in subclass to log or handle exceptions
-        pass
-
-    def _cleanup(self) -> None:
-        pass
-
-    @abc.abstractmethod
-    def _on_event(self, event: events.bases.EventBase) -> None:
-        # Must not block indefinitely; wait_until_idle() has no timeout
-        ...

onesecondtrader/core/models/__init__.py

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

onesecondtrader/core/models/data.py

@@ -1,18 +0,0 @@
-from __future__ import annotations
-
-import enum
-
-
-class BarPeriod(enum.Enum):
-    SECOND = enum.auto()
-    MINUTE = enum.auto()
-    HOUR = enum.auto()
-    DAY = enum.auto()
-
-
-class InputSource(enum.Enum):
-    OPEN = enum.auto()
-    HIGH = enum.auto()
-    LOW = enum.auto()
-    CLOSE = enum.auto()
-    VOLUME = enum.auto()

onesecondtrader/core/models/orders.py

@@ -1,27 +0,0 @@
-from __future__ import annotations
-
-import enum
-
-
-class OrderType(enum.Enum):
-    LIMIT = enum.auto()
-    MARKET = enum.auto()
-    STOP = enum.auto()
-    STOP_LIMIT = enum.auto()
-
-
-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

@@ -1,21 +0,0 @@
-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

@@ -1,34 +0,0 @@
-from __future__ import annotations
-
-import dataclasses
-import uuid
-
-import pandas as pd
-
-from . import orders
-
-
-@dataclasses.dataclass
-class OrderRecord:
-    order_id: uuid.UUID
-    symbol: str
-    order_type: orders.OrderType
-    side: orders.OrderSide
-    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
-
-
-@dataclasses.dataclass
-class FillRecord:
-    fill_id: uuid.UUID
-    order_id: uuid.UUID
-    symbol: str
-    side: orders.OrderSide
-    quantity: float
-    price: float
-    commission: float
-    ts_event: pd.Timestamp

onesecondtrader/core/strategies/__init__.py

@@ -1,7 +0,0 @@
-__all__ = [
-    "StrategyBase",
-    "SMACrossover",
-]
-
-from .base import StrategyBase
-from .examples import SMACrossover