voly 0.0.152__py3-none-any.whl → 0.0.154__py3-none-any.whl

voly/client.py

@@ -23,8 +23,7 @@ from voly.core.rnd import get_rnd_surface
 from voly.core.hd import get_historical_data, get_hd_surface
 from voly.core.interpolate import interpolate_model
 from voly.core.charts import (
-    plot_all_smiles, plot_raw_parameters, plot_jw_parameters, plot_fit_performance, plot_3d_surface,
-    plot_fit_performance
+    plot_all_smiles, plot_raw_parameters, plot_jw_parameters, plot_fit_performance, plot_3d_surface
 )
 
 
@@ -37,10 +36,14 @@ class VolyClient:
         - enable_file_logging: Whether to enable file-based logging
         - logs_dir: Directory for log files if file logging is enabled
         """
+
+        from importlib.metadata import version
+        voly_version = version("voly")
+
         if enable_file_logging:
             setup_file_logging(logs_dir)
 
-        logger.info("VolyClient initialized")
+        logger.info(f"VolyClient (v{voly_version}) initialized")
         self._loop = None  # For async operations
 
     def _get_event_loop(self):
@@ -156,10 +159,6 @@ class VolyClient:
            option_type: str = 'call') -> float:
         return iv(option_price, s, K, r, t, option_type)
 
-    @staticmethod
-    def pdf_to_calls(pdf_K: np.ndarray, s: float, K: np.ndarray, r: float, t: float):
-        return pdf_to_calls(pdf_K, s, K, r, t)
-
     # -------------------------------------------------------------------------
     # Model Fitting
     # -------------------------------------------------------------------------
@@ -307,8 +306,19 @@ class VolyClient:
     def get_rnd_surface(model_results: pd.DataFrame,
                         domain_params: Tuple[float, float, int] = (-1.5, 1.5, 1000),
                         return_domain: str = 'log_moneyness',
-                        method: str = 'rookley') -> Tuple[Dict[str, np.ndarray], Dict[str, np.ndarray], Dict[str, np.ndarray], pd.DataFrame]:
+                        method: str = 'rookley') -> Dict[str, Any]:
+        """
+        Generate risk-neutral density surface from volatility surface parameters.
+
+        Parameters:
+        - model_results: DataFrame from fit_model() or interpolate_model()
+        - domain_params: Tuple of (min_log_moneyness, max_log_moneyness, num_points)
+        - return_domain: Domain for results ('log_moneyness', 'moneyness', 'returns', 'strikes')
+        - method: Method for RND estimation ('rookley' or 'breeden')
 
+        Returns:
+        - Dictionary with pdf_surface, cdf_surface, x_surface, and moments
+        """
         logger.info("Calculating RND surface")
 
         return get_rnd_surface(
@@ -326,41 +336,50 @@ class VolyClient:
     def get_historical_data(currency: str = 'BTC',
                             lookback_days: str = '90d',
                             granularity: str = '15m',
-                            exchange_name: str = 'binance'):
+                            exchange_name: str = 'binance') -> pd.DataFrame:
+        """
+        Fetch historical OHLCV data for a cryptocurrency.
 
-        # Generate the surface
-        df_hist = get_historical_data(
+        Parameters:
+        - currency: The cryptocurrency to fetch data for (e.g., 'BTC', 'ETH')
+        - lookback_days: The lookback period in days, formatted as '90d', '30d', etc.
+        - granularity: The time interval for data points (e.g., '15m', '1h', '1d')
+        - exchange_name: The exchange to fetch data from (default: 'binance')
+
+        Returns:
+        - Historical price data with OHLCV columns and datetime index
+        """
+        logger.info(f"Fetching historical {currency} data from {exchange_name}...")
+
+        return get_historical_data(
             currency=currency,
             lookback_days=lookback_days,
             granularity=granularity,
             exchange_name=exchange_name
         )
 
-        return df_hist
-
     @staticmethod
     def get_hd_surface(model_results: pd.DataFrame,
                        df_hist: pd.DataFrame,
                        domain_params: Tuple[float, float, int] = (-1.5, 1.5, 1000),
-                       return_domain: str = 'log_moneyness',
-                       method: str = 'garch',
-                       distribution: str = 'normal',
-                       window_length: str = '30d',
-                       n_fits: int = 400,
-                       simulations: int = 5000,
-                       bandwidth: str = 'silverman') -> Dict[str, Any]:
+                       return_domain: str = 'log_moneyness') -> Dict[str, Any]:
+        """
+        Generate historical density surface using normal distributions.
 
-        logger.info(f"Calculating historical density surface using {method} method")
+        Parameters:
+        - model_results: DataFrame with model parameters and maturities
+        - df_hist: DataFrame with historical price data
+        - domain_params: Tuple of (min_log_moneyness, max_log_moneyness, num_points)
+        - return_domain: Domain for results ('log_moneyness', 'moneyness', 'returns', 'strikes')
+
+        Returns:
+        - Dictionary with pdf_surface, cdf_surface, x_surface, and moments
+        """
+        logger.info("Calculating HD surface")
 
         return get_hd_surface(
             model_results=model_results,
             df_hist=df_hist,
             domain_params=domain_params,
-            return_domain=return_domain,
-            method=method,
-            distribution=distribution,
-            window_length=window_length,
-            n_fits=n_fits,
-            simulations=simulations,
-            bandwidth=bandwidth
+            return_domain=return_domain
         )