voly 0.0.86__py3-none-any.whl → 0.0.87__py3-none-any.whl

voly/client.py

@@ -349,7 +349,7 @@ class VolyClient:
 
     @staticmethod
     def get_iv_surface(model_results: pd.DataFrame,
-                       log_moneyness_params: Tuple[float, float, int] = (-2, 2, 500),
+                       domain_params: Tuple[float, float, int] = (-2, 2, 500),
                        return_domain: str = 'log_moneyness',
                        ) -> Dict[str, Any]:
         """
@@ -357,7 +357,7 @@ class VolyClient:
 
         Parameters:
             - model_results: DataFrame from fit_model() or interpolate_model()
-            - log_moneyness_params: Tuple of (min, max, num_points) for the moneyness grid
+            - domain_params: Tuple of (min, max, num_points) for the moneyness grid
             - return_domain: str Domain for x-axis values ('log_moneyness', 'moneyness', 'strikes', 'delta')
 
         Returns:
@@ -366,7 +366,7 @@ class VolyClient:
         # Generate the surface
         iv_surface, x_surface = get_iv_surface(
             model_results=model_results,
-            log_moneyness_params=log_moneyness_params,
+            domain_params=domain_params,
             return_domain=return_domain
         )
 
@@ -375,7 +375,7 @@ class VolyClient:
     @staticmethod
     def plot_model(fit_results: pd.DataFrame,
                    option_chain: pd.DataFrame = None,
-                   log_moneyness_params: Tuple[float, float, int] = (-2, 2, 500),
+                   domain_params: Tuple[float, float, int] = (-2, 2, 500),
                    return_domain: str = 'log_moneyness',
                    ) -> Dict[str, Any]:
         """
@@ -384,8 +384,8 @@ class VolyClient:
         Parameters:
         - fit_results: DataFrame with fitting results from fit_model()
         - option_chain: Optional market data for comparison
-        - log_moneyness_params: Grid of log-moneyness values
-        - return_domain: Domain for x-axis values ('log_moneyness', 'moneyness', 'strikes', 'delta')
+        - domain_params: Grid of log-moneyness values
+        - return_domain: Domain for x-axis values ('log_moneyness', 'moneyness', 'strikes', 'returns', 'delta')
 
         Returns:
         - Dictionary of plot figures
@@ -393,7 +393,7 @@ class VolyClient:
         plots = {}
 
         # Generate IV surface and domain
-        iv_surface, x_surface = get_iv_surface(fit_results, log_moneyness_params, return_domain)
+        iv_surface, x_surface = get_iv_surface(fit_results, domain_params, return_domain)
 
         # Plot volatility smiles
         plots['smiles'] = plot_all_smiles(
@@ -453,202 +453,19 @@ class VolyClient:
     # -------------------------------------------------------------------------
 
     @staticmethod
-    def get_rnd_surface(fit_results: Dict[str, Any],
-                        moneyness_params: Tuple[float, float, int] = (-2, 2, 500)
-                        ) -> Dict[str, np.ndarray]:
-        """
-        Calculate risk-neutral density from fitted model.
-
-        Parameters:
+    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]:
 
-        Returns:
-        - Array with RND results over moneyness
-        """
-        logger.info("Calculating risk-neutral density")
+        logger.info("Calculating RND surface")
 
         # Generate the surface
-        moneyness_array, rnd_surface = get_rnd_surface(
-            fit_results=fit_results,
-            moneyness_params=moneyness_params
-        )
-
-        return {
-            'moneyness_array': moneyness_array,
-            'rnd_surface': rnd_surface
-        }
-
-    @staticmethod
-    def pdf(rnd_results: Dict[str, Any],
-            maturity: Optional[str] = None,
-            plot: bool = False) -> Tuple[np.ndarray, np.ndarray]:
-        """
-        Calculate probability density function (PDF) from RND results.
-
-        Parameters:
-        - rnd_results: Dictionary with RND results from rnd()
-        - maturity: Optional maturity name for a specific expiry
-        - plot: Whether to generate and return a plot
-
-        Returns:
-        - Tuple of (prices, pdf_values) and optional plot
-        """
-        logger.info("Calculating PDF from RND")
-
-        # Extract required data
-        moneyness_grid = rnd_results['moneyness_grid']
-        rnd_surface = rnd_results['rnd_surface']
-        spot_price = rnd_results['spot_price']
-
-        # Select maturity
-        if maturity is None:
-            # Use first maturity if not specified
-            maturity = list(rnd_surface.keys())[0]
-        elif maturity not in rnd_surface:
-            raise VolyError(f"Maturity '{maturity}' not found in RND results")
-
-        # Get RND values for the selected maturity
-        rnd_values = rnd_surface[maturity]
-
-        # Calculate PDF
-        prices, pdf_values = calculate_pdf(moneyness_grid, rnd_values, spot_price)
-
-        result = (prices, pdf_values)
-
-        # Generate plot if requested
-        if plot:
-            logger.info(f"Generating PDF plot for {maturity}")
-            pdf_plot = plot_pdf(
-                moneyness_grid, rnd_values, spot_price,
-                title=f"Probability Density Function - {maturity}"
-            )
-            result = (prices, pdf_values, pdf_plot)
-
-        return result
-
-    @staticmethod
-    def cdf(rnd_results: Dict[str, Any],
-            maturity: Optional[str] = None,
-            plot: bool = False) -> Tuple[np.ndarray, np.ndarray]:
-        """
-        Calculate cumulative distribution function (CDF) from RND results.
-
-        Parameters:
-        - rnd_results: Dictionary with RND results from rnd()
-        - maturity: Optional maturity name for a specific expiry
-        - plot: Whether to generate and return a plot
-
-        Returns:
-        - Tuple of (prices, cdf_values) and optional plot
-        """
-        logger.info("Calculating CDF from RND")
-
-        # Extract required data
-        moneyness_grid = rnd_results['moneyness_grid']
-        rnd_surface = rnd_results['rnd_surface']
-        spot_price = rnd_results['spot_price']
-
-        # Select maturity
-        if maturity is None:
-            # Use first maturity if not specified
-            maturity = list(rnd_surface.keys())[0]
-        elif maturity not in rnd_surface:
-            raise VolyError(f"Maturity '{maturity}' not found in RND results")
-
-        # Get RND values for the selected maturity
-        rnd_values = rnd_surface[maturity]
-
-        # Calculate CDF
-        prices, cdf_values = calculate_cdf(moneyness_grid, rnd_values, spot_price)
-
-        result = (prices, cdf_values)
-
-        # Generate plot if requested
-        if plot:
-            logger.info(f"Generating CDF plot for {maturity}")
-            cdf_plot = plot_cdf(
-                moneyness_grid, rnd_values, spot_price,
-                title=f"Cumulative Distribution Function - {maturity}"
-            )
-            result = (prices, cdf_values, cdf_plot)
-
-        return result
-
-    @staticmethod
-    def probability(rnd_results: Dict[str, Any],
-                    target_price: float,
-                    maturity: Optional[str] = None,
-                    direction: str = 'above') -> float:
-        """
-        Calculate the probability of price being above or below a target price.
-
-        Parameters:
-        - rnd_results: Dictionary with RND results from rnd()
-        - target_price: Target price level
-        - maturity: Optional maturity name for a specific expiry
-        - direction: 'above' or 'below'
-
-        Returns:
-        - Probability (0 to 1)
-        """
-        if direction not in ['above', 'below']:
-            raise VolyError("Direction must be 'above' or 'below'")
-
-        # Extract required data
-        moneyness_grid = rnd_results['moneyness_grid']
-        rnd_surface = rnd_results['rnd_surface']
-        spot_price = rnd_results['spot_price']
-
-        # Select maturity
-        if maturity is None:
-            # Use first maturity if not specified
-            maturity = list(rnd_surface.keys())[0]
-        elif maturity not in rnd_surface:
-            raise VolyError(f"Maturity '{maturity}' not found in RND results")
-
-        # Get RND values for the selected maturity
-        rnd_values = rnd_surface[maturity]
-
-        # Calculate probability
-        prob = calculate_strike_probability(
-            target_price, moneyness_grid, rnd_values, spot_price, direction
-        )
-
-        return prob
-
-    # -------------------------------------------------------------------------
-    # Interpolation
-    # -------------------------------------------------------------------------
-
-    @staticmethod
-    def interpolate(fit_results: Dict[str, Any],
-                    specific_days: Optional[List[int]] = None,
-                    num_points: int = 10,
-                    method: str = 'cubic',
-                    plot: bool = False) -> Dict[str, Any]:
-        """
-        Interpolate a fitted model to specific days to expiry.
-
-        Parameters:
-        - fit_results: Dictionary with fitting results from fit_model()
-        - specific_days: Optional list of specific days to include (e.g., [7, 30, 90, 180])
-        - num_points: Number of points for regular grid if specific_days is None
-        - method: Interpolation method ('linear', 'cubic', 'pchip', etc.)
-        - plot: Whether to generate and return a plot
-
-        Returns:
-        - Dictionary with interpolation results and optional plot
-        """
-        logger.info(f"Interpolating model with {method} method")
-
-        # Interpolate the model
-        interp_results = interpolate_model(
-            fit_results, specific_days, num_points, method
+        pdf_surface, cdf_surface, x_surface, moments = get_rnd_surface(
+            model_results=model_results,
+            domain_params=domain_params,
+            return_domain=return_domain,
+            method=method
         )
 
-        # Generate plot if requested
-        if plot:
-            logger.info("Generating interpolated surface plot")
-            interp_plot = plot_interpolated_surface(interp_results)
-            interp_results['plot'] = interp_plot
-
-        return interp_results
+        return pdf_surface, cdf_surface, x_surface, moments