Feat: Market Cap Filtering (Smallest/Largest 50)

api/static/index.html

@@ -466,6 +466,8 @@
                 "excluded_sectors": excluded,
                 "excluded_tickers": excludedTickers,
                 "max_weight": maxWeight,
+                "strategy": strategy,
+                "top_n": topN,
                 "initial_investment": 100000
             };
 
@@ -493,15 +495,18 @@
         function displayData(data, excluded) {
             // Metrics
             document.getElementById('teMetric').innerText = (data.tracking_error * 100).toFixed(4) + "%";
-            
+
             let constraintText = excluded.length > 0 ? "Excl: " + excluded.join(", ") : "None";
             if (data.max_weight_applied) {
                 constraintText += ` | Max Wgt: ${(data.max_weight_applied * 100).toFixed(1)}%`;
             } else if (payload.max_weight) {
-                // Determine if backend ignored it or if we just want to show what we sent
-                constraintText += ` | Max Wgt: ${(payload.max_weight * 100).toFixed(1)}% (Requested)`;
+                constraintText += ` | Max Wgt: ${(payload.max_weight * 100).toFixed(1)}% (Req)`;
+            }
+
+            if (payload.strategy) {
+                constraintText += ` | Strat: ${payload.strategy.replace('_market_cap', '')} ${payload.top_n}`;
             }
-            
+
             document.getElementById('excludedMetric').innerText = constraintText;
 
             // AI Text - Markdown clean

core/schema.py

@@ -27,6 +27,8 @@ class OptimizationRequest(BaseModel):
     excluded_sectors: List[str] = Field(default_factory=list, description="List of sectors to exclude (e.g., ['Energy'])")
     excluded_tickers: List[str] = Field(default_factory=list, description="List of specific tickers to exclude (e.g., ['AMZN'])")
     max_weight: Optional[float] = Field(None, description="Maximum weight for any single asset (e.g., 0.05)")
+    strategy: Optional[str] = Field(None, description="Global Filter Strategy: 'smallest_market_cap' or 'largest_market_cap'")
+    top_n: Optional[int] = Field(None, description="Number of assets to select for strategy (e.g. 50)")
     benchmark: str = "^GSPC"
 
     class Config:

data/data_manager.py

@@ -150,3 +150,55 @@ class MarketDataEngine:
 
     def get_sector_map(self) -> Dict[str, str]:
         return self.sector_cache.sector_map
+
+    def fetch_market_caps(self, tickers: List[str]) -> Dict[str, float]:
+        """
+        Fetches market caps for a list of tickers, using a local cache to speed up subsequent runs.
+        """
+        cache_file = os.path.join(settings.DATA_DIR, "market_cap_cache.json")
+        caps = {}
+        
+        # Load Cache
+        if os.path.exists(cache_file):
+            try:
+                with open(cache_file, 'r') as f:
+                    caps = json.load(f)
+            except Exception as e:
+                logger.error(f"Failed to load cap cache: {e}")
+
+        # Identify missing tickers
+        missing = [t for t in tickers if t not in caps]
+        
+        if missing:
+            logger.info(f"Fetching market caps for {len(missing)} tickers (can take 60s)...")
+            import concurrent.futures
+            
+            def get_cap(ticker):
+                try:
+                    # Use yfinance fast_info for speed (no web scraping)
+                    # fast_info works well, fallback to info
+                    info = yf.Ticker(ticker).fast_info
+                    return ticker, info['market_cap']
+                except:
+                    # Retry logic or just 0
+                    try:
+                        return ticker, yf.Ticker(ticker).info.get('marketCap', 0)
+                    except:
+                        return ticker, 0
+
+            with concurrent.futures.ThreadPoolExecutor(max_workers=20) as executor:
+                results = executor.map(get_cap, missing)
+                
+            for ticker, cap in results:
+                if cap and cap > 0:
+                    caps[ticker] = cap
+                    
+            # Save Cache
+            try:
+                with open(cache_file, 'w') as f:
+                    json.dump(caps, f, indent=2)
+            except Exception as e:
+                logger.error(f"Failed to save cap cache: {e}")
+                
+        # Return only requested tickers
+        return {t: caps.get(t, 0) for t in tickers}

main.py

@@ -44,6 +44,29 @@ class QuantScaleSystem:
         # 3. Compute Risk Model
         # Ensure we align returns and tickers
         valid_tickers = returns.columns.tolist()
+        
+        # APPLY FILTERING STRATEGY (New)
+        if request.strategy and request.top_n:
+            logger.info(f"Applying Strategy: {request.strategy} with Top N={request.top_n}")
+            caps = self.data_engine.fetch_market_caps(valid_tickers)
+            
+            # Sort valid_tickers by cap
+            # Filter out 0 caps (failed fetches)
+            valid_caps = {t: c for t, c in caps.items() if c > 0}
+            sorted_tickers = sorted(valid_caps.keys(), key=lambda t: valid_caps[t])
+            
+            if request.strategy == "smallest_market_cap":
+                valid_tickers = sorted_tickers[:request.top_n]
+                logger.info(f"Filtered to Smallest {request.top_n}: {valid_tickers[:5]}...")
+                
+            elif request.strategy == "largest_market_cap":
+                valid_tickers = sorted_tickers[-request.top_n:]
+                logger.info(f"Filtered to Largest {request.top_n}: {valid_tickers[:5]}...")
+                
+            # Re-fetch returns for just these? No, we already have `returns` DF.
+            # Just slice the DF to save computation in Risk Model
+            returns = returns[valid_tickers]
+            
         cov_matrix = self.risk_model.compute_covariance_matrix(returns)
         
         # 4. Get Benchmark Data (S&P 500)