chore: format codebase with black and fix lint warnings

Author: ayushkrtiwari

.coverage

@@ -46,7 +46,9 @@ def _calculate_risk_metrics(self) -> Dict[str, float]:
         vol = float(self.returns.std(ddof=1) * np.sqrt(252))
         downside_returns = self.returns[self.returns < 0]
         downside_vol = (
-            float(downside_returns.std(ddof=1) * np.sqrt(252)) if len(downside_returns) > 0 else 0.0
+            float(downside_returns.std(ddof=1) * np.sqrt(252))
+            if len(downside_returns) > 0
+            else 0.0
         )
 
         max_drawdown, drawdown_duration = self._calculate_drawdown()
@@ -57,7 +59,9 @@ def _calculate_risk_metrics(self) -> Dict[str, float]:
             "max_drawdown": max_drawdown,
             "drawdown_duration": drawdown_duration,
             "var_95": float(self.returns.quantile(0.05)),
-            "cvar_95": float(self.returns[self.returns <= self.returns.quantile(0.05)].mean()),
+            "cvar_95": float(
+                self.returns[self.returns <= self.returns.quantile(0.05)].mean()
+            ),
         }
 
     def _calculate_ratio_metrics(self) -> Dict[str, float]:
@@ -91,7 +95,9 @@ def _calculate_benchmark_metrics(self) -> Dict[str, float]:
             return {}
 
         # Ensure identical index after dropna
-        strategy_returns, benchmark_returns = strategy_returns.align(benchmark_returns, join="inner")
+        strategy_returns, benchmark_returns = strategy_returns.align(
+            benchmark_returns, join="inner"
+        )
 
         x = benchmark_returns.values.astype(float)
         y = strategy_returns.values.astype(float)
@@ -114,10 +120,18 @@ def _calculate_benchmark_metrics(self) -> Dict[str, float]:
 
         # Tracking error (annualized std of active returns)
         active_returns = (strategy_returns - benchmark_returns).dropna()
-        tracking_error = float(active_returns.std(ddof=1) * np.sqrt(252)) if len(active_returns) > 1 else 0.0
+        tracking_error = (
+            float(active_returns.std(ddof=1) * np.sqrt(252))
+            if len(active_returns) > 1
+            else 0.0
+        )
 
         # Information ratio
-        info_ratio = float((strategy_cagr - benchmark_cagr) / tracking_error) if tracking_error > 0 else 0.0
+        info_ratio = (
+            float((strategy_cagr - benchmark_cagr) / tracking_error)
+            if tracking_error > 0
+            else 0.0
+        )
 
         return {
             "alpha": alpha,
@@ -144,7 +158,11 @@ def _calculate_cagr_from_returns(self, returns: pd.Series) -> float:
     def _calculate_downside_vol(self) -> float:
         """Calculate downside volatility (for Sortino ratio)."""
         downside_returns = self.returns[self.returns < 0]
-        return float(downside_returns.std(ddof=1) * np.sqrt(252)) if len(downside_returns) > 0 else 0.0
+        return (
+            float(downside_returns.std(ddof=1) * np.sqrt(252))
+            if len(downside_returns) > 0
+            else 0.0
+        )
 
     def _calculate_drawdown(self) -> Tuple[float, int]:
         """Calculate maximum drawdown and duration."""
@@ -168,8 +186,14 @@ def _calculate_drawdown(self) -> Tuple[float, int]:
         try:
             prior_max_mask = running_max[running_max.index <= max_dd_period]
             drawdown_start_val = prior_max_mask.max()
-            start_candidates = prior_max_mask[prior_max_mask == drawdown_start_val].index
-            drawdown_start = start_candidates[-1] if len(start_candidates) > 0 else running_max.index[0]
+            start_candidates = prior_max_mask[
+                prior_max_mask == drawdown_start_val
+            ].index
+            drawdown_start = (
+                start_candidates[-1]
+                if len(start_candidates) > 0
+                else running_max.index[0]
+            )
             drawdown_duration = int((max_dd_period - drawdown_start).days)
         except Exception:
             drawdown_duration = 0

src/quant_research_starter/metrics/__pycache__/risk.cpython-312.pyc

@@ -123,7 +123,11 @@ def test_benchmark_metrics(self, sample_returns, benchmark_returns):
         # compute Spearman correlation between series (fallback to ensure relation is meaningful)
         strategy = sample_returns.loc[benchmark_returns.index].dropna()
         bench = benchmark_returns.loc[strategy.index].dropna()
-        if len(strategy) > 10 and np.all(np.isfinite(strategy)) and np.all(np.isfinite(bench)):
+        if (
+            len(strategy) > 10
+            and np.all(np.isfinite(strategy))
+            and np.all(np.isfinite(bench))
+        ):
             spearman = strategy.corr(bench, method="spearman")
             # if the two series are meaningfully correlated (|spearman| > 0.2), expect beta in a reasonable range
             if abs(spearman) > 0.2: