onesecondtrader 0.35.0__py3-none-any.whl → 0.36.0__py3-none-any.whl

onesecondtrader/core/strategies/base.py

@@ -0,0 +1,318 @@
+from __future__ import annotations
+
+import abc
+import uuid
+from types import SimpleNamespace
+
+import pandas as pd
+
+from onesecondtrader.core import events, indicators, messaging, models
+
+
+class StrategyBase(messaging.Subscriber, abc.ABC):
+    symbols: list[str] = []
+    bar_period: models.BarPeriod = models.BarPeriod.SECOND
+
+    def __init__(self, event_bus: messaging.EventBus) -> None:
+        super().__init__(event_bus)
+        self._subscribe(
+            events.BarReceived,
+            events.OrderSubmissionAccepted,
+            events.OrderModificationAccepted,
+            events.OrderCancellationAccepted,
+            events.OrderSubmissionRejected,
+            events.OrderModificationRejected,
+            events.OrderCancellationRejected,
+            events.OrderFilled,
+            events.OrderExpired,
+        )
+
+        self._current_symbol: str = ""
+        self._current_ts: pd.Timestamp = pd.Timestamp.now(tz="UTC")
+        self._indicators: list[indicators.Indicator] = []
+
+        self._fills: dict[str, list[models.FillRecord]] = {}
+        self._positions: dict[str, float] = {}
+        self._avg_prices: dict[str, float] = {}
+        self._pending_orders: dict[uuid.UUID, models.OrderRecord] = {}
+        self._submitted_orders: dict[uuid.UUID, models.OrderRecord] = {}
+        self._submitted_modifications: dict[uuid.UUID, models.OrderRecord] = {}
+        self._submitted_cancellations: dict[uuid.UUID, models.OrderRecord] = {}
+
+        # OHLCV as indicators for history access: self.bar.close.history
+        self.bar = SimpleNamespace(
+            open=self.add_indicator(indicators.Open()),
+            high=self.add_indicator(indicators.High()),
+            low=self.add_indicator(indicators.Low()),
+            close=self.add_indicator(indicators.Close()),
+            volume=self.add_indicator(indicators.Volume()),
+        )
+
+        # Hook for subclasses to register indicators without overriding __init__
+        self.setup()
+
+    def add_indicator(self, ind: indicators.Indicator) -> indicators.Indicator:
+        self._indicators.append(ind)
+        return ind
+
+    @property
+    def position(self) -> float:
+        return self._positions.get(self._current_symbol, 0.0)
+
+    @property
+    def avg_price(self) -> float:
+        return self._avg_prices.get(self._current_symbol, 0.0)
+
+    def submit_order(
+        self,
+        order_type: models.OrderType,
+        side: models.OrderSide,
+        quantity: float,
+        limit_price: float | None = None,
+        stop_price: float | None = None,
+    ) -> uuid.UUID:
+        # Uses bar timestamp for backtest compatibility; ts_created tracks real wall-clock time
+        order_id = uuid.uuid4()
+
+        event = events.OrderSubmission(
+            ts_event=self._current_ts,
+            system_order_id=order_id,
+            symbol=self._current_symbol,
+            order_type=order_type,
+            side=side,
+            quantity=quantity,
+            limit_price=limit_price,
+            stop_price=stop_price,
+        )
+
+        order = models.OrderRecord(
+            order_id=order_id,
+            symbol=self._current_symbol,
+            order_type=order_type,
+            side=side,
+            quantity=quantity,
+            limit_price=limit_price,
+            stop_price=stop_price,
+        )
+
+        self._submitted_orders[order_id] = order
+        self._publish(event)
+        return order_id
+
+    def submit_modification(
+        self,
+        order_id: uuid.UUID,
+        quantity: float | None = None,
+        limit_price: float | None = None,
+        stop_price: float | None = None,
+    ) -> bool:
+        original_order = self._pending_orders.get(order_id)
+        if original_order is None:
+            return False
+
+        event = events.OrderModification(
+            ts_event=self._current_ts,
+            system_order_id=order_id,
+            symbol=original_order.symbol,
+            quantity=quantity,
+            limit_price=limit_price,
+            stop_price=stop_price,
+        )
+
+        modified_order = models.OrderRecord(
+            order_id=order_id,
+            symbol=original_order.symbol,
+            order_type=original_order.order_type,
+            side=original_order.side,
+            quantity=quantity if quantity is not None else original_order.quantity,
+            limit_price=(
+                limit_price if limit_price is not None else original_order.limit_price
+            ),
+            stop_price=(
+                stop_price if stop_price is not None else original_order.stop_price
+            ),
+            filled_quantity=original_order.filled_quantity,
+        )
+
+        self._submitted_modifications[order_id] = modified_order
+        self._publish(event)
+        return True
+
+    def submit_cancellation(self, order_id: uuid.UUID) -> bool:
+        original_order = self._pending_orders.get(order_id)
+        if original_order is None:
+            return False
+
+        event = events.OrderCancellation(
+            ts_event=self._current_ts,
+            system_order_id=order_id,
+            symbol=original_order.symbol,
+        )
+
+        self._submitted_cancellations[order_id] = original_order
+        self._publish(event)
+        return True
+
+    def _on_event(self, event: events.EventBase) -> None:
+        match event:
+            case events.BarReceived() as bar_event:
+                self._on_bar_received(bar_event)
+            case events.OrderSubmissionAccepted() as accepted:
+                self._on_order_submission_accepted(accepted)
+            case events.OrderModificationAccepted() as accepted:
+                self._on_order_modification_accepted(accepted)
+            case events.OrderCancellationAccepted() as accepted:
+                self._on_order_cancellation_accepted(accepted)
+            case events.OrderSubmissionRejected() as rejected:
+                self._on_order_submission_rejected(rejected)
+            case events.OrderModificationRejected() as rejected:
+                self._on_order_modification_rejected(rejected)
+            case events.OrderCancellationRejected() as rejected:
+                self._on_order_cancellation_rejected(rejected)
+            case events.OrderFilled() as filled:
+                self._on_order_filled(filled)
+            case events.OrderExpired() as expired:
+                self._on_order_expired(expired)
+            case _:
+                return
+
+    def _on_bar_received(self, event: events.BarReceived) -> None:
+        if event.symbol not in self.symbols:
+            return
+        if event.bar_period != self.bar_period:
+            return
+
+        self._current_symbol = event.symbol
+        self._current_ts = event.ts_event
+
+        for ind in self._indicators:
+            ind.update(event)
+
+        self._emit_processed_bar(event)
+        self.on_bar(event)
+
+    def _emit_processed_bar(self, event: events.BarReceived) -> None:
+        ohlcv_names = {"OPEN", "HIGH", "LOW", "CLOSE", "VOLUME"}
+
+        indicator_values = {
+            f"{ind.plot_at:02d}_{ind.name}": ind.latest
+            for ind in self._indicators
+            if ind.name not in ohlcv_names
+        }
+
+        processed_bar = events.BarProcessed(
+            ts_event=event.ts_event,
+            symbol=event.symbol,
+            bar_period=event.bar_period,
+            open=event.open,
+            high=event.high,
+            low=event.low,
+            close=event.close,
+            volume=event.volume,
+            indicators=indicator_values,
+        )
+
+        self._publish(processed_bar)
+
+    def _on_order_submission_accepted(
+        self, event: events.OrderSubmissionAccepted
+    ) -> None:
+        order = self._submitted_orders.pop(event.associated_order_id, None)
+        if order is not None:
+            self._pending_orders[event.associated_order_id] = order
+
+    def _on_order_modification_accepted(
+        self, event: events.OrderModificationAccepted
+    ) -> None:
+        modified_order = self._submitted_modifications.pop(
+            event.associated_order_id, None
+        )
+        if modified_order is not None:
+            self._pending_orders[event.associated_order_id] = modified_order
+
+    def _on_order_cancellation_accepted(
+        self, event: events.OrderCancellationAccepted
+    ) -> None:
+        self._submitted_cancellations.pop(event.associated_order_id, None)
+        self._pending_orders.pop(event.associated_order_id, None)
+
+    def _on_order_submission_rejected(
+        self, event: events.OrderSubmissionRejected
+    ) -> None:
+        self._submitted_orders.pop(event.associated_order_id, None)
+
+    def _on_order_modification_rejected(
+        self, event: events.OrderModificationRejected
+    ) -> None:
+        self._submitted_modifications.pop(event.associated_order_id, None)
+
+    def _on_order_cancellation_rejected(
+        self, event: events.OrderCancellationRejected
+    ) -> None:
+        self._submitted_cancellations.pop(event.associated_order_id, None)
+
+    def _on_order_filled(self, event: events.OrderFilled) -> None:
+        # Track partial fills: only remove order when fully filled
+        order = self._pending_orders.get(event.associated_order_id)
+        if order:
+            order.filled_quantity += event.quantity_filled
+            if order.filled_quantity >= order.quantity:
+                self._pending_orders.pop(event.associated_order_id)
+
+        fill = models.FillRecord(
+            fill_id=event.fill_id,
+            order_id=event.associated_order_id,
+            symbol=event.symbol,
+            side=event.side,
+            quantity=event.quantity_filled,
+            price=event.fill_price,
+            commission=event.commission,
+            ts_event=event.ts_event,
+        )
+
+        self._fills.setdefault(event.symbol, []).append(fill)
+        self._update_position(event)
+
+    def _update_position(self, event: events.OrderFilled) -> None:
+        symbol = event.symbol
+        fill_qty = event.quantity_filled
+        fill_price = event.fill_price
+
+        signed_qty = 0.0
+        match event.side:
+            case models.OrderSide.BUY:
+                signed_qty = fill_qty
+            case models.OrderSide.SELL:
+                signed_qty = -fill_qty
+
+        old_pos = self._positions.get(symbol, 0.0)
+        old_avg = self._avg_prices.get(symbol, 0.0)
+        new_pos = old_pos + signed_qty
+
+        if new_pos == 0.0:
+            new_avg = 0.0
+        elif old_pos == 0.0:
+            new_avg = fill_price
+        elif (old_pos > 0 and signed_qty > 0) or (old_pos < 0 and signed_qty < 0):
+            new_avg = (old_avg * abs(old_pos) + fill_price * abs(signed_qty)) / abs(
+                new_pos
+            )
+        else:
+            if abs(new_pos) <= abs(old_pos):
+                new_avg = old_avg
+            else:
+                new_avg = fill_price
+
+        self._positions[symbol] = new_pos
+        self._avg_prices[symbol] = new_avg
+
+    def _on_order_expired(self, event: events.OrderExpired) -> None:
+        self._pending_orders.pop(event.associated_order_id, None)
+
+    # Override to register indicators. Called at end of __init__.
+    def setup(self) -> None:
+        pass
+
+    @abc.abstractmethod
+    def on_bar(self, event: events.BarReceived) -> None:
+        pass

onesecondtrader/core/strategies/examples.py

@@ -0,0 +1,35 @@
+from onesecondtrader.core import events, indicators, models
+from .base import StrategyBase
+
+
+class SMACrossover(StrategyBase):
+    fast_period: int = 20
+    slow_period: int = 100
+    quantity: float = 1.0
+
+    def setup(self) -> None:
+        self.fast_sma = self.add_indicator(
+            indicators.SimpleMovingAverage(period=self.fast_period)
+        )
+        self.slow_sma = self.add_indicator(
+            indicators.SimpleMovingAverage(period=self.slow_period)
+        )
+
+    def on_bar(self, event: events.BarReceived) -> None:
+        if (
+            self.fast_sma[-2] <= self.slow_sma[-2]
+            and self.fast_sma.latest > self.slow_sma.latest
+            and self.position <= 0
+        ):
+            self.submit_order(
+                models.OrderType.MARKET, models.OrderSide.BUY, self.quantity
+            )
+
+        if (
+            self.fast_sma[-2] >= self.slow_sma[-2]
+            and self.fast_sma.latest < self.slow_sma.latest
+            and self.position >= 0
+        ):
+            self.submit_order(
+                models.OrderType.MARKET, models.OrderSide.SELL, self.quantity
+            )

onesecondtrader/secmaster/__init__.py

@@ -0,0 +1,5 @@
+__all__ = [
+    "init_secmaster",
+]
+
+from onesecondtrader.secmaster.utils import init_secmaster

onesecondtrader/secmaster/schema.sql

@@ -0,0 +1,46 @@
+-- Security Master Database Schema
+--
+-- Stores instrument metadata and OHLCV market data. Prices are stored as
+-- fixed-point integers (scale factor $10^9$) to avoid floating-point errors.
+-- Timestamps are nanoseconds since Unix epoch.
+
+-- Data providers. Separated from instruments because the same symbol (e.g.,
+-- `ESH5`) may exist across multiple vendors with different `instrument_id`s.
+CREATE TABLE publishers (
+    publisher_id INTEGER PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE,
+    dataset TEXT NOT NULL,
+    venue TEXT
+);
+
+-- Security/instrument metadata. The UNIQUE constraint on (`publisher_id`, `raw_symbol`)
+-- allows the same symbol from different vendors while preventing duplicates.
+CREATE TABLE instruments (
+    instrument_id INTEGER PRIMARY KEY,
+    publisher_id INTEGER NOT NULL,
+    raw_symbol TEXT NOT NULL,
+    instrument_class TEXT NOT NULL DEFAULT 'K',
+    exchange TEXT,
+    currency TEXT DEFAULT 'USD',
+    min_price_increment INTEGER,
+    ts_recv INTEGER NOT NULL,
+    FOREIGN KEY (publisher_id) REFERENCES publishers(publisher_id),
+    UNIQUE(publisher_id, raw_symbol)
+);
+
+-- OHLCV bar data. The primary key order (`instrument_id`, `rtype`, `ts_event`) ensures
+-- bars for the same instrument/timeframe are contiguous on disk, making range
+-- queries fast. `WITHOUT ROWID` stores data directly in the primary key B-tree,
+-- eliminating the indirection of a separate rowid lookup.
+CREATE TABLE ohlcv (
+    instrument_id INTEGER NOT NULL,
+    rtype INTEGER NOT NULL,
+    ts_event INTEGER NOT NULL,
+    open INTEGER NOT NULL,
+    high INTEGER NOT NULL,
+    low INTEGER NOT NULL,
+    close INTEGER NOT NULL,
+    volume INTEGER NOT NULL,
+    FOREIGN KEY (instrument_id) REFERENCES instruments(instrument_id),
+    PRIMARY KEY (instrument_id, rtype, ts_event)
+) WITHOUT ROWID;

onesecondtrader/secmaster/utils.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+import pathlib
+import sqlite3
+
+
+def init_secmaster(db_path: pathlib.Path) -> None:
+    """Initialize a new secmaster database at the specified path.
+
+    Creates the database file with the schema defined in schema.sql (publishers, instruments,
+    and ohlcv tables) but does not populate any data.
+
+    Args:
+        db_path: Path where the database file will be created.
+
+    Raises:
+        FileExistsError: If a database already exists at the path.
+    """
+    if db_path.exists():
+        raise FileExistsError(f"Database already exists: {db_path}")
+    db_path.parent.mkdir(parents=True, exist_ok=True)
+    schema_path = pathlib.Path(__file__).parent / "schema.sql"
+    conn = sqlite3.connect(str(db_path))
+    conn.executescript(schema_path.read_text())
+    conn.commit()
+    conn.close()

{onesecondtrader-0.35.0.dist-info → onesecondtrader-0.36.0.dist-info}/METADATA

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

@@ -0,0 +1,62 @@
+onesecondtrader/__init__.py,sha256=bzV-SaWcDnq7os8pUtsaq8GAsBWjxBDhkFvRs3Z9FJw,1008
+onesecondtrader/brokers/__init__.py,sha256=YofzD0qlrfo_BzL6gwiHb9by7Webp36TQ_1O5EV0uzY,124
+onesecondtrader/brokers/base.py,sha256=b6Xq2gBUdy3RTpnUfpUiNSXwbuq_bRIjXJ-s89Xu7nE,1345
+onesecondtrader/brokers/simulated.py,sha256=pJvZ7b76xAs-NBbOX_v78IJgVrdnuTLCadqj8kYQ5sg,12694
+onesecondtrader/connectors/__init__.py,sha256=TDV1mXCkNVuMS8FQWRts_6FDwBEeNciMqYtZb8HNl2w,120
+onesecondtrader/connectors/brokers/__init__.py,sha256=O67ETIic6yrGDQp_wJSNTsjZ4Tt_3NGO3v4RJf3bm7Q,70
+onesecondtrader/connectors/brokers/simulated.py,sha256=ck0gWdz88KSyEMkiHW2CP0vuLrBELBTz3KveYIwbLuI,12722
+onesecondtrader/connectors/datafeeds/__init__.py,sha256=OzrPQcmdwzI6Fo8BONoWeJQtp0ttQ6TMYL6dUvvery4,113
+onesecondtrader/connectors/datafeeds/base.py,sha256=hpffDlv5Z92OZnL_B3vs_rRmq7uRU4HCf8N6IZkRxmM,482
+onesecondtrader/connectors/datafeeds/simulated.py,sha256=aMLSDu2CVaQcxxeWOcznFrfPgXq3icEB2rRe4KNK0Wg,3011
+onesecondtrader/core/__init__.py,sha256=5T2eAX4I_yo2ku9zywhFvl628kPTINxoLY92u7x_gy0,324
+onesecondtrader/core/brokers/__init__.py,sha256=mC-nNPdaT17oy-rjluwNvbKzxi5q8xxZ4mAkU7aJU0Y,55
+onesecondtrader/core/brokers/base.py,sha256=n82DHGvqkP9c4ATW8qT9yosPRoRQGUrs1oveGASdhlY,1350
+onesecondtrader/core/events/__init__.py,sha256=IOlFRdiOXz93SpvkpKL8wr1954d_8olKSB1n9mlTL3Y,898
+onesecondtrader/core/events/bases.py,sha256=g-ykq2jgcitIAueRurUlqAq0jINQwuhSWi_khAniPHw,662
+onesecondtrader/core/events/market.py,sha256=UY04TH6G-98NgYPEvBQSY92_ddeiT4yNwaUXnHdongQ,514
+onesecondtrader/core/events/requests.py,sha256=7cnt7TiuE7yl9ezFruIixY0v5A-mzZDWdoTBkAcVff0,836
+onesecondtrader/core/events/responses.py,sha256=biHIFa6usnsgSEX9bh2zOs1zB00I7HVSS01Dh_pZISE,1441
+onesecondtrader/core/indicators/__init__.py,sha256=hRg3FCP1FT7LYOLzztybWn48gTR5QvewzzdELPYbdoY,239
+onesecondtrader/core/indicators/averages.py,sha256=sCAIJrOYhtkwO5MkS2vx-4CfzHIVLJZpwYDzwv1GZ7Y,1905
+onesecondtrader/core/indicators/bar.py,sha256=9NUckrLO1AhyO3uTJlNCL2_Pqge58x5S_TcSz4qrk-c,1120
+onesecondtrader/core/indicators/base.py,sha256=_2pJ7PS0MRUz85UT0YpvzJ5V6ce60koT8MbjoerZ9eM,1894
+onesecondtrader/core/messaging/__init__.py,sha256=vMRDabHBgse_vZRTRFtnU8M8v2sY_o4pHjGzgu3hp3E,115
+onesecondtrader/core/messaging/eventbus.py,sha256=SaXLRoqz9tWBBlyEo0ry1HHr_8azj2U2dEaQEnr3PNo,1581
+onesecondtrader/core/messaging/subscriber.py,sha256=Sp77pB6bGyW57FlV0rdzAWy1Jv_nHA77YEtN64spZjs,2111
+onesecondtrader/core/models/__init__.py,sha256=7amHCQ6BAhHKps0ke63E-zh8IJNmkdDogZq-PfBukMs,249
+onesecondtrader/core/models/data.py,sha256=fBmddVl6EXYC5u2UnvQ59DXAXeZeIb48KP1ZdeTL52A,322
+onesecondtrader/core/models/orders.py,sha256=y6Ar-6fMqaOd_hRnRGvfWUF0Z13H_2hfTOW3ROOk0A8,254
+onesecondtrader/core/models/records.py,sha256=vdCWBtoDQs5R4iB_8_3fXkxWEvoCxOssk9XBnS4l7Vk,599
+onesecondtrader/core/strategies/__init__.py,sha256=Nq1n6HCdZ-GKkpn4WAlKxconPnOmeVKo0nhTk0J1ybA,121
+onesecondtrader/core/strategies/base.py,sha256=wZMjPu4sSMclvoyMptIZKllaqFkRrA06CZ5EG7uQ-Uo,11211
+onesecondtrader/core/strategies/examples.py,sha256=j4K092_qt0bcvajp-i4ugrGqzbaFebYX6rBbtZawtvE,1124
+onesecondtrader/dashboard/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+onesecondtrader/datafeeds/__init__.py,sha256=zSj1cQhBS-Z5271ICsmGc_zq-1fOd8yLQ7c4F0oJIVk,124
+onesecondtrader/datafeeds/base.py,sha256=bSIHBlZ8kbJ4rTZrUMiMgl8_j0Kqe6Eh2hNX5E3DhHU,477
+onesecondtrader/datafeeds/simulated.py,sha256=mbnEh0jjgZWRDhRLIASMbUpV1ybQktBA8opTv6nj33s,3006
+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/indicators/__init__.py,sha256=hRg3FCP1FT7LYOLzztybWn48gTR5QvewzzdELPYbdoY,239
+onesecondtrader/indicators/averages.py,sha256=DpRRdY5G5ze3jwNOV19PPjV6slA0IEeOOla67yChi2Y,1900
+onesecondtrader/indicators/bar.py,sha256=0H07mKNiUx5cE1fQvx1oPVY0R_MXcmAAgsLek175vTk,1115
+onesecondtrader/indicators/base.py,sha256=64HJD8JWBnUdR7PLd02N3hbNrRfKMjWHEKGeSyMRms8,1889
+onesecondtrader/messaging/__init__.py,sha256=vMRDabHBgse_vZRTRFtnU8M8v2sY_o4pHjGzgu3hp3E,115
+onesecondtrader/messaging/eventbus.py,sha256=Y8VbDZlEz8Q6KcCkfXRKsVIixsctBMRW1a5ANw297Ls,1576
+onesecondtrader/messaging/subscriber.py,sha256=ImpFmu5IstLXLoKVMaebmLp5MXN6225vHLdTL1ZOPvw,2106
+onesecondtrader/models/__init__.py,sha256=7amHCQ6BAhHKps0ke63E-zh8IJNmkdDogZq-PfBukMs,249
+onesecondtrader/models/data.py,sha256=fBmddVl6EXYC5u2UnvQ59DXAXeZeIb48KP1ZdeTL52A,322
+onesecondtrader/models/orders.py,sha256=y6Ar-6fMqaOd_hRnRGvfWUF0Z13H_2hfTOW3ROOk0A8,254
+onesecondtrader/models/records.py,sha256=vdCWBtoDQs5R4iB_8_3fXkxWEvoCxOssk9XBnS4l7Vk,599
+onesecondtrader/secmaster/__init__.py,sha256=HUpfkdWpz6t5YO0QgiEyM5MU32RQNGv9lfsvdE8HHZQ,96
+onesecondtrader/secmaster/schema.sql,sha256=NHHBb86cwZYtSZbOWlBgXd8dQsi5B26KZC-OR5sytAU,1802
+onesecondtrader/secmaster/utils.py,sha256=82DUBbzdGbNmQHewhC2qmcbbarnrr4g9PhEsucxbT4Y,831
+onesecondtrader/strategies/__init__.py,sha256=5TlEckz3RnwZTs1Isj0wJ_9Og5R9MMXBL90Vu9b45io,126
+onesecondtrader/strategies/base.py,sha256=kIi6by4Y8YuB9gPMPMr2Unm5_i9SGAANyiW2UaHiRO0,11206
+onesecondtrader/strategies/sma_crossover.py,sha256=s2u_uL_D5CrZTACiAbojnrLrLf4jqIPdfOCiNDEIsDA,1119
+onesecondtrader-0.36.0.dist-info/METADATA,sha256=BaNIEbmpAsU8S94iLlVRUiabpgeTIJ8p6BwBcyTQ78s,9682
+onesecondtrader-0.36.0.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
+onesecondtrader-0.36.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+onesecondtrader-0.36.0.dist-info/RECORD,,

onesecondtrader/observers/__init__.py

@@ -1,5 +0,0 @@
-__all__ = [
-    "CSVBookkeeper",
-]
-
-from .csvbookkeeper import CSVBookkeeper