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

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

@@ -1,70 +1,72 @@
-Metadata-Version: 2.1
-Name: ivolatility_backtesting
-Version: 1.0.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
-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.0.1 → 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.0.1 → ivolatility_backtesting-1.2.0}/ivolatility_backtesting/ivolatility_backtesting.py

@@ -1,14 +1,24 @@
 """
-ivolatility_backtesting.py
-Universal Backtest Framework with One-Command Runner
+ivolatility_backtesting.py - UNIVERSAL BACKTEST FRAMEWORK
+Version 2.0 - With DataFrame/Dict Auto-Normalization
+
+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"))
     
-    CONFIG = {...}
+    # Use api_call for normalized responses
+    data = api_call('/equities/eod/stock-prices', symbol='AAPL', from_='2024-01-01')
+    
+    # Run backtest
     analyzer = run_backtest(my_strategy, CONFIG)
 """
 
@@ -19,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')
@@ -26,118 +38,363 @@ plt.rcParams['figure.figsize'] = (15, 8)
 
 
 # ============================================================
-# GLOBAL API MANAGER
+# RESOURCE MONITOR - NEW!
 # ============================================================
-class APIManager:
-    """
-    Centralized API key management for IVolatility API
+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
     
-    Usage:
-        from ivolatility_backtesting import init_api, get_api_method
+    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
         
-        # Initialize once at the start
-        init_api(os.getenv("API_KEY"))
+        # 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()
         
-        # Use anywhere in your code
-        getOptionsData = get_api_method('/equities/eod/stock-opts-by-param')
-        data = getOptionsData(symbol='SPY', tradeDate='2024-01-01', ...)
+        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:
+    """
+    Normalizes API responses to consistent format
+    Handles: dict, DataFrame, or None
+    """
+    
+    @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:
+                    print(f"[APIHelper] Dict response: {len(response['data'])} records")
+                return response
+            else:
+                if debug:
+                    print("[APIHelper] Dict without 'data' key")
+                return None
+        
+        # Case 2: DataFrame - convert to dict
+        if isinstance(response, pd.DataFrame):
+            if response.empty:
+                if debug:
+                    print("[APIHelper] Empty DataFrame")
+                return None
+            
+            records = response.to_dict('records')
+            if debug:
+                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
     _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
-        
-        Args:
-            endpoint: API endpoint path (e.g. '/equities/eod/stock-opts-by-param')
-        
-        Returns:
-            Callable API method
-        """
+        """Get API method with cached instances"""
         if cls._api_key is None:
-            # Auto-initialize from environment if not set
             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)
         
-        # Cache methods to avoid recreation
         if endpoint not in cls._methods:
-            # Re-set login params before creating method
             ivol.setLoginParams(apiKey=cls._api_key)
             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
+# ============================================================
+# PUBLIC API FUNCTIONS
+# ============================================================
 def init_api(api_key=None):
     """
-    Initialize IVolatility API with key
-    
-    Args:
-        api_key: API key string. If None, tries to load from API_KEY env variable
+    Initialize IVolatility API
     
     Example:
         init_api("your-api-key")
         # or
-        init_api()  # Auto-loads from environment
+        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):
+def api_call(endpoint, debug=False, **kwargs):
     """
-    Get API method for specified endpoint
+    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:
-        Callable API method with key already configured
+        dict with 'data' key or None
     
     Example:
-        getOptionsData = get_api_method('/equities/eod/stock-opts-by-param')
-        data = getOptionsData(symbol='SPY', tradeDate='2024-01-01', cp='C')
+        # 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'])
     """
-    return APIManager.get_method(endpoint)
+    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
+            
+            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 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] Endpoint: {endpoint}")
+            print(f"[api_call] Params: {kwargs}")
+        return None
 
 
+# ============================================================
+# BACKTEST RESULTS
+# ============================================================
 class BacktestResults:
-    """
-    Universal container for backtest results
-    ANY strategy must return this format
-    """
+    """Universal container for backtest results"""
+    
     def __init__(self, 
-                 equity_curve,           # List of equity values
-                 equity_dates,           # List of dates (matching equity_curve)
-                 trades,                 # List of dicts with trade info
-                 initial_capital,        # Starting capital
-                 config,                 # Strategy config dict
-                 benchmark_prices=None,  # Optional: dict {date: price}
-                 benchmark_symbol='SPY', # Optional: benchmark ticker
-                 daily_returns=None,     # Optional: if not provided, calculated
-                 debug_info=None):       # Optional: debug information
+                 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
@@ -149,7 +406,6 @@ class BacktestResults:
         self.benchmark_symbol = benchmark_symbol
         self.debug_info = debug_info if debug_info else []
         
-        # Calculate daily returns if not provided
         if daily_returns is None and len(equity_curve) > 1:
             self.daily_returns = [
                 (equity_curve[i] - equity_curve[i-1]) / equity_curve[i-1]
@@ -158,7 +414,6 @@ class BacktestResults:
         else:
             self.daily_returns = daily_returns if daily_returns else []
         
-        # Calculate max drawdown
         self.max_drawdown = self._calculate_max_drawdown()
     
     def _calculate_max_drawdown(self):
@@ -169,11 +424,12 @@ class BacktestResults:
         return abs(np.min(drawdowns))
 
 
+# ============================================================
+# BACKTEST ANALYZER
+# ============================================================
 class BacktestAnalyzer:
-    """
-    Universal metrics calculator
-    Works with any BacktestResults object
-    """
+    """Calculate 30+ metrics from BacktestResults"""
+    
     def __init__(self, results):
         self.results = results
         self.metrics = {}
@@ -182,23 +438,21 @@ 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 AGAINST DIVISION BY ZERO
+        # CAGR with zero-division protection
         if len(r.equity_dates) > 0:
             start_date = min(r.equity_dates)
             end_date = max(r.equity_dates)
             days_diff = (end_date - start_date).days
             
-            # PROTECTION: если даты одинаковые или разница < 1 день
             if days_diff <= 0:
                 self.metrics['cagr'] = 0
                 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
@@ -438,8 +692,11 @@ class BacktestAnalyzer:
         return min(exposure_pct, 100.0)
 
 
+# ============================================================
+# RESULTS REPORTER
+# ============================================================
 class ResultsReporter:
-    """Universal results printer"""
+    """Print comprehensive metrics report"""
     
     @staticmethod
     def print_full_report(analyzer):
@@ -451,17 +708,15 @@ class ResultsReporter:
         print("="*80)
         print()
         
-        # PRINT DEBUG INFO IF AVAILABLE
         if hasattr(r, 'debug_info') and len(r.debug_info) > 0:
             print("DEBUG INFORMATION")
             print("-"*80)
-            for debug_msg in r.debug_info[:10]:  # First 10 messages
+            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()
         
-        # Profitability
         print("PROFITABILITY METRICS")
         print("-"*80)
         print(f"Initial Capital:        ${r.initial_capital:>15,.2f}")
@@ -475,7 +730,6 @@ class ResultsReporter:
                 print(f"Annualized Return:       {m['cagr']:>15.2f}%  (extrapolated to 1 year)")
         print()
         
-        # Risk
         print("RISK METRICS")
         print("-"*80)
         print(f"Sharpe Ratio:            {m['sharpe']:>15.2f}  (>1 good, >2 excellent)")
@@ -509,16 +763,15 @@ class ResultsReporter:
         # 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()
         
-        # Efficiency
         print("EFFICIENCY METRICS")
         print("-"*80)
         if m['recovery_factor'] != 0:
@@ -527,7 +780,6 @@ class ResultsReporter:
             print(f"Exposure Time:           {m['exposure_time']:>15.1f}%  (time in market)")
         print()
         
-        # Trading stats
         print("TRADING STATISTICS")
         print("-"*80)
         print(f"Total Trades:            {m['total_trades']:>15}")
@@ -548,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'):
@@ -659,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'):
@@ -671,28 +929,27 @@ class ResultsExporter:
             print("No trades to export")
             return
         
-        # Export trades
+        # 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")
         
-        # Export equity curve
+        # 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")
         
-        # Export summary
+        # 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")
@@ -703,7 +960,7 @@ 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")
 
 
 # ============================================================
@@ -718,32 +975,8 @@ def run_backtest(strategy_function, config,
     """
     Run complete backtest with one command
     
-    Args:
-        strategy_function: Your strategy function that returns BacktestResults
-        config: Configuration dictionary for the strategy
-        print_report: Print full metrics report (default: True)
-        create_charts: Generate 6 charts (default: True)
-        export_results: Export to CSV files (default: True)
-        chart_filename: Name for chart file (default: 'backtest_results.png')
-        export_prefix: Prefix for exported files (default: 'backtest')
-    
-    Returns:
-        BacktestAnalyzer object with all metrics
-    
     Example:
-        from ivolatility_backtesting import run_backtest
-        
-        def my_strategy(config):
-            # ... your strategy logic
-            return BacktestResults(...)
-        
-        CONFIG = {'initial_capital': 100000, ...}
-        
-        # Run everything with one command!
         analyzer = run_backtest(my_strategy, CONFIG)
-        
-        # Access metrics
-        print(f"Sharpe: {analyzer.metrics['sharpe']:.2f}")
     """
     
     print("="*80)
@@ -754,60 +987,36 @@ def run_backtest(strategy_function, config,
     print(f"Capital: ${config.get('initial_capital', 0):,.0f}")
     print("="*80 + "\n")
     
-    # Run strategy
     results = strategy_function(config)
     
-    # Calculate metrics
     print("\n[*] Calculating metrics...")
     analyzer = BacktestAnalyzer(results)
     analyzer.calculate_all_metrics()
     
-    # Print report
     if print_report:
         print("\n" + "="*80)
         ResultsReporter.print_full_report(analyzer)
     
-    # Create charts
     if create_charts and len(results.trades) > 0:
         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")
     
-    # Export results
     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")
-    
-    # Final summary
-    #print("\n" + "="*80)
-    #print(" "*30 + "SUMMARY")
-    #print("="*80)
-    #print(f"Total Return:    {analyzer.metrics['total_return']:>10.2f}%")
-    #print(f"Sharpe Ratio:    {analyzer.metrics['sharpe']:>10.2f}")
-    #print(f"Max Drawdown:    {analyzer.metrics['max_drawdown']:>10.2f}%")
-    #print(f"Win Rate:        {analyzer.metrics['win_rate']:>10.1f}%")
-    #print(f"Total Trades:    {analyzer.metrics['total_trades']:>10}")
-    #print(f"Profit Factor:   {analyzer.metrics['profit_factor']:>10.2f}")
-    #print("="*80)
     
     return analyzer
 
 
-# Export all classes and functions
+# ============================================================
+# EXPORTS
+# ============================================================
 __all__ = [
     'BacktestResults',
     'BacktestAnalyzer', 
@@ -816,6 +1025,11 @@ __all__ = [
     'ResultsExporter',
     'run_backtest',
     'init_api',
-    'get_api_method',
-    'APIManager'
-]
+    'api_call',
+    'APIHelper',
+    'APIManager',
+    'ResourceMonitor',
+    'create_progress_bar',
+    'update_progress',
+    'format_time'
+]

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

@@ -1,70 +1,72 @@
-Metadata-Version: 2.1
-Name: ivolatility_backtesting
-Version: 1.0.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
-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.0.1 → 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.0.1 → ivolatility_backtesting-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ivolatility_backtesting"
-version = "1.0.1"
+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.0.1 → 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
+