openstatz 0.1.0__py3-none-any.whl

openstatz/__init__.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python
+#
+# OpenStatz: Portfolio analytics for quants (a modern rebuild of QuantStats)
+# https://github.com/ranaroussi/quantstats  (upstream)
+#
+# Copyright 2019-2025 Ran Aroussi  (original QuantStats)
+# Copyright 2026 OpenStatz contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from . import version
+
+__version__ = version.version
+__author__ = "Ran Aroussi (QuantStats) / OpenStatz contributors"
+
+from . import plots, providers, reports, stats, utils
+
+__all__ = ["stats", "plots", "reports", "utils", "providers", "extend_pandas"]
+
+# try automatic matplotlib inline
+utils._in_notebook(matplotlib_inline=True)
+
+
+def extend_pandas():
+    """
+    Extends pandas by exposing methods to be used like:
+    df.sharpe(), df.best('day'), ...
+    """
+    from pandas.core.base import PandasObject as _po  # type: ignore[import]
+
+    _po.compsum = stats.compsum  # type: ignore[attr-defined]
+    _po.comp = stats.comp  # type: ignore[attr-defined]
+    _po.expected_return = stats.expected_return  # type: ignore[attr-defined]
+    _po.geometric_mean = stats.geometric_mean  # type: ignore[attr-defined]
+    _po.ghpr = stats.ghpr  # type: ignore[attr-defined]
+    _po.outliers = stats.outliers  # type: ignore[attr-defined]
+    _po.remove_outliers = stats.remove_outliers  # type: ignore[attr-defined]
+    _po.best = stats.best  # type: ignore[attr-defined]
+    _po.worst = stats.worst  # type: ignore[attr-defined]
+    _po.consecutive_wins = stats.consecutive_wins  # type: ignore[attr-defined]
+    _po.consecutive_losses = stats.consecutive_losses  # type: ignore[attr-defined]
+    _po.exposure = stats.exposure  # type: ignore[attr-defined]
+    _po.win_rate = stats.win_rate  # type: ignore[attr-defined]
+    _po.avg_return = stats.avg_return  # type: ignore[attr-defined]
+    _po.avg_win = stats.avg_win  # type: ignore[attr-defined]
+    _po.avg_loss = stats.avg_loss  # type: ignore[attr-defined]
+    _po.volatility = stats.volatility  # type: ignore[attr-defined]
+    _po.rolling_volatility = stats.rolling_volatility  # type: ignore[attr-defined]
+    _po.implied_volatility = stats.implied_volatility  # type: ignore[attr-defined]
+    _po.sharpe = stats.sharpe  # type: ignore[attr-defined]
+    _po.smart_sharpe = stats.smart_sharpe  # type: ignore[attr-defined]
+    _po.rolling_sharpe = stats.rolling_sharpe  # type: ignore[attr-defined]
+    _po.sortino = stats.sortino  # type: ignore[attr-defined]
+    _po.smart_sortino = stats.smart_sortino  # type: ignore[attr-defined]
+    _po.adjusted_sortino = stats.adjusted_sortino  # type: ignore[attr-defined]
+    _po.rolling_sortino = stats.rolling_sortino  # type: ignore[attr-defined]
+    _po.omega = stats.omega  # type: ignore[attr-defined]
+    _po.cagr = stats.cagr  # type: ignore[attr-defined]
+    _po.rar = stats.rar  # type: ignore[attr-defined]
+    _po.skew = stats.skew  # type: ignore[attr-defined]
+    _po.kurtosis = stats.kurtosis  # type: ignore[attr-defined]
+    _po.calmar = stats.calmar  # type: ignore[attr-defined]
+    _po.ulcer_index = stats.ulcer_index  # type: ignore[attr-defined]
+    _po.ulcer_performance_index = stats.ulcer_performance_index  # type: ignore[attr-defined]
+    _po.upi = stats.upi  # type: ignore[attr-defined]
+    _po.serenity_index = stats.serenity_index  # type: ignore[attr-defined]
+    _po.risk_of_ruin = stats.risk_of_ruin  # type: ignore[attr-defined]
+    _po.ror = stats.ror  # type: ignore[attr-defined]
+    _po.value_at_risk = stats.value_at_risk  # type: ignore[attr-defined]
+    _po.var = stats.var  # type: ignore[attr-defined]
+    _po.conditional_value_at_risk = stats.conditional_value_at_risk  # type: ignore[attr-defined]
+    _po.cvar = stats.cvar  # type: ignore[attr-defined]
+    _po.expected_shortfall = stats.expected_shortfall  # type: ignore[attr-defined]
+    _po.tail_ratio = stats.tail_ratio  # type: ignore[attr-defined]
+    _po.payoff_ratio = stats.payoff_ratio  # type: ignore[attr-defined]
+    _po.win_loss_ratio = stats.win_loss_ratio  # type: ignore[attr-defined]
+    _po.profit_ratio = stats.profit_ratio  # type: ignore[attr-defined]
+    _po.profit_factor = stats.profit_factor  # type: ignore[attr-defined]
+    _po.gain_to_pain_ratio = stats.gain_to_pain_ratio  # type: ignore[attr-defined]
+    _po.cpc_index = stats.cpc_index  # type: ignore[attr-defined]
+    _po.common_sense_ratio = stats.common_sense_ratio  # type: ignore[attr-defined]
+    _po.outlier_win_ratio = stats.outlier_win_ratio  # type: ignore[attr-defined]
+    _po.outlier_loss_ratio = stats.outlier_loss_ratio  # type: ignore[attr-defined]
+    _po.recovery_factor = stats.recovery_factor  # type: ignore[attr-defined]
+    _po.risk_return_ratio = stats.risk_return_ratio  # type: ignore[attr-defined]
+    _po.max_drawdown = stats.max_drawdown  # type: ignore[attr-defined]
+    _po.to_drawdown_series = stats.to_drawdown_series  # type: ignore[attr-defined]
+    _po.kelly_criterion = stats.kelly_criterion  # type: ignore[attr-defined]
+    _po.monthly_returns = stats.monthly_returns  # type: ignore[attr-defined]
+    _po.pct_rank = stats.pct_rank  # type: ignore[attr-defined]
+
+    _po.treynor_ratio = stats.treynor_ratio  # type: ignore[attr-defined]
+    _po.probabilistic_sharpe_ratio = stats.probabilistic_sharpe_ratio  # type: ignore[attr-defined]
+    _po.probabilistic_sortino_ratio = stats.probabilistic_sortino_ratio  # type: ignore[attr-defined]
+    _po.probabilistic_adjusted_sortino_ratio = (  # type: ignore[attr-defined]
+        stats.probabilistic_adjusted_sortino_ratio
+    )
+
+    # Monte Carlo simulation
+    _po.montecarlo = stats.montecarlo  # type: ignore[attr-defined]
+    _po.montecarlo_sharpe = stats.montecarlo_sharpe  # type: ignore[attr-defined]
+    _po.montecarlo_drawdown = stats.montecarlo_drawdown  # type: ignore[attr-defined]
+    _po.montecarlo_cagr = stats.montecarlo_cagr  # type: ignore[attr-defined]
+
+    # methods from utils
+    _po.to_returns = utils.to_returns  # type: ignore[attr-defined]
+    _po.to_prices = utils.to_prices  # type: ignore[attr-defined]
+    _po.to_log_returns = utils.to_log_returns  # type: ignore[attr-defined]
+    _po.log_returns = utils.log_returns  # type: ignore[attr-defined]
+    _po.exponential_stdev = utils.exponential_stdev  # type: ignore[attr-defined]
+    _po.rebase = utils.rebase  # type: ignore[attr-defined]
+    _po.aggregate_returns = utils.aggregate_returns  # type: ignore[attr-defined]
+    _po.to_excess_returns = utils.to_excess_returns  # type: ignore[attr-defined]
+    _po.multi_shift = utils.multi_shift  # type: ignore[attr-defined]
+    _po.curr_month = utils._pandas_current_month  # type: ignore[attr-defined]
+    _po.date = utils._pandas_date  # type: ignore[attr-defined]
+    _po.mtd = utils._mtd  # type: ignore[attr-defined]
+    _po.qtd = utils._qtd  # type: ignore[attr-defined]
+    _po.ytd = utils._ytd  # type: ignore[attr-defined]
+
+    # methods that requires benchmark stats
+    _po.r_squared = stats.r_squared  # type: ignore[attr-defined]
+    _po.r2 = stats.r2  # type: ignore[attr-defined]
+    _po.information_ratio = stats.information_ratio  # type: ignore[attr-defined]
+    _po.greeks = stats.greeks  # type: ignore[attr-defined]
+    _po.rolling_greeks = stats.rolling_greeks  # type: ignore[attr-defined]
+    _po.compare = stats.compare  # type: ignore[attr-defined]
+
+    # plotting methods
+    _po.plot_snapshot = plots.snapshot  # type: ignore[attr-defined]
+    _po.plot_earnings = plots.earnings  # type: ignore[attr-defined]
+    _po.plot_daily_returns = plots.daily_returns  # type: ignore[attr-defined]
+    _po.plot_distribution = plots.distribution  # type: ignore[attr-defined]
+    _po.plot_drawdown = plots.drawdown  # type: ignore[attr-defined]
+    _po.plot_drawdowns_periods = plots.drawdowns_periods  # type: ignore[attr-defined]
+    _po.plot_histogram = plots.histogram  # type: ignore[attr-defined]
+    _po.plot_log_returns = plots.log_returns  # type: ignore[attr-defined]
+    _po.plot_returns = plots.returns  # type: ignore[attr-defined]
+    _po.plot_rolling_beta = plots.rolling_beta  # type: ignore[attr-defined]
+    _po.plot_rolling_sharpe = plots.rolling_sharpe  # type: ignore[attr-defined]
+    _po.plot_rolling_sortino = plots.rolling_sortino  # type: ignore[attr-defined]
+    _po.plot_rolling_volatility = plots.rolling_volatility  # type: ignore[attr-defined]
+    _po.plot_yearly_returns = plots.yearly_returns  # type: ignore[attr-defined]
+    _po.plot_monthly_heatmap = plots.monthly_heatmap  # type: ignore[attr-defined]
+    _po.plot_montecarlo = plots.montecarlo  # type: ignore[attr-defined]
+    _po.plot_montecarlo_distribution = plots.montecarlo_distribution  # type: ignore[attr-defined]
+
+    _po.metrics = reports.metrics  # type: ignore[attr-defined]
+
+
+# extend_pandas()

openstatz/__main__.py

@@ -0,0 +1,11 @@
+#!/usr/bin/env python
+#
+# Lets you run the CLI without the installed console script, e.g.:
+#   python -m openstatz serve --port 8200
+#
+# Licensed under the Apache License, Version 2.0.
+
+from openstatz.app.cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

openstatz/_compat.py

@@ -0,0 +1,430 @@
+#!/usr/bin/env python
+"""
+Compatibility layer for pandas/numpy versions
+Handles version differences and deprecated functionality
+
+This module provides a unified interface for working with different versions of pandas
+and numpy, ensuring that quantstats functions work consistently across various
+dependency versions. It handles deprecated functionality and version-specific changes.
+"""
+
+import pandas as pd
+import numpy as np
+import warnings
+from packaging import version
+import yfinance as yf
+from typing import Union, Optional, List, Callable
+
+# Version detection - Parse version strings to enable version comparisons
+PANDAS_VERSION = version.parse(pd.__version__)
+NUMPY_VERSION = version.parse(np.__version__)
+
+# Frequency alias mapping for pandas compatibility
+# Starting from pandas 2.2.0, frequency aliases changed to be more explicit
+# M -> ME (Month End), Q -> QE (Quarter End), A/Y -> YE (Year End)
+FREQUENCY_ALIASES = {
+    "M": "ME" if PANDAS_VERSION >= version.parse("2.2.0") else "M",
+    "Q": "QE" if PANDAS_VERSION >= version.parse("2.2.0") else "Q",
+    "A": "YE" if PANDAS_VERSION >= version.parse("2.2.0") else "A",
+    "Y": "YE" if PANDAS_VERSION >= version.parse("2.2.0") else "Y",
+}
+
+
+def get_frequency_alias(freq: str) -> str:
+    """
+    Get the correct frequency alias for current pandas version.
+
+    This function maps old frequency strings to their new equivalents in
+    pandas 2.2.0+, ensuring backward compatibility across pandas versions.
+
+    Parameters
+    ----------
+    freq : str
+        The frequency string (e.g., 'M', 'Q', 'A', 'Y')
+
+    Returns
+    -------
+    str
+        The appropriate frequency alias for the current pandas version
+
+    Examples
+    --------
+    >>> get_frequency_alias('M')  # Returns 'ME' in pandas 2.2.0+, 'M' in older versions
+    >>> get_frequency_alias('D')  # Returns 'D' (unchanged)
+    """
+    # Look up the frequency in our mapping, return original if not found
+    return FREQUENCY_ALIASES.get(freq, freq)
+
+
+def normalize_timezone(data: Union[pd.Series, pd.DataFrame]) -> Union[pd.Series, pd.DataFrame]:
+    """
+    Normalize timezone information for consistent comparisons.
+    
+    If data has timezone info, converts to UTC then removes timezone info.
+    This ensures all data can be compared regardless of original timezone.
+    
+    Parameters
+    ----------
+    data : pd.Series or pd.DataFrame
+        Time series data with DatetimeIndex
+        
+    Returns
+    -------
+    pd.Series or pd.DataFrame
+        Data with timezone-naive DatetimeIndex
+    """
+    if not isinstance(data.index, pd.DatetimeIndex):
+        return data
+    
+    # If timezone aware, convert to UTC then make naive
+    if data.index.tz is not None:
+        result = data.copy()
+        result.index = result.index.tz_convert('UTC').tz_localize(None)
+        return result
+    
+    # Already timezone naive, return as is
+    return data
+
+
+def safe_resample(data: Union[pd.Series, pd.DataFrame],
+                  freq: str,
+                  func_name: Optional[Union[str, Callable]] = None,
+                  **kwargs):
+    """
+    Safe resample operation that works with all pandas versions.
+
+    This function handles the resampling of time series data using the correct
+    frequency aliases and aggregation methods that are compatible across
+    different pandas versions. It also normalizes timezones to ensure
+    consistent comparisons.
+
+    Parameters
+    ----------
+    data : pd.Series or pd.DataFrame
+        The time series data to resample
+    freq : str
+        The frequency to resample to (e.g., 'M', 'Q', 'A', 'D')
+    func_name : str or callable, optional
+        The aggregation function to apply. Can be a string name like 'sum',
+        'mean', 'std', etc., or a callable function
+    **kwargs
+        Additional arguments passed to the aggregation function
+
+    Returns
+    -------
+    pd.Series or pd.DataFrame
+        The resampled data with the specified frequency and aggregation,
+        with timezone normalized to UTC if present, or naive if not
+
+    Examples
+    --------
+    >>> safe_resample(data, 'M', 'sum')  # Monthly sum aggregation
+    >>> safe_resample(data, 'Q', 'mean')  # Quarterly mean aggregation
+    """
+    # Convert frequency to the appropriate alias for current pandas version
+    freq_alias = get_frequency_alias(freq)
+
+    # Create the resampler object using the correct frequency
+    resampler = data.resample(freq_alias)
+
+    # If no aggregation function specified, return the resampler object
+    if func_name is None:
+        return resampler
+
+    # Handle string function names with explicit method calls
+    # This approach avoids deprecation warnings and ensures compatibility
+    result = None
+    if isinstance(func_name, str):
+        # Map common aggregation functions to their pandas methods
+        if func_name == "sum":
+            result = resampler.sum(**kwargs)
+        elif func_name == "mean":
+            result = resampler.mean(**kwargs)
+        elif func_name == "std":
+            result = resampler.std(**kwargs)
+        elif func_name == "count":
+            result = resampler.count(**kwargs)
+        elif func_name == "min":
+            result = resampler.min(**kwargs)
+        elif func_name == "max":
+            result = resampler.max(**kwargs)
+        elif func_name == "first":
+            result = resampler.first(**kwargs)
+        elif func_name == "last":
+            result = resampler.last(**kwargs)
+        else:
+            # Try to find the method on the resampler object
+            if hasattr(resampler, func_name):
+                result = getattr(resampler, func_name)(**kwargs)
+            else:
+                # Fallback to apply for custom string functions
+                result = resampler.apply(func_name, **kwargs)
+    else:
+        # For callable functions, use apply method
+        # Suppress FutureWarning about callable usage - our use is intentional
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", category=FutureWarning, 
+                                    message=".*callable.*")
+            result = resampler.apply(func_name, **kwargs)
+    
+    # Normalize timezone to ensure consistent comparisons
+    return normalize_timezone(result)
+
+
+def safe_concat(objs: List[Union[pd.Series, pd.DataFrame]],
+                axis: int = 0,
+                ignore_index: bool = False,
+                sort: bool = False,
+                **kwargs) -> Union[pd.Series, pd.DataFrame]:
+    """
+    Safe concatenation that handles pandas version differences.
+
+    This function provides a wrapper around pd.concat with consistent parameters.
+
+    Parameters
+    ----------
+    objs : list of pd.Series or pd.DataFrame
+        Objects to concatenate along the specified axis
+    axis : int, default 0
+        Axis to concatenate along. 0 for rows, 1 for columns
+    ignore_index : bool, default False
+        Whether to ignore the index and create a new default integer index
+    sort : bool, default False
+        Whether to sort the result
+    **kwargs
+        Additional arguments passed to pd.concat
+
+    Returns
+    -------
+    pd.Series or pd.DataFrame
+        The concatenated result
+
+    Examples
+    --------
+    >>> safe_concat([df1, df2])  # Concatenate along rows
+    >>> safe_concat([df1, df2], axis=1)  # Concatenate along columns
+    """
+    # Perform the concatenation with sort parameter (available in pandas 2.0+)
+    return pd.concat(objs, axis=axis, ignore_index=ignore_index, sort=sort, **kwargs)  # type: ignore[arg-type]
+
+
+def safe_append(df: pd.DataFrame,
+                other: Union[pd.DataFrame, pd.Series],
+                ignore_index: bool = False,
+                sort: bool = False) -> pd.DataFrame:
+    """
+    Safe append operation using pd.concat.
+
+    DataFrame.append() was removed in pandas 2.0.0. This function provides
+    a unified interface using pd.concat.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        The DataFrame to append to (base DataFrame)
+    other : pd.DataFrame or pd.Series
+        The data to append to the base DataFrame
+    ignore_index : bool, default False
+        Whether to ignore the index and create a new default integer index
+    sort : bool, default False
+        Whether to sort the result by columns
+
+    Returns
+    -------
+    pd.DataFrame
+        The result of the append operation
+
+    Examples
+    --------
+    >>> safe_append(df, new_row)  # Append a new row
+    >>> safe_append(df, other_df, ignore_index=True)  # Append and reset index
+    """
+    # Use concat (append was removed in pandas 2.0)
+    result = safe_concat([df, other], ignore_index=ignore_index, sort=sort)
+    # Ensure we return a DataFrame
+    if isinstance(result, pd.DataFrame):
+        return result
+    elif isinstance(result, pd.Series):
+        return pd.DataFrame([result])
+    else:
+        return pd.DataFrame(result)
+
+
+def safe_frequency_conversion(data: Union[pd.Series, pd.DataFrame],
+                              freq: str) -> Union[pd.Series, pd.DataFrame]:
+    """
+    Safe frequency conversion for time series data.
+
+    This function converts time series data to a specified frequency using
+    the most appropriate method available in the current pandas version.
+
+    Parameters
+    ----------
+    data : pd.Series or pd.DataFrame
+        Time series data with a datetime index
+    freq : str
+        Target frequency (e.g., 'D', 'M', 'Q', 'A')
+
+    Returns
+    -------
+    pd.Series or pd.DataFrame
+        Data with converted frequency
+
+    Examples
+    --------
+    >>> safe_frequency_conversion(data, 'M')  # Convert to monthly frequency
+    >>> safe_frequency_conversion(data, 'D')  # Convert to daily frequency
+    """
+    # Get the appropriate frequency alias for current pandas version
+    freq_alias = get_frequency_alias(freq)
+
+    # Handle different methods for frequency conversion
+    if hasattr(data, "asfreq"):
+        # Use asfreq if available (most direct method)
+        return data.asfreq(freq_alias)
+    else:
+        # Fallback to resampling with 'last' aggregation
+        # This preserves the last value in each period
+        return safe_resample(data, freq_alias, "last")
+
+
+def handle_pandas_warnings():
+    """
+    Context manager to handle pandas warnings appropriately.
+
+    This function returns a context manager that can be used to suppress
+    or handle pandas warnings in a controlled manner. Useful for managing
+    deprecation warnings when working with multiple pandas versions.
+
+    Returns
+    -------
+    warnings.catch_warnings
+        A context manager for handling warnings
+
+    Examples
+    --------
+    >>> with handle_pandas_warnings():
+    ...     # Code that might generate pandas warnings
+    ...     pass
+    """
+    # Return the warnings context manager for flexible warning handling
+    return warnings.catch_warnings()
+
+
+# Pandas accessor compatibility functions
+def get_datetime_accessor(series: pd.Series):
+    """
+    Get datetime accessor for pandas Series.
+
+    This function provides a consistent interface for accessing datetime
+    properties of a pandas Series across different versions.
+
+    Parameters
+    ----------
+    series : pd.Series
+        The series with datetime data to get the accessor for
+
+    Returns
+    -------
+    pd.Series.dt
+        The datetime accessor for the series
+
+    Examples
+    --------
+    >>> dt_accessor = get_datetime_accessor(date_series)
+    >>> dt_accessor.year  # Access year component
+    >>> dt_accessor.month  # Access month component
+    """
+    # Return the datetime accessor - consistent across pandas versions
+    return series.dt
+
+
+def get_string_accessor(series: pd.Series):
+    """
+    Get string accessor for pandas Series.
+
+    This function provides a consistent interface for accessing string
+    methods of a pandas Series across different versions.
+
+    Parameters
+    ----------
+    series : pd.Series
+        The series with string data to get the accessor for
+
+    Returns
+    -------
+    pd.Series.str
+        The string accessor for the series
+
+    Examples
+    --------
+    >>> str_accessor = get_string_accessor(string_series)
+    >>> str_accessor.lower()  # Convert to lowercase
+    >>> str_accessor.contains('pattern')  # Check for pattern
+    """
+    # Return the string accessor - consistent across pandas versions
+    return series.str
+
+
+def safe_yfinance_download(tickers: Union[str, List[str]],
+                           proxy: Optional[str] = None,
+                           **kwargs) -> pd.DataFrame:
+    """
+    Safe yfinance download that handles proxy configuration properly.
+
+    This function provides a wrapper around yfinance.download that handles
+    proxy configuration differences between yfinance versions. It ensures
+    compatibility with both old and new yfinance proxy configuration methods.
+
+    Parameters
+    ----------
+    tickers : str or list
+        Ticker symbols to download data for. Can be a single ticker string
+        or a list of ticker symbols
+    proxy : str, optional
+        Proxy configuration string (e.g., 'http://proxy.server:port')
+        Handled automatically based on yfinance version
+    **kwargs
+        Additional arguments passed to yfinance.download such as:
+        - start: Start date for data download
+        - end: End date for data download
+        - period: Period to download (e.g., '1y', '6mo')
+        - interval: Data interval (e.g., '1d', '1h')
+
+    Returns
+    -------
+    pd.DataFrame
+        Downloaded financial data with columns like Open, High, Low, Close, Volume
+
+    Examples
+    --------
+    >>> data = safe_yfinance_download('AAPL', start='2020-01-01', end='2021-01-01')
+    >>> data = safe_yfinance_download(['AAPL', 'MSFT'], period='1y')
+    """
+    # Handle proxy configuration based on yfinance version
+    if proxy is not None:
+        # Check if the new configuration method exists in yfinance
+        if hasattr(yf, "set_config"):
+            # New method: use set_config for global proxy configuration
+            # This approach is preferred in newer yfinance versions
+            yf.set_config(proxy=proxy)
+            # Remove proxy from kwargs to avoid duplicate parameter error
+            kwargs.pop("proxy", None)
+        else:
+            # Old method: pass proxy directly to download function
+            # This is for backward compatibility with older yfinance versions
+            kwargs["proxy"] = proxy
+
+    # Suppress yfinance warnings about deprecation and future changes
+    # This keeps the output clean while maintaining functionality
+    with warnings.catch_warnings():
+        warnings.filterwarnings("ignore", category=FutureWarning, module="yfinance")
+        # Download the data using yfinance with all provided parameters
+        result = yf.download(tickers, **kwargs)
+
+        # Handle case where yfinance returns None (network issues, invalid ticker, etc.)
+        if result is None:
+            # Return empty DataFrame with standard yfinance columns
+            return pd.DataFrame(columns=['Open', 'High', 'Low', 'Close', 'Volume', 'Adj Close'])
+
+        return result