riskoptima 2.3.0__tar.gz → 2.3.2__tar.gz

{riskoptima-2.3.0 → riskoptima-2.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: riskoptima
-Version: 2.3.0
+Version: 2.3.2
 Summary: RiskOptima is a powerful Python toolkit for financial risk analysis, portfolio optimization, and advanced quantitative modeling. It integrates state-of-the-art methodologies, including Monte Carlo simulations, Value at Risk (VaR), Conditional VaR (CVaR), Black-Scholes, Heston, and Merton Jump Diffusion models, to aid investors in making data-driven investment decisions.
 Home-page: https://github.com/JordiCorbilla/RiskOptima
 License: MIT
@@ -108,6 +108,25 @@ equity_curve, weights_history = run_backtest(prices, strategy, config, cost_mode
 
 See `examples/example_factor_backtest.py` for a runnable end-to-end example.
 
+### SMA Crossover Strategy
+
+RiskOptima includes reusable SMA crossover helpers for a simple long-only trend-following workflow. The short moving average crossing above the long moving average creates an entry signal; a bearish cross, stop loss, or take profit closes the trade.
+
+```python
+from riskoptima.backtest import build_sma_signal_frame, run_sma_strategy_with_risk
+
+signals = build_sma_signal_frame(prices[["Close"]], short_window=20, long_window=50)
+trades = run_sma_strategy_with_risk(
+    "SPY",
+    start="2024-01-01",
+    end="2025-01-01",
+    stop_loss=0.05,
+    take_profit=0.10,
+)
+```
+
+The notebook `05-portfolio_sma_strategy.ipynb` shows single-asset, equal-weight multi-asset, and custom-weight portfolio runs.
+
 ### Offline sample datasets
 
 RiskOptima includes small synthetic datasets for deterministic examples:

{riskoptima-2.3.0 → riskoptima-2.3.2}/README.md

@@ -80,6 +80,25 @@ equity_curve, weights_history = run_backtest(prices, strategy, config, cost_mode
 
 See `examples/example_factor_backtest.py` for a runnable end-to-end example.
 
+### SMA Crossover Strategy
+
+RiskOptima includes reusable SMA crossover helpers for a simple long-only trend-following workflow. The short moving average crossing above the long moving average creates an entry signal; a bearish cross, stop loss, or take profit closes the trade.
+
+```python
+from riskoptima.backtest import build_sma_signal_frame, run_sma_strategy_with_risk
+
+signals = build_sma_signal_frame(prices[["Close"]], short_window=20, long_window=50)
+trades = run_sma_strategy_with_risk(
+    "SPY",
+    start="2024-01-01",
+    end="2025-01-01",
+    stop_loss=0.05,
+    take_profit=0.10,
+)
+```
+
+The notebook `05-portfolio_sma_strategy.ipynb` shows single-asset, equal-weight multi-asset, and custom-weight portfolio runs.
+
 ### Offline sample datasets
 
 RiskOptima includes small synthetic datasets for deterministic examples:

{riskoptima-2.3.0 → riskoptima-2.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "riskoptima"
-version = "2.3.0"
+version = "2.3.2"
 description = "RiskOptima is a powerful Python toolkit for financial risk analysis, portfolio optimization, and advanced quantitative modeling. It integrates state-of-the-art methodologies, including Monte Carlo simulations, Value at Risk (VaR), Conditional VaR (CVaR), Black-Scholes, Heston, and Merton Jump Diffusion models, to aid investors in making data-driven investment decisions."
 authors = ["Jordi Corbilla <jordi.coll.corbilla@gmail.com>"]
 license = "MIT"

{riskoptima-2.3.0 → riskoptima-2.3.2}/riskoptima/__init__.py

@@ -11,7 +11,7 @@
 #----------------------------------------------------------------------------
 # Created By  : Jordi Corbilla
 # Created Date: 2025
-# version ='2.3.0'
+# version ='2.3.2'
 # ---------------------------------------------------------------------------
 
 from .riskoptima import RiskOptima
@@ -19,6 +19,7 @@ from .core import MarketData, Portfolio, BacktestConfig, RiskReport
 from .risk import FactorRiskModel
 from .optim import Constraints, optimize_max_sharpe, optimize_min_variance, SimpleCostModel
 from .backtest import run_backtest, Strategy, SMACrossStrategy, PortfolioState
+from .backtest import build_sma_signal_frame, run_sma_strategy_with_risk
 from .credit import expected_loss, credit_var, merton_pd
 from .reporting import build_market_risk_report
 from .options import black_scholes_price, black_scholes_greeks, implied_volatility
@@ -38,6 +39,8 @@ __all__ = [
     "Strategy",
     "SMACrossStrategy",
     "PortfolioState",
+    "build_sma_signal_frame",
+    "run_sma_strategy_with_risk",
     "expected_loss",
     "credit_var",
     "merton_pd",

riskoptima-2.3.2/riskoptima/backtest/__init__.py

@@ -0,0 +1,34 @@
+###############################################################################
+#                                 __init__.py                                  
+###############################################################################
+# Product: RiskOptima
+# Author: Jordi Corbilla
+# Description: RiskOptima module
+###############################################################################
+
+from .engine import run_backtest
+from .strategy import Strategy, SMACrossStrategy
+from .portfolio import PortfolioState
+from .sma import (
+    build_sma_signal_frame,
+    trades_from_sma_signals,
+    run_sma_strategy_with_risk,
+    run_strategy_on_portfolio,
+    run_and_plot_sma_strategy,
+    plot_sma_strategy_cumulative_return,
+    plot_sma_strategy_trades,
+)
+
+__all__ = [
+    "run_backtest",
+    "Strategy",
+    "SMACrossStrategy",
+    "PortfolioState",
+    "build_sma_signal_frame",
+    "trades_from_sma_signals",
+    "run_sma_strategy_with_risk",
+    "run_strategy_on_portfolio",
+    "run_and_plot_sma_strategy",
+    "plot_sma_strategy_cumulative_return",
+    "plot_sma_strategy_trades",
+]

riskoptima-2.3.2/riskoptima/backtest/sma.py

@@ -0,0 +1,302 @@
+###############################################################################
+#                                    sma.py
+###############################################################################
+# Product: RiskOptima
+# Author: Jordi Corbilla
+# Description: SMA crossover helpers
+###############################################################################
+
+from __future__ import annotations
+
+from datetime import datetime
+import os
+from typing import Iterable
+
+import numpy as np
+import pandas as pd
+
+
+TRADE_COLUMNS = [
+    "Ticker",
+    "Entry Date",
+    "Exit Date",
+    "Entry Price",
+    "Exit Price",
+    "Return",
+    "Exit Reason",
+]
+
+PORTFOLIO_TRADE_COLUMNS = TRADE_COLUMNS + ["Weight", "Weighted Return"]
+
+
+def _close_frame(prices) -> pd.DataFrame:
+    data = pd.DataFrame(prices).copy()
+    if isinstance(data.columns, pd.MultiIndex):
+        if "Close" in data.columns.get_level_values(0):
+            close_data = data.xs("Close", axis=1, level=0)
+        elif "Close" in data.columns.get_level_values(-1):
+            close_data = data.xs("Close", axis=1, level=-1)
+        else:
+            raise ValueError("prices must contain a Close column or a single price column")
+        data = close_data.iloc[:, [0]].copy()
+        data.columns = ["Close"]
+    elif "Close" in data.columns:
+        data = data[["Close"]].copy()
+    elif data.shape[1] == 1:
+        data.columns = ["Close"]
+    else:
+        raise ValueError("prices must contain a Close column or a single price column")
+    data["Close"] = pd.to_numeric(data["Close"], errors="coerce")
+    return data.dropna(subset=["Close"])
+
+
+def download_close_prices(ticker: str, start: str, end: str) -> pd.DataFrame:
+    """
+    Downloads close prices with yfinance.
+    """
+    import yfinance as yf
+
+    return yf.download(ticker, start=start, end=end, progress=False, auto_adjust=False)[["Close"]].copy()
+
+
+def build_sma_signal_frame(prices, short_window: int = 20, long_window: int = 50) -> pd.DataFrame:
+    """
+    Builds close, SMA, and crossover signal columns.
+
+    Signal is +1 on bullish short-over-long crosses, -1 on bearish crosses, and 0 otherwise.
+    """
+    if short_window <= 0 or long_window <= 0:
+        raise ValueError("short_window and long_window must be positive")
+    if short_window >= long_window:
+        raise ValueError("short_window must be smaller than long_window")
+
+    df = _close_frame(prices)
+    df[f"SMA{short_window}"] = df["Close"].rolling(short_window).mean()
+    df[f"SMA{long_window}"] = df["Close"].rolling(long_window).mean()
+
+    short_ma = df[f"SMA{short_window}"]
+    long_ma = df[f"SMA{long_window}"]
+    bullish = (short_ma > long_ma) & (short_ma.shift(1) <= long_ma.shift(1))
+    bearish = (short_ma < long_ma) & (short_ma.shift(1) >= long_ma.shift(1))
+
+    df["Signal"] = 0
+    df.loc[bullish, "Signal"] = 1
+    df.loc[bearish, "Signal"] = -1
+    return df
+
+
+def trades_from_sma_signals(
+    signal_frame: pd.DataFrame,
+    ticker: str,
+    stop_loss: float = None,
+    take_profit: float = None,
+) -> pd.DataFrame:
+    """
+    Converts SMA entry/exit signals into a long-only trade log.
+    """
+    required = {"Close", "Signal"}
+    missing = required - set(signal_frame.columns)
+    if missing:
+        raise ValueError(f"signal_frame is missing required columns: {sorted(missing)}")
+
+    trades = []
+    position = None
+    entry_price = None
+    entry_date = None
+
+    for exit_date, row in signal_frame.iterrows():
+        price = float(row["Close"])
+        signal = int(row["Signal"])
+
+        if position is None and signal == 1:
+            position = "long"
+            entry_price = price
+            entry_date = exit_date
+        elif position == "long":
+            pnl = (price - entry_price) / entry_price
+            hit_stop = stop_loss is not None and pnl <= -stop_loss
+            hit_take = take_profit is not None and pnl >= take_profit
+
+            if signal == -1 or hit_stop or hit_take:
+                trades.append(
+                    {
+                        "Ticker": ticker,
+                        "Entry Date": entry_date,
+                        "Exit Date": exit_date,
+                        "Entry Price": entry_price,
+                        "Exit Price": price,
+                        "Return": pnl,
+                        "Exit Reason": (
+                            "Sell Signal" if signal == -1 else "Stop Loss" if hit_stop else "Take Profit"
+                        ),
+                    }
+                )
+                position = None
+
+    return pd.DataFrame(trades, columns=TRADE_COLUMNS)
+
+
+def run_sma_strategy_with_risk(
+    ticker: str,
+    start: str,
+    end: str,
+    stop_loss: float = None,
+    take_profit: float = None,
+    short_window: int = 20,
+    long_window: int = 50,
+    prices: pd.DataFrame = None,
+) -> pd.DataFrame:
+    """
+    Runs an SMA crossover strategy for one ticker and returns a trade log.
+    """
+    price_data = prices if prices is not None else download_close_prices(ticker, start, end)
+    signals = build_sma_signal_frame(price_data, short_window=short_window, long_window=long_window)
+    return trades_from_sma_signals(signals, ticker=ticker, stop_loss=stop_loss, take_profit=take_profit)
+
+
+def run_strategy_on_portfolio(
+    asset_table: pd.DataFrame,
+    start: str,
+    end: str,
+    stop_loss: float = None,
+    take_profit: float = None,
+    short_window: int = 20,
+    long_window: int = 50,
+) -> pd.DataFrame:
+    """
+    Runs the SMA strategy across an asset table with Asset and Weight columns.
+    """
+    if not {"Asset", "Weight"}.issubset(asset_table.columns):
+        raise ValueError("asset_table must contain Asset and Weight columns")
+
+    results = []
+    for _, row in asset_table.iterrows():
+        trades_df = run_sma_strategy_with_risk(
+            row["Asset"],
+            start,
+            end,
+            stop_loss=stop_loss,
+            take_profit=take_profit,
+            short_window=short_window,
+            long_window=long_window,
+        )
+        if trades_df.empty:
+            continue
+        trades_df["Weight"] = row["Weight"]
+        trades_df["Weighted Return"] = trades_df["Return"] * row["Weight"]
+        results.append(trades_df)
+
+    if not results:
+        return pd.DataFrame(columns=PORTFOLIO_TRADE_COLUMNS)
+
+    all_trades = pd.concat(results, ignore_index=True)
+    return all_trades.sort_values(by="Entry Date")
+
+
+def plot_sma_strategy_cumulative_return(trade_log: pd.DataFrame, title="Portfolio Return"):
+    """
+    Plots cumulative weighted returns from an SMA trade log.
+    """
+    import matplotlib.pyplot as plt
+
+    fig, ax = plt.subplots(figsize=(20, 12))
+
+    if not trade_log.empty:
+        trade_log = trade_log.sort_values("Exit Date").copy()
+        trade_log["Cumulative Return"] = (1 + trade_log["Weighted Return"]).cumprod()
+        plt.plot(trade_log["Exit Date"], trade_log["Cumulative Return"], marker="o")
+
+    plt.title(title)
+    plt.xlabel("Date")
+    plt.ylabel("Cumulative Return")
+    plt.grid(alpha=0.3)
+    plt.text(
+        0.995,
+        -0.20,
+        "Created by RiskOptima",
+        fontsize=12,
+        color="gray",
+        alpha=0.7,
+        transform=ax.transAxes,
+        ha="right",
+    )
+    plt.tight_layout()
+    plt.show()
+
+
+def plot_sma_strategy_trades(signal_frame: pd.DataFrame, ticker: str):
+    """
+    Plots close prices, SMA bands, and buy/sell markers.
+    """
+    import matplotlib.pyplot as plt
+
+    df = signal_frame.copy()
+    sma_cols = [col for col in df.columns if col.startswith("SMA")]
+
+    fig, ax = plt.subplots(figsize=(20, 12))
+    plt.plot(df.index, df["Close"], label="Close Price", alpha=0.5)
+    for col in sma_cols:
+        plt.plot(df.index, df[col], label=col, alpha=0.8)
+
+    plt.scatter(df.index[df["Signal"] == 1], df["Close"][df["Signal"] == 1], marker="^", color="green", s=100, label="Buy Signal")
+    plt.scatter(df.index[df["Signal"] == -1], df["Close"][df["Signal"] == -1], marker="v", color="red", s=100, label="Sell Signal")
+    plt.title(f"{ticker} - SMA Strategy with Signals")
+    plt.xlabel("Date")
+    plt.ylabel("Price")
+    plt.legend()
+    plt.grid(alpha=0.3)
+    plt.tight_layout()
+
+    plots_folder = "plots"
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    if not os.path.exists(plots_folder):
+        os.makedirs(plots_folder)
+    plot_path = os.path.join(plots_folder, f"riskoptima_sma_strategy_{timestamp}.png")
+    plt.savefig(plot_path, dpi=150, bbox_inches="tight")
+    plt.show()
+
+
+def normalize_asset_table(tickers) -> pd.DataFrame:
+    """
+    Normalizes a ticker string, ticker list, or asset table into Asset/Weight rows.
+    """
+    if isinstance(tickers, str):
+        return pd.DataFrame([{"Asset": tickers, "Weight": 1.0}])
+    if isinstance(tickers, Iterable) and not isinstance(tickers, pd.DataFrame):
+        tickers = list(tickers)
+        return pd.DataFrame([{"Asset": ticker, "Weight": 1.0 / len(tickers)} for ticker in tickers])
+    if isinstance(tickers, pd.DataFrame):
+        return tickers.copy()
+    raise ValueError("Tickers must be a string, list, or DataFrame.")
+
+
+def run_and_plot_sma_strategy(
+    tickers,
+    start_date,
+    end_date,
+    stop_loss=None,
+    take_profit=None,
+    short_window: int = 20,
+    long_window: int = 50,
+):
+    """
+    Runs and plots SMA signals plus cumulative weighted trade returns.
+    """
+    asset_table = normalize_asset_table(tickers)
+    portfolio_trades = run_strategy_on_portfolio(
+        asset_table,
+        start=start_date,
+        end=end_date,
+        stop_loss=stop_loss,
+        take_profit=take_profit,
+        short_window=short_window,
+        long_window=long_window,
+    )
+
+    for ticker in asset_table["Asset"]:
+        prices = download_close_prices(ticker, start_date, end_date)
+        signals = build_sma_signal_frame(prices, short_window=short_window, long_window=long_window)
+        plot_sma_strategy_trades(signals, ticker)
+
+    plot_sma_strategy_cumulative_return(portfolio_trades, title="SMA Strategy - Cumulative Return")
+    return portfolio_trades

{riskoptima-2.3.0 → riskoptima-2.3.2}/riskoptima/optim/mean_variance.py

@@ -41,10 +41,12 @@ def optimize_max_sharpe(
         return -(port_ret - risk_free_rate) / port_vol
 
     cons = [_sum_to_one_constraint()]
-    cons += factor_constraint_func(init_guess, factor_exposures, constraints.factor_bounds)
-
-    result = minimize(neg_sharpe, init_guess, method="SLSQP", bounds=bounds, constraints=cons)
-    return pd.Series(result.x, index=expected_returns.index)
+    cons += factor_constraint_func(init_guess, factor_exposures, constraints.factor_bounds)
+
+    result = minimize(neg_sharpe, init_guess, method="SLSQP", bounds=bounds, constraints=cons)
+    if not result.success:
+        raise ValueError(f"Max Sharpe optimization failed: {result.message}")
+    return pd.Series(result.x, index=expected_returns.index)
 
 
 def optimize_min_variance(
@@ -67,8 +69,10 @@ def optimize_min_variance(
     cons = [_sum_to_one_constraint()]
     if target_return is not None and expected_returns is not None:
         cons.append({"type": "eq", "fun": lambda w: np.dot(w, expected_returns.values) - target_return})
-    cons += factor_constraint_func(init_guess, factor_exposures, constraints.factor_bounds)
-
-    result = minimize(portfolio_vol, init_guess, method="SLSQP", bounds=bounds, constraints=cons)
-    index = expected_returns.index if expected_returns is not None else cov.index
-    return pd.Series(result.x, index=index)
+    cons += factor_constraint_func(init_guess, factor_exposures, constraints.factor_bounds)
+
+    result = minimize(portfolio_vol, init_guess, method="SLSQP", bounds=bounds, constraints=cons)
+    if not result.success:
+        raise ValueError(f"Minimum variance optimization failed: {result.message}")
+    index = expected_returns.index if expected_returns is not None else cov.index
+    return pd.Series(result.x, index=index)

{riskoptima-2.3.0 → riskoptima-2.3.2}/riskoptima/options/binomial.py

@@ -18,8 +18,25 @@ def binomial_tree_price(S, K, T, r, sigma, steps=100, option_type="call", q=0.0,
     option_type = option_type.lower()
     if option_type not in {"call", "put"}:
         raise ValueError("option_type must be 'call' or 'put'")
+    if S <= 0 or K <= 0:
+        raise ValueError("S and K must be positive")
+    if T < 0:
+        raise ValueError("T must be non-negative")
+    if sigma < 0:
+        raise ValueError("sigma must be non-negative")
     if steps <= 0:
         raise ValueError("steps must be positive")
+    if T == 0:
+        intrinsic = max(S - K, 0.0) if option_type == "call" else max(K - S, 0.0)
+        return float(intrinsic)
+    if sigma == 0:
+        discounted_strike = K * np.exp(-r * T)
+        deterministic = (
+            max(S * np.exp(-q * T) - discounted_strike, 0.0)
+            if option_type == "call"
+            else max(discounted_strike - S * np.exp(-q * T), 0.0)
+        )
+        return float(deterministic)
 
     dt = T / steps
     u = np.exp(sigma * np.sqrt(dt))

{riskoptima-2.3.0 → riskoptima-2.3.2}/riskoptima/options/black_scholes.py

@@ -24,10 +24,16 @@ def black_scholes_price(S, K, T, r, sigma, option_type="call", q=0.0):
     Prices a European option using the Black-Scholes-Merton formula.
     """
     option_type = _option_type(option_type)
-    if T <= 0:
+    if S <= 0 or K <= 0:
+        raise ValueError("S and K must be positive")
+    if T < 0:
+        raise ValueError("T must be non-negative")
+    if sigma < 0:
+        raise ValueError("sigma must be non-negative")
+    if T == 0:
         intrinsic = max(S - K, 0.0) if option_type == "call" else max(K - S, 0.0)
         return float(intrinsic)
-    if sigma <= 0:
+    if sigma == 0:
         forward_intrinsic = (
             max(S * np.exp(-q * T) - K * np.exp(-r * T), 0.0)
             if option_type == "call"

{riskoptima-2.3.0 → riskoptima-2.3.2}/riskoptima/reporting/market_risk.py

@@ -15,6 +15,28 @@ from scipy.stats import norm
 from riskoptima.core import RiskReport
 
 
+def _validated_weights(weights, columns) -> pd.Series:
+    if weights is None:
+        return pd.Series(np.repeat(1.0 / len(columns), len(columns)), index=columns, dtype=float)
+
+    if isinstance(weights, pd.Series):
+        missing = [col for col in columns if col not in weights.index]
+        if missing:
+            raise ValueError(f"weights are missing assets: {missing}")
+        w = weights.reindex(columns).astype(float)
+    else:
+        values = np.asarray(weights, dtype=float)
+        if values.ndim != 1 or len(values) != len(columns):
+            raise ValueError("weights must be a 1D array-like with one value per return column")
+        w = pd.Series(values, index=columns, dtype=float)
+
+    if not np.isfinite(w).all():
+        raise ValueError("weights must be finite")
+    if np.isclose(w.sum(), 0.0):
+        raise ValueError("weights must not sum to zero")
+    return w / w.sum()
+
+
 def _portfolio_returns(returns, weights=None) -> pd.Series:
     data = pd.DataFrame(returns).copy() if not isinstance(returns, pd.Series) else returns.to_frame("portfolio")
     data = data.apply(pd.to_numeric, errors="coerce").dropna(how="all")
@@ -23,14 +45,9 @@ def _portfolio_returns(returns, weights=None) -> pd.Series:
         return data.iloc[:, 0].dropna().rename("portfolio")
 
     clean = data.dropna(how="any")
-    if weights is None:
-        w = np.repeat(1.0 / clean.shape[1], clean.shape[1])
-    else:
-        w = pd.Series(weights, index=clean.columns if len(weights) == clean.shape[1] else None, dtype=float)
-        if list(w.index) != list(clean.columns):
-            w = pd.Series(np.asarray(weights, dtype=float), index=clean.columns)
-        if not np.isclose(w.sum(), 1.0):
-            w = w / w.sum()
+    if clean.empty:
+        raise ValueError("returns must contain at least one complete finite row")
+    w = _validated_weights(weights, clean.columns)
     return clean.dot(w).rename("portfolio")
 
 

{riskoptima-2.3.0 → riskoptima-2.3.2}/riskoptima/riskoptima.py

@@ -79,7 +79,7 @@ warnings.filterwarnings(
 
 class RiskOptima:
     TRADING_DAYS = 260  # default is 260, though 252 is also common
-    VERSION = '2.3.0'
+    VERSION = '2.3.2'
 
     @staticmethod
     def get_trading_days():
@@ -3479,234 +3479,52 @@ class RiskOptima:
     
     @staticmethod    
     def run_sma_strategy_with_risk(ticker: str, start: str, end: str, stop_loss: float = None, take_profit: float = None):
-        trade_columns = [
-            'Ticker',
-            'Entry Date',
-            'Exit Date',
-            'Entry Price',
-            'Exit Price',
-            'Return',
-            'Exit Reason',
-        ]
-    
-        df = yf.download(ticker, start=start, end=end, progress=False, auto_adjust=False)[['Close']].copy()
-        
-        df['SMA20'] = df['Close'].rolling(20).mean()
-        df['SMA50'] = df['Close'].rolling(50).mean()
-    
-        df['Signal'] = 0
-        df.loc[df.index[50]:, 'Signal'] = (
-            (df['SMA20'][50:] > df['SMA50'][50:]) & 
-            (df['SMA20'].shift(1)[50:] <= df['SMA50'].shift(1)[50:])
-        ).astype(int) - (
-            (df['SMA20'][50:] < df['SMA50'][50:]) & 
-            (df['SMA20'].shift(1)[50:] >= df['SMA50'].shift(1)[50:])
-        ).astype(int)
-    
-        trades = []
-        position = None
-        entry_price = None
-        entry_date = None
-    
-        for exit_date, row in df.iterrows():
-            price = row['Close'].item() if hasattr(row['Close'], 'item') else float(row['Close'])
-            signal = row['Signal'].item() if hasattr(row['Signal'], 'item') else int(row['Signal'])
-    
-            if position is None and signal == 1:
-                position = 'long'
-                entry_price = price
-                entry_date = exit_date
-    
-            elif position == 'long':
-                pnl = (price - entry_price) / entry_price
-                hit_stop = stop_loss is not None and pnl <= -stop_loss
-                hit_take = take_profit is not None and pnl >= take_profit
-    
-                if signal == -1 or hit_stop or hit_take:
-                    trades.append({
-                        'Ticker': ticker,
-                        'Entry Date': entry_date,
-                        'Exit Date': exit_date,
-                        'Entry Price': entry_price,
-                        'Exit Price': price,
-                        'Return': pnl,
-                        'Exit Reason': (
-                            'Sell Signal' if signal == -1 else
-                            'Stop Loss' if hit_stop else
-                            'Take Profit'
-                        )
-                    })
-                    position = None
-    
-        return pd.DataFrame(trades, columns=trade_columns)
+        from riskoptima.backtest.sma import run_sma_strategy_with_risk
+
+        return run_sma_strategy_with_risk(
+            ticker=ticker,
+            start=start,
+            end=end,
+            stop_loss=stop_loss,
+            take_profit=take_profit,
+        )
     
     @staticmethod 
-    def run_strategy_on_portfolio(asset_table: pd.DataFrame, start: str, end: str,
-                                  stop_loss: float = None, take_profit: float = None):
-        results = []
-        print(asset_table)
-        for _, row in asset_table.iterrows():
-            ticker = row['Asset']
-            weight = row['Weight']
-            trades_df = RiskOptima.run_sma_strategy_with_risk(
-                ticker, start, end,
-                stop_loss=stop_loss, take_profit=take_profit
-            )
-            trades_df['Weight'] = weight
-            trades_df['Weighted Return'] = trades_df['Return'] * weight if 'Return' in trades_df else pd.Series(dtype=float)
-            results.append(trades_df)
-    
-        if not results:
-            return pd.DataFrame(columns=[
-                'Ticker', 'Entry Date', 'Exit Date', 'Entry Price', 'Exit Price',
-                'Return', 'Exit Reason', 'Weight', 'Weighted Return'
-            ])
+    def run_strategy_on_portfolio(asset_table: pd.DataFrame, start: str, end: str,
+                                  stop_loss: float = None, take_profit: float = None):
+        from riskoptima.backtest.sma import run_strategy_on_portfolio
 
-        all_trades = pd.concat(results, ignore_index=True)
-        if all_trades.empty:
-            return all_trades
-        all_trades = all_trades.sort_values(by='Entry Date')
-        return all_trades
+        return run_strategy_on_portfolio(
+            asset_table=asset_table,
+            start=start,
+            end=end,
+            stop_loss=stop_loss,
+            take_profit=take_profit,
+        )
     
     @staticmethod 
     def plot_sma_strategy_cumulative_return(trade_log: pd.DataFrame, title="Portfolio Return"):
-        if trade_log.empty:
-            fig, ax = plt.subplots(figsize=(20, 12))
-            plt.title(title)
-            plt.xlabel("Date")
-            plt.ylabel("Cumulative Return")
-            plt.grid(alpha=0.3)
-            plt.text(
-                0.995, -0.20, f"Created by RiskOptima v{RiskOptima.VERSION}",
-                fontsize=12, color='gray', alpha=0.7, transform=ax.transAxes, ha='right'
-            )
-            plt.tight_layout()
-            plt.show()
-            return
+        from riskoptima.backtest.sma import plot_sma_strategy_cumulative_return
 
-        trade_log = trade_log.sort_values('Exit Date').copy()
-        trade_log['Cumulative Return'] = (1 + trade_log['Weighted Return']).cumprod()
-    
-        fig, ax = plt.subplots(figsize=(20, 12))
-        
-        plt.plot(trade_log['Exit Date'], trade_log['Cumulative Return'], marker='o')
-        plt.title(title)
-        plt.xlabel("Date")
-        plt.ylabel("Cumulative Return")
-        plt.grid(alpha=0.3)
-        
-        plt.text(
-            0.995, -0.20, f"Created by RiskOptima v{RiskOptima.VERSION}",
-            fontsize=12, color='gray', alpha=0.7, transform=ax.transAxes, ha='right'
-        )
-        
-        plt.tight_layout()
-        
-        plots_folder = "plots"
-        
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    
-        if not os.path.exists(plots_folder):
-            os.makedirs(plots_folder)
-    
-        plot_path = os.path.join(plots_folder, f"riskoptima_sma_strategy_cum_ret_{timestamp}.png")
-    
-        plt.savefig(plot_path, dpi=150, bbox_inches='tight')
-        plt.show()
+        return plot_sma_strategy_cumulative_return(trade_log=trade_log, title=title)
         
     @staticmethod 
-    def plot_sma_strategy_trades(df: pd.DataFrame, ticker: str):
-        fig, ax = plt.subplots(figsize=(20, 12))
-        plt.plot(df.index, df['Close'], label='Close Price', alpha=0.5)
-        plt.plot(df.index, df['SMA20'], label='SMA20', alpha=0.8)
-        plt.plot(df.index, df['SMA50'], label='SMA50', alpha=0.8)
-    
-        plt.scatter(df.index[df['Signal'] == 1], df['Close'][df['Signal'] == 1],
-                    marker='^', color='green', s=100, label='Buy Signal')
-        plt.scatter(df.index[df['Signal'] == -1], df['Close'][df['Signal'] == -1],
-                    marker='v', color='red', s=100, label='Sell Signal')
-    
-        plt.title(f"{ticker} - SMA Strategy with Signals")
-        plt.xlabel("Date")
-        plt.ylabel("Price")
-        plt.legend()
-        plt.grid(alpha=0.3)
-        
-        plt.text(
-            0.995, -0.20, f"Created by RiskOptima v{RiskOptima.VERSION}",
-            fontsize=12, color='gray', alpha=0.7, transform=ax.transAxes, ha='right'
-        )
-        
-        plt.tight_layout()
-        
-        plots_folder = "plots"
-        
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-    
-        if not os.path.exists(plots_folder):
-            os.makedirs(plots_folder)
-    
-        plot_path = os.path.join(plots_folder, f"riskoptima_sma_strategy_{timestamp}.png")
-    
-        plt.savefig(plot_path, dpi=150, bbox_inches='tight')
-        
-        plt.show()
+    def plot_sma_strategy_trades(df: pd.DataFrame, ticker: str):
+        from riskoptima.backtest.sma import plot_sma_strategy_trades
+
+        return plot_sma_strategy_trades(signal_frame=df, ticker=ticker)
         
     @staticmethod 
-    def run_and_plot_sma_strategy(tickers, start_date, end_date, stop_loss=None, take_profit=None):
-        # Normalize input
-        if isinstance(tickers, str):
-            asset_table = pd.DataFrame([{"Asset": tickers, "Weight": 1.0}])
-        elif isinstance(tickers, list):
-            asset_table = pd.DataFrame([{"Asset": t, "Weight": 1.0 / len(tickers)} for t in tickers])
-        elif isinstance(tickers, pd.DataFrame):
-            asset_table = tickers.copy()
-        else:
-            raise ValueError("Tickers must be a string, list, or DataFrame.")
-    
-        # Run portfolio strategy
-        portfolio_trades = RiskOptima.run_strategy_on_portfolio(
-            asset_table, start=start_date, end=end_date,
-            stop_loss=stop_loss, take_profit=take_profit
-        )
-    
-        # If only one ticker, also show price chart with signals
-        if len(asset_table) == 1:
-            ticker = asset_table.iloc[0]['Asset']
-            df = yf.download(ticker, start=start_date, end=end_date, progress=False, auto_adjust=False)[['Close']]
-            df['SMA20'] = df['Close'].rolling(20).mean()
-            df['SMA50'] = df['Close'].rolling(50).mean()
-            df['Signal'] = 0
-            df.loc[df.index[50]:, 'Signal'] = (
-                (df['SMA20'][50:] > df['SMA50'][50:]) & 
-                (df['SMA20'].shift(1)[50:] <= df['SMA50'].shift(1)[50:])
-            ).astype(int) - (
-                (df['SMA20'][50:] < df['SMA50'][50:]) & 
-                (df['SMA20'].shift(1)[50:] >= df['SMA50'].shift(1)[50:])
-            ).astype(int)
-        
-            RiskOptima.plot_sma_strategy_trades(df, ticker)
-        
-        else:
-            for ticker in asset_table['Asset']:
-                df = yf.download(ticker, start=start_date, end=end_date, progress=False, auto_adjust=False)[['Close']]
-                df['SMA20'] = df['Close'].rolling(20).mean()
-                df['SMA50'] = df['Close'].rolling(50).mean()
-                df['Signal'] = 0
-                df.loc[df.index[50]:, 'Signal'] = (
-                    (df['SMA20'][50:] > df['SMA50'][50:]) & 
-                    (df['SMA20'].shift(1)[50:] <= df['SMA50'].shift(1)[50:])
-                ).astype(int) - (
-                    (df['SMA20'][50:] < df['SMA50'][50:]) & 
-                    (df['SMA20'].shift(1)[50:] >= df['SMA50'].shift(1)[50:])
-                ).astype(int)
-            
-                RiskOptima.plot_sma_strategy_trades(df, ticker)
-        
-        # Always plot cumulative return
-        RiskOptima.plot_sma_strategy_cumulative_return(portfolio_trades, title="SMA Strategy - Cumulative Return")
-    
-        return portfolio_trades
+    def run_and_plot_sma_strategy(tickers, start_date, end_date, stop_loss=None, take_profit=None):
+        from riskoptima.backtest.sma import run_and_plot_sma_strategy
+
+        return run_and_plot_sma_strategy(
+            tickers=tickers,
+            start_date=start_date,
+            end_date=end_date,
+            stop_loss=stop_loss,
+            take_profit=take_profit,
+        )
     
     @staticmethod
     def implied_volatility_screener(symbol='AMZN', lookback_days=30):

riskoptima-2.3.0/riskoptima/backtest/__init__.py

@@ -1,13 +0,0 @@
-###############################################################################
-#                                 __init__.py                                  
-###############################################################################
-# Product: RiskOptima
-# Author: Jordi Corbilla
-# Description: RiskOptima module
-###############################################################################
-
-from .engine import run_backtest
-from .strategy import Strategy, SMACrossStrategy
-from .portfolio import PortfolioState
-
-__all__ = ["run_backtest", "Strategy", "SMACrossStrategy", "PortfolioState"]