vortex-api 2.0.7__tar.gz → 2.1.1__tar.gz

{vortex_api-2.0.7/vortex_api.egg-info → vortex_api-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vortex_api
-Version: 2.0.7
+Version: 2.1.1
 Summary: Vortex APIs to place orders in Rupeezy application
 Author-email: "Astha Credit & Securities Pvt Ltd." <tech@rupeezy.in>
 License: MIT

{vortex_api-2.0.7 → vortex_api-2.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vortex_api"
-version = "2.0.7"
+version = "2.1.1"
 description = "Vortex APIs to place orders in Rupeezy application"
 readme = "README.md"
 license = { text = "MIT" }
@@ -38,4 +38,4 @@ Homepage = "https://vortex.rupeezy.in"
 Repository = "https://github.com/RupeezyTech/pyvortex"
 
 [tool.setuptools.packages.find]
-include = ["vortex_api"]
+include = ["vortex_api", "vortex_api.*"]

vortex_api-2.1.1/vortex_api/__version__.py

@@ -0,0 +1 @@
+__version__ = "2.1.1"

{vortex_api-2.0.7 → vortex_api-2.1.1}/vortex_api/api.py

@@ -2,7 +2,6 @@ import requests
 import csv
 import datetime
 import logging
-import math
 from enum import Enum
 import inspect
 import wrapt
@@ -658,9 +657,13 @@ class VortexAPI:
         """
         Save backtest results to Rupeezy for viewing on the developer portal.
 
+        Supports multiple backtesting libraries (auto-detected from the result type):
+        - **backtesting.py**: pass the stats object from Backtest.run()
+        - **vectorbt**: pass a vbt.Portfolio object
+        - **backtrader**: pass the strategy from cerebro.run() (i.e. results[0])
+
         Args:
-            stats: The Stats object returned by Backtest.run() or Backtest.optimize()
-                   from the backtesting.py library.
+            stats: The result object from any supported backtesting library.
             name (str): A label for this backtest run (e.g. "SMA Crossover v2").
             symbol (str, optional): Primary instrument symbol.
             description (str, optional): Notes about this run.
@@ -669,206 +672,83 @@ class VortexAPI:
         Returns:
             dict: { "status": "success", "backtest_id": "bt_abc123", "url": "https://..." }
         """
-        payload = _serialize_stats(stats, name, symbol, description, tags or [])
+        from .backtest import serialize_stats
+        payload = serialize_stats(stats, name, symbol, description, tags or [])
         endpoint = "/strategies/backtests"
 
         return self._make_api_request("POST", endpoint, data=payload)
 
-# ─── Backtest serialization helpers (module-level) ───────────────────────────
-
-def _safe_float(val):
-    """Convert a value to float, returning None for NaN/None/invalid."""
-    if val is None:
-        return None
-    try:
-        f = float(val)
-        if math.isnan(f) or math.isinf(f):
-            return None
-        return round(f, 4)
-    except (ValueError, TypeError):
-        return None
-
-
-def _safe_isoformat(val):
-    """Convert a datetime-like value to ISO format string."""
-    if val is None:
-        return None
-    try:
-        return val.isoformat()
-    except AttributeError:
-        return str(val)
-
-
-def _duration_to_days(val):
-    """Convert a timedelta-like value to integer days."""
-    if val is None:
-        return None
-    try:
-        return val.days
-    except AttributeError:
-        return None
-
-
-def _serialize_stats(stats, name, symbol, description, tags):
-    def _sf(val):
-        if val is None:
-            return 0.0
-        try:
-            f = float(val)
-            return 0.0 if (math.isnan(f) or math.isinf(f)) else round(f, 4)
-        except (ValueError, TypeError):
-            return 0.0
-
-    def _dd(val):
-        if val is None:
-            return 0
-        try:
-            return val.days
-        except AttributeError:
-            return 0
-
-    summary = {
-        "return_pct": _sf(stats.get("Return [%]")),
-        "return_ann_pct": _sf(stats.get("Return (Ann.) [%]")),
-        "volatility_ann_pct": _sf(stats.get("Volatility (Ann.) [%]")),
-        "cagr_pct": _sf(stats.get("CAGR [%]")),
-        "buy_hold_return_pct": _sf(stats.get("Buy & Hold Return [%]")),
-        "alpha_pct": _sf(stats.get("Alpha [%]")),
-        "beta": _sf(stats.get("Beta")),
-        "sharpe_ratio": _sf(stats.get("Sharpe Ratio")),
-        "sortino_ratio": _sf(stats.get("Sortino Ratio")),
-        "calmar_ratio": _sf(stats.get("Calmar Ratio")),
-        "max_drawdown_pct": _sf(stats.get("Max. Drawdown [%]")),
-        "avg_drawdown_pct": _sf(stats.get("Avg. Drawdown [%]")),
-        "max_drawdown_duration_days": _dd(stats.get("Max. Drawdown Duration")),
-        "avg_drawdown_duration_days": _dd(stats.get("Avg. Drawdown Duration")),
-        "equity_final": _sf(stats.get("Equity Final [$]")),
-        "equity_peak": _sf(stats.get("Equity Peak [$]")),
-        "commissions_total": _sf(stats.get("Commissions [$]")),
-        "exposure_time_pct": _sf(stats.get("Exposure Time [%]")),
-        "total_trades": int(stats.get("# Trades", 0)),
-        "win_rate_pct": _sf(stats.get("Win Rate [%]")),
-        "best_trade_pct": _sf(stats.get("Best Trade [%]")),
-        "worst_trade_pct": _sf(stats.get("Worst Trade [%]")),
-        "avg_trade_pct": _sf(stats.get("Avg. Trade [%]")),
-        "max_trade_duration_days": _dd(stats.get("Max. Trade Duration")),
-        "avg_trade_duration_days": _dd(stats.get("Avg. Trade Duration")),
-        "profit_factor": _sf(stats.get("Profit Factor")),
-        "expectancy_pct": _sf(stats.get("Expectancy [%]")),
-        "sqn": _sf(stats.get("SQN")),
-        "kelly_criterion": _sf(stats.get("Kelly Criterion")),
-    }
-
-    # --- Strategy name and parameters ---
-    strategy_name = "Unknown"
-    parameters = {}
-    strategy = stats.get("_strategy")
-    if strategy is not None:
-        strategy_class = strategy if isinstance(strategy, type) else strategy.__class__
-        strategy_name = strategy_class.__name__
-        for attr in vars(strategy_class):
-            if attr.startswith("_"):
-                continue
-            val = getattr(strategy_class, attr, None)
-            if callable(val):
-                continue
-            if isinstance(val, (int, float, str, bool)):
-                parameters[attr] = val
-
-    # --- Equity curve ---
-    equity_curve = []
-    ec = stats.get("_equity_curve")
-    if ec is not None and hasattr(ec, "index"):
-        equity_series = ec["Equity"]
-        step = max(1, len(equity_series) // 500)
-        for i in range(0, len(equity_series), step):
-            equity_curve.append({
-                "date": equity_series.index[i].strftime("%Y-%m-%d"),
-                "equity": round(float(equity_series.iloc[i]), 2),
-            })
-        if equity_curve and equity_curve[-1]["date"] != equity_series.index[-1].strftime("%Y-%m-%d"):
-            equity_curve.append({
-                "date": equity_series.index[-1].strftime("%Y-%m-%d"),
-                "equity": round(float(equity_series.iloc[-1]), 2),
-            })
-
-    # --- Drawdown curve (computed from equity peak) ---
-    drawdown_curve = []
-    if ec is not None and hasattr(ec, "index"):
-        equity_series = ec["Equity"]
-        running_max = equity_series.cummax()
-        drawdown = ((equity_series - running_max) / running_max) * 100
-        step = max(1, len(drawdown) // 500)
-        for i in range(0, len(drawdown), step):
-            dd_val = round(float(drawdown.iloc[i]), 4)
-            if dd_val < -0.01:
-                drawdown_curve.append({
-                    "date": drawdown.index[i].strftime("%Y-%m-%d"),
-                    "equity": round(float(equity_series.iloc[i]), 2),
-                    "drawdown_pct": dd_val,
-                })
-
-    # --- Trade log ---
-    trades_list = []
-    trades = stats.get("_trades")
-    if trades is not None and hasattr(trades, "iterrows"):
-        for i, trade in trades.iterrows():
-            size = trade.get("Size", 0)
-            entry_time = trade.get("EntryTime")
-            exit_time = trade.get("ExitTime")
-            duration = 0
-            if hasattr(entry_time, "strftime") and hasattr(exit_time, "strftime"):
-                duration = (exit_time - entry_time).days
-            trades_list.append({
-                "trade_number": i + 1,
-                "side": "LONG" if size > 0 else "SHORT",
-                "size": abs(int(size)) if size else 0,
-                "entry_bar": int(trade.get("EntryBar", 0)),
-                "exit_bar": int(trade.get("ExitBar", 0)),
-                "entry_date": entry_time.strftime("%Y-%m-%d") if hasattr(entry_time, "strftime") else str(entry_time),
-                "exit_date": exit_time.strftime("%Y-%m-%d") if hasattr(exit_time, "strftime") else str(exit_time),
-                "entry_price": _sf(trade.get("EntryPrice")),
-                "exit_price": _sf(trade.get("ExitPrice")),
-                "pnl_abs": _sf(trade.get("PnL")),
-                "pnl_pct": _sf(trade.get("ReturnPct")),  # already in % form
-                "duration_days": duration,
-            })
-
-    # --- Monthly returns ---
-    monthly_returns = []
-    if ec is not None and hasattr(ec, "index"):
-        try:
-            equity_series = ec["Equity"]
-            monthly = equity_series.resample("ME").last()
-            pct = monthly.pct_change().dropna() * 100
-            for date, ret in pct.items():
-                monthly_returns.append({
-                    "year": date.year,
-                    "month": date.month,
-                    "return_pct": _sf(ret),
-                })
-        except Exception:
-            pass
-
-    # --- Dates as YYYY-MM-DD ---
-    start_val = stats.get("Start")
-    end_val = stats.get("End")
-    start_date = start_val.strftime("%Y-%m-%d") if hasattr(start_val, "strftime") else str(start_val)
-    end_date = end_val.strftime("%Y-%m-%d") if hasattr(end_val, "strftime") else str(end_val)
-
-    return {
-        "name": name[:200],
-        "symbol": symbol[:50],
-        "description": description[:2000],
-        "tags": tags[:20],
-        "strategy_name": strategy_name,
-        "start_date": start_date,
-        "end_date": end_date,
-        "starting_capital": round(float(equity_curve[0]["equity"]), 2) if equity_curve else 0,
-        "parameters": parameters,
-        "summary": summary,
-        "equity_curve": equity_curve,
-        "drawdown_curve": drawdown_curve,
-        "trades": trades_list,
-        "monthly_returns": monthly_returns,
-    }
+    def save_optimization_result(
+        self,
+        stats,
+        heatmap,
+        name: str,
+        symbol: str = "",
+        description: str = "",
+        maximize="Sharpe Ratio",
+        param_ranges: dict = None,
+    ) -> dict:
+        """
+        Save optimization results to Rupeezy for viewing on the developer portal.
+
+        Supports multiple backtesting libraries (auto-detected from the result type):
+        - **backtesting.py**: pass stats + heatmap from bt.optimize(return_heatmap=True)
+        - **vectorbt**: pass Portfolio + metric Series from multi-param run
+        - **backtrader**: pass results list from cerebro.run() after optstrategy()
+
+        Args:
+            stats: The result object from any supported backtesting library.
+            heatmap: The heatmap/metric Series (backtesting.py/vectorbt) or
+                     metric extraction callable (backtrader).
+            name (str): A label for this optimization run (e.g. "SMA Grid Search").
+            symbol (str, optional): Primary instrument symbol (e.g. "NIFTY").
+            description (str, optional): Notes about this optimization run.
+            maximize: The metric that was optimized. Should match the `maximize`
+                      argument passed to Backtest.optimize(). Can be a string
+                      metric name (e.g. "Sharpe Ratio") or a callable.
+                      Defaults to "Sharpe Ratio".
+            param_ranges (dict, optional): Explicit parameter range definitions.
+                Keys are parameter names, values are range() objects or lists.
+                Example: {"sma_fast": range(5, 51, 5), "sma_slow": range(20, 201, 10)}
+                If not provided, ranges are inferred from the heatmap index.
+
+        Returns:
+            dict: {"status": "success", "optimization_id": "opt_xxx", "backtest_id": "bt_xxx"}
+
+        Example::
+
+            stats, heatmap = bt.optimize(
+                sma_fast=range(5, 51, 5),
+                sma_slow=range(20, 201, 10),
+                maximize='Sharpe Ratio',
+                return_heatmap=True,
+            )
+            client.save_optimization_result(
+                stats=stats,
+                heatmap=heatmap,
+                name="SMA Crossover Grid Search",
+                symbol="NIFTY",
+                maximize='Sharpe Ratio',
+                param_ranges={"sma_fast": range(5, 51, 5), "sma_slow": range(20, 201, 10)},
+            )
+        """
+        is_maximize = True
+        objective_metric = maximize
+
+        if isinstance(maximize, bool):
+            is_maximize = maximize
+            objective_metric = "Sharpe Ratio"
+
+        from .backtest import serialize_optimization
+        payload = serialize_optimization(
+            result=stats,
+            heatmap=heatmap,
+            name=name,
+            symbol=symbol,
+            description=description,
+            objective_metric=objective_metric,
+            maximize=is_maximize,
+            param_ranges=param_ranges,
+        )
+        endpoint = "/strategies/optimizations"
+        return self._make_api_request("POST", endpoint, data=payload)

vortex_api-2.1.1/vortex_api/backtest/__init__.py

@@ -0,0 +1,117 @@
+"""Backtest serialization subpackage.
+
+Auto-detects the backtesting library from the result object type and
+dispatches to the appropriate adapter. Supports:
+
+- backtesting.py (Backtest.run() / Backtest.optimize())
+- vectorbt (vbt.Portfolio)
+- backtrader (cerebro.run() Strategy)
+
+Usage from api.py:
+    from .backtest import serialize_stats, serialize_optimization
+"""
+
+
+def _is_backtestingpy(result):
+    """Check if result is a backtesting.py stats object (pd.Series with _strategy key)."""
+    return hasattr(result, "get") and result.get("_strategy") is not None
+
+
+def _is_vectorbt(result):
+    """Check if result is a vectorbt Portfolio object."""
+    return (hasattr(result, "stats")
+            and hasattr(result, "value")
+            and hasattr(result, "trades"))
+
+
+def _is_backtrader(result):
+    """Check if result is a backtrader Strategy object."""
+    # Single strategy
+    if hasattr(result, "analyzers"):
+        return True
+    # List of strategies from cerebro.run()
+    if isinstance(result, list) and len(result) > 0:
+        item = result[0]
+        if hasattr(item, "analyzers"):
+            return True
+        # Optimization result: list of lists
+        if isinstance(item, list) and len(item) > 0 and hasattr(item[0], "analyzers"):
+            return True
+    return False
+
+
+def serialize_stats(result, name, symbol, description, tags):
+    """Auto-detect library and serialize backtest stats to backend payload.
+
+    Args:
+        result: Stats/Portfolio/Strategy object from any supported library.
+        name: Backtest name.
+        symbol: Trading symbol.
+        description: Description text.
+        tags: List of tag strings.
+
+    Returns:
+        dict: Payload ready for POST to /strategies/backtests.
+
+    Raises:
+        TypeError: If the result type is not recognized.
+    """
+    if _is_backtestingpy(result):
+        from ._backtestingpy import serialize_stats as _serialize
+        return _serialize(result, name, symbol, description, tags)
+
+    if _is_vectorbt(result):
+        from ._vectorbt import serialize_stats as _serialize
+        return _serialize(result, name, symbol, description, tags)
+
+    if _is_backtrader(result):
+        from ._backtrader import serialize_stats as _serialize
+        return _serialize(result, name, symbol, description, tags)
+
+    raise TypeError(
+        f"Unsupported backtest result type: {type(result).__name__}. "
+        f"Expected stats from backtesting.py, a vectorbt Portfolio, "
+        f"or a backtrader Strategy."
+    )
+
+
+def serialize_optimization(result, heatmap, name, symbol, description,
+                           objective_metric, maximize, param_ranges):
+    """Auto-detect library and serialize optimization results.
+
+    Args:
+        result: Stats/Portfolio/Strategy-list from any supported library.
+        heatmap: Heatmap Series (backtesting.py/vectorbt) or metric_fn (backtrader).
+        name: Optimization name.
+        symbol: Trading symbol.
+        description: Description text.
+        objective_metric: Metric that was optimized.
+        maximize: Boolean — True to maximize, False to minimize.
+        param_ranges: Dict of param_name -> range/list.
+
+    Returns:
+        dict: Payload ready for POST to /strategies/optimizations.
+
+    Raises:
+        TypeError: If the result type is not recognized.
+    """
+    if _is_backtestingpy(result):
+        from ._backtestingpy import serialize_optimization as _serialize
+        return _serialize(result, heatmap, name, symbol, description,
+                          objective_metric, maximize, param_ranges)
+
+    if _is_vectorbt(result):
+        from ._vectorbt import serialize_optimization as _serialize
+        return _serialize(result, heatmap, name, symbol, description,
+                          objective_metric, maximize, param_ranges)
+
+    if _is_backtrader(result):
+        from ._backtrader import serialize_optimization as _serialize
+        return _serialize(result, heatmap, name, symbol, description,
+                          objective_metric, maximize, param_ranges)
+
+    raise TypeError(
+        f"Unsupported optimization result type: {type(result).__name__}. "
+        f"Expected stats from backtesting.py, a vectorbt Portfolio, "
+        f"or backtrader optimization results."
+    )