py-backtesting-lib 0.1.0__py3-none-any.whl

Backtesting/execution/market_data.py

@@ -0,0 +1,108 @@
+# Backtesting/execution/market_data.py
+# Market data providers for the execution engine
+
+import csv
+from pathlib import Path
+from typing import Iterator, List
+from decimal import Decimal
+from datetime import datetime
+from ..definition import MarketBar, MarketDataProvider
+
+
+class CSVMarketDataProvider(MarketDataProvider):
+    """
+    Provides market data from a local CSV file.
+    Assumes columns: timestamp, open, high, low, close, volume
+    """
+    def __init__(
+        self,
+        csv_file_path: str,
+        symbol: str,
+        timestamp_col: str = "timestamp",
+        open_col: str = "open",
+        high_col: str = "high",
+        low_col: str = "low",
+        close_col: str = "close",
+        volume_col: str = "volume",
+    ):
+        self.path = Path(csv_file_path)
+        if not self.path.exists():
+            raise FileNotFoundError(f"Market data CSV file not found: {csv_file_path}")
+
+        self.symbol = symbol
+        self.ts_col = timestamp_col
+        self.o_col = open_col
+        self.h_col = high_col
+        self.l_col = low_col
+        self.c_col = close_col
+        self.v_col = volume_col
+
+        self.rows = []
+        with self.path.open(newline="", encoding="utf-8") as f:
+            reader = csv.DictReader(f)
+            required_cols = {self.ts_col, self.o_col, self.h_col, self.l_col, self.c_col, self.v_col}
+            missing = required_cols - set(reader.fieldnames or [])
+            if missing:
+                raise ValueError(
+                    f"CSV file {csv_file_path} is missing required columns: {missing}"
+                )
+
+            for line_num, row in enumerate(reader, start=2):
+                try:
+                    timestamp = datetime.fromisoformat(row[self.ts_col].strip())
+                except Exception as e:
+                    raise ValueError(
+                        f"Could not parse timestamp column '{self.ts_col}' in {csv_file_path} "
+                        f"on line {line_num}: {e}"
+                    )
+
+                self.rows.append({
+                    "timestamp": timestamp,
+                    "open": Decimal(str(row[self.o_col]).strip()),
+                    "high": Decimal(str(row[self.h_col]).strip()),
+                    "low": Decimal(str(row[self.l_col]).strip()),
+                    "close": Decimal(str(row[self.c_col]).strip()),
+                    "volume": Decimal(str(row[self.v_col]).strip()),
+                })
+
+        self.rows.sort(key=lambda x: x["timestamp"])
+
+    def get_bars(self) -> Iterator[MarketBar]:
+        """
+        Yields MarketBar objects from the loaded CSV data.
+        """
+        for row in self.rows:
+            yield MarketBar(
+                symbol=self.symbol,
+                timestamp=row["timestamp"],
+                open=row["open"],
+                high=row["high"],
+                low=row["low"],
+                close=row["close"],
+                volume=row["volume"],
+            )
+
+
+def create_dummy_market_data(num_bars: int, start_price: Decimal = Decimal("1.0000")) -> List[MarketBar]:
+    """
+    Creates a simple sequence of dummy market bars for testing.
+    Price increases by 0.0001 per bar.
+    """
+    bars = []
+    current_price = start_price
+
+    for i in range(num_bars):
+        timestamp = datetime(2022, 1, 1, i)
+        bar = MarketBar(
+            symbol="DUMMY",
+            timestamp=timestamp,
+            open=current_price,
+            high=current_price + Decimal("0.0001"),
+            low=current_price - Decimal("0.0001"),
+            close=current_price + Decimal("0.0001") * (i % 2),
+            volume=Decimal("1000"),
+        )
+        bars.append(bar)
+        current_price += Decimal("0.0001")
+
+    return bars

Backtesting/execution/pipeline.py

@@ -0,0 +1,105 @@
+# Backtesting/execution/pipeline.py
+# Coordinates the flow: Strategy -> Signal -> MM -> Order -> Broker -> Fill
+
+from decimal import Decimal
+from ..definition import EventType, SignalGenerated, OrderSubmitted, OrderFilled, OrderCancelled, FillExecuted, MarketBarReceived # Import specific events if needed
+from Backtesting.execution.event import EventBus
+from .books.order_book import OrderBook
+from .books.position_book import PositionBook
+from .books.trade_book import TradeBook
+from .portfolio import Portfolio
+from ..definition.core.domain_models import Fill, MarketBar # Import core models from definition
+from ..definition.plugins import Strategy, MoneyManager, Broker # Import plugin interfaces
+
+
+class ExecutionPipeline:
+    """
+    Orchestrates the core trading logic pipeline: Market Data -> Strategy -> Signal -> MM -> Order -> Broker -> Fill.
+    Integrates with Books, Portfolio, and EventBus.
+    """
+    def __init__(self, strategy: Strategy, money_manager: MoneyManager, broker: Broker,
+                 order_book: OrderBook, position_book: PositionBook, trade_book: TradeBook,
+                 portfolio: Portfolio, event_bus: EventBus):
+        self.strategy = strategy
+        self.money_manager = money_manager
+        self.broker = broker
+        self.order_book = order_book
+        self.position_book = position_book
+        self.trade_book = trade_book
+        self.portfolio = portfolio
+        self.event_bus = event_bus
+
+    def process_bar(self, bar: MarketBar):
+        """
+        Processes a single market bar through the entire pipeline.
+        """
+        # 1. Mark-to-market positions based on the new bar's price BEFORE generating signals
+        self.portfolio.update_market_price(bar, self.position_book)
+        self.position_book.update_market_price(bar)
+
+        # 2. Strategy generates signals based on the bar
+        signals = self.strategy.on_data(bar)
+
+        for signal in signals:
+            # 3. Emit SignalGenerated event
+            signal_event = SignalGenerated(signal=signal)
+            self.event_bus.publish(signal_event)
+
+            # 4. Money Manager sizes the signal into an order
+            # Pass current portfolio state if needed by MM
+            portfolio_state = {"cash": self.portfolio.cash} # Simplified state
+            orders = self.money_manager.size_order(signal, portfolio_state)
+
+            for order in orders:
+                # 5. Add order to OrderBook
+                self.order_book.add_order(order)
+
+                # 6. Emit OrderSubmitted event
+                order_event = OrderSubmitted(order=order)
+                self.event_bus.publish(order_event)
+
+                # 7. Broker simulates the order execution against the current bar
+                fills = self.broker.process_order(order, bar)
+
+                for fill in fills:
+                    # 8. Apply fill to books and portfolio
+                    self.apply_fill(fill)
+
+    def apply_fill(self, fill: Fill):
+        order = self.order_book.get_order_by_event(fill.order_id)
+        if not order:
+            print(f"Warning: Fill {fill.fill_id} references unknown order {fill.order_id}. Cannot archive trade.")
+            order = None
+
+        # Get position state *before* applying fill
+        position_before = Decimal('0')
+        existing_pos = self.position_book.get_position(fill.symbol)
+        if existing_pos:
+            position_before = existing_pos.net_size
+
+        # ✅ CAPTURE ENTRY PRICE BEFORE MUTATION
+        entry_price = existing_pos.avg_entry_price if existing_pos else Decimal('0')
+
+        # Apply fill to OrderBook
+        self.order_book.apply_fill(fill)
+
+        # Apply fill to PositionBook (this mutates the position, setting avg_entry_price to 0 if closed)
+        self.position_book.apply_fill(fill)
+
+        # Get position state *after* applying fill
+        position_after = Decimal('0')
+        updated_pos = self.position_book.get_position(fill.symbol)
+        if updated_pos:
+            position_after = updated_pos.net_size
+
+        # Apply fill to Portfolio
+        self.portfolio.apply_fill(fill)
+
+        # Archive trade if position closed (crossed zero)
+        if order and (position_before > 0 and position_after <= 0) or (position_before < 0 and position_after >= 0):
+            # Use the captured entry_price (not mutated)
+            self.trade_book.apply_fill(fill, order, position_before, position_after, entry_price)
+
+        # Emit FillExecuted event
+        fill_event = FillExecuted(fill=fill)
+        self.event_bus.publish(fill_event)

Backtesting/execution/portfolio.py

@@ -0,0 +1,72 @@
+
+from decimal import Decimal
+from .books import PositionBook
+from ..definition import Fill as EventFill, MarketBar as EventMarketBar, OrderSide
+
+class Portfolio:
+    """
+    Tracks the account's financial state: cash, equity, margin usage.
+    Equity is a derived value: cash + sum(unrealized_pnl of all positions).
+    State is updated only via the apply_* methods, driven by events from the EventBus.
+    """
+    def __init__(self, initial_cash: Decimal):
+        self._initial_cash = initial_cash
+        self._cash = initial_cash
+        self._margin_used = Decimal('0') # Placeholder for future margin calculation logic
+
+    def apply_fill(self, fill: EventFill):
+        """
+        Updates the cash balance based on a Fill event (cost of purchase or proceeds from sale).
+        Commission is subtracted from cash.
+        """
+        # Calculate the cost/proceeds of the fill
+        fill_value = fill.quantity * fill.fill_price
+        if fill.side == OrderSide.BUY:
+            # Buying reduces cash: fill cost + commission
+            self._cash -= fill_value + fill.commission
+            print(f"DEBUG: Portfolio cash decreased by {fill_value + fill.commission} (value {fill_value} + commission {fill.commission}) due to buy fill. New cash: {self._cash}")
+        elif fill.side == OrderSide.SELL:
+            # Selling increases cash: fill proceeds - commission
+            self._cash += fill_value - fill.commission
+            print(f"DEBUG: Portfolio cash increased by {fill_value - fill.commission} (value {fill_value} - commission {fill.commission}) due to sell fill. New cash: {self._cash}")
+
+    def update_market_price(self, bar: EventMarketBar, position_book: PositionBook):
+        """
+        Updates the total equity by marking positions to market.
+        Does not directly change cash.
+        Requires the PositionBook to get unrealized PnL.
+        """
+        # Equity = Cash + Unrealized PnL from all positions
+        # The cash component remains unchanged here.
+        # The unrealized PnL is updated within the PositionBook itself via its update_market_price method.
+        # Therefore, calculating equity involves summing the UPLs from the PositionBook.
+        unrealized_pnl_total = Decimal('0')
+        for position in position_book.get_all_positions().values():
+            unrealized_pnl_total += position.unrealized_pnl
+
+        equity = self._cash + unrealized_pnl_total
+        print(f"DEBUG: Portfolio equity updated to {equity} (Cash: {self._cash}, UPL: {unrealized_pnl_total})")
+
+    @property
+    def cash(self) -> Decimal:
+        """Read-only property for the current cash balance."""
+        return self._cash
+
+    def get_equity(self, position_book: PositionBook) -> Decimal:
+        """
+        Calculates and returns the total equity.
+        Equity = Cash + Unrealized PnL from all open positions.
+        Requires the PositionBook to get unrealized PnL.
+        """
+        unrealized_pnl_total = Decimal('0')
+        for position in position_book.get_all_positions().values():
+            unrealized_pnl_total += position.unrealized_pnl
+        return self._cash + unrealized_pnl_total
+
+    def get_margin_usage(self) -> Decimal:
+        """Placeholder for margin calculation."""
+        return self._margin_used
+
+    def get_initial_cash(self) -> Decimal:
+        """Returns the initial cash balance."""
+        return self._initial_cash

Backtesting/experiments/base.yaml

@@ -0,0 +1,32 @@
+# experiments/beta_test.yaml
+experiment:
+  name: "Beta Test - SMA Crossover Synthetic"
+  metadata:
+    author: "Zhiro"
+    version: "1.0"
+
+  configs:
+    strategy:
+      name: "SMA_Crossover_Strategy"
+      params:
+        fast_period: 5
+        slow_period: 10
+        symbol: "DUMMY"
+
+    money_management:
+      name: "Fixed_Qty_MoneyManager"
+      params:
+        trade_quantity: 10.0
+
+    broker:
+      name: "Simple_Market_Broker"
+      params:
+        commission_per_trade: 1.50
+        initial_capital: 100000
+
+    market_data:
+      name: "Dummy_Market_Data"
+      params:
+        num_bars: 300
+        symbol: "DUMMY"
+        start_price: 100.0

Backtesting/main.py

@@ -0,0 +1,148 @@
+
+import typer
+import uuid
+from pathlib import Path
+from datetime import datetime
+from decimal import Decimal
+from .definition import Experiment
+from .definition.plugins.plugin_registry import resolve, PluginNotFoundError
+from .execution.engine import ExecutionEngine
+from .execution.market_data import CSVMarketDataProvider
+from .analysis.result import ExperimentResult
+from .analysis.reports.console_report import ConsoleTradeReport
+from .analysis.persistence.event_sink import DuckDBEventSink
+from .definition import Trade
+from . import plugins   # it will initialize default plugins
+
+app = typer.Typer()
+
+@app.command()
+def run(config_file: str = typer.Option(..., "--config", "-c", help="Path to the experiment YAML configuration file.")):
+    """
+    Runs a backtesting experiment defined by the given YAML file.
+    """
+    config_path = Path(config_file)
+    if not config_path.exists():
+        typer.echo(f"Error: Configuration file not found: {config_file}", err=True)
+        raise typer.Exit(code=1)
+
+    try:
+        # 1. Load and validate the experiment definition
+        experiment_def = Experiment.from_yaml(config_file)
+        experiment_def.validate()
+        print(f"Loaded experiment: {experiment_def.name}")
+
+        # 2. Resolve plugin classes
+        strategy_cls = resolve(experiment_def.strategy_config.name)
+        mm_cls = resolve(experiment_def.money_management_config.name)
+        broker_cls = resolve(experiment_def.broker_config.name)
+        market_data_cls = resolve(experiment_def.market_data_config.name)
+
+        strategy_params = experiment_def.strategy_config.params or {}
+        mm_params = experiment_def.money_management_config.params or {}
+        broker_params = experiment_def.broker_config.params or {}
+        market_data_params = experiment_def.market_data_config.params or {}
+
+        # Instantiate plugins
+        strategy = strategy_cls()
+        money_manager = mm_cls()
+        broker = broker_cls()
+
+        market_data_provider = market_data_cls(**market_data_params)
+
+        # Initialize plugins with their guaranteed-dict configs
+        strategy.initialize(strategy_params)
+        money_manager.initialize(mm_params)
+        broker.initialize(broker_params)
+
+        # 3. Extract initial capital safely using the guaranteed dict
+        initial_capital = Decimal(str(broker_params.get('initial_capital', 100000)))
+
+        # 4. Create unique run ID and start timestamp
+        run_id = str(uuid.uuid4())
+        start_time = datetime.now()
+
+        # 5. Initialize Event Sink and subscribe to the engine's event bus
+        event_sink = DuckDBEventSink()
+
+        engine = ExecutionEngine(
+            strategy=strategy,
+            money_manager=money_manager,
+            broker=broker,
+            initial_cash=initial_capital,
+            market_data_provider=market_data_provider
+        )
+        event_sink.subscribe_to_engine(engine.event_bus, run_id) # Pass the bus from the engine instance
+
+        # 6. Run the engine
+        print("Starting backtest...")
+        engine.run()
+        end_time = datetime.now()
+        print("Backtest completed.")
+
+        # 7. Construct the ExperimentResult aggregate
+        # Final state snapshots
+        portfolio_snap = {
+            "cash": engine.portfolio.cash,
+            "equity": engine.portfolio.get_equity(engine.position_book),
+            "margin_used": engine.portfolio.get_margin_usage(),
+            "initial_cash": engine.portfolio.get_initial_cash()
+        }
+
+        pos_snap = {}
+        for symbol, pos in engine.position_book.get_all_positions().items():
+            pos_snap[symbol] = {
+                "net_size": pos.net_size,
+                "avg_entry_price": pos.avg_entry_price,
+                "unrealized_pnl": pos.unrealized_pnl
+            }
+
+        trade_snap = [trade.__dict__ for trade in engine.trade_book.get_closed_trades()] # Serialize Trade objects
+
+        event_log_query_result = event_sink.query_events(experiment_id=run_id).fetchall()
+
+        event_log_serialized = [
+            {"id": row[0], "experiment_id": row[1], "timestamp": row[2], "type": row[3], "data": row[4]}
+            for row in event_log_query_result
+        ]
+
+
+        result = ExperimentResult(
+            experiment_id=run_id,
+            experiment_name=experiment_def.name,
+            started_at=start_time,
+            finished_at=end_time,
+            portfolio_snapshot=portfolio_snap,
+            position_book_snapshot=pos_snap,
+            trade_book_snapshot=trade_snap,
+            event_log=event_log_serialized # Note: This fetches from DB, which might be redundant if DB is primary output
+        )
+
+        # 8. Generate and print the report
+        report = ConsoleTradeReport()
+        report.generate_report(result)
+
+        # 9. Close resources
+        event_sink.close_connection()
+
+        print(f"\nExperiment '{experiment_def.name}' (ID: {run_id}) completed successfully.")
+        print(f"Results summary printed to console.")
+        print(f"Full event log persisted to database.")
+
+    except FileNotFoundError as e:
+        typer.echo(f"Error: {e}", err=True)
+        raise typer.Exit(code=1)
+    except ValueError as e: # Catch errors from CSV provider, YAML parsing, etc.
+        typer.echo(f"Configuration Error: {e}", err=True)
+        raise typer.Exit(code=1)
+    except PluginNotFoundError as e:
+        typer.echo(f"Plugin Error: {e}", err=True)
+        raise typer.Exit(code=1)
+    except Exception as e:
+        typer.echo(f"An unexpected error occurred during execution: {e}", err=True)
+        typer.echo("Check logs for details.", err=True)
+        raise typer.Exit(code=1) # Propagate to trigger fail-fast behavior
+
+
+if __name__ == "__main__":
+    app()

Backtesting/plugins/__init__.py

@@ -0,0 +1,13 @@
+# plugins/__init__.py
+from Backtesting.definition.plugins.plugin_registry import register
+
+from .strategies import SMACrossoverStrategy
+from .money_managers import FixedQtyMoneyManager
+from .brokers import SimpleMarketBroker
+from .market_data import DummyMarketDataProvider
+
+# Register all plugins so the Experiment Aggregate can resolve them
+register("SMA_Crossover_Strategy", SMACrossoverStrategy)
+register("Fixed_Qty_MoneyManager", FixedQtyMoneyManager)
+register("Simple_Market_Broker", SimpleMarketBroker)
+register("Dummy_Market_Data", DummyMarketDataProvider)

Backtesting/plugins/brokers/__init__.py

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

Backtesting/plugins/brokers/instant_market_fill.py

@@ -0,0 +1,26 @@
+from decimal import Decimal
+from typing import List
+import uuid
+from Backtesting.definition.plugins import Broker
+from Backtesting.definition.core.domain_models import Order, MarketBar, Fill
+
+class SimpleMarketBroker(Broker):
+    def initialize(self, config: dict):
+        self.commission = Decimal(str(config.get('commission_per_trade', '1.50')))
+
+    def reset(self):
+        pass
+
+    def process_order(self, order: Order, current_market_bar: MarketBar) -> List[Fill]:
+        # Simple market fill at the current bar's close price
+        fill = Fill(
+            fill_id=str(uuid.uuid4()),
+            order_id=order.order_id,
+            symbol=order.symbol,
+            side=order.side,
+            quantity=order.quantity,
+            fill_price=current_market_bar.close,
+            fill_time=current_market_bar.timestamp,
+            commission=self.commission
+        )
+        return [fill]

Backtesting/plugins/market_data/__init__.py

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

Backtesting/plugins/market_data/dummy_data_provider.py

@@ -0,0 +1,32 @@
+import math
+from decimal import Decimal
+from datetime import datetime, timedelta
+from typing import Iterator
+from Backtesting.execution.market_data import MarketDataProvider
+from Backtesting.definition.core.domain_models import MarketBar
+
+
+class DummyMarketDataProvider(MarketDataProvider):
+    """Generates a synthetic sine-wave market to guarantee SMA crossovers."""
+
+    def __init__(self, num_bars: int = 50, symbol: str = "DUMMY", start_price: Decimal = Decimal("100.0"), **kwargs):
+        self.num_bars = int(num_bars)
+        self.symbol = symbol
+        self.start_price = Decimal(str(start_price))
+
+    def get_bars(self) -> Iterator[MarketBar]:
+        base_time = datetime(2023, 1, 1)
+        for i in range(self.num_bars):
+            # Create a predictable wave: goes up, then down, triggering crossovers
+            trend = math.sin(i / 4.0) * 15
+            price = self.start_price + Decimal(str(trend))
+
+            yield MarketBar(
+                symbol=self.symbol,
+                timestamp=base_time + timedelta(hours=i),
+                open=price,
+                high=price + Decimal("1.0"),
+                low=price - Decimal("1.0"),
+                close=price,
+                volume=Decimal("1000")
+            )

Backtesting/plugins/money_managers/__init__.py

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

Backtesting/plugins/money_managers/fixed_quality.py

@@ -0,0 +1,36 @@
+from decimal import Decimal
+from typing import List
+import uuid
+from Backtesting.definition.plugins import MoneyManager
+from Backtesting.definition.core.domain_models import Signal, Order, OrderType, OrderSide, OrderStatus, SignalType
+
+class FixedQtyMoneyManager(MoneyManager):
+    def initialize(self, config: dict):
+        self.trade_quantity = Decimal(str(config.get('trade_quantity', '10.0')))
+
+    def reset(self):
+        pass
+
+    def size_order(self, signal: Signal, current_portfolio_state: dict) -> List[Order]:
+        if signal.signal_type == SignalType.BUY_LONG:
+            side = OrderSide.BUY
+        elif signal.signal_type == SignalType.EXIT_LONG:
+            side = OrderSide.SELL
+        else:
+            return [] # Ignore shorts for this simple beta test
+
+        order = Order(
+            order_id=str(uuid.uuid4()),
+            signal_id=signal.id,
+            symbol=signal.symbol,
+            order_type=OrderType.MARKET,
+            side=side,
+            quantity=self.trade_quantity,
+            price=None,
+            stop_price=None,
+            status=OrderStatus.SUBMITTED,
+            filled_quantity=Decimal('0'),
+            average_fill_price=Decimal('0'),
+            commission=Decimal('0')
+        )
+        return [order]

Backtesting/plugins/strategies/SMA_crossovr.py

@@ -0,0 +1,52 @@
+from collections import deque
+from decimal import Decimal
+from typing import List
+import uuid
+from Backtesting.definition.plugins import Strategy
+from Backtesting.definition.core.domain_models import MarketBar, Signal, SignalType
+
+
+class SMACrossoverStrategy(Strategy):
+    def initialize(self, config: dict):
+        self.fast_period = int(config.get('fast_period', 5))
+        self.slow_period = int(config.get('slow_period', 10))
+        self.symbol = config.get('symbol', 'DUMMY')
+
+        self.prices = deque(maxlen=self.slow_period)
+        self.prev_fast_sma = None
+        self.prev_slow_sma = None
+
+    def reset(self):
+        self.prices.clear()
+        self.prev_fast_sma = None
+        self.prev_slow_sma = None
+
+    def on_data(self, bar: MarketBar) -> List[Signal]:
+        self.prices.append(bar.close)
+
+        # Wait until we have enough data to calculate the slow SMA
+        if len(self.prices) < self.slow_period:
+            return []
+
+        # Calculate SMAs using Decimal math to prevent drift
+        fast_sma = sum(list(self.prices)[-self.fast_period:], Decimal('0')) / self.fast_period
+        slow_sma = sum(self.prices, Decimal('0')) / self.slow_period
+
+        signals = []
+        if self.prev_fast_sma is not None and self.prev_slow_sma is not None:
+            # Golden Cross (Buy)
+            if self.prev_fast_sma <= self.prev_slow_sma and fast_sma > slow_sma:
+                signals.append(Signal(
+                    id=str(uuid.uuid4()), symbol=self.symbol,
+                    signal_type=SignalType.BUY_LONG, strength=Decimal('1.0')
+                ))
+            # Death Cross (Exit)
+            elif self.prev_fast_sma >= self.prev_slow_sma and fast_sma < slow_sma:
+                signals.append(Signal(
+                    id=str(uuid.uuid4()), symbol=self.symbol,
+                    signal_type=SignalType.EXIT_LONG, strength=Decimal('1.0')
+                ))
+
+        self.prev_fast_sma = fast_sma
+        self.prev_slow_sma = slow_sma
+        return signals

Backtesting/plugins/strategies/__init__.py

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