ivolatility-backtesting 1.1.0__tar.gz → 1.2.0__tar.gz

{ivolatility_backtesting-1.1.0 → ivolatility_backtesting-1.2.0}/PKG-INFO

@@ -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.2.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.1.0 → ivolatility_backtesting-1.2.0}/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-1.1.0 → ivolatility_backtesting-1.2.0}/ivolatility_backtesting/ivolatility_backtesting.py

@@ -1,23 +1,25 @@
 """
-ivolatility_backtesting.py - UPDATED VERSION
-Universal Backtest Framework with API Response Normalization
+ivolatility_backtesting.py - UNIVERSAL BACKTEST FRAMEWORK
+Version 2.0 - With DataFrame/Dict Auto-Normalization
 
-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:
+- Handles both dict and DataFrame API responses automatically
+- Universal BacktestResults interface
+- 30+ calculated metrics
+- Automatic reporting, charts, and exports
+- One-command runner: run_backtest()
 
 Usage:
     from ivolatility_backtesting import *
     
-    # Initialize API once
+    # Initialize API
     init_api(os.getenv("API_KEY"))
     
-    # Use API helper for normalized responses
+    # Use api_call 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)
+    
+    # Run backtest
+    analyzer = run_backtest(my_strategy, CONFIG)
 """
 
 import pandas as pd
@@ -27,6 +29,8 @@ 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')
@@ -34,40 +38,217 @@ plt.rcParams['figure.figsize'] = (15, 8)
 
 
 # ============================================================
-# API HELPER - NEW!
+# RESOURCE MONITOR - NEW!
+# ============================================================
+class ResourceMonitor:
+    """Monitor CPU and RAM using cgroups v2 and psutil fallback"""
+    
+    def __init__(self):
+        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()
+        
+    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')
+        except:
+            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:
+                    if line.startswith('usage_usec'):
+                        return int(line.split()[1])
+        except:
+            pass
+        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())
+            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 usage percentage with cgroups v2 fallback to psutil"""
+        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:
+                    # Convert microseconds to percentage
+                    cpu_percent = (cpu_delta / (time_delta * 1_000_000)) * 100
+                    cpu_percent = min(cpu_percent, 100 * self.cpu_count)
+                    
+                    self.last_cpu_time = current_cpu
+                    self.last_check_time = current_time
+                    
+                    return round(cpu_percent, 1)
+            
+            self.last_cpu_time = current_cpu
+            self.last_check_time = current_time
+        
+        # Fallback to psutil
+        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)
+        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)
+        
+        # Fallback to psutil
+        try:
+            mem = self.process.memory_info()
+            mb = mem.rss / (1024 * 1024)
+            total = psutil.virtual_memory().total
+            percent = (mem.rss / total) * 100
+            return round(mb, 1), round(percent, 1)
+        except:
+            return 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)
+    """
+    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
+    
+    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
+    """
+    progress = (current / total) * 100
+    progress_bar.value = progress
+    
+    # Calculate ETA
+    elapsed = time.time() - start_time
+    if current > 0:
+        eta_seconds = (elapsed / current) * (total - current)
+        eta_str = format_time(eta_seconds)
+    else:
+        eta_str = "calculating..."
+    
+    # Get resources
+    cpu = monitor.get_cpu_percent()
+    ram_mb, ram_pct = monitor.get_memory_info()
+    
+    # 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>"
+    )
+
+
+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:
     """
-    Helper class for normalized API responses
-    Automatically handles both dict and DataFrame responses
+    Normalizes API responses to consistent format
+    Handles: dict, DataFrame, or None
     """
     
     @staticmethod
     def normalize_response(response, debug=False):
         """
-        Convert API response to consistent dict format
-        
-        Args:
-            response: API response (dict, DataFrame, or other)
-            debug: Print debug information
+        Convert API response to dict format
         
         Returns:
-            dict with 'data' key containing list of records, or None if invalid
+            dict with 'data' key or None
         """
         if response is None:
             if debug:
                 print("[APIHelper] Response is None")
             return None
         
-        # Case 1: Already a dict with 'data' key
+        # Case 1: 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
@@ -79,73 +260,39 @@ 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)
+# API MANAGER
 # ============================================================
 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"""
+        """Initialize API with key"""
         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"""
+        """Get API method with cached instances"""
         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,77 +300,91 @@ 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)
+# ============================================================
+# PUBLIC API FUNCTIONS
+# ============================================================
 def init_api(api_key=None):
-    """Initialize IVolatility API with key"""
+    """
+    Initialize IVolatility API
+    
+    Example:
+        init_api("your-api-key")
+        # or
+        init_api()  # Auto-load from API_KEY env variable
+    """
     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
+        debug: Enable debug output (prints full URL with API key)
         **kwargs: API parameters
     
     Returns:
-        dict with 'data' key (normalized format) or None if error
+        dict with 'data' key or None
     
     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'])
+        # Automatic handling of dict or DataFrame
+        data = api_call('/equities/eod/stock-prices', 
+                       symbol='AAPL', 
+                       from_='2024-01-01',
+                       debug=True)
         
-        # New way (automatic):
-        data = api_call('/equities/eod/stock-prices', symbol='AAPL', from_='2024-01-01')
         if data:
             df = pd.DataFrame(data['data'])
     """
     try:
-        method = get_api_method(endpoint)
+        # 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
+            
+            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
     
     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] 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,
@@ -264,10 +425,11 @@ class BacktestResults:
 
 
 # ============================================================
-# BACKTEST ANALYZER (Unchanged - same as before)
+# BACKTEST ANALYZER
 # ============================================================
 class BacktestAnalyzer:
-    """Universal metrics calculator"""
+    """Calculate 30+ metrics from BacktestResults"""
+    
     def __init__(self, results):
         self.results = results
         self.metrics = {}
@@ -276,11 +438,11 @@ class BacktestAnalyzer:
         """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 with zero-division protection
         if len(r.equity_dates) > 0:
             start_date = min(r.equity_dates)
             end_date = max(r.equity_dates)
@@ -291,7 +453,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
@@ -532,11 +693,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 +714,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")
@@ -600,14 +760,15 @@ 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:")
+            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,8 +800,11 @@ 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'):
@@ -750,8 +914,11 @@ class ChartGenerator:
         print(f"Chart saved: {filename}")
 
 
+# ============================================================
+# RESULTS EXPORTER
+# ============================================================
 class ResultsExporter:
-    """Universal results exporter"""
+    """Export results to CSV files"""
     
     @staticmethod
     def export_all(analyzer, prefix='backtest'):
@@ -762,25 +929,27 @@ 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"Trades exported: {prefix}_trades.csv")
+        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
         })
         equity_df.to_csv(f'{prefix}_equity.csv', index=False)
-        print(f"Equity exported: {prefix}_equity.csv")
+        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("PERFORMANCE\n")
             f.write("-"*70 + "\n")
             f.write(f"Initial Capital: ${r.initial_capital:,.2f}\n")
@@ -791,11 +960,11 @@ class ResultsExporter:
             f.write(f"Win Rate: {m['win_rate']:.2f}%\n")
             f.write(f"Total Trades: {m['total_trades']}\n")
         
-        print(f"Summary exported: {prefix}_summary.txt")
+        print(f"Exported: {prefix}_summary.txt")
 
 
 # ============================================================
-# ONE-COMMAND RUNNER (Unchanged)
+# ONE-COMMAND RUNNER
 # ============================================================
 def run_backtest(strategy_function, config, 
                  print_report=True,
@@ -803,7 +972,12 @@ def run_backtest(strategy_function, config,
                  export_results=True,
                  chart_filename='backtest_results.png',
                  export_prefix='backtest'):
-    """Run complete backtest with one command"""
+    """
+    Run complete backtest with one command
+    
+    Example:
+        analyzer = run_backtest(my_strategy, CONFIG)
+    """
     
     print("="*80)
     print(" "*25 + "STARTING BACKTEST")
@@ -827,24 +1001,15 @@ 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")
     
     if export_results and len(results.trades) > 0:
-        print(f"\n[*] Exporting results: {export_prefix}_*.csv")
+        print(f"\n[*] Exporting results: {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
 
@@ -860,8 +1025,11 @@ __all__ = [
     'ResultsExporter',
     'run_backtest',
     'init_api',
-    'get_api_method',
-    'api_call',           # NEW!
-    'APIHelper',          # NEW!
-    'APIManager'
+    'api_call',
+    'APIHelper',
+    'APIManager',
+    'ResourceMonitor',
+    'create_progress_bar',
+    'update_progress',
+    'format_time'
 ]

{ivolatility_backtesting-1.1.0 → ivolatility_backtesting-1.2.0}/ivolatility_backtesting.egg-info/PKG-INFO

@@ -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.2.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.1.0 → ivolatility_backtesting-1.2.0}/ivolatility_backtesting.egg-info/requires.txt

@@ -3,3 +3,4 @@ numpy>=1.21.0
 matplotlib>=3.5.0
 seaborn>=0.11.0
 ivolatility>=1.8.2
+psutil>=7.1.0

{ivolatility_backtesting-1.1.0 → ivolatility_backtesting-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ivolatility_backtesting"
-version = "1.1.0"
+version = "1.2.0"
 description = "A universal backtesting framework for financial strategies using the IVolatility API."
 readme = "README.md"
 authors = [
@@ -17,7 +17,8 @@ dependencies = [
     "numpy>=1.21.0",
     "matplotlib>=3.5.0",
     "seaborn>=0.11.0",
-    "ivolatility>=1.8.2"
+    "ivolatility>=1.8.2",
+    "psutil>=7.1.0",
 ]
 keywords = ["backtesting", "finance", "trading", "ivolatility"]
 classifiers = [

{ivolatility_backtesting-1.1.0 → ivolatility_backtesting-1.2.0}/setup.cfg

@@ -1,4 +1,4 @@
-[egg_info]
-tag_build = 
-tag_date = 0
-
+[egg_info]
+tag_build = 
+tag_date = 0
+