onesecondtrader 0.23.0__py3-none-any.whl → 0.25.0__py3-none-any.whl

onesecondtrader/events/__init__.py

@@ -0,0 +1,33 @@
+__all__ = [
+    "EventBase",
+    "MarketEvent",
+    "BrokerRequestEvent",
+    "BrokerResponseEvent",
+    "BarReceived",
+    "BarProcessed",
+    "OrderSubmission",
+    "OrderModification",
+    "OrderCancellation",
+    "OrderSubmissionAccepted",
+    "OrderSubmissionRejected",
+    "OrderModificationAccepted",
+    "OrderModificationRejected",
+    "OrderCancellationAccepted",
+    "OrderCancellationRejected",
+    "OrderFilled",
+    "OrderExpired",
+]
+
+from .bases import EventBase, MarketEvent, BrokerRequestEvent, BrokerResponseEvent
+from .market import BarReceived, BarProcessed
+from .requests import OrderSubmission, OrderModification, OrderCancellation
+from .responses import (
+    OrderSubmissionAccepted,
+    OrderSubmissionRejected,
+    OrderModificationAccepted,
+    OrderModificationRejected,
+    OrderCancellationAccepted,
+    OrderCancellationRejected,
+    OrderFilled,
+    OrderExpired,
+)

onesecondtrader/events/bases.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import dataclasses
+import pandas as pd
+import uuid
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class EventBase:
+    ts_event: pd.Timestamp
+    ts_created: pd.Timestamp = dataclasses.field(
+        default_factory=lambda: pd.Timestamp.now(tz="UTC")
+    )
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class MarketEvent(EventBase):
+    pass
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class BrokerRequestEvent(EventBase):
+    system_order_id: uuid.UUID
+
+
+@dataclasses.dataclass(kw_only=True, frozen=True)
+class BrokerResponseEvent(EventBase):
+    ts_broker: pd.Timestamp
+    associated_order_id: uuid.UUID

onesecondtrader/events/market.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import dataclasses
+
+from onesecondtrader 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/events/requests.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import dataclasses
+import uuid
+
+from onesecondtrader 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
+
+
+@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/events/responses.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import dataclasses
+import uuid
+
+from onesecondtrader 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/messaging/__init__.py

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

onesecondtrader/messaging/contracts.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+import typing
+
+from onesecondtrader import events
+
+
+@typing.runtime_checkable
+class EventSubscriberLike(typing.Protocol):
+    def receive(self, event: events.bases.EventBase) -> None: ...
+    def wait_until_idle(self) -> None: ...

onesecondtrader/messaging/eventbus.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import collections
+import threading
+
+from onesecondtrader import events
+from . import contracts
+
+
+class EventBus:
+    def __init__(self) -> None:
+        self._per_event_subscriptions: collections.defaultdict[
+            type[events.bases.EventBase], set[contracts.EventSubscriberLike]
+        ] = collections.defaultdict(set)
+        self._subscribers: set[contracts.EventSubscriberLike] = set()
+        self._lock: threading.Lock = threading.Lock()
+
+    def subscribe(
+        self,
+        subscriber: contracts.EventSubscriberLike,
+        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: contracts.EventSubscriberLike) -> 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:
+        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/models/__init__.py

@@ -0,0 +1,8 @@
+__all__ = [
+    "BarPeriod",
+    "OrderSide",
+    "OrderType",
+]
+
+from .data import BarPeriod
+from .orders import OrderSide, OrderType

onesecondtrader/models/data.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+import enum
+
+
+class BarPeriod(enum.Enum):
+    SECOND = enum.auto()
+    MINUTE = enum.auto()
+    HOUR = enum.auto()
+    DAY = enum.auto()

onesecondtrader/models/orders.py

@@ -0,0 +1,15 @@
+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()

{onesecondtrader-0.23.0.dist-info → onesecondtrader-0.25.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onesecondtrader
-Version: 0.23.0
+Version: 0.25.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.25.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+onesecondtrader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+onesecondtrader/events/__init__.py,sha256=IOlFRdiOXz93SpvkpKL8wr1954d_8olKSB1n9mlTL3Y,898
+onesecondtrader/events/bases.py,sha256=g-ykq2jgcitIAueRurUlqAq0jINQwuhSWi_khAniPHw,662
+onesecondtrader/events/market.py,sha256=IfHuIGfp_IUiw-dFay4c4RYmkoNzshxbhuWTglBqfN0,509
+onesecondtrader/events/requests.py,sha256=2KXwSckiar9-fy8wkN3vcSIeOkeBfeo_XhUhrNKEd2Q,831
+onesecondtrader/events/responses.py,sha256=w_BH1nkkPyxQjh30EXEVFcUGDoMprFc2PuAaqpVrQ8A,1436
+onesecondtrader/messaging/__init__.py,sha256=9yLobI20ZmqipPHG_pwVgdGOEoj-sIAdGWhH17MKSu4,132
+onesecondtrader/messaging/contracts.py,sha256=_LCDtwqgCqNZ5Js1Ht5iFvqNqZUMzi83RVeJgXpTeno,267
+onesecondtrader/messaging/eventbus.py,sha256=J36tmuemRjDATHikSSzL3-7Kmx5fu_sX09X7tb94IF0,1522
+onesecondtrader/models/__init__.py,sha256=cH5xyniz78MQjM9_-fFdP1ZW6FFLTmayMwQauFO23bU,135
+onesecondtrader/models/data.py,sha256=TqUvTtjpmzTJT8ZdTYnlVoyI7Qck2IsseCazWZxJgD0,173
+onesecondtrader/models/orders.py,sha256=y6Ar-6fMqaOd_hRnRGvfWUF0Z13H_2hfTOW3ROOk0A8,254
+onesecondtrader-0.25.0.dist-info/METADATA,sha256=eWtsWhZOEqTGaEubNmJhXnWFtYxSfhYwJheci2HAwkI,9682
+onesecondtrader-0.25.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+onesecondtrader-0.25.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+onesecondtrader-0.25.0.dist-info/RECORD,,

onesecondtrader/core/component.py

@@ -1,119 +0,0 @@
-"""
-Read first: [`events.py`](./events.md), [`eventbus.py`](./eventbus.md).
-
----
-This module defines the `Component` class.
-
-In an event-driven system, components interact exclusively via event messages.
-The `Component` class is an abstract base class that defines a common interface for
-publishing and receiving such messages and is intended to be subclassed by all system
-components.
----
-"""
-
-import abc
-import queue
-import threading
-
-from .events import Event
-from .eventbus import EventBus
-
-
-class Component(abc.ABC):
-    """
-    Abstract base class for all system components.
-
-    Incoming events are delivered via `receive()` and stored in an internal queue.
-    A dedicated thread runs an event loop that consumes queued events and dispatches
-    them to `_process()`, which subclasses must implement.
-    For publication, `publish()` forwards events to the event bus.
-    The `join_queue()` method is used by the event bus to block until all queued events
-    have been processed, which is useful for deterministic, stepwise execution in
-    backtesting.
-    """
-
-    def __init__(self, eventbus: EventBus) -> None:
-        """
-        Initialize the component and start its event-loop thread.
-
-        Stores a reference to the event bus, creates an internal queue for incoming
-        events, and starts a non-daemon thread for the event loop that runs until
-        shutdown.
-        """
-        self._event_bus = eventbus
-        self._incoming_event_queue: queue.Queue[Event | None] = queue.Queue()
-        self._thread: threading.Thread = threading.Thread(
-            target=self._event_loop,
-            name=self.__class__.__name__,
-            daemon=False,
-        )
-        self._thread.start()
-
-    def publish(self, event: Event) -> None:
-        """
-        Wrapper for the event bus's `publish()` method.
-
-        For convenience, this method can be used by subclasses to publish events via the
-        event bus's publication mechanism.
-        """
-        self._event_bus.publish(event)
-
-    def receive(self, event: Event) -> None:
-        """
-        Store incoming events in the component's queue.
-
-        This method is typically called by the event bus when an event is published that
-        the component has subscribed to.
-        It simply puts the event in the queue for processing by the subscribed
-        component.
-        """
-        self._incoming_event_queue.put(event)
-
-    def join_queue(self) -> None:
-        """
-        Block until all queued events have been processed.
-
-        This method is used by the event bus to block until all queued events have been
-        processed.
-        This is useful for deterministic, stepwise execution in backtesting.
-        """
-        self._incoming_event_queue.join()
-
-    def _event_loop(self) -> None:
-        """
-        Event-processing loop executed in the component’s dedicated thread.
-
-        The loop continuously retrieves events from the `incoming_event_queue`,
-        processes each event via `_process()`, and signals completion with
-        `task_done()`.
-        Execution terminates upon receipt of a `None` sentinel, at which point
-        `_shutdown()` is invoked before exiting the thread to ensure proper cleanup.
-        """
-        while True:
-            incoming_event = self._incoming_event_queue.get()
-            if incoming_event is None:
-                self._shutdown()
-                self._incoming_event_queue.task_done()
-                break
-            self._process(incoming_event)
-            self._incoming_event_queue.task_done()
-
-    @abc.abstractmethod
-    def _process(self, event: Event) -> None:
-        """
-        Process a single event.
-
-        This method is invoked by the event loop for each incoming event.
-        Subclasses must implement it to define event-handling behavior.
-        """
-        pass
-
-    def _shutdown(self) -> None:
-        """
-        Perform cleanup when the component is shutting down.
-
-        Called by `_event_loop()` when a `None` sentinel is received.
-        Subclasses may override this method to perform cleanup tasks such as closing
-        files or connections before the thread exits.
-        """
-        pass

onesecondtrader/core/eventbus.py

@@ -1,85 +0,0 @@
-"""
-Read first: [`events.py`](./events.md), [`component.py`](./component.md).
-
----
-This module defines the `EventBus` class.
-
-The event bus provides a publish–subscribe mechanism for event-driven systems.
-It maintains subscriptions between event types and components and delivers
-published events to all subscribed components in a thread-safe manner.
----
-"""
-
-import collections
-import threading
-
-from .component import Component
-from .events import Event
-
-
-class EventBus:
-    """
-    Central event-dispatch mechanism for the system.
-
-    The event bus manages subscriptions between event types and components and
-    forwards published events to all subscribed components.
-    """
-
-    def __init__(self) -> None:
-        """
-        Initialize the event bus.
-
-        Sets up internal data structures for managing subscriptions and registered
-        components and initializes a lock to ensure thread-safe access.
-        """
-        self._subscriptions: collections.defaultdict[type[Event], set[Component]] = (
-            collections.defaultdict(set)
-        )
-        self._components: set[Component] = set()
-        self._lock: threading.Lock = threading.Lock()
-
-    def subscribe(self, subscriber: Component, *event_types: type[Event]) -> None:
-        """
-        Subscribe a component to one or more event types.
-
-        The subscriber will receive all future events whose type matches one of the
-        specified event types.
-        """
-        with self._lock:
-            self._components.add(subscriber)
-            for event_type in event_types:
-                self._subscriptions[event_type].add(subscriber)
-
-    def unsubscribe(self, subscriber: Component) -> None:
-        """
-        Remove a component from all event subscriptions.
-
-        After unsubscription, the component will no longer receive published events.
-        """
-        with self._lock:
-            for component_set in self._subscriptions.values():
-                component_set.discard(subscriber)
-            self._components.discard(subscriber)
-
-    def publish(self, event: Event) -> None:
-        """
-        Publish an event to all subscribed components.
-
-        The event is delivered to each subscriber by invoking its `receive()` method.
-        """
-        with self._lock:
-            components = self._subscriptions[type(event)].copy()
-        for component in components:
-            component.receive(event)
-
-    def wait_until_idle(self) -> None:
-        """
-        Block until all components have processed their queued events.
-
-        This method is primarily used in backtesting to enforce deterministic,
-        system-wide synchronization.
-        """
-        with self._lock:
-            components = self._components.copy()
-        for component in components:
-            component.join_queue()

onesecondtrader/core/events.py

@@ -1,224 +0,0 @@
-"""
-Read first: [`models.py`](./models.md).
-
----
-This module provides all event message classes used in the system.
-
-In an event-driven system, components communicate by sending event messages to each
-other. An event message is an immutable object that contains all information relevant
-to a specific occurrence, such as incoming market data, order submissions, fills, or
-other domain-specific events.
----
-"""
-
-import dataclasses
-import uuid
-
-import pandas as pd
-
-from .models import BarPeriod, OrderType, OrderSide
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class Event:
-    """
-    Base class for all event messages in the system.
-
-    All events include a timestamp indicating when the event was created or received.
-    Subclasses define specific event types with additional fields relevant to that
-    event.
-    """
-
-    ts_event: pd.Timestamp = dataclasses.field(
-        default_factory=lambda: pd.Timestamp.now(tz="UTC")
-    )
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class ReceivedNewBar(Event):
-    """
-    Event indicating a new bar of market data has been received.
-
-    Contains OHLCV data for a specific symbol and bar period. This event is typically
-    emitted by data feed components when new market data arrives.
-    """
-
-    ts_event: pd.Timestamp
-    symbol: str
-    bar_period: BarPeriod
-    open: float
-    high: float
-    low: float
-    close: float
-    volume: int | None = None
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class ProcessedBar(Event):
-    """
-    Event indicating a bar has been processed and enriched with indicator values.
-
-    Contains the same OHLCV data as ReceivedNewBar, plus a dictionary of computed
-    indicator values. This event is typically emitted after strategies or other
-    components have calculated technical indicators for the bar.
-    """
-
-    ts_event: pd.Timestamp
-    symbol: str
-    bar_period: BarPeriod
-    open: float
-    high: float
-    low: float
-    close: float
-    volume: int | None = None
-    indicators: dict[str, float] = dataclasses.field(default_factory=dict)
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class RequestOrderSubmission(Event):
-    """
-    Event requesting submission of a new order with the broker.
-
-    Contains all parameters needed to submit an order, including symbol, order type,
-    side, quantity, and optional limit/stop prices. A unique order_id is automatically
-    generated if not provided.
-    """
-
-    order_id: uuid.UUID = dataclasses.field(default_factory=uuid.uuid4)
-    symbol: str
-    order_type: OrderType
-    side: OrderSide
-    quantity: float
-    limit_price: float | None = None
-    stop_price: float | None = None
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class RequestOrderModification(Event):
-    """
-    Event requesting modification of an existing order.
-
-    Identifies the order to modify by order_id and symbol. Any of quantity, limit_price,
-    or stop_price can be updated by providing new values.
-    """
-
-    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 RequestOrderCancellation(Event):
-    """
-    Event requesting cancellation of an existing order.
-
-    Identifies the order to cancel by order_id and symbol.
-    """
-
-    symbol: str
-    order_id: uuid.UUID
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class AcceptedOrderSubmission(Event):
-    """
-    Event indicating the broker has accepted an order submission.
-
-    Contains the system's order_id and optionally the broker's order_id if provided
-    by the broker.
-    """
-
-    order_id: uuid.UUID
-    broker_order_id: str | None = None
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class AcceptedOrderModification(Event):
-    """
-    Event indicating the broker has accepted an order modification.
-
-    Contains the system's order_id and optionally the broker's order_id if provided
-    by the broker.
-    """
-
-    order_id: uuid.UUID
-    broker_order_id: str | None = None
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class AcceptedOrderCancellation(Event):
-    """
-    Event indicating the broker has accepted an order cancellation.
-
-    Contains the system's order_id for the cancelled order.
-    """
-
-    order_id: uuid.UUID
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class RejectedOrderSubmission(Event):
-    """
-    Event indicating the broker has rejected an order submission.
-
-    Contains the system's order_id for the rejected order.
-    """
-
-    order_id: uuid.UUID
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class RejectedOrderModification(Event):
-    """
-    Event indicating the broker has rejected an order modification.
-
-    Contains the system's order_id for the order that could not be modified.
-    """
-
-    order_id: uuid.UUID
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class RejectedOrderCancellation(Event):
-    """
-    Event indicating the broker has rejected an order cancellation.
-
-    Contains the system's order_id for the order that could not be cancelled.
-    """
-
-    order_id: uuid.UUID
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class OrderFilled(Event):
-    """
-    Event indicating an order has been filled (fully or partially).
-
-    Contains details about the fill including quantity, price, commission, and the
-    associated order. A unique fill_id is automatically generated if not provided.
-    The broker may optionally provide a broker_fill_id.
-    """
-
-    fill_id: uuid.UUID = dataclasses.field(default_factory=uuid.uuid4)
-    broker_fill_id: str | None = None
-    associated_order_id: uuid.UUID
-    symbol: str
-    side: OrderSide
-    quantity_filled: float
-    fill_price: float
-    commission: float
-    exchange: str = "SIMULATED"
-
-
-@dataclasses.dataclass(kw_only=True, frozen=True)
-class OrderExpired(Event):
-    """
-    Event indicating an order has expired without being filled.
-
-    Contains the system's order_id for the expired order. This typically occurs for
-    time-limited orders that were not filled before their expiration time.
-    """
-
-    order_id: uuid.UUID

onesecondtrader/core/models.py

@@ -1,70 +0,0 @@
-"""
----
-This module provides core domain models used throughout the system.
-
-Domain models are enumerations that define the vocabulary and valid values for key
-concepts in the trading system. These models are used across all components to ensure
-type safety and consistency when representing domain-specific concepts.
----
-"""
-
-import enum
-
-
-class BarPeriod(enum.Enum):
-    """
-    Time period for aggregating market data into bars.
-
-    Defines the standard time intervals used for OHLCV bar data.
-    Each bar represents market activity aggregated over the specified period.
-    """
-
-    SECOND = 32
-    MINUTE = 33
-    HOUR = 34
-    DAY = 35
-
-
-class OrderType(enum.Enum):
-    """
-    Type of order to submit to the broker.
-
-    Defines the execution behavior for an order.
-    Market orders execute immediately at current market price.
-    Limit orders execute only at a specified price or better.
-    Stop orders become market orders when a trigger price is reached.
-    Stop-limit orders become limit orders when a trigger price is reached.
-    """
-
-    MARKET = enum.auto()
-    LIMIT = enum.auto()
-    STOP = enum.auto()
-    STOP_LIMIT = enum.auto()
-
-
-class OrderSide(enum.Enum):
-    """
-    Direction of an order or position.
-
-    Indicates whether an order is buying or selling a security.
-    """
-
-    BUY = enum.auto()
-    SELL = enum.auto()
-
-
-class InputSource(enum.Enum):
-    """
-    Source field from bar data to use as input for indicators.
-
-    Specifies which component of OHLCV bar data should be used when calculating
-    technical indicators.
-    For example, many indicators use CLOSE prices per default, but could also be
-    calculated based on other fields.
-    """
-
-    OPEN = enum.auto()
-    HIGH = enum.auto()
-    LOW = enum.auto()
-    CLOSE = enum.auto()
-    VOLUME = enum.auto()

onesecondtrader-0.23.0.dist-info/RECORD

@@ -1,10 +0,0 @@
-onesecondtrader/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-onesecondtrader/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-onesecondtrader/core/component.py,sha256=I1pO48qT6yAuSQMAbte9YubGxK1FVzv0HJ-qsIWyanU,4193
-onesecondtrader/core/eventbus.py,sha256=o4cQ6FR61TXdDYC3K_tdKCWYbK5UOPfHSYflNfsCANQ,2818
-onesecondtrader/core/events.py,sha256=tRtanpMVcBEfcl7Wcw9CLR-gd6wFf7yABajnnXVGXJM,6167
-onesecondtrader/core/models.py,sha256=wdp3bFlvu21o5vsEHT2Lk_3kb2Vk5N0RmgcnZXelAxo,1806
-onesecondtrader-0.23.0.dist-info/METADATA,sha256=LlsTFMLyQYjSY2yec848Y5cln9x4ADwxuhFUiMzttxc,9682
-onesecondtrader-0.23.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-onesecondtrader-0.23.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-onesecondtrader-0.23.0.dist-info/RECORD,,