squarequant 0.1.0__tar.gz → 0.1.1__tar.gz

squarequant-0.1.1/PKG-INFO

@@ -0,0 +1,221 @@
+Metadata-Version: 2.4
+Name: squarequant
+Version: 0.1.1
+Summary: A Python package for financial risk metrics and stock data analysis
+Home-page: https://github.com/SquareQuant/squarequant-package
+Author: Gabriel Bosch
+Author-email: contact@squarequant.org
+Project-URL: Documentation, https://www.squarequant.org
+Project-URL: Bug Tracker, https://github.com/SquareQuant/squarequant-package/issues
+Keywords: finance,risk,portfolio,investment,stocks,analysis,visualization,drawdown,var,cvar,entropic,ulcer index
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+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: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Intended Audience :: Science/Research
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=1.0.0
+Requires-Dist: numpy>=1.18.0
+Requires-Dist: yfinance>=0.1.63
+Requires-Dist: scipy>=1.5.0
+Requires-Dist: matplotlib>=3.3.0
+Requires-Dist: statsmodels>=0.12.0
+Provides-Extra: optimization
+Requires-Dist: cvxpy>=1.0.0; extra == "optimization"
+Provides-Extra: advanced
+Requires-Dist: scikit-learn>=1.0.0; extra == "advanced"
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0.0; extra == "dev"
+Requires-Dist: black>=21.5b2; extra == "dev"
+Requires-Dist: flake8>=3.9.0; extra == "dev"
+Requires-Dist: sphinx>=4.0.0; extra == "dev"
+Requires-Dist: sphinx-rtd-theme>=0.5.0; extra == "dev"
+Requires-Dist: sphinx-autodoc-typehints>=1.22.0; extra == "dev"
+Requires-Dist: myst-parser>=1.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=2.12.0; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# SquareQuant
+
+SquareQuant is a comprehensive Python package for financial risk metrics and stock data analysis. It provides a suite of tools for quantitative finance, including risk metrics calculation, data retrieval, and visualization.
+
+## Features
+
+- **Financial Data Access**: Easy-to-use interface for downloading historical price data
+- **Extensive Risk Metrics**: Comprehensive set of traditional and advanced risk measures
+- **Performance Analysis**: Tools for evaluating investment performance
+- **Visualization**: Built-in plotting functions for visual analysis
+- **Flexible API**: Consistent function-based and object-oriented interfaces
+
+## Installation
+
+```bash
+pip install squarequant
+```
+
+## Quick Start
+
+```python
+import squarequant as sq
+import matplotlib.pyplot as plt
+
+# Configure data download
+config = sq.DownloadConfig(
+    start_date="2020-01-01",
+    end_date="2023-12-31",
+    interval='1d',
+    columns=['Close']
+)
+
+# Download data
+data = sq.download_tickers(['AAPL', 'MSFT', 'GOOGL'], config)
+
+# Calculate volatility
+vol = sq.vol(data=data, assets=['AAPL', 'MSFT', 'GOOGL'], window=21)
+
+# Calculate Sharpe ratio
+sharpe = sq.sharpe(data=data, assets=['AAPL', 'MSFT', 'GOOGL'], window=252)
+
+# Visualize results
+plt.figure(figsize=(12, 6))
+plt.plot(vol)
+plt.title('21-Day Rolling Volatility')
+plt.legend(vol.columns)
+plt.show()
+```
+
+## Available Risk Metrics
+
+SquareQuant provides a comprehensive set of risk metrics, including:
+
+| Metric | Function | Description |
+|--------|----------|-------------|
+| Sharpe Ratio | `sq.sharpe()` | Risk-adjusted return using standard deviation |
+| Sortino Ratio | `sq.sortino()` | Risk-adjusted return using downside deviation |
+| Volatility | `sq.vol()` | Standard deviation of returns |
+| Maximum Drawdown | `sq.mdd()` | Largest peak-to-trough decline |
+| Value at Risk | `sq.var()` | Maximum expected loss at given confidence level |
+| Conditional Value at Risk | `sq.cvar()` | Expected loss beyond the VaR threshold |
+| Semi-Deviation | `sq.semidev()` | Downside volatility below target return |
+| Average Drawdown | `sq.avgdd()` | Mean of all drawdowns in a period |
+| Ulcer Index | `sq.ulcer()` | Square root of mean squared drawdown percentage |
+| Mean Absolute Deviation | `sq.mad()` | Average absolute deviation from mean |
+| Entropic Risk Measure | `sq.erm()` | Risk measure based on information theory |
+| Entropic Value at Risk | `sq.evar()` | VAR using entropy concepts |
+| Conditional Drawdown at Risk | `sq.cdar()` | Expected drawdown beyond threshold |
+| Entropic Drawdown at Risk | `sq.edar()` | Drawdown risk using entropy concepts |
+
+## Advanced Usage Examples
+
+### Analyzing Multiple Risk Metrics
+
+```python
+import squarequant as sq
+import matplotlib.pyplot as plt
+
+# Download data
+config = sq.DownloadConfig(
+    start_date="2018-01-01",
+    end_date="2023-12-31",
+    interval='1d'
+)
+data = sq.download_tickers(['SPY', 'QQQ'], config)
+
+# Calculate multiple risk metrics
+vol = sq.vol(data=data, assets=['SPY', 'QQQ'], window=21)
+mad = sq.mad(data=data, assets=['SPY', 'QQQ'], window=252)
+mdd = sq.mdd(data=data, assets=['SPY', 'QQQ'], window=252)
+ulcer = sq.ulcer(data=data, assets=['SPY', 'QQQ'], window=252)
+
+# Visualize comparison
+sq.plot_risk_comparison(
+    metrics=[vol, mdd, ulcer],
+    labels=['Volatility', 'Max Drawdown', 'Ulcer Index'],
+    asset='SPY'
+)
+```
+
+### Portfolio Risk Analysis
+
+```python
+import squarequant as sq
+import pandas as pd
+
+# Example portfolio weights
+weights = pd.Series({'AAPL': 0.3, 'MSFT': 0.3, 'AMZN': 0.2, 'GOOGL': 0.2})
+
+# Download data
+config = sq.DownloadConfig(start_date="2020-01-01", end_date="2023-12-31")
+data = sq.download_tickers(weights.index.tolist(), config)
+
+# Calculate portfolio risk measures
+portfolio_var = sq.var(
+    data=data,
+    assets=weights.index.tolist(),
+    confidence=0.95,
+    window=252,
+    holding_period=10
+)
+
+# Visualize weight allocation
+sq.plot_weight_allocation(weights)
+```
+
+### Using Advanced Risk Measures
+
+```python
+import squarequant as sq
+
+# Download data
+config = sq.DownloadConfig(start_date="2018-01-01", end_date="2023-12-31")
+data = sq.download_tickers(['SPY'], config)
+
+# Calculate Entropic Risk Measure with different risk aversion parameters
+erm1 = sq.erm(data=data, assets=['SPY'], z=0.5, confidence=0.95)
+erm2 = sq.erm(data=data, assets=['SPY'], z=1.0, confidence=0.95)
+erm3 = sq.erm(data=data, assets=['SPY'], z=2.0, confidence=0.95)
+
+# Compare with traditional VaR and CVaR
+var = sq.var(data=data, assets=['SPY'], confidence=0.95)
+cvar = sq.cvar(data=data, assets=['SPY'], confidence=0.95)
+
+print(f"Latest ERM (z=0.5): {erm1.iloc[-1, 0]:.4f}")
+print(f"Latest ERM (z=1.0): {erm2.iloc[-1, 0]:.4f}")
+print(f"Latest ERM (z=2.0): {erm3.iloc[-1, 0]:.4f}")
+print(f"Latest VaR (95%): {var.iloc[-1, 0]:.4f}")
+print(f"Latest CVaR (95%): {cvar.iloc[-1, 0]:.4f}")
+```
+
+## Documentation
+
+For detailed documentation on each function and class, please see the [official documentation](https://www.squarequant.org).
+
+## License
+
+MIT License
+
+## Credits
+
+SquareQuant was developed to provide financial analysts, quantitative researchers, and portfolio managers with a comprehensive toolkit for risk assessment and performance analysis.

squarequant-0.1.1/README.md

@@ -0,0 +1,162 @@
+# SquareQuant
+
+SquareQuant is a comprehensive Python package for financial risk metrics and stock data analysis. It provides a suite of tools for quantitative finance, including risk metrics calculation, data retrieval, and visualization.
+
+## Features
+
+- **Financial Data Access**: Easy-to-use interface for downloading historical price data
+- **Extensive Risk Metrics**: Comprehensive set of traditional and advanced risk measures
+- **Performance Analysis**: Tools for evaluating investment performance
+- **Visualization**: Built-in plotting functions for visual analysis
+- **Flexible API**: Consistent function-based and object-oriented interfaces
+
+## Installation
+
+```bash
+pip install squarequant
+```
+
+## Quick Start
+
+```python
+import squarequant as sq
+import matplotlib.pyplot as plt
+
+# Configure data download
+config = sq.DownloadConfig(
+    start_date="2020-01-01",
+    end_date="2023-12-31",
+    interval='1d',
+    columns=['Close']
+)
+
+# Download data
+data = sq.download_tickers(['AAPL', 'MSFT', 'GOOGL'], config)
+
+# Calculate volatility
+vol = sq.vol(data=data, assets=['AAPL', 'MSFT', 'GOOGL'], window=21)
+
+# Calculate Sharpe ratio
+sharpe = sq.sharpe(data=data, assets=['AAPL', 'MSFT', 'GOOGL'], window=252)
+
+# Visualize results
+plt.figure(figsize=(12, 6))
+plt.plot(vol)
+plt.title('21-Day Rolling Volatility')
+plt.legend(vol.columns)
+plt.show()
+```
+
+## Available Risk Metrics
+
+SquareQuant provides a comprehensive set of risk metrics, including:
+
+| Metric | Function | Description |
+|--------|----------|-------------|
+| Sharpe Ratio | `sq.sharpe()` | Risk-adjusted return using standard deviation |
+| Sortino Ratio | `sq.sortino()` | Risk-adjusted return using downside deviation |
+| Volatility | `sq.vol()` | Standard deviation of returns |
+| Maximum Drawdown | `sq.mdd()` | Largest peak-to-trough decline |
+| Value at Risk | `sq.var()` | Maximum expected loss at given confidence level |
+| Conditional Value at Risk | `sq.cvar()` | Expected loss beyond the VaR threshold |
+| Semi-Deviation | `sq.semidev()` | Downside volatility below target return |
+| Average Drawdown | `sq.avgdd()` | Mean of all drawdowns in a period |
+| Ulcer Index | `sq.ulcer()` | Square root of mean squared drawdown percentage |
+| Mean Absolute Deviation | `sq.mad()` | Average absolute deviation from mean |
+| Entropic Risk Measure | `sq.erm()` | Risk measure based on information theory |
+| Entropic Value at Risk | `sq.evar()` | VAR using entropy concepts |
+| Conditional Drawdown at Risk | `sq.cdar()` | Expected drawdown beyond threshold |
+| Entropic Drawdown at Risk | `sq.edar()` | Drawdown risk using entropy concepts |
+
+## Advanced Usage Examples
+
+### Analyzing Multiple Risk Metrics
+
+```python
+import squarequant as sq
+import matplotlib.pyplot as plt
+
+# Download data
+config = sq.DownloadConfig(
+    start_date="2018-01-01",
+    end_date="2023-12-31",
+    interval='1d'
+)
+data = sq.download_tickers(['SPY', 'QQQ'], config)
+
+# Calculate multiple risk metrics
+vol = sq.vol(data=data, assets=['SPY', 'QQQ'], window=21)
+mad = sq.mad(data=data, assets=['SPY', 'QQQ'], window=252)
+mdd = sq.mdd(data=data, assets=['SPY', 'QQQ'], window=252)
+ulcer = sq.ulcer(data=data, assets=['SPY', 'QQQ'], window=252)
+
+# Visualize comparison
+sq.plot_risk_comparison(
+    metrics=[vol, mdd, ulcer],
+    labels=['Volatility', 'Max Drawdown', 'Ulcer Index'],
+    asset='SPY'
+)
+```
+
+### Portfolio Risk Analysis
+
+```python
+import squarequant as sq
+import pandas as pd
+
+# Example portfolio weights
+weights = pd.Series({'AAPL': 0.3, 'MSFT': 0.3, 'AMZN': 0.2, 'GOOGL': 0.2})
+
+# Download data
+config = sq.DownloadConfig(start_date="2020-01-01", end_date="2023-12-31")
+data = sq.download_tickers(weights.index.tolist(), config)
+
+# Calculate portfolio risk measures
+portfolio_var = sq.var(
+    data=data,
+    assets=weights.index.tolist(),
+    confidence=0.95,
+    window=252,
+    holding_period=10
+)
+
+# Visualize weight allocation
+sq.plot_weight_allocation(weights)
+```
+
+### Using Advanced Risk Measures
+
+```python
+import squarequant as sq
+
+# Download data
+config = sq.DownloadConfig(start_date="2018-01-01", end_date="2023-12-31")
+data = sq.download_tickers(['SPY'], config)
+
+# Calculate Entropic Risk Measure with different risk aversion parameters
+erm1 = sq.erm(data=data, assets=['SPY'], z=0.5, confidence=0.95)
+erm2 = sq.erm(data=data, assets=['SPY'], z=1.0, confidence=0.95)
+erm3 = sq.erm(data=data, assets=['SPY'], z=2.0, confidence=0.95)
+
+# Compare with traditional VaR and CVaR
+var = sq.var(data=data, assets=['SPY'], confidence=0.95)
+cvar = sq.cvar(data=data, assets=['SPY'], confidence=0.95)
+
+print(f"Latest ERM (z=0.5): {erm1.iloc[-1, 0]:.4f}")
+print(f"Latest ERM (z=1.0): {erm2.iloc[-1, 0]:.4f}")
+print(f"Latest ERM (z=2.0): {erm3.iloc[-1, 0]:.4f}")
+print(f"Latest VaR (95%): {var.iloc[-1, 0]:.4f}")
+print(f"Latest CVaR (95%): {cvar.iloc[-1, 0]:.4f}")
+```
+
+## Documentation
+
+For detailed documentation on each function and class, please see the [official documentation](https://www.squarequant.org).
+
+## License
+
+MIT License
+
+## Credits
+
+SquareQuant was developed to provide financial analysts, quantitative researchers, and portfolio managers with a comprehensive toolkit for risk assessment and performance analysis.

{squarequant-0.1.0 → squarequant-0.1.1}/setup.py

@@ -5,15 +5,15 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="squarequant",
-    version="0.1.0",
+    version="0.1.1",
     author="Gabriel Bosch",
-    author_email="contact@suqarequant.org",
-    description="A Python package for quantitative finance",
+    author_email="contact@squarequant.org",
+    description="A Python package for financial risk metrics and stock data analysis",
     long_description=long_description,
     long_description_content_type="text/markdown",
     url="https://github.com/SquareQuant/squarequant-package",
     project_urls={
-        "Documentation": "https://squarequant.readthedocs.io",
+        "Documentation": "https://www.squarequant.org",
         "Bug Tracker": "https://github.com/SquareQuant/squarequant-package/issues",
     },
     packages=find_packages(),
@@ -22,6 +22,8 @@ setup(
         "Programming Language :: Python :: 3.7",
         "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
         "License :: OSI Approved :: MIT License",
         "Operating System :: OS Independent",
         "Topic :: Office/Business :: Financial :: Investment",
@@ -37,16 +39,21 @@ setup(
         "yfinance>=0.1.63",
         "scipy>=1.5.0",
         "matplotlib>=3.3.0",
+        "statsmodels>=0.12.0",
     ],
     extras_require={
         "optimization": ["cvxpy>=1.0.0"],
+        "advanced": ["scikit-learn>=1.0.0"],
         "dev": [
             "pytest>=6.0.0",
             "black>=21.5b2",
             "flake8>=3.9.0",
             "sphinx>=4.0.0",
             "sphinx-rtd-theme>=0.5.0",
+            "sphinx-autodoc-typehints>=1.22.0",
+            "myst-parser>=1.0.0",
+            "pytest-cov>=2.12.0",
         ],
     },
-    keywords="finance, risk, portfolio, investment, stocks, analysis, visualization",
+    keywords="finance, risk, portfolio, investment, stocks, analysis, visualization, drawdown, var, cvar, entropic, ulcer index",
 )

{squarequant-0.1.0 → squarequant-0.1.1}/squarequant/__init__.py

@@ -3,7 +3,7 @@
 SquareQuant: A Python package for financial risk metrics and stock data analysis
 """
 
-__version__ = '0.1.0'
+__version__ = '0.1.1'
 
 # Import main functions for easy access
 from squarequant.core.data import download_tickers, DownloadConfig

{squarequant-0.1.0 → squarequant-0.1.1}/squarequant/api.py

@@ -244,7 +244,9 @@ def cvar(data: pd.DataFrame,
          window: int = DEFAULT_CVAR_WINDOW,
          start: Optional[str] = None,
          end: Optional[str] = None,
-         method: str = 'historical') -> pd.DataFrame:
+         method: str = 'historical',
+         holding_period: int = DEFAULT_VAR_HOLDING_PERIOD,  # Add parameter
+         scaling_method: str = 'sqrt_time') -> pd.DataFrame:  # Add parameter
     """
     Calculate rolling Conditional Value at Risk (CVaR) for specified assets
 
@@ -256,6 +258,8 @@ def cvar(data: pd.DataFrame,
     start (str, optional): Start date in format 'YYYY-MM-DD'
     end (str, optional): End date in format 'YYYY-MM-DD'
     method (str): Method to calculate CVaR - 'historical', 'parametric', default is 'historical'
+    holding_period (int): Holding period in days, default is 10 days
+    scaling_method (str): Method to scale 1-day CVaR, default is 'sqrt_time'
 
     Returns:
     DataFrame: Rolling CVaR for specified assets
@@ -267,7 +271,9 @@ def cvar(data: pd.DataFrame,
         window=window,
         start=start,
         end=end,
-        method=method
+        method=method,
+        holding_period=holding_period,  # Pass parameter
+        scaling_method=scaling_method  # Pass parameter
     )
     return calculator.calculate()
 
@@ -389,21 +395,31 @@ def mad(data: pd.DataFrame,
 def erm(data: pd.DataFrame,
         assets: List[str],
         z: float = 1.0,
-        alpha: float = DEFAULT_CONFIDENCE,
+        confidence: float = DEFAULT_CONFIDENCE,
         window: int = DEFAULT_ERM_WINDOW,
         start: Optional[str] = None,
-        end: Optional[str] = None) -> pd.DataFrame:
+        end: Optional[str] = None,
+        method: str = 'historical',
+        holding_period: int = 1,
+        scaling_method: str = 'sqrt_time',
+        decay_factor: float = 0.94) -> pd.DataFrame:
     """
     Calculate the Entropic Risk Measure (ERM) for specified assets.
 
     Parameters:
     data (DataFrame): DataFrame with asset price data
     assets (List[str]): List of asset columns to calculate for
-    z (float): Risk aversion parameter, must be greater than zero
-    alpha (float): Significance level (0-1), default is 0.95 (95%)
+    z (float): Risk aversion parameter, must be greater than zero. Default is 1.0
+    confidence (float): Significance level (0-1), default is 0.95 (95%)
     window (int): Rolling window size in trading days, default is 252 (1 year)
     start (str, optional): Start date in format 'YYYY-MM-DD'
     end (str, optional): End date in format 'YYYY-MM-DD'
+    method (str, optional): Method to use for calculation: 'historical', 'parametric', or 'weighted'.
+                           Default is 'historical'
+    holding_period (int, optional): Time horizon for risk projection. Default is 1
+    scaling_method (str, optional): Method to scale for holding period: 'sqrt_time', 'linear', or 'none'.
+                                   Default is 'sqrt_time'
+    decay_factor (float, optional): Decay factor for weighted method (between 0 and 1). Default is 0.94
 
     Returns:
     DataFrame: Entropic Risk Measure for specified assets
@@ -412,43 +428,42 @@ def erm(data: pd.DataFrame,
         data=data,
         assets=assets,
         z=z,
-        alpha=alpha,
+        confidence=confidence,
         window=window,
         start=start,
-        end=end
+        end=end,
+        holding_period=holding_period,
+        scaling_method=scaling_method
     )
     return calculator.calculate()
 
-
-def evar(data: pd.DataFrame,
-         assets: List[str],
-         alpha: float = DEFAULT_CONFIDENCE,
-         window: int = DEFAULT_EVAR_WINDOW,
-         start: Optional[str] = None,
-         end: Optional[str] = None,
-         solver: Optional[str] = None,
-         batch_size: int = 1,
-         fallback_z_min: float = 0.01,
-         fallback_z_max: float = 100.0,
-         fallback_steps: int = 20) -> pd.DataFrame:
+def evar(
+        data: pd.DataFrame,
+        assets: List[str],
+        confidence: float = DEFAULT_CONFIDENCE,  # Changed from alpha to confidence
+        window: int = DEFAULT_EVAR_WINDOW,
+        start: Optional[str] = None,
+        end: Optional[str] = None,
+        holding_period: int = 1,
+        scaling_method: str = 'sqrt_time',
+        z_bounds: tuple = (0.1, 10.0),  # Added z_bounds parameter
+        z_default: float = 1.0  # Changed from initial_z to z_default
+) -> pd.DataFrame:
     """
-    Calculate the Entropic Value at Risk (EVaR) for specified assets.
-    This implementation uses convex optimization via CVXPY when available,
-    with fallback to grid search if needed.
+    Calculate Entropic Value at Risk for specified assets.
 
     Parameters:
     data (DataFrame): DataFrame with asset price data
     assets (List[str]): List of asset columns to calculate for
-    alpha (float): Significance level (0-1), default is 0.95 (95%)
+    confidence (float): Confidence level (0-1), default is 0.95 (95%)
     window (int): Rolling window size in trading days, default is 252 (1 year)
     start (str, optional): Start date in format 'YYYY-MM-DD'
     end (str, optional): End date in format 'YYYY-MM-DD'
-    solver (str, optional): CVXPY solver to use (e.g., 'MOSEK', 'ECOS', 'SCS')
-                           If None, CVXPY will choose automatically.
-    batch_size (int): Number of assets to process in one batch for memory efficiency
-    fallback_z_min (float): Minimum value of z for fallback grid search
-    fallback_z_max (float): Maximum value of z for fallback grid search
-    fallback_steps (int): Number of steps for fallback grid search
+    method (str, optional): Method to use - 'historical', 'parametric', or 'weighted'. Default is 'parametric'
+    holding_period (int): Time horizon for risk projection, default is 1
+    scaling_method (str): Method to scale 1-day EVaR, default is 'sqrt_time'
+    z_bounds (tuple): Bounds for z parameter optimization (lower, upper). Default is (0.1, 10.0)
+    z_default (float): Default z value to use if optimization fails. Default is 1.0
 
     Returns:
     DataFrame: Entropic Value at Risk for specified assets
@@ -456,18 +471,18 @@ def evar(data: pd.DataFrame,
     calculator = EntropicValueAtRisk(
         data=data,
         assets=assets,
-        alpha=alpha,
+        confidence=confidence,  # Match the parameter name with the class
         window=window,
         start=start,
         end=end,
-        solver=solver,
-        batch_size=batch_size,
-        fallback_z_min=fallback_z_min,
-        fallback_z_max=fallback_z_max,
-        fallback_steps=fallback_steps
+        holding_period=holding_period,
+        scaling_method=scaling_method,
+        z_bounds=z_bounds,
+        z_default=z_default
     )
     return calculator.calculate()
 
+
 def cdar(data: pd.DataFrame,
          assets: List[str],
          confidence: float = DEFAULT_CONFIDENCE,

{squarequant-0.1.0 → squarequant-0.1.1}/squarequant/constants.py

@@ -26,7 +26,7 @@ DEFAULT_VAR_CONFIDENCE = 0.99
 VALID_VAR_SCALING_METHODS = {'sqrt_time', 'overlapping'}
 
 # Default values
-DEFAULT_CONFIDENCE = 0.95
+DEFAULT_CONFIDENCE = 0.99
 
 
 # Valid options

squarequant-0.1.1/squarequant/core/__init__.py

@@ -0,0 +1,6 @@
+# squarequant/core/__init__.py
+"""
+Core components of the Squarequant package
+"""
+
+# This file is intentionally left empty to mark the directory as a Python package