ivolatility-backtesting 1.1.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

ivolatility_backtesting/__init__.py

@@ -1,17 +1,23 @@
 from .ivolatility_backtesting import (
     BacktestResults, BacktestAnalyzer, ResultsReporter, 
     ChartGenerator, ResultsExporter, run_backtest, 
-    init_api, get_api_method, APIManager
+    init_api, api_call, APIHelper, APIManager, 
+    ResourceMonitor, create_progress_bar, update_progress, format_time
 )
 
 __all__ = [
     'BacktestResults',
-    'BacktestAnalyzer',
+    'BacktestAnalyzer', 
     'ResultsReporter',
     'ChartGenerator',
     'ResultsExporter',
     'run_backtest',
     'init_api',
-    'get_api_method',
-    'APIManager'
+    'api_call',
+    'APIHelper',
+    'APIManager',
+    'ResourceMonitor',
+    'create_progress_bar',
+    'update_progress',
+    'format_time'
 ]

ivolatility_backtesting/ivolatility_backtesting.py

@@ -1,23 +1,38 @@
 """
-ivolatility_backtesting.py - UPDATED VERSION
-Universal Backtest Framework with API Response Normalization
+ivolatility_backtesting.py - UNIVERSAL BACKTEST FRAMEWORK
+Version 4.1 - Dual RAM Display (Process + Container)
 
-NEW FEATURES:
-- APIHelper class for automatic response normalization
-- Handles both dict and DataFrame responses from IVolatility API
-- Safe data extraction with proper error handling
-- Unified interface for all API calls
+Key Features:
+- 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 once
     init_api(os.getenv("API_KEY"))
     
-    # Use API helper for normalized responses
-    data = api_call('/equities/eod/stock-prices', symbol='AAPL', from_='2024-01-01')
-    if data:  # Always returns dict or None
-        df = pd.DataFrame(data)
+    data = api_call('/equities/eod/stock-prices', 
+                   symbol='AAPL', 
+                   from_='2024-01-01',
+                   to='2024-12-31',
+                   debug=True)
+    
+    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
@@ -27,50 +42,303 @@ import seaborn as sns
 from datetime import datetime, timedelta
 import ivolatility as ivol
 import os
+import time
+import psutil
 
-# Set style
 sns.set_style('darkgrid')
 plt.rcParams['figure.figsize'] = (15, 8)
 
 
 # ============================================================
-# API HELPER - NEW!
+# RESOURCE MONITOR
 # ============================================================
-class APIHelper:
-    """
-    Helper class for normalized API responses
-    Automatically handles both dict and DataFrame responses
-    """
+class ResourceMonitor:
+    """Monitor CPU and RAM - shows PROCESS resources (Python), not full container"""
     
-    @staticmethod
-    def normalize_response(response, debug=False):
-        """
-        Convert API response to consistent dict format
+    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"
         
-        Args:
-            response: API response (dict, DataFrame, or other)
-            debug: Print debug information
+    def _check_cgroups_v2(self):
+        try:
+            return os.path.exists('/sys/fs/cgroup/cpu.stat') and \
+                   os.path.exists('/sys/fs/cgroup/memory.current')
+        except:
+            return False
+    
+    def _read_cgroup_cpu(self):
+        try:
+            with open('/sys/fs/cgroup/cpu.stat', 'r') as f:
+                for line in f:
+                    if line.startswith('usage_usec'):
+                        return int(line.split()[1])
+        except:
+            pass
+        return None
+    
+    def _read_cgroup_memory(self):
+        try:
+            with open('/sys/fs/cgroup/memory.current', 'r') as f:
+                current = int(f.read().strip())
+            with open('/sys/fs/cgroup/memory.max', 'r') as f:
+                max_mem = f.read().strip()
+                if max_mem == 'max':
+                    max_mem = psutil.virtual_memory().total
+                else:
+                    max_mem = int(max_mem)
+            return current, max_mem
+        except:
+            pass
+        return None, None
+    
+    def get_cpu_percent(self):
+        """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()
+            
+            if current_cpu and self.last_cpu_time and self.last_check_time:
+                time_delta = current_time - self.last_check_time
+                cpu_delta = current_cpu - self.last_cpu_time
+                
+                if time_delta > 0:
+                    # 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 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: host resources with smoothing
+        try:
+            cpu = self.process.cpu_percent(interval=0.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 - returns BOTH process and container/host
         
         Returns:
-            dict with 'data' key containing list of records, or None if invalid
+            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()
+            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
+            
+            # 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, 0.0, 0.0
+
+
+def create_progress_bar():
+    """Create enhanced progress bar with ETA, CPU%, RAM"""
+    from IPython.display import display
+    import ipywidgets as widgets
+    
+    progress_bar = widgets.FloatProgress(
+        value=0, min=0, max=100,
+        description='Progress:',
+        bar_style='info',
+        style={'bar_color': '#00ff00'},
+        layout=widgets.Layout(width='100%', height='30px')
+    )
+    
+    status_label = widgets.HTML(
+        value="<b style='color:#0066cc'>Starting...</b>"
+    )
+    
+    display(widgets.VBox([progress_bar, status_label]))
+    
+    monitor = ResourceMonitor()
+    start_time = time.time()
+    
+    return progress_bar, status_label, monitor, start_time
+
+
+def update_progress(progress_bar, status_label, monitor, current, total, start_time, message="Processing"):
+    """
+    Update progress bar with ETA, CPU%, RAM (shows BOTH process and container)
+    """
+    progress = (current / total) * 100
+    progress_bar.value = progress
+    
+    elapsed = time.time() - start_time
+    if current > 0:
+        eta_seconds = (elapsed / current) * (total - current)
+        eta_str = format_time(eta_seconds)
+    else:
+        eta_str = "calculating..."
+    
+    cpu = monitor.get_cpu_percent()
+    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"
+    
+    status_label.value = (
+        f"<b style='color:#0066cc'>{message} ({current}/{total})</b><br>"
+        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>"
+    )
+
+
+def format_time(seconds):
+    """Format seconds to human readable time"""
+    if seconds < 60:
+        return f"{int(seconds)}s"
+    elif seconds < 3600:
+        return f"{int(seconds // 60)}m {int(seconds % 60)}s"
+    else:
+        hours = int(seconds // 3600)
+        minutes = int((seconds % 3600) // 60)
+        return f"{hours}h {minutes}m"
+
+
+# ============================================================
+# API HELPER - AUTOMATIC NORMALIZATION
+# ============================================================
+class APIHelper:
+    """Normalizes API responses to consistent format"""
+    
+    @staticmethod
+    def normalize_response(response, debug=False):
         if response is None:
             if debug:
                 print("[APIHelper] Response is None")
             return None
         
-        # Case 1: Already a dict with 'data' key
         if isinstance(response, dict):
             if 'data' in response:
                 if debug:
-                    print(f"[APIHelper] Dict response with {len(response['data'])} records")
+                    print(f"[APIHelper] Dict response: {len(response['data'])} records")
                 return response
             else:
                 if debug:
-                    print("[APIHelper] Dict response without 'data' key")
+                    print("[APIHelper] Dict without 'data' key")
                 return None
         
-        # Case 2: DataFrame - convert to dict
         if isinstance(response, pd.DataFrame):
             if response.empty:
                 if debug:
@@ -79,73 +347,33 @@ class APIHelper:
             
             records = response.to_dict('records')
             if debug:
-                print(f"[APIHelper] Converted DataFrame to dict with {len(records)} records")
+                print(f"[APIHelper] DataFrame converted: {len(records)} records")
             return {'data': records, 'status': 'success'}
         
-        # Case 3: Unknown type
         if debug:
-            print(f"[APIHelper] Unexpected response type: {type(response)}")
+            print(f"[APIHelper] Unexpected type: {type(response)}")
         return None
-    
-    @staticmethod
-    def safe_dataframe(response, debug=False):
-        """
-        Safely convert API response to DataFrame
-        
-        Args:
-            response: API response (any type)
-            debug: Print debug information
-        
-        Returns:
-            pandas DataFrame or empty DataFrame if invalid
-        """
-        normalized = APIHelper.normalize_response(response, debug=debug)
-        
-        if normalized is None or 'data' not in normalized:
-            if debug:
-                print("[APIHelper] Cannot create DataFrame - no valid data")
-            return pd.DataFrame()
-        
-        try:
-            df = pd.DataFrame(normalized['data'])
-            if debug:
-                print(f"[APIHelper] Created DataFrame with shape {df.shape}")
-            return df
-        except Exception as e:
-            if debug:
-                print(f"[APIHelper] DataFrame creation failed: {e}")
-            return pd.DataFrame()
 
 
-# ============================================================
-# GLOBAL API MANAGER (Updated)
-# ============================================================
 class APIManager:
-    """
-    Centralized API key management for IVolatility API
-    Now includes response normalization
-    """
+    """Centralized API key management"""
     _api_key = None
     _methods = {}
     
     @classmethod
     def initialize(cls, api_key):
-        """Set API key globally - call this once at startup"""
         if not api_key:
             raise ValueError("API key cannot be empty")
         cls._api_key = api_key
         ivol.setLoginParams(apiKey=api_key)
-        print(f"[API] Initialized with key: {api_key[:10]}...{api_key[-5:]}")
+        print(f"[API] Initialized: {api_key[:10]}...{api_key[-5:]}")
     
     @classmethod
     def get_method(cls, endpoint):
-        """Get API method with automatic key injection"""
         if cls._api_key is None:
             api_key = os.getenv("API_KEY")
             if not api_key:
-                raise ValueError(
-                    "API key not initialized. Call init_api(key) first or set API_KEY environment variable"
-                )
+                raise ValueError("API key not set. Call init_api(key) first")
             cls.initialize(api_key)
         
         if endpoint not in cls._methods:
@@ -153,61 +381,39 @@ class APIManager:
             cls._methods[endpoint] = ivol.setMethod(endpoint)
         
         return cls._methods[endpoint]
-    
-    @classmethod
-    def is_initialized(cls):
-        """Check if API is initialized"""
-        return cls._api_key is not None
 
 
-# Public API functions (Updated)
 def init_api(api_key=None):
-    """Initialize IVolatility API with key"""
+    """Initialize IVolatility API"""
     if api_key is None:
         api_key = os.getenv("API_KEY")
     APIManager.initialize(api_key)
 
 
-def get_api_method(endpoint):
-    """Get API method for specified endpoint"""
-    return APIManager.get_method(endpoint)
-
-
 def api_call(endpoint, debug=False, **kwargs):
-    """
-    Make API call with automatic response normalization
-    
-    Args:
-        endpoint: API endpoint path
-        debug: Enable debug output
-        **kwargs: API parameters
-    
-    Returns:
-        dict with 'data' key (normalized format) or None if error
-    
-    Example:
-        # Old way (manual handling):
-        method = get_api_method('/equities/eod/stock-prices')
-        response = method(symbol='AAPL', from_='2024-01-01')
-        if isinstance(response, pd.DataFrame):
-            df = response
-        elif isinstance(response, dict):
-            df = pd.DataFrame(response['data'])
-        
-        # New way (automatic):
-        data = api_call('/equities/eod/stock-prices', symbol='AAPL', from_='2024-01-01')
-        if data:
-            df = pd.DataFrame(data['data'])
-    """
+    """Make API call with automatic response normalization"""
     try:
-        method = get_api_method(endpoint)
+        if debug and APIManager._api_key:
+            base_url = "https://restapi.ivolatility.com"
+            url_params = {}
+            for key, value in kwargs.items():
+                clean_key = key.rstrip('_') if key.endswith('_') else key
+                url_params[clean_key] = value
+            
+            params_str = "&".join([f"{k}={v}" for k, v in url_params.items()])
+            full_url = f"{base_url}{endpoint}?apiKey={APIManager._api_key}&{params_str}"
+            print(f"\n[API] Full URL:")
+            print(f"[API] {full_url}\n")
+        
+        method = APIManager.get_method(endpoint)
         response = method(**kwargs)
         
         normalized = APIHelper.normalize_response(response, debug=debug)
         
         if normalized is None and debug:
-            print(f"[api_call] Failed to get valid data from {endpoint}")
-            print(f"[api_call] Parameters: {kwargs}")
+            print(f"[api_call] Failed to get data")
+            print(f"[api_call] Endpoint: {endpoint}")
+            print(f"[api_call] Params: {kwargs}")
         
         return normalized
     
@@ -215,25 +421,19 @@ def api_call(endpoint, debug=False, **kwargs):
         if debug:
             print(f"[api_call] Exception: {e}")
             print(f"[api_call] Endpoint: {endpoint}")
-            print(f"[api_call] Parameters: {kwargs}")
+            print(f"[api_call] Params: {kwargs}")
         return None
 
 
 # ============================================================
-# BACKTEST RESULTS (Unchanged)
+# BACKTEST RESULTS
 # ============================================================
 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
@@ -264,23 +464,23 @@ class BacktestResults:
 
 
 # ============================================================
-# BACKTEST ANALYZER (Unchanged - same as before)
+# BACKTEST ANALYZER (30+ METRICS)
 # ============================================================
 class BacktestAnalyzer:
-    """Universal metrics calculator"""
+    """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
         
-        # Basic profitability
+        # 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 protection
+        # CAGR
         if len(r.equity_dates) > 0:
             start_date = min(r.equity_dates)
             end_date = max(r.equity_dates)
@@ -291,7 +491,6 @@ class BacktestAnalyzer:
                 self.metrics['show_cagr'] = False
             else:
                 years = days_diff / 365.25
-                
                 if years >= 1.0:
                     self.metrics['cagr'] = ((r.final_capital / r.initial_capital) ** (1/years) - 1) * 100
                     self.metrics['show_cagr'] = True
@@ -306,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)
@@ -335,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)
@@ -381,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
@@ -532,11 +732,10 @@ class BacktestAnalyzer:
 
 
 # ============================================================
-# RESULTS REPORTER, CHART GENERATOR, RESULTS EXPORTER
-# (All unchanged - same as before)
+# RESULTS REPORTER
 # ============================================================
 class ResultsReporter:
-    """Universal results printer"""
+    """Print comprehensive metrics report"""
     
     @staticmethod
     def print_full_report(analyzer):
@@ -554,7 +753,7 @@ class ResultsReporter:
             for debug_msg in r.debug_info[:10]:
                 print(debug_msg)
             if len(r.debug_info) > 10:
-                print(f"... and {len(r.debug_info) - 10} more debug messages")
+                print(f"... and {len(r.debug_info) - 10} more messages")
             print()
         
         print("PROFITABILITY METRICS")
@@ -602,12 +801,12 @@ class ResultsReporter:
         
         if abs(m['total_return']) > 200 or m['volatility'] > 150:
             print()
-            print("UNREALISTIC RESULTS DETECTED:")
+            print("⚠️  UNREALISTIC RESULTS DETECTED:")
             if abs(m['total_return']) > 200:
-                print(f"  Total return {m['total_return']:.1f}% is extremely high")
+                print(f"  • Total return {m['total_return']:.1f}% is extremely high")
             if m['volatility'] > 150:
-                print(f"  Volatility {m['volatility']:.1f}% is higher than leveraged ETFs")
-            print("  Review configuration before trusting results")
+                print(f"  • Volatility {m['volatility']:.1f}% is higher than leveraged ETFs")
+            print("  → Review configuration before trusting results")
         
         print()
         
@@ -639,13 +838,15 @@ class ResultsReporter:
         print("="*80)
 
 
+# ============================================================
+# CHART GENERATOR
+# ============================================================
 class ChartGenerator:
-    """Universal chart creator"""
+    """Generate 6 professional charts"""
     
     @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")
@@ -653,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)
@@ -669,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()
@@ -750,8 +938,11 @@ class ChartGenerator:
         print(f"Chart saved: {filename}")
 
 
+# ============================================================
+# RESULTS EXPORTER
+# ============================================================
 class ResultsExporter:
-    """Universal results exporter"""
+    """Export results to CSV"""
     
     @staticmethod
     def export_all(analyzer, prefix='backtest'):
@@ -766,41 +957,35 @@ class ResultsExporter:
         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"Trades exported: {prefix}_trades.csv")
+        print(f"Exported: {prefix}_trades.csv")
         
         equity_df = pd.DataFrame({
             'date': pd.to_datetime(r.equity_dates).strftime('%Y-%m-%d'),
             'equity': r.equity_curve
         })
         equity_df.to_csv(f'{prefix}_equity.csv', index=False)
-        print(f"Equity exported: {prefix}_equity.csv")
+        print(f"Exported: {prefix}_equity.csv")
         
         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"Summary exported: {prefix}_summary.txt")
+        print(f"Exported: {prefix}_summary.txt")
 
 
 # ============================================================
-# ONE-COMMAND RUNNER (Unchanged)
+# 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"""
@@ -809,7 +994,7 @@ def run_backtest(strategy_function, config,
     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")
     
@@ -827,41 +1012,22 @@ def run_backtest(strategy_function, config,
         print(f"\n[*] Creating charts: {chart_filename}")
         try:
             ChartGenerator.create_all_charts(analyzer, chart_filename)
-            print(f"[OK] Charts saved: {chart_filename}")
         except Exception as e:
-            print(f"[ERROR] Chart creation failed: {e}")
-    elif create_charts and len(results.trades) == 0:
-        print("\n[!] No trades - skipping charts")
+            print(f"[ERROR] Charts failed: {e}")
     
     if export_results and len(results.trades) > 0:
-        print(f"\n[*] Exporting results: {export_prefix}_*.csv")
+        print(f"\n[*] Exporting: {export_prefix}_*")
         try:
             ResultsExporter.export_all(analyzer, export_prefix)
-            print(f"[OK] Files exported:")
-            print(f"  - {export_prefix}_trades.csv")
-            print(f"  - {export_prefix}_equity.csv")
-            print(f"  - {export_prefix}_summary.txt")
         except Exception as e:
             print(f"[ERROR] Export failed: {e}")
-    elif export_results and len(results.trades) == 0:
-        print("\n[!] No trades - skipping export")
     
     return analyzer
 
 
-# ============================================================
-# EXPORTS
-# ============================================================
 __all__ = [
-    'BacktestResults',
-    'BacktestAnalyzer', 
-    'ResultsReporter',
-    'ChartGenerator',
-    'ResultsExporter',
-    'run_backtest',
-    'init_api',
-    'get_api_method',
-    'api_call',           # NEW!
-    'APIHelper',          # NEW!
-    'APIManager'
-]
+    'BacktestResults', 'BacktestAnalyzer', 'ResultsReporter',
+    'ChartGenerator', 'ResultsExporter', 'run_backtest',
+    'init_api', 'api_call', 'APIHelper', 'APIManager',
+    'ResourceMonitor', 'create_progress_bar', 'update_progress', 'format_time'
+]

{ivolatility_backtesting-1.1.0.dist-info → ivolatility_backtesting-1.3.0.dist-info}/METADATA

@@ -1,70 +1,72 @@
-Metadata-Version: 2.1
-Name: ivolatility_backtesting
-Version: 1.1.0
-Summary: A universal backtesting framework for financial strategies using the IVolatility API.
-Author-email: IVolatility <support@ivolatility.com>
-Project-URL: Homepage, https://ivolatility.com
-Keywords: backtesting,finance,trading,ivolatility
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: pandas>=1.5.0
-Requires-Dist: numpy>=1.21.0
-Requires-Dist: matplotlib>=3.5.0
-Requires-Dist: seaborn>=0.11.0
-Requires-Dist: ivolatility>=1.8.2
-
-# IVolatility Backtesting
-A universal backtesting framework for financial strategies using the IVolatility API.
-
-## Installation
-```bash
-pip install ivolatility_backtesting
-```
-
-## Usage
-```python
-from ivolatility_backtesting import run_backtest, init_api
-
-# Initialize API
-init_api("your-api-key")
-
-# Define your strategy
-def my_strategy(config):
-    # Strategy logic
-    return BacktestResults(
-        equity_curve=[100000, 110000],
-        equity_dates=["2023-01-01", "2023-01-02"],
-        trades=[{"pnl": 1000, "entry_date": "2023-01-01", "exit_date": "2023-01-02"}],
-        initial_capital=100000,
-        config=config
-    )
-
-# Run backtest
-CONFIG = {
-    "initial_capital": 100000,
-    "start_date": "2023-01-01",
-    "end_date": "2024-01-01",
-    "strategy_name": "My Strategy"
-}
-analyzer = run_backtest(my_strategy, CONFIG)
-
-# Access metrics
-print(f"Sharpe Ratio: {analyzer.metrics['sharpe']:.2f}")
-```
-
-## Requirements
-- Python >= 3.8
-- pandas >= 1.5.0
-- numpy >= 1.21.0
-- matplotlib >= 3.5.0
-- seaborn >= 0.11.0
-- ivolatility >= 1.8.2
+Metadata-Version: 2.4
+Name: ivolatility_backtesting
+Version: 1.3.0
+Summary: A universal backtesting framework for financial strategies using the IVolatility API.
+Author-email: IVolatility <support@ivolatility.com>
+Project-URL: Homepage, https://ivolatility.com
+Keywords: backtesting,finance,trading,ivolatility
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=1.5.0
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: matplotlib>=3.5.0
+Requires-Dist: seaborn>=0.11.0
+Requires-Dist: ivolatility>=1.8.2
+Requires-Dist: psutil>=7.1.0
+Dynamic: license-file
+
+# IVolatility Backtesting
+A universal backtesting framework for financial strategies using the IVolatility API.
+
+## Installation
+```bash
+pip install ivolatility_backtesting
+```
+
+## Usage
+```python
+from ivolatility_backtesting import run_backtest, init_api
+
+# Initialize API
+init_api("your-api-key")
+
+# Define your strategy
+def my_strategy(config):
+    # Strategy logic
+    return BacktestResults(
+        equity_curve=[100000, 110000],
+        equity_dates=["2023-01-01", "2023-01-02"],
+        trades=[{"pnl": 1000, "entry_date": "2023-01-01", "exit_date": "2023-01-02"}],
+        initial_capital=100000,
+        config=config
+    )
+
+# Run backtest
+CONFIG = {
+    "initial_capital": 100000,
+    "start_date": "2023-01-01",
+    "end_date": "2024-01-01",
+    "strategy_name": "My Strategy"
+}
+analyzer = run_backtest(my_strategy, CONFIG)
+
+# Access metrics
+print(f"Sharpe Ratio: {analyzer.metrics['sharpe']:.2f}")
+```
+
+## Requirements
+- Python >= 3.8
+- pandas >= 1.5.0
+- numpy >= 1.21.0
+- matplotlib >= 3.5.0
+- seaborn >= 0.11.0
+- ivolatility >= 1.8.2

ivolatility_backtesting-1.3.0.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.0.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ivolatility_backtesting-1.3.0.dist-info/METADATA,sha256=bf-tS5-RMyzIaHVGAeOOfxUtcN5BCkV9X4JKR83TK5I,2052
+ivolatility_backtesting-1.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ivolatility_backtesting-1.3.0.dist-info/top_level.txt,sha256=Qv3irUBntr8b11WIKNN6zzCSguwaWC4nWR-ZKq8NsjY,24
+ivolatility_backtesting-1.3.0.dist-info/RECORD,,

{ivolatility_backtesting-1.1.0.dist-info → ivolatility_backtesting-1.3.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.3.2)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

ivolatility_backtesting-1.1.0.dist-info/RECORD

@@ -1,7 +0,0 @@
-ivolatility_backtesting/__init__.py,sha256=-VS3l4sUlmlMjVDwPY2BoXOVoYa5oVGYH9cscK5NLzw,395
-ivolatility_backtesting/ivolatility_backtesting.py,sha256=GLO_h72_mPmLDoknBIH6_rRWXxrZ0BSAr7Q85QTFBkk,35661
-ivolatility_backtesting-1.1.0.dist-info/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ivolatility_backtesting-1.1.0.dist-info/METADATA,sha256=d8vKlXZcuCGCiXzwbJ2DQncLGnFdP844f4NXi0aDG18,2071
-ivolatility_backtesting-1.1.0.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-ivolatility_backtesting-1.1.0.dist-info/top_level.txt,sha256=Qv3irUBntr8b11WIKNN6zzCSguwaWC4nWR-ZKq8NsjY,24
-ivolatility_backtesting-1.1.0.dist-info/RECORD,,