Fix flake8 and black linting violations across the codebase

Author: johngeorgea157-stack

.github/workflows/ci.yml

@@ -29,7 +29,7 @@ jobs:
           flake8 data/ qubo/ qaoa/ classical/ \
             --max-line-length=100 \
             --exclude=__pycache__,*.ipynb_checkpoints \
-            --ignore=E402
+            --ignore=E402,W503
 
       - name: Run black (formatting check)
         run: |

classical/greedy.py

@@ -16,7 +16,9 @@
 import os
 
 
-def load_portfolio_data(cached_dir='/Users/johngeorgealexander/qc/quantum-portfolio-opt/data/cached'):
+def load_portfolio_data(
+    cached_dir="/Users/johngeorgealexander/qc/quantum-portfolio-opt/data/cached",
+):
     """
     Load portfolio data from Day 2 cached results.
 
@@ -26,11 +28,13 @@ def load_portfolio_data(cached_dir='/Users/johngeorgealexander/qc/quantum-portfo
         stock_names (list): List of stock names
     """
     # Load mean returns (μ) and covariance (Σ)
-    mu = np.load(os.path.join(cached_dir, 'mu.npy'))
-    sigma = np.load(os.path.join(cached_dir, 'sigma.npy'))
+    mu = np.load(os.path.join(cached_dir, "mu.npy"))
+    sigma = np.load(os.path.join(cached_dir, "sigma.npy"))
 
     # Load stock names from CSV
-    expected_returns_df = pd.read_csv(os.path.join(cached_dir, 'expected_returns.csv'), index_col=0)
+    expected_returns_df = pd.read_csv(
+        os.path.join(cached_dir, "expected_returns.csv"), index_col=0
+    )
     stock_names = expected_returns_df.index.tolist()
 
     return mu, sigma, stock_names
@@ -66,8 +70,11 @@ def optimize_portfolio(mu, sigma, target_return):
 
     # Constraints
     constraints = [
-        {'type': 'eq', 'fun': lambda w: w.sum() - 1},  # weights sum to 1
-        {'type': 'eq', 'fun': lambda w: portfolio_return(w, mu) - target_return}  # target return
+        {"type": "eq", "fun": lambda w: w.sum() - 1},  # weights sum to 1
+        {
+            "type": "eq",
+            "fun": lambda w: portfolio_return(w, mu) - target_return,
+        },  # target return
     ]
 
     # Bounds: no short selling (w_i >= 0)
@@ -78,10 +85,10 @@ def optimize_portfolio(mu, sigma, target_return):
         portfolio_variance,
         w0,
         args=(sigma,),
-        method='SLSQP',
+        method="SLSQP",
         bounds=bounds,
         constraints=constraints,
-        options={'disp': False}
+        options={"disp": False},
     )
 
     if result.success:
@@ -118,12 +125,14 @@ def generate_efficient_frontier(mu, sigma, n_points=50):
     for target_ret in target_returns:
         w_opt, ret_opt, var_opt = optimize_portfolio(mu, sigma, target_ret)
         if w_opt is not None:
-            portfolios.append({
-                'return': ret_opt,
-                'variance': var_opt,
-                'volatility': np.sqrt(var_opt),
-                'weights': w_opt
-            })
+            portfolios.append(
+                {
+                    "return": ret_opt,
+                    "variance": var_opt,
+                    "volatility": np.sqrt(var_opt),
+                    "weights": w_opt,
+                }
+            )
 
     return portfolios
 
@@ -136,8 +145,8 @@ def get_efficient_frontier_data(mu, sigma, n_points=30):
         tuple: (returns_list, volatilities_list, portfolios_list)
     """
     portfolios = generate_efficient_frontier(mu, sigma, n_points)
-    returns = [p['return'] for p in portfolios]
-    volatilities = [p['volatility'] for p in portfolios]
+    returns = [p["return"] for p in portfolios]
+    volatilities = [p["volatility"] for p in portfolios]
     return returns, volatilities, portfolios
 
 
@@ -168,22 +177,28 @@ def get_efficient_frontier_data(mu, sigma, n_points=30):
     portfolios = generate_efficient_frontier(mu, sigma, n_points=20)
     if portfolios:
         print(f"\nGenerated {len(portfolios)} portfolios on efficient frontier")
-        print(f"Return range: {min(p['return'] for p in portfolios):.4f} to {max(p['return'] for p in portfolios):.4f}")
-        print(f"Volatility range: {min(p['volatility'] for p in portfolios):.4f} to {max(p['volatility'] for p in portfolios):.4f}")
+        min_ret = min(p["return"] for p in portfolios)
+        max_ret = max(p["return"] for p in portfolios)
+        print(f"Return range: {min_ret:.4f} to {max_ret:.4f}")
+
+        min_vol = min(p["volatility"] for p in portfolios)
+        max_vol = max(p["volatility"] for p in portfolios)
+        print(f"Volatility range: {min_vol:.4f} to {max_vol:.4f}")
 
     print("=" * 70)
 import time
 
+
 def greedy_qubo_search(Q, k):
     """
     Greedy heuristic to find an approximate solution for a QUBO.
     Iteratively adds the single asset that minimizes the objective
     until k assets are selected.
-    
+
     Args:
         Q: QUBO matrix (numpy array)
         k: Int, number of stocks to pick
-        
+
     Returns:
         best_x: numpy array (binary vector)
         best_obj: float
@@ -192,28 +207,28 @@ def greedy_qubo_search(Q, k):
     start_time = time.time()
     n = len(Q)
     x = np.zeros(n, dtype=int)
-    
+
     # We want exactly k stocks
     for _ in range(k):
         best_gain = float("inf")
         best_idx = -1
-        
+
         # Test flipping each 0 to 1
         for i in range(n):
             if x[i] == 0:
                 x_test = x.copy()
                 x_test[i] = 1
                 obj = float(x_test @ Q @ x_test)
-                
+
                 if obj < best_gain:
                     best_gain = obj
                     best_idx = i
-                    
+
         # Permanently flip the best one
         if best_idx != -1:
             x[best_idx] = 1
-            
+
     final_obj = float(x @ Q @ x)
     exec_time = time.time() - start_time
-    
+
     return x, final_obj, exec_time

classical/sim_annealing.py

@@ -2,95 +2,94 @@
 import time
 import math
 
-def simulated_annealing_qubo(Q, k, T_start=1000.0, cooling_rate=0.99, max_iter=10000, seed=None):
+
+def simulated_annealing_qubo(
+    Q, k, T_start=1000.0, cooling_rate=0.99, max_iter=10000, seed=None
+):
     """
     Simulated Annealing heuristic for the QUBO formulation of the portfolio problem.
     Maintains exactly k selected assets at all times to satisfy the constraint naturally.
-    
+
     Args:
         Q: QUBO matrix (numpy array)
         k: Int, number of stocks to pick
         T_start: Float, initial high temperature
         cooling_rate: Float, multiplier to cool temperature (e.g. 0.99)
         max_iter: Int, max iterations
         seed: Int, optional random seed for reproducibility
-        
+
     Returns:
         best_x: numpy array (binary vector)
         best_obj: float
         exec_time: float
     """
     if seed is not None:
         np.random.seed(seed)
-        
+
     start_time = time.time()
     n = len(Q)
-    
+
     # Random initial valid portfolio (exactly k ones)
     x_current = np.zeros(n, dtype=int)
     random_indices = np.random.choice(n, k, replace=False)
     x_current[random_indices] = 1
-    
+
     current_obj = float(x_current @ Q @ x_current)
-    
+
     best_x = x_current.copy()
     best_obj = current_obj
-    
+
     T = T_start
-    
+
     for _ in range(max_iter):
         # Stop if temperature is virtually 0
         if T < 1e-8:
             break
-            
+
         # Generate a neighbor: flip one 1 to 0, and one 0 to 1
         x_neighbor = x_current.copy()
-        
+
         # Find indices of current 1s and 0s
         ones_idx = np.where(x_neighbor == 1)[0]
         zeros_idx = np.where(x_neighbor == 0)[0]
-        
+
         if len(ones_idx) > 0 and len(zeros_idx) > 0:
             # Pick a random 1 to flip to 0
             flip_to_zero = np.random.choice(ones_idx)
             # Pick a random 0 to flip to 1
             flip_to_one = np.random.choice(zeros_idx)
-            
+
             x_neighbor[flip_to_zero] = 0
             x_neighbor[flip_to_one] = 1
-            
+
         neighbor_obj = float(x_neighbor @ Q @ x_neighbor)
-        
+
         # Delta E (change in energy)
         delta = neighbor_obj - current_obj
-        
+
         # If neighbor is better (delta < 0), accept it!
         # If neighbor is worse, accept with probability e^(-delta / T)
         if delta < 0 or np.random.rand() < math.exp(-delta / T):
             x_current = x_neighbor.copy()
             current_obj = neighbor_obj
-            
+
             # Keep track of absolute best found so far
             if current_obj < best_obj:
                 best_obj = current_obj
                 best_x = x_current.copy()
-                
+
         # Cool down the temperature
         T *= cooling_rate
-        
+
     exec_time = time.time() - start_time
-    
+
     return best_x, best_obj, exec_time
 
+
 if __name__ == "__main__":
     # Simple test case
-    Q_test = np.array([
-        [-10,  2,  2,  5],
-        [  2, -8,  3,  1],
-        [  2,  3, -6,  4],
-        [  5,  1,  4,-12]
-    ])
-    
+    Q_test = np.array([[-10, 2, 2, 5], [2, -8, 3, 1], [2, 3, -6, 4], [5, 1, 4, -12]])
+
     print("Testing Simulated Annealing...")
     best_x, best_obj, t = simulated_annealing_qubo(Q_test, k=2)
     print(f"Best X: {best_x}")

classical/test_classical.py

@@ -16,6 +16,7 @@
 
 # ── Fixtures ─────────────────────────────────────────────────────────────────
 
+
 @pytest.fixture
 def problem():
     """Standard 5-asset test problem."""
@@ -32,12 +33,14 @@ def problem():
 def Q_matrix(problem):
     """Pre-built Q matrix for SA tests."""
     from qubo.qubo_builder import build_Q_matrix
+
     returns, cov, n, k = problem
     return build_Q_matrix(returns, cov, penalty=5.0, k=k), n, k
 
 
 # ── Greedy Tests ─────────────────────────────────────────────────────────────
 
+
 def test_greedy_output_length(Q_matrix):
     """Greedy must return a binary vector of length n."""
     Q, n, k = Q_matrix
@@ -80,6 +83,7 @@ def test_greedy_prefers_high_return(Q_matrix, problem):
 
 # ── Simulated Annealing Tests ─────────────────────────────────────────────────
 
+
 def test_sa_output_length(Q_matrix):
     """SA must return a binary vector of length n."""
     Q, n, k = Q_matrix
@@ -120,6 +124,7 @@ def test_sa_reproducible_with_seed(Q_matrix):
 def test_sa_better_than_random(Q_matrix):
     """SA should outperform a random feasible solution on average."""
     from qubo.qubo_builder import compute_objective
+
     Q, n, k = Q_matrix
     _, sa_obj, _ = simulated_annealing_qubo(Q, k, seed=42)
 
@@ -132,6 +137,6 @@ def test_sa_better_than_random(Q_matrix):
         random_objs.append(compute_objective(Q, x))
 
     avg_random = np.mean(random_objs)
-    assert sa_obj <= avg_random, (
-        f"SA obj {sa_obj:.4f} worse than random avg {avg_random:.4f}"
-    )
+    assert (
+        sa_obj <= avg_random
+    ), f"SA obj {sa_obj:.4f} worse than random avg {avg_random:.4f}"