onesecondtrader 0.22.0__py3-none-any.whl → 0.49.0__py3-none-any.whl

onesecondtrader/brokers.py

@@ -1,92 +0,0 @@
-import abc
-import uuid
-
-from onesecondtrader.core import BaseConsumer, Events, event_bus
-
-
-class BaseBroker(BaseConsumer):
-    """
-    Base class for all brokers.
-    """
-
-    def __init__(self) -> None:
-        super().__init__()
-        event_bus.subscribe(self, Events.SubmitOrder)
-        event_bus.subscribe(self, Events.CancelOrder)
-        event_bus.subscribe(self, Events.ModifyOrder)
-
-    def on_event(self, event) -> None:
-        match event:
-            case Events.SubmitOrder():
-                self.on_submit_order(event)
-            case Events.CancelOrder():
-                self.on_cancel_order(event)
-            case Events.ModifyOrder():
-                self.on_modify_order(event)
-
-    @abc.abstractmethod
-    def on_submit_order(self, event: Events.SubmitOrder) -> None:
-        pass
-
-    @abc.abstractmethod
-    def on_cancel_order(self, event: Events.CancelOrder) -> None:
-        pass
-
-    @abc.abstractmethod
-    def on_modify_order(self, event: Events.ModifyOrder) -> None:
-        pass
-
-
-class SimulatedBroker(BaseBroker):
-    """
-    Simulated broker for backtesting.
-    """
-
-    def __init__(self) -> None:
-        super().__init__()
-        event_bus.subscribe(self, Events.IncomingBar)
-
-        self._pending_market_orders: dict[str, dict[uuid.UUID, Events.SubmitOrder]] = {}
-        self._pending_limit_orders: dict[str, dict[uuid.UUID, Events.SubmitOrder]] = {}
-        self._pending_stop_orders: dict[str, dict[uuid.UUID, Events.SubmitOrder]] = {}
-        self._pending_stop_limit_orders: dict[
-            str, dict[uuid.UUID, Events.SubmitOrder]
-        ] = {}
-
-    def on_event(self, event) -> None:
-        match event:
-            case Events.SubmitOrder():
-                self.on_submit_order(event)
-            case Events.CancelOrder():
-                self.on_cancel_order(event)
-            case Events.ModifyOrder():
-                self.on_modify_order(event)
-            case Events.IncomingBar():
-                self.on_incoming_bar(event)
-
-    def on_submit_order(self, event: Events.SubmitOrder) -> None:
-        pass
-
-    def on_cancel_order(self, event: Events.CancelOrder) -> None:
-        pass
-
-    def on_modify_order(self, event: Events.ModifyOrder) -> None:
-        pass
-
-    def on_incoming_bar(self, event: Events.IncomingBar) -> None:
-        self._process_pending_orders(event)
-
-        bar_ready = Events.BarReady(
-            ts_event=event.ts_event,
-            symbol=event.symbol,
-            record_type=event.record_type,
-            open=event.open,
-            high=event.high,
-            low=event.low,
-            close=event.close,
-            volume=event.volume,
-        )
-        event_bus.publish(bar_ready)
-
-    def _process_pending_orders(self, event: Events.IncomingBar) -> None:
-        pass

onesecondtrader/core.py

@@ -1,260 +0,0 @@
-"""
-Core module containing the backbone of OneSecondTrader's event-driven architecture.
-"""
-
-import abc
-import dataclasses
-import enum
-import logging
-import pandas as pd
-import queue
-import threading
-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.
-    """
-
-    class RecordType(enum.Enum):
-        OHLCV_1S = 32
-        OHLCV_1M = 33
-        OHLCV_1H = 34
-        OHLCV_1D = 35
-
-    class OrderSide(enum.Enum):
-        BUY = enum.auto()
-        SELL = enum.auto()
-
-    class OrderType(enum.Enum):
-        MARKET = enum.auto()
-        LIMIT = enum.auto()
-        STOP = enum.auto()
-        STOP_LIMIT = enum.auto()
-
-    class RejectionReason(enum.Enum):
-        ORDER_ALREADY_FILLED = enum.auto()
-        ORDER_ALREADY_CANCELLED = enum.auto()
-        ORDER_PENDING_EXECUTION = enum.auto()
-        INSUFFICIENT_FUNDS = 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(
-            default_factory=lambda: pd.Timestamp.now(tz="UTC")
-        )
-
-    # SYSTEM EVENTS
-    @dataclasses.dataclass(kw_only=True, frozen=True)
-    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 MarketEvent(BaseEvent):
-        pass
-
-    @dataclasses.dataclass(kw_only=True, frozen=True)
-    class IncomingBar(MarketEvent):
-        ts_event: pd.Timestamp
-        symbol: str
-        record_type: Models.RecordType
-        open: float
-        high: float
-        low: float
-        close: float
-        volume: int | None = None
-
-    @dataclasses.dataclass(kw_only=True, frozen=True)
-    class BarReady(MarketEvent):
-        ts_event: pd.Timestamp
-        symbol: str
-        record_type: Models.RecordType
-        open: float
-        high: float
-        low: float
-        close: float
-        volume: int | None = None
-
-    # BROKER REQUESTS EVENTS
-    @dataclasses.dataclass(kw_only=True, frozen=True)
-    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):
-        symbol: str
-        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):
-        symbol: str
-        order_id: uuid.UUID
-
-    # BROKER RESPONSE EVENTS
-    @dataclasses.dataclass(kw_only=True, frozen=True)
-    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.RejectionReason
-
-    @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.RejectionReason
-
-    @dataclasses.dataclass(kw_only=True, frozen=True)
-    class ModifyRejected(BrokerResponseEvent):
-        order_id: uuid.UUID
-        reason: Models.RejectionReason
-
-
-class BaseConsumer(abc.ABC):
-    """
-    Base class for all consumers.
-    """
-
-    def __init__(self) -> None:
-        self.queue: queue.Queue[Events.BaseEvent] = queue.Queue()
-        self._thread = threading.Thread(
-            target=self._consume, name=self.__class__.__name__, daemon=True
-        )
-        self._thread.start()
-
-    @abc.abstractmethod
-    def on_event(self, event: Events.BaseEvent) -> None:
-        pass
-
-    def receive(self, event: Events.BaseEvent) -> None:
-        self.queue.put(event)
-
-    def _consume(self) -> None:
-        while True:
-            event = self.queue.get()
-            if isinstance(event, Events.SystemShutdown):
-                self.queue.task_done()
-                break
-            self.on_event(event)
-            self.queue.task_done()
-
-
-class EventBus:
-    """
-    Event bus for publishing events to the consumers subscribed to them.
-    """
-
-    def __init__(self) -> None:
-        self._subscriptions: defaultdict[type[Events.BaseEvent], list[BaseConsumer]] = (
-            defaultdict(list)
-        )
-        self._consumers: set[BaseConsumer] = set()
-        self._lock: threading.Lock = threading.Lock()
-
-    def subscribe(self, subscriber: BaseConsumer, event_type: type[Events.BaseEvent]):
-        with self._lock:
-            self._consumers.add(subscriber)
-            if subscriber not in self._subscriptions[event_type]:
-                self._subscriptions[event_type].append(subscriber)
-
-    def unsubscribe(self, subscriber: BaseConsumer):
-        with self._lock:
-            for consumer_list in self._subscriptions.values():
-                if subscriber in consumer_list:
-                    consumer_list.remove(subscriber)
-            if not any(subscriber in cl for cl in self._subscriptions.values()):
-                self._consumers.discard(subscriber)
-
-    def publish(self, event: Events.BaseEvent) -> None:
-        with self._lock:
-            consumers = list(self._subscriptions[type(event)])
-        for consumer in consumers:
-            consumer.receive(event)
-
-    # Enable synchronous execution via wait_until_idle()
-    def wait_until_idle(self) -> None:
-        with self._lock:
-            consumers = list(self._consumers)
-        for consumer in consumers:
-            consumer.queue.join()
-
-
-event_bus = EventBus()
-"""
-Global instance of `EventBus`.
-"""

onesecondtrader/datafeeds.py

@@ -1,173 +0,0 @@
-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)
-                event_bus.wait_until_idle()
-
-                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/indicators.py

@@ -1,106 +0,0 @@
-"""
-OneSecondTrader's library of pre-built indicators.
-"""
-
-import abc
-import enum
-import numpy as np
-import threading
-
-from collections import deque
-from onesecondtrader.core import Events
-
-
-class BaseIndicator(abc.ABC):
-    """
-    Base class for indicators. Subclasses must set the `name` property and implement
-    the `_compute_indicator()` method. See `SimpleMovingAverage` for an example.
-    """
-
-    def __init__(self, max_history: int = 100) -> None:
-        self._lock = threading.Lock()
-        self._history: deque[float] = deque(maxlen=max(1, int(max_history)))
-
-    @property
-    @abc.abstractmethod
-    def name(self) -> str:
-        pass
-
-    def update(self, incoming_bar: Events.IncomingBar) -> None:
-        _latest_value: float = self._compute_indicator(incoming_bar)
-        with self._lock:
-            self._history.append(_latest_value)
-
-    @abc.abstractmethod
-    def _compute_indicator(self, incoming_bar: Events.IncomingBar) -> float:
-        pass
-
-    @property
-    def latest(self) -> float:
-        with self._lock:
-            return self._history[-1] if self._history else np.nan
-
-    @property
-    def history(self) -> deque[float]:
-        return self._history
-
-
-class InputSource(enum.Enum):
-    """
-    Enum of supported input sources for indicators. Indicators with a `input_source`
-    parameter can be configured to use one of these sources for their calculations.
-    """
-
-    OPEN = enum.auto()
-    HIGH = enum.auto()
-    LOW = enum.auto()
-    CLOSE = enum.auto()
-    VOLUME = enum.auto()
-
-
-class SimpleMovingAverage(BaseIndicator):
-    """
-    Simple Moving Average (SMA) indicator. Can be configured to use different input
-    sources (see `InputSource` enum, default is `InputSource.CLOSE`).
-    """
-
-    def __init__(
-        self,
-        period: int = 200,
-        max_history: int = 100,
-        input_source: InputSource = InputSource.CLOSE,
-    ) -> None:
-        super().__init__(max_history=max_history)
-        self.period: int = max(1, int(period))
-        self.input_source: InputSource = input_source
-        self._window: deque[float] = deque(maxlen=self.period)
-
-    @property
-    def name(self) -> str:
-        return f"SMA_{self.period}_{self.input_source.name}"
-
-    def _compute_indicator(self, incoming_bar: Events.IncomingBar) -> float:
-        value: float = self._extract_input(incoming_bar)
-        self._window.append(value)
-        if len(self._window) < self.period:
-            return np.nan
-        return sum(self._window) / self.period
-
-    def _extract_input(self, incoming_bar: Events.IncomingBar) -> float:
-        match self.input_source:
-            case InputSource.OPEN:
-                return incoming_bar.open
-            case InputSource.HIGH:
-                return incoming_bar.high
-            case InputSource.LOW:
-                return incoming_bar.low
-            case InputSource.CLOSE:
-                return incoming_bar.close
-            case InputSource.VOLUME:
-                return (
-                    float(incoming_bar.volume)
-                    if incoming_bar.volume is not None
-                    else np.nan
-                )
-            case _:
-                return incoming_bar.close

onesecondtrader-0.22.0.dist-info/RECORD

@@ -1,9 +0,0 @@
-onesecondtrader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-onesecondtrader/brokers.py,sha256=fDElmF0y6KD6NIVBX0lo8Z-nQzpe-Rp2J2C75TrbSNg,2779
-onesecondtrader/core.py,sha256=5H-JydCnMOedLw-GrSB1aooDj6s0R1gpVwI_JgxZpzA,7495
-onesecondtrader/datafeeds.py,sha256=IlMipy1OFLx8aMBa46d74Mm3rhhb-uR905odhVP_uX0,6149
-onesecondtrader/indicators.py,sha256=wGn-5v8L1gepMP45KcVrEo-f2ReOCD3r8lva9aEIUnY,3199
-onesecondtrader-0.22.0.dist-info/METADATA,sha256=lp8FV-Gaqm8IH36ubGu0EPzCXyPog5PfOVYRv3LBJZc,9682
-onesecondtrader-0.22.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-onesecondtrader-0.22.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-onesecondtrader-0.22.0.dist-info/RECORD,,