ivolatility-backtesting 1.2.0__py3-none-any.whl → 1.3.1__py3-none-any.whl

ivolatility_backtesting/ivolatility_backtesting.py

@@ -1,25 +1,38 @@
 """
 ivolatility_backtesting.py - UNIVERSAL BACKTEST FRAMEWORK
-Version 2.0 - With DataFrame/Dict Auto-Normalization
+Version 4.1 - Dual RAM Display (Process + Container)
 
 Key Features:
-- Handles both dict and DataFrame API responses automatically
-- Universal BacktestResults interface
-- 30+ calculated metrics
-- Automatic reporting, charts, and exports
-- One-command runner: run_backtest()
+- ResourceMonitor: CPU/RAM tracking (cgroups v2 + psutil fallback)
+- Enhanced progress bar with ETA, CPU%, RAM
+- Shows BOTH Python process RAM AND container total RAM
+- api_call(): Auto-normalization for dict/DataFrame responses
+- 30+ metrics, charts, exports
+- One-command: run_backtest()
 
 Usage:
     from ivolatility_backtesting import *
     
-    # Initialize API
     init_api(os.getenv("API_KEY"))
     
-    # Use api_call for normalized responses
-    data = api_call('/equities/eod/stock-prices', symbol='AAPL', from_='2024-01-01')
+    data = api_call('/equities/eod/stock-prices', 
+                   symbol='AAPL', 
+                   from_='2024-01-01',
+                   to='2024-12-31',
+                   debug=True)
     
-    # Run backtest
     analyzer = run_backtest(my_strategy, CONFIG)
+
+Resource Monitoring:
+    - CPU: Process CPU % (smoothed over 5 readings)
+    - RAM: Shows BOTH metrics when in container:
+      * Green: Python process memory (your strategy)
+      * Blue: Total container memory (includes Jupyter, cache, etc.)
+    
+Progress Display Example:
+    Processing 2024-07-30 (144/252)
+    ETA: 5m 23s | CPU: 46.8% | RAM: 856MB (42%) Python | 1280MB (64%) Container
+    Container: 1.0 cores, 2.0GB limit
 """
 
 import pandas as pd
@@ -32,26 +45,68 @@ import os
 import time
 import psutil
 
-# Set style
 sns.set_style('darkgrid')
 plt.rcParams['figure.figsize'] = (15, 8)
 
 
 # ============================================================
-# RESOURCE MONITOR - NEW!
+# RESOURCE MONITOR
 # ============================================================
 class ResourceMonitor:
-    """Monitor CPU and RAM using cgroups v2 and psutil fallback"""
+    """Monitor CPU and RAM - shows PROCESS resources (Python), not full container"""
     
-    def __init__(self):
+    def __init__(self, show_container_total=False):
         self.process = psutil.Process()
         self.cpu_count = psutil.cpu_count()
         self.last_cpu_time = None
         self.last_check_time = None
         self.use_cgroups = self._check_cgroups_v2()
+        self.show_container_total = show_container_total  # False = process RAM, True = container RAM
+        
+        # CPU smoothing for more stable readings
+        self.cpu_history = []
+        self.cpu_history_max = 5  # Average over last 5 readings
+        
+        # Determine actual CPU quota for containers
+        if self.use_cgroups:
+            quota = self._read_cpu_quota()
+            if quota and quota > 0:
+                self.cpu_count = quota  # Override with container quota
+        
+        self.context = "Container" if self.use_cgroups else "Host"
+        
+    def _read_cpu_quota(self):
+        """Read CPU quota from cgroups v2 (returns cores, e.g., 1.5)"""
+        try:
+            with open('/sys/fs/cgroup/cpu.max', 'r') as f:
+                line = f.read().strip()
+                if line == 'max':
+                    return None  # No limit
+                parts = line.split()
+                if len(parts) == 2:
+                    quota = int(parts[0])  # microseconds
+                    period = int(parts[1])  # microseconds
+                    return quota / period  # cores (e.g., 100000/100000 = 1.0)
+        except:
+            pass
+        return None
+        
+    def get_context_info(self):
+        """Returns monitoring context and resource limits"""
+        if self.use_cgroups:
+            current, max_mem = self._read_cgroup_memory()
+            ram_info = ""
+            if max_mem:
+                max_mem_gb = max_mem / (1024**3)
+                ram_info = f", {max_mem_gb:.1f}GB limit"
+            
+            mem_type = "container total" if self.show_container_total else "process only"
+            return f"Container (CPU: {self.cpu_count:.1f} cores{ram_info}) - RAM: {mem_type}"
+        else:
+            total_ram_gb = psutil.virtual_memory().total / (1024**3)
+            return f"Host ({self.cpu_count} cores, {total_ram_gb:.0f}GB RAM) - RAM: process"
         
     def _check_cgroups_v2(self):
-        """Check if cgroups v2 is available"""
         try:
             return os.path.exists('/sys/fs/cgroup/cpu.stat') and \
                    os.path.exists('/sys/fs/cgroup/memory.current')
@@ -59,7 +114,6 @@ class ResourceMonitor:
             return False
     
     def _read_cgroup_cpu(self):
-        """Read CPU usage from cgroups v2"""
         try:
             with open('/sys/fs/cgroup/cpu.stat', 'r') as f:
                 for line in f:
@@ -70,7 +124,6 @@ class ResourceMonitor:
         return None
     
     def _read_cgroup_memory(self):
-        """Read memory usage from cgroups v2"""
         try:
             with open('/sys/fs/cgroup/memory.current', 'r') as f:
                 current = int(f.read().strip())
@@ -86,7 +139,7 @@ class ResourceMonitor:
         return None, None
     
     def get_cpu_percent(self):
-        """Get CPU usage percentage with cgroups v2 fallback to psutil"""
+        """Get CPU% with smoothing - shows container limits if in container, host if not"""
         if self.use_cgroups:
             current_time = time.time()
             current_cpu = self._read_cgroup_cpu()
@@ -96,58 +149,95 @@ class ResourceMonitor:
                 cpu_delta = current_cpu - self.last_cpu_time
                 
                 if time_delta > 0:
-                    # Convert microseconds to percentage
+                    # Calculate based on container CPU quota
                     cpu_percent = (cpu_delta / (time_delta * 1_000_000)) * 100
+                    
+                    # Clamp to container limits
                     cpu_percent = min(cpu_percent, 100 * self.cpu_count)
                     
+                    # Add to history for smoothing
+                    self.cpu_history.append(cpu_percent)
+                    if len(self.cpu_history) > self.cpu_history_max:
+                        self.cpu_history.pop(0)
+                    
                     self.last_cpu_time = current_cpu
                     self.last_check_time = current_time
                     
-                    return round(cpu_percent, 1)
+                    # Return smoothed average
+                    return round(sum(self.cpu_history) / len(self.cpu_history), 1)
             
             self.last_cpu_time = current_cpu
             self.last_check_time = current_time
         
-        # Fallback to psutil
+        # Fallback: host resources with smoothing
         try:
             cpu = self.process.cpu_percent(interval=0.1)
-            return round(cpu, 1) if cpu > 0 else round(psutil.cpu_percent(interval=0.1), 1)
+            if cpu == 0:
+                cpu = psutil.cpu_percent(interval=0.1)
+            
+            self.cpu_history.append(cpu)
+            if len(self.cpu_history) > self.cpu_history_max:
+                self.cpu_history.pop(0)
+            
+            return round(sum(self.cpu_history) / len(self.cpu_history), 1)
         except:
             return 0.0
     
     def get_memory_info(self):
-        """Get memory usage (MB and %) with cgroups v2 fallback to psutil"""
-        if self.use_cgroups:
-            current, max_mem = self._read_cgroup_memory()
-            if current and max_mem:
-                mb = current / (1024 * 1024)
-                percent = (current / max_mem) * 100
-                return round(mb, 1), round(percent, 1)
+        """
+        Get memory usage - returns BOTH process and container/host
         
-        # Fallback to psutil
+        Returns:
+            tuple: (process_mb, process_pct, container_mb, container_pct)
+                   If no container, container values = process values
+        """
         try:
+            # Get process memory (Python only)
             mem = self.process.memory_info()
-            mb = mem.rss / (1024 * 1024)
+            process_mb = mem.rss / (1024 * 1024)
+            
+            if self.use_cgroups:
+                # Get container total and limit
+                current, max_mem = self._read_cgroup_memory()
+                if max_mem:
+                    process_percent = (mem.rss / max_mem) * 100
+                    
+                    if current:
+                        container_mb = current / (1024 * 1024)
+                        container_percent = (current / max_mem) * 100
+                        return (
+                            round(process_mb, 1), 
+                            round(process_percent, 1),
+                            round(container_mb, 1),
+                            round(container_percent, 1)
+                        )
+                    
+                    # No container data, return process only
+                    return (
+                        round(process_mb, 1), 
+                        round(process_percent, 1),
+                        round(process_mb, 1),
+                        round(process_percent, 1)
+                    )
+            
+            # Host: calculate % of total RAM
             total = psutil.virtual_memory().total
             percent = (mem.rss / total) * 100
-            return round(mb, 1), round(percent, 1)
+            
+            # On host, process = "container" (no container isolation)
+            return (
+                round(process_mb, 1), 
+                round(percent, 1),
+                round(process_mb, 1),
+                round(percent, 1)
+            )
+            
         except:
-            return 0.0, 0.0
+            return 0.0, 0.0, 0.0, 0.0
 
 
 def create_progress_bar():
-    """
-    Create enhanced progress bar with ETA, CPU%, RAM
-    
-    Returns:
-        tuple: (progress_bar, status_label, resource_monitor, start_time)
-    
-    Example:
-        progress_bar, status_label, monitor, start_time = create_progress_bar()
-        
-        for i in range(total):
-            update_progress(progress_bar, status_label, monitor, i, total, start_time)
-    """
+    """Create enhanced progress bar with ETA, CPU%, RAM"""
     from IPython.display import display
     import ipywidgets as widgets
     
@@ -173,21 +263,11 @@ def create_progress_bar():
 
 def update_progress(progress_bar, status_label, monitor, current, total, start_time, message="Processing"):
     """
-    Update progress bar with ETA, CPU%, RAM
-    
-    Args:
-        progress_bar: Progress widget
-        status_label: Status HTML widget
-        monitor: ResourceMonitor instance
-        current: Current iteration (0-based)
-        total: Total iterations
-        start_time: Start timestamp
-        message: Status message
+    Update progress bar with ETA, CPU%, RAM (shows BOTH process and container)
     """
     progress = (current / total) * 100
     progress_bar.value = progress
     
-    # Calculate ETA
     elapsed = time.time() - start_time
     if current > 0:
         eta_seconds = (elapsed / current) * (total - current)
@@ -195,14 +275,32 @@ def update_progress(progress_bar, status_label, monitor, current, total, start_t
     else:
         eta_str = "calculating..."
     
-    # Get resources
     cpu = monitor.get_cpu_percent()
-    ram_mb, ram_pct = monitor.get_memory_info()
+    process_mb, process_pct, container_mb, container_pct = monitor.get_memory_info()
+    
+    # Build RAM display - show both if different, otherwise just one
+    if abs(container_mb - process_mb) > 10:  # Significant difference (>10MB)
+        ram_display = (
+            f"RAM: <span style='color:#4CAF50'>{process_mb}MB ({process_pct}%)</span> Python | "
+            f"<span style='color:#2196F3'>{container_mb}MB ({container_pct}%)</span> Container"
+        )
+    else:
+        # Same values (on host or small difference)
+        ram_display = f"RAM: {process_mb}MB ({process_pct}%)"
+    
+    # Context info
+    if monitor.use_cgroups:
+        context_info = f"Container: {monitor.cpu_count:.1f} cores"
+        current, max_mem = monitor._read_cgroup_memory()
+        if max_mem:
+            context_info += f", {max_mem / (1024**3):.1f}GB limit"
+    else:
+        context_info = f"Host: {monitor.cpu_count} cores"
     
-    # Update status
     status_label.value = (
         f"<b style='color:#0066cc'>{message} ({current}/{total})</b><br>"
-        f"<span style='color:#666'>ETA: {eta_str} | CPU: {cpu}% | RAM: {ram_mb}MB ({ram_pct}%)</span>"
+        f"<span style='color:#666'>ETA: {eta_str} | CPU: {cpu}% | {ram_display}</span><br>"
+        f"<span style='color:#999;font-size:10px'>{context_info}</span>"
     )
 
 
@@ -222,25 +320,15 @@ def format_time(seconds):
 # API HELPER - AUTOMATIC NORMALIZATION
 # ============================================================
 class APIHelper:
-    """
-    Normalizes API responses to consistent format
-    Handles: dict, DataFrame, or None
-    """
+    """Normalizes API responses to consistent format"""
     
     @staticmethod
     def normalize_response(response, debug=False):
-        """
-        Convert API response to dict format
-        
-        Returns:
-            dict with 'data' key or None
-        """
         if response is None:
             if debug:
                 print("[APIHelper] Response is None")
             return None
         
-        # Case 1: Dict with 'data' key
         if isinstance(response, dict):
             if 'data' in response:
                 if debug:
@@ -251,7 +339,6 @@ class APIHelper:
                     print("[APIHelper] Dict without 'data' key")
                 return None
         
-        # Case 2: DataFrame - convert to dict
         if isinstance(response, pd.DataFrame):
             if response.empty:
                 if debug:
@@ -263,15 +350,11 @@ class APIHelper:
                 print(f"[APIHelper] DataFrame converted: {len(records)} records")
             return {'data': records, 'status': 'success'}
         
-        # Case 3: Unknown type
         if debug:
             print(f"[APIHelper] Unexpected type: {type(response)}")
         return None
 
 
-# ============================================================
-# API MANAGER
-# ============================================================
 class APIManager:
     """Centralized API key management"""
     _api_key = None
@@ -279,7 +362,6 @@ class APIManager:
     
     @classmethod
     def initialize(cls, api_key):
-        """Initialize API with key"""
         if not api_key:
             raise ValueError("API key cannot be empty")
         cls._api_key = api_key
@@ -288,7 +370,6 @@ class APIManager:
     
     @classmethod
     def get_method(cls, endpoint):
-        """Get API method with cached instances"""
         if cls._api_key is None:
             api_key = os.getenv("API_KEY")
             if not api_key:
@@ -302,55 +383,20 @@ class APIManager:
         return cls._methods[endpoint]
 
 
-# ============================================================
-# PUBLIC API FUNCTIONS
-# ============================================================
 def init_api(api_key=None):
-    """
-    Initialize IVolatility API
-    
-    Example:
-        init_api("your-api-key")
-        # or
-        init_api()  # Auto-load from API_KEY env variable
-    """
+    """Initialize IVolatility API"""
     if api_key is None:
         api_key = os.getenv("API_KEY")
     APIManager.initialize(api_key)
 
 
 def api_call(endpoint, debug=False, **kwargs):
-    """
-    Make API call with automatic response normalization
-    
-    Args:
-        endpoint: API endpoint path
-        debug: Enable debug output (prints full URL with API key)
-        **kwargs: API parameters
-    
-    Returns:
-        dict with 'data' key or None
-    
-    Example:
-        # Automatic handling of dict or DataFrame
-        data = api_call('/equities/eod/stock-prices', 
-                       symbol='AAPL', 
-                       from_='2024-01-01',
-                       debug=True)
-        
-        if data:
-            df = pd.DataFrame(data['data'])
-    """
+    """Make API call with automatic response normalization"""
     try:
-        # Build full URL for debugging
         if debug and APIManager._api_key:
             base_url = "https://restapi.ivolatility.com"
-            
-            # Convert Python parameter names to API parameter names
-            # from_ -> from, to_ -> to
             url_params = {}
             for key, value in kwargs.items():
-                # Remove trailing underscore for reserved Python keywords
                 clean_key = key.rstrip('_') if key.endswith('_') else key
                 url_params[clean_key] = value
             
@@ -365,7 +411,7 @@ def api_call(endpoint, debug=False, **kwargs):
         normalized = APIHelper.normalize_response(response, debug=debug)
         
         if normalized is None and debug:
-            print(f"[api_call] ❌ Failed to get data")
+            print(f"[api_call] Failed to get data")
             print(f"[api_call] Endpoint: {endpoint}")
             print(f"[api_call] Params: {kwargs}")
         
@@ -373,7 +419,7 @@ def api_call(endpoint, debug=False, **kwargs):
     
     except Exception as e:
         if debug:
-            print(f"[api_call] ❌ Exception: {e}")
+            print(f"[api_call] Exception: {e}")
             print(f"[api_call] Endpoint: {endpoint}")
             print(f"[api_call] Params: {kwargs}")
         return None
@@ -385,16 +431,9 @@ def api_call(endpoint, debug=False, **kwargs):
 class BacktestResults:
     """Universal container for backtest results"""
     
-    def __init__(self, 
-                 equity_curve,
-                 equity_dates,
-                 trades,
-                 initial_capital,
-                 config,
-                 benchmark_prices=None,
-                 benchmark_symbol='SPY',
-                 daily_returns=None,
-                 debug_info=None):
+    def __init__(self, equity_curve, equity_dates, trades, initial_capital, 
+                 config, benchmark_prices=None, benchmark_symbol='SPY',
+                 daily_returns=None, debug_info=None):
         
         self.equity_curve = equity_curve
         self.equity_dates = equity_dates
@@ -425,24 +464,23 @@ class BacktestResults:
 
 
 # ============================================================
-# BACKTEST ANALYZER
+# BACKTEST ANALYZER (30+ METRICS)
 # ============================================================
 class BacktestAnalyzer:
-    """Calculate 30+ metrics from BacktestResults"""
+    """Calculate all metrics from BacktestResults"""
     
     def __init__(self, results):
         self.results = results
         self.metrics = {}
-        
+    
     def calculate_all_metrics(self):
-        """Calculate all available metrics"""
         r = self.results
         
         # Profitability
         self.metrics['total_pnl'] = r.final_capital - r.initial_capital
         self.metrics['total_return'] = (self.metrics['total_pnl'] / r.initial_capital) * 100
         
-        # CAGR with zero-division protection
+        # CAGR
         if len(r.equity_dates) > 0:
             start_date = min(r.equity_dates)
             end_date = max(r.equity_dates)
@@ -467,12 +505,7 @@ class BacktestAnalyzer:
         self.metrics['sharpe'] = self._sharpe_ratio(r.daily_returns)
         self.metrics['sortino'] = self._sortino_ratio(r.daily_returns)
         self.metrics['max_drawdown'] = r.max_drawdown
-        
-        if len(r.daily_returns) > 0:
-            self.metrics['volatility'] = np.std(r.daily_returns) * np.sqrt(252) * 100
-        else:
-            self.metrics['volatility'] = 0
-            
+        self.metrics['volatility'] = np.std(r.daily_returns) * np.sqrt(252) * 100 if len(r.daily_returns) > 0 else 0
         self.metrics['calmar'] = abs(self.metrics['total_return'] / r.max_drawdown) if r.max_drawdown > 0 else 0
         self.metrics['omega'] = self._omega_ratio(r.daily_returns)
         self.metrics['ulcer'] = self._ulcer_index(r.equity_curve)
@@ -496,37 +529,9 @@ class BacktestAnalyzer:
         
         # Trading stats
         if len(r.trades) > 0:
-            trades_df = pd.DataFrame(r.trades)
-            winning = trades_df[trades_df['pnl'] > 0]
-            losing = trades_df[trades_df['pnl'] <= 0]
-            
-            self.metrics['total_trades'] = len(trades_df)
-            self.metrics['winning_trades'] = len(winning)
-            self.metrics['losing_trades'] = len(losing)
-            self.metrics['win_rate'] = (len(winning) / len(trades_df)) * 100 if len(trades_df) > 0 else 0
-            
-            wins_sum = winning['pnl'].sum() if len(winning) > 0 else 0
-            losses_sum = abs(losing['pnl'].sum()) if len(losing) > 0 else 0
-            self.metrics['profit_factor'] = wins_sum / losses_sum if losses_sum > 0 else float('inf')
-            
-            self.metrics['avg_win'] = winning['pnl'].mean() if len(winning) > 0 else 0
-            self.metrics['avg_loss'] = losing['pnl'].mean() if len(losing) > 0 else 0
-            self.metrics['best_trade'] = trades_df['pnl'].max()
-            self.metrics['worst_trade'] = trades_df['pnl'].min()
-            
-            if len(winning) > 0 and len(losing) > 0:
-                self.metrics['avg_win_loss_ratio'] = abs(self.metrics['avg_win'] / self.metrics['avg_loss'])
-            else:
-                self.metrics['avg_win_loss_ratio'] = 0
-            
-            self.metrics['max_win_streak'], self.metrics['max_loss_streak'] = self._win_loss_streaks(r.trades)
+            self._calculate_trading_stats(r.trades)
         else:
-            self.metrics.update({
-                'total_trades': 0, 'winning_trades': 0, 'losing_trades': 0,
-                'win_rate': 0, 'profit_factor': 0, 'avg_win': 0, 'avg_loss': 0,
-                'best_trade': 0, 'worst_trade': 0, 'avg_win_loss_ratio': 0,
-                'max_win_streak': 0, 'max_loss_streak': 0
-            })
+            self._set_empty_trading_stats()
         
         # Efficiency
         running_max = np.maximum.accumulate(r.equity_curve)
@@ -542,6 +547,40 @@ class BacktestAnalyzer:
         
         return self.metrics
     
+    def _calculate_trading_stats(self, trades):
+        trades_df = pd.DataFrame(trades)
+        winning = trades_df[trades_df['pnl'] > 0]
+        losing = trades_df[trades_df['pnl'] <= 0]
+        
+        self.metrics['total_trades'] = len(trades_df)
+        self.metrics['winning_trades'] = len(winning)
+        self.metrics['losing_trades'] = len(losing)
+        self.metrics['win_rate'] = (len(winning) / len(trades_df)) * 100 if len(trades_df) > 0 else 0
+        
+        wins_sum = winning['pnl'].sum() if len(winning) > 0 else 0
+        losses_sum = abs(losing['pnl'].sum()) if len(losing) > 0 else 0
+        self.metrics['profit_factor'] = wins_sum / losses_sum if losses_sum > 0 else float('inf')
+        
+        self.metrics['avg_win'] = winning['pnl'].mean() if len(winning) > 0 else 0
+        self.metrics['avg_loss'] = losing['pnl'].mean() if len(losing) > 0 else 0
+        self.metrics['best_trade'] = trades_df['pnl'].max()
+        self.metrics['worst_trade'] = trades_df['pnl'].min()
+        
+        if len(winning) > 0 and len(losing) > 0:
+            self.metrics['avg_win_loss_ratio'] = abs(self.metrics['avg_win'] / self.metrics['avg_loss'])
+        else:
+            self.metrics['avg_win_loss_ratio'] = 0
+        
+        self.metrics['max_win_streak'], self.metrics['max_loss_streak'] = self._win_loss_streaks(trades)
+    
+    def _set_empty_trading_stats(self):
+        self.metrics.update({
+            'total_trades': 0, 'winning_trades': 0, 'losing_trades': 0,
+            'win_rate': 0, 'profit_factor': 0, 'avg_win': 0, 'avg_loss': 0,
+            'best_trade': 0, 'worst_trade': 0, 'avg_win_loss_ratio': 0,
+            'max_win_streak': 0, 'max_loss_streak': 0
+        })
+    
     def _sharpe_ratio(self, returns):
         if len(returns) < 2:
             return 0
@@ -760,7 +799,6 @@ class ResultsReporter:
             print(f"Beta (vs {r.benchmark_symbol}):      {m['beta']:>15.2f}  (<1 defensive, >1 aggressive)")
             print(f"R^2 (vs {r.benchmark_symbol}):        {m['r_squared']:>15.2f}  (market correlation 0-1)")
         
-        # Warning for unrealistic results
         if abs(m['total_return']) > 200 or m['volatility'] > 150:
             print()
             print("⚠️  UNREALISTIC RESULTS DETECTED:")
@@ -809,7 +847,6 @@ class ChartGenerator:
     @staticmethod
     def create_all_charts(analyzer, filename='backtest_results.png'):
         r = analyzer.results
-        m = analyzer.metrics
         
         if len(r.trades) == 0:
             print("No trades to visualize")
@@ -817,13 +854,12 @@ class ChartGenerator:
         
         trades_df = pd.DataFrame(r.trades)
         fig, axes = plt.subplots(3, 2, figsize=(18, 14))
-        fig.suptitle('Backtest Results - Comprehensive Analysis', 
-                     fontsize=16, fontweight='bold', y=0.995)
+        fig.suptitle('Backtest Results', fontsize=16, fontweight='bold', y=0.995)
         
         dates = pd.to_datetime(r.equity_dates)
         equity_array = np.array(r.equity_curve)
         
-        # Equity Curve
+        # 1. Equity Curve
         ax1 = axes[0, 0]
         ax1.plot(dates, equity_array, linewidth=2.5, color='#2196F3')
         ax1.axhline(y=r.initial_capital, color='gray', linestyle='--', alpha=0.7)
@@ -833,78 +869,66 @@ class ChartGenerator:
         ax1.fill_between(dates, r.initial_capital, equity_array,
                          where=(equity_array < r.initial_capital), 
                          alpha=0.3, color='red', interpolate=True)
-        ax1.set_title('Portfolio Equity Curve', fontsize=12, fontweight='bold')
+        ax1.set_title('Equity Curve', fontsize=12, fontweight='bold')
         ax1.set_ylabel('Equity ($)')
         ax1.grid(True, alpha=0.3)
-        ax1.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: f'${x/1000:.0f}K'))
         
-        # Drawdown
+        # 2. Drawdown
         ax2 = axes[0, 1]
         running_max = np.maximum.accumulate(equity_array)
         drawdown = (equity_array - running_max) / running_max * 100
         ax2.fill_between(dates, 0, drawdown, alpha=0.6, color='#f44336')
         ax2.plot(dates, drawdown, color='#d32f2f', linewidth=2)
-        max_dd_idx = np.argmin(drawdown)
-        ax2.scatter(dates[max_dd_idx], drawdown[max_dd_idx], color='darkred', s=100, zorder=5, marker='v')
-        ax2.set_title('Drawdown Over Time', fontsize=12, fontweight='bold')
+        ax2.set_title('Drawdown', fontsize=12, fontweight='bold')
         ax2.set_ylabel('Drawdown (%)')
         ax2.grid(True, alpha=0.3)
         
-        # P&L Distribution
+        # 3. P&L Distribution
         ax3 = axes[1, 0]
         pnl_values = trades_df['pnl'].values
         ax3.hist(pnl_values, bins=40, color='#4CAF50', alpha=0.7, edgecolor='black')
         ax3.axvline(x=0, color='red', linestyle='--', linewidth=2)
-        ax3.axvline(x=np.median(pnl_values), color='blue', linestyle='--', linewidth=2)
-        ax3.set_title('Trade P&L Distribution', fontsize=12, fontweight='bold')
+        ax3.set_title('P&L Distribution', fontsize=12, fontweight='bold')
         ax3.set_xlabel('P&L ($)')
-        ax3.set_ylabel('Frequency')
         ax3.grid(True, alpha=0.3, axis='y')
         
-        # Signal Performance
+        # 4. Signal Performance
         ax4 = axes[1, 1]
         if 'signal' in trades_df.columns:
             signal_pnl = trades_df.groupby('signal')['pnl'].sum()
             colors = ['#4CAF50' if x > 0 else '#f44336' for x in signal_pnl.values]
-            bars = ax4.bar(signal_pnl.index, signal_pnl.values, color=colors, alpha=0.7, edgecolor='black')
-            for bar in bars:
-                height = bar.get_height()
-                ax4.text(bar.get_x() + bar.get_width()/2., height,
-                        f'${height:,.0f}', ha='center', va='bottom' if height > 0 else 'top', fontweight='bold')
-            ax4.set_title('P&L by Signal Type', fontsize=12, fontweight='bold')
+            ax4.bar(signal_pnl.index, signal_pnl.values, color=colors, alpha=0.7, edgecolor='black')
+            ax4.set_title('P&L by Signal', fontsize=12, fontweight='bold')
         else:
             ax4.text(0.5, 0.5, 'No signal data', ha='center', va='center', transform=ax4.transAxes)
-        ax4.set_ylabel('Total P&L ($)')
-        ax4.axhline(y=0, color='black', linestyle='-', linewidth=1)
+        ax4.axhline(y=0, color='black', linewidth=1)
         ax4.grid(True, alpha=0.3, axis='y')
         
-        # Monthly Returns
+        # 5. Monthly Returns
         ax5 = axes[2, 0]
         trades_df['exit_date'] = pd.to_datetime(trades_df['exit_date'])
         trades_df['month'] = trades_df['exit_date'].dt.to_period('M')
         monthly_pnl = trades_df.groupby('month')['pnl'].sum()
-        colors_monthly = ['#4CAF50' if x > 0 else '#f44336' for x in monthly_pnl.values]
-        ax5.bar(range(len(monthly_pnl)), monthly_pnl.values, color=colors_monthly, alpha=0.7, edgecolor='black')
+        colors = ['#4CAF50' if x > 0 else '#f44336' for x in monthly_pnl.values]
+        ax5.bar(range(len(monthly_pnl)), monthly_pnl.values, color=colors, alpha=0.7, edgecolor='black')
         ax5.set_title('Monthly P&L', fontsize=12, fontweight='bold')
-        ax5.set_ylabel('P&L ($)')
         ax5.set_xticks(range(len(monthly_pnl)))
         ax5.set_xticklabels([str(m) for m in monthly_pnl.index], rotation=45, ha='right')
-        ax5.axhline(y=0, color='black', linestyle='-', linewidth=1)
+        ax5.axhline(y=0, color='black', linewidth=1)
         ax5.grid(True, alpha=0.3, axis='y')
         
-        # Top Symbols
+        # 6. Top Symbols
         ax6 = axes[2, 1]
         if 'symbol' in trades_df.columns:
             symbol_pnl = trades_df.groupby('symbol')['pnl'].sum().sort_values(ascending=True).tail(10)
-            colors_symbols = ['#4CAF50' if x > 0 else '#f44336' for x in symbol_pnl.values]
-            ax6.barh(range(len(symbol_pnl)), symbol_pnl.values, color=colors_symbols, alpha=0.7, edgecolor='black')
+            colors = ['#4CAF50' if x > 0 else '#f44336' for x in symbol_pnl.values]
+            ax6.barh(range(len(symbol_pnl)), symbol_pnl.values, color=colors, alpha=0.7, edgecolor='black')
             ax6.set_yticks(range(len(symbol_pnl)))
             ax6.set_yticklabels(symbol_pnl.index, fontsize=9)
-            ax6.set_title('Top 10 Symbols by P&L', fontsize=12, fontweight='bold')
+            ax6.set_title('Top Symbols', fontsize=12, fontweight='bold')
         else:
             ax6.text(0.5, 0.5, 'No symbol data', ha='center', va='center', transform=ax6.transAxes)
-        ax6.set_xlabel('Total P&L ($)')
-        ax6.axvline(x=0, color='black', linestyle='-', linewidth=1)
+        ax6.axvline(x=0, color='black', linewidth=1)
         ax6.grid(True, alpha=0.3, axis='x')
         
         plt.tight_layout()
@@ -918,7 +942,7 @@ class ChartGenerator:
 # RESULTS EXPORTER
 # ============================================================
 class ResultsExporter:
-    """Export results to CSV files"""
+    """Export results to CSV"""
     
     @staticmethod
     def export_all(analyzer, prefix='backtest'):
@@ -929,14 +953,12 @@ class ResultsExporter:
             print("No trades to export")
             return
         
-        # Trades
         trades_df = pd.DataFrame(r.trades)
         trades_df['entry_date'] = pd.to_datetime(trades_df['entry_date']).dt.strftime('%Y-%m-%d')
         trades_df['exit_date'] = pd.to_datetime(trades_df['exit_date']).dt.strftime('%Y-%m-%d')
         trades_df.to_csv(f'{prefix}_trades.csv', index=False)
         print(f"Exported: {prefix}_trades.csv")
         
-        # Equity
         equity_df = pd.DataFrame({
             'date': pd.to_datetime(r.equity_dates).strftime('%Y-%m-%d'),
             'equity': r.equity_curve
@@ -944,46 +966,35 @@ class ResultsExporter:
         equity_df.to_csv(f'{prefix}_equity.csv', index=False)
         print(f"Exported: {prefix}_equity.csv")
         
-        # Summary
         with open(f'{prefix}_summary.txt', 'w') as f:
             f.write("BACKTEST SUMMARY\n")
             f.write("="*70 + "\n\n")
             f.write(f"Strategy: {r.config.get('strategy_name', 'Unknown')}\n")
-            f.write(f"Period: {r.config.get('start_date', 'N/A')} to {r.config.get('end_date', 'N/A')}\n\n")
+            f.write(f"Period: {r.config.get('start_date')} to {r.config.get('end_date')}\n\n")
             f.write("PERFORMANCE\n")
             f.write("-"*70 + "\n")
-            f.write(f"Initial Capital: ${r.initial_capital:,.2f}\n")
-            f.write(f"Final Equity: ${r.final_capital:,.2f}\n")
             f.write(f"Total Return: {m['total_return']:.2f}%\n")
-            f.write(f"Sharpe Ratio: {m['sharpe']:.2f}\n")
-            f.write(f"Max Drawdown: {m['max_drawdown']:.2f}%\n")
-            f.write(f"Win Rate: {m['win_rate']:.2f}%\n")
-            f.write(f"Total Trades: {m['total_trades']}\n")
+            f.write(f"Sharpe: {m['sharpe']:.2f}\n")
+            f.write(f"Max DD: {m['max_drawdown']:.2f}%\n")
+            f.write(f"Trades: {m['total_trades']}\n")
         
         print(f"Exported: {prefix}_summary.txt")
 
 
 # ============================================================
-# ONE-COMMAND RUNNER
+# RUN BACKTEST
 # ============================================================
-def run_backtest(strategy_function, config, 
-                 print_report=True,
-                 create_charts=True, 
-                 export_results=True,
+def run_backtest(strategy_function, config, print_report=True,
+                 create_charts=True, export_results=True,
                  chart_filename='backtest_results.png',
                  export_prefix='backtest'):
-    """
-    Run complete backtest with one command
-    
-    Example:
-        analyzer = run_backtest(my_strategy, CONFIG)
-    """
+    """Run complete backtest with one command"""
     
     print("="*80)
     print(" "*25 + "STARTING BACKTEST")
     print("="*80)
     print(f"Strategy: {config.get('strategy_name', 'Unknown')}")
-    print(f"Period: {config.get('start_date', 'N/A')} to {config.get('end_date', 'N/A')}")
+    print(f"Period: {config.get('start_date')} to {config.get('end_date')}")
     print(f"Capital: ${config.get('initial_capital', 0):,.0f}")
     print("="*80 + "\n")
     
@@ -1002,10 +1013,10 @@ def run_backtest(strategy_function, config,
         try:
             ChartGenerator.create_all_charts(analyzer, chart_filename)
         except Exception as e:
-            print(f"[ERROR] Chart creation failed: {e}")
+            print(f"[ERROR] Charts failed: {e}")
     
     if export_results and len(results.trades) > 0:
-        print(f"\n[*] Exporting results: {export_prefix}_*")
+        print(f"\n[*] Exporting: {export_prefix}_*")
         try:
             ResultsExporter.export_all(analyzer, export_prefix)
         except Exception as e:
@@ -1014,22 +1025,9 @@ def run_backtest(strategy_function, config,
     return analyzer
 
 
-# ============================================================
-# EXPORTS
-# ============================================================
 __all__ = [
-    'BacktestResults',
-    'BacktestAnalyzer', 
-    'ResultsReporter',
-    'ChartGenerator',
-    'ResultsExporter',
-    'run_backtest',
-    'init_api',
-    'api_call',
-    'APIHelper',
-    'APIManager',
-    'ResourceMonitor',
-    'create_progress_bar',
-    'update_progress',
-    'format_time'
-]
+    'BacktestResults', 'BacktestAnalyzer', 'ResultsReporter',
+    'ChartGenerator', 'ResultsExporter', 'run_backtest',
+    'init_api', 'api_call', 'APIHelper', 'APIManager',
+    'ResourceMonitor', 'create_progress_bar', 'update_progress', 'format_time'
+]

{ivolatility_backtesting-1.2.0.dist-info → ivolatility_backtesting-1.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ivolatility_backtesting
-Version: 1.2.0
+Version: 1.3.1
 Summary: A universal backtesting framework for financial strategies using the IVolatility API.
 Author-email: IVolatility <support@ivolatility.com>
 Project-URL: Homepage, https://ivolatility.com

ivolatility_backtesting-1.3.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+ivolatility_backtesting/__init__.py,sha256=abZYqTZwvzgSdSs55g3_zU8mtbNKveUndoDgKU8tnIo,577
+ivolatility_backtesting/ivolatility_backtesting.py,sha256=xyvYFfUp4jNrfso5MpbUNBY-kK4lUnvyj0lmoMelCYQ,42141
+ivolatility_backtesting-1.3.1.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ivolatility_backtesting-1.3.1.dist-info/METADATA,sha256=erCDHvApgidlPP3kF7PRkfQBc1Edwu9qAFiOzch1qr0,2052
+ivolatility_backtesting-1.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ivolatility_backtesting-1.3.1.dist-info/top_level.txt,sha256=Qv3irUBntr8b11WIKNN6zzCSguwaWC4nWR-ZKq8NsjY,24
+ivolatility_backtesting-1.3.1.dist-info/RECORD,,

ivolatility_backtesting-1.2.0.dist-info/RECORD

@@ -1,7 +0,0 @@
-ivolatility_backtesting/__init__.py,sha256=abZYqTZwvzgSdSs55g3_zU8mtbNKveUndoDgKU8tnIo,577
-ivolatility_backtesting/ivolatility_backtesting.py,sha256=_lo2QrdWTf8IVpp4AIIGw7_t88GhbSeHRAT4KEcwmBw,40916
-ivolatility_backtesting-1.2.0.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ivolatility_backtesting-1.2.0.dist-info/METADATA,sha256=SRFqAyNI-qOs2CeX3DZF0kJwbVnsQQMbOCkPs2LNOKc,2052
-ivolatility_backtesting-1.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ivolatility_backtesting-1.2.0.dist-info/top_level.txt,sha256=Qv3irUBntr8b11WIKNN6zzCSguwaWC4nWR-ZKq8NsjY,24
-ivolatility_backtesting-1.2.0.dist-info/RECORD,,