Update app.py

app.py

@@ -941,9 +941,8 @@ HTML_TEMPLATE = """
     function validateSnapshot(data) {
         // 1. Identify Reference Price (Spot or Future)
         let refPrice = 0;
-        let hasOptions = false;
         
-        // Loop to find Reference and check if data exists
+        // Loop to find Reference
         for(let sym in data) {
             // Check for Spot or Index (Priority)
             if(sym.includes('INDEX') || sym.endsWith('-EQ') || sym.startsWith('BSE:SENSEX')) {
@@ -953,60 +952,67 @@ HTML_TEMPLATE = """
             else if(sym.endsWith('FUT') && refPrice === 0) {
                 if(data[sym].ltp > 0) refPrice = data[sym].ltp;
             }
-            // Check if options exist in this packet
-            if(sym.endsWith('CE') || sym.endsWith('PE')) hasOptions = true;
         }
 
         // CRITERIA 1: Missing Reference Price (Corrupted)
         if(refPrice === 0) return false;
 
-        // CRITERIA 2: Validate ATM ± Range Data (Zero Qty Check)
-        if(hasOptions) {
-            // Extract valid strikes from symbol keys
-            let strikes = [];
-            for(let sym in data) {
-                // Regex matches Fyers symbols ending in Number+CE/PE (e.g., ...22100CE)
-                let match = sym.match(/(\d+)(CE|PE)$/); 
-                if(match && match[1]) {
-                    strikes.push({
-                        k: parseFloat(match[1]),
-                        d: data[sym]
-                    });
-                }
-            }
+        // 2. Parse and Organize Data by Strike
+        let strikesMap = {}; // { 21000: { CE: obj, PE: obj } }
+        let allStrikes = [];
 
-            if(strikes.length > 0) {
-                // Find ATM Strike based on Ref Price
-                strikes.sort((a,b) => a.k - b.k);
-                let closest = strikes.reduce((prev, curr) => 
-                    Math.abs(curr.k - refPrice) < Math.abs(prev.k - refPrice) ? curr : prev
-                );
+        for(let sym in data) {
+            // Regex to extract Strike + Type (e.g. ...22100CE -> 22100, CE)
+            // Handles potential decimal strikes as well
+            let match = sym.match(/(\d+(?:\.\d+)?)(CE|PE)$/); 
+            if(match && match[1]) {
+                let k = parseFloat(match[1]);
+                let type = match[2]; // 'CE' or 'PE'
                 
-                // Get unique strikes to determine index range
-                let uniqKs = [...new Set(strikes.map(i => i.k))].sort((a,b)=>a-b);
-                let atmIndex = uniqKs.indexOf(closest.k);
+                if(!strikesMap[k]) strikesMap[k] = { CE: null, PE: null };
+                strikesMap[k][type] = data[sym];
                 
-                // Define Range: ATM ± 5 strikes
-                let start = Math.max(0, atmIndex - 5);
-                let end = Math.min(uniqKs.length - 1, atmIndex + 5);
-                let targetKs = uniqKs.slice(start, end + 1);
-
-                // Check specific options in this range
-                for(let item of strikes) {
-                    if(targetKs.includes(item.k)) {
-                        let qB = item.d.totalbuyqty;
-                        let qS = item.d.totalsellqty;
-                        
-                        // THE CHECK: If both Buy AND Sell Qty are 0 or undefined -> Data is inefficient
-                        if((!qB && !qS) || (qB === 0 && qS === 0)) {
-                            return false; // Mark as Bad
-                        }
-                    }
-                }
+                if(!allStrikes.includes(k)) allStrikes.push(k);
             }
         }
+
+        if(allStrikes.length === 0) return false; // No options found
+
+        // 3. Find ATM Strike based on Ref Price
+        allStrikes.sort((a,b) => a - b);
+        let closest = allStrikes.reduce((prev, curr) => 
+            Math.abs(curr - refPrice) < Math.abs(prev - refPrice) ? curr : prev
+        );
+        let atmIdx = allStrikes.indexOf(closest);
+
+        // 4. Validate Range: ATM ± 7 Strikes
+        let start = Math.max(0, atmIdx - 7);
+        let end = Math.min(allStrikes.length - 1, atmIdx + 7);
         
-        return true; // Data passed checks
+        // Iterate through the specific range
+        for(let i = start; i <= end; i++) {
+            let k = allStrikes[i];
+            let instruments = strikesMap[k];
+
+            // CRITERIA 2: Missing Instrument (Pair Check)
+            // If either CE or PE is completely missing from the data -> Corrupted
+            if(!instruments.CE || !instruments.PE) {
+                return false; 
+            }
+
+            // CRITERIA 3: Data Quality (Zero Qty Check)
+            // Check CE Quality
+            let ceB = instruments.CE.totalbuyqty || 0;
+            let ceS = instruments.CE.totalsellqty || 0;
+            if(ceB === 0 && ceS === 0) return false;
+
+            // Check PE Quality
+            let peB = instruments.PE.totalbuyqty || 0;
+            let peS = instruments.PE.totalsellqty || 0;
+            if(peB === 0 && peS === 0) return false;
+        }
+
+        return true; // Data Passed all checks
     }
 
     function renderSecondBar() {
@@ -1020,7 +1026,7 @@ HTML_TEMPLATE = """
             <div class="sec-pill ${idx===0?'active':''} ${statusClass}" 
                  onclick="selectSnapshot(${idx})" 
                  id="pill-${idx}"
-                 title="${isValid ? 'Data OK' : 'Data Inefficient (Zero Qty or Missing Ref)'}">
+                 title="${isValid ? 'Data OK' : 'Inefficient Data: Missing Inst/Qty or Ref'}">
                  :${item.s}
             </div>
         `}).join('');