sovai 0.2.71__tar.gz → 0.2.73__tar.gz

{sovai-0.2.71 → sovai-0.2.73}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sovai
-Version: 0.2.71
+Version: 0.2.73
 Summary: python for asset management
 License: Proprietary License
 License-File: LICENSE

{sovai-0.2.71 → sovai-0.2.73}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "sovai"
-version = "0.2.71"
+version = "0.2.73"
 description = "python for asset management"
 authors = [
     {name = "Derek Snow", email = "d.snow@outlook.com"}

{sovai-0.2.71 → sovai-0.2.73}/sovai/extensions/signal_evaluation.py

@@ -423,6 +423,32 @@ from plotly.subplots import make_subplots
 import numpy as np
 
 
+def _get_first_valid_index(data):
+    """
+    Find the first index where any series has valid (non-NaN) data.
+    
+    Parameters:
+    -----------
+    data : pd.Series or pd.DataFrame
+        Time series data to check
+        
+    Returns:
+    --------
+    First valid index position, or None if all data is NaN
+    """
+    if isinstance(data, pd.DataFrame):
+        # For DataFrames, find first row where at least one column is not NaN
+        valid_mask = data.notna().any(axis=1)
+        if valid_mask.any():
+            return data.index[valid_mask.argmax()]
+    elif isinstance(data, pd.Series):
+        # For Series, find first non-NaN value
+        valid_mask = data.notna()
+        if valid_mask.any():
+            return data.index[valid_mask.argmax()]
+    return None
+
+
 def calculate_rolling_sharpe_ratio(returns, window=52, risk_free_rate=0):
     excess_returns = returns - risk_free_rate
     rolling_mean = excess_returns.rolling(window=window).mean()
@@ -438,6 +464,14 @@ def plot_cumulative_performance_with_sharpe_and_random(
     # Calculate rolling Sharpe ratio
     rolling_sharpe = calculate_rolling_sharpe_ratio(portfolio_returns)
     average_sharpe = rolling_sharpe.mean()
+    
+    # Find the first valid index across all series
+    first_valid_idx = _get_first_valid_index(cumulative_returns)
+    if first_valid_idx is not None:
+        cumulative_returns = cumulative_returns.loc[first_valid_idx:]
+        rolling_sharpe = rolling_sharpe.loc[rolling_sharpe.index >= first_valid_idx]
+        lower_5_strategy = lower_5_strategy.loc[lower_5_strategy.index >= first_valid_idx]
+        upper_95_strategy = upper_95_strategy.loc[upper_95_strategy.index >= first_valid_idx]
 
     # Create the plot
     fig = make_subplots(specs=[[{"secondary_y": True}]])
@@ -589,6 +623,11 @@ def get_event_returns(returns, start_date, end_date):
 
 
 def stress_plotting(portfolio_returns):
+    # Find the first valid index
+    first_valid_idx = _get_first_valid_index(portfolio_returns)
+    if first_valid_idx is not None:
+        portfolio_returns = portfolio_returns.loc[first_valid_idx:]
+    
     # Define stress event dates
     stress_events = {
         "Dotcom": ("2000-03-01", "2002-10-01"),
@@ -837,6 +876,11 @@ from plotly.subplots import make_subplots
 
 
 def drawdown_plot(portfolio_returns):
+    # Find the first valid index
+    first_valid_idx = _get_first_valid_index(portfolio_returns)
+    if first_valid_idx is not None:
+        portfolio_returns = portfolio_returns.loc[first_valid_idx:]
+    
     # Calculate cumulative returns
     cumulative_returns = (1 + portfolio_returns).cumprod()
 
@@ -1298,6 +1342,11 @@ import numpy as np
 def create_weekly_returns_heatmap(portfolio_returns):
     # Ensure the index is datetime
     portfolio_returns.index = pd.to_datetime(portfolio_returns.index)
+    
+    # Find the first valid index
+    first_valid_idx = _get_first_valid_index(portfolio_returns)
+    if first_valid_idx is not None:
+        portfolio_returns = portfolio_returns.loc[first_valid_idx:]
 
     # Get all unique years from the index
     all_years = sorted(portfolio_returns.index.year.unique())
@@ -1413,7 +1462,11 @@ def calculate_turnover(df, mask):
 def turnover_plot(df_balance, rebalance_mask):
     # Calculate turnover percentages
     turnover_df = calculate_turnover(df_balance, rebalance_mask)
-    turnover_df = turnover_df.query("index >= '1999-01-01'")
+    
+    # Find the first valid index instead of using hardcoded date
+    first_valid_idx = _get_first_valid_index(turnover_df)
+    if first_valid_idx is not None:
+        turnover_df = turnover_df.loc[first_valid_idx:]
 
     # Find the max and min values
     y_max = max(
@@ -1524,7 +1577,12 @@ def fast_rolling_autocorrelation(df, window):
 def signal_correlation(df_signal):
     window_size = 12
     autocorrelation = fast_rolling_autocorrelation(df_signal, window_size)
-    autocorrelation_single = autocorrelation.query("date >='1999-01-01'").mean(axis=1)
+    autocorrelation_single = autocorrelation.mean(axis=1)
+    
+    # Find the first valid index instead of using hardcoded date
+    first_valid_idx = _get_first_valid_index(autocorrelation_single)
+    if first_valid_idx is not None:
+        autocorrelation_single = autocorrelation_single.loc[first_valid_idx:]
 
     mean_autocorrelation = np.mean(autocorrelation_single)
 
@@ -1615,6 +1673,12 @@ def decile_plots(df_signal, df_prices):
     # Convert results to dictionaries
     decile_returns = {decile: returns for decile, returns, _ in results}
     decile_sharpes = {decile: sharpe for decile, _, sharpe in results}
+    
+    # Find the first valid index across all decile returns
+    all_returns = pd.DataFrame(decile_returns)
+    first_valid_idx = _get_first_valid_index(all_returns)
+    if first_valid_idx is not None:
+        decile_returns = {decile: returns.loc[first_valid_idx:] for decile, returns in decile_returns.items()}
 
     # Create the plot with secondary y-axis
     fig = make_subplots(specs=[[{"secondary_y": True}]])