Update app.py

app.py

@@ -143,46 +143,32 @@ def fetch_series(
     t_end = f"{date} {end_time}:59"
     
     if mode == "advanced":
-        # 1. Fetch available instruments
+        # 1. Fetch available instruments (Lightweight metadata fetch)
         inst_data = sb_rpc("get_instruments_for_expiry", {"p_date": date, "p_root": root, "p_expiry": expiry})
         instruments = [r['instrument_name'] for r in inst_data]
         
         if not instruments:
             return JSONResponse({"error": f"No data found for expiry {expiry}", "labels":[], "P":[]})
         
-        # 2. Intelligent Default Selection (Spot/Equity > Future > First Available)
+        # 2. Intelligent Default Selection (Spot > Future > First Available)
         ref_instrument = instrument
+        
+        # If user left instrument blank, find the best reference (Index or Future)
         if not ref_instrument:
-            spot_keys =[k for k in instruments if k.endswith('-INDEX') or k.endswith('-EQ')]
+            spot_keys = [k for k in instruments if k.endswith('-INDEX') or k.endswith('-EQ')]
             fut_keys = [k for k in instruments if 'FUT' in k]
+            
             if spot_keys:
                 ref_instrument = spot_keys[0]
             elif fut_keys:
                 ref_instrument = fut_keys[0]
             else:
-                ref_instrument = instruments[0]
-
-        if ref_instrument not in instruments:
-            return JSONResponse({"error": f"Ref Instrument '{ref_instrument}' not found in DB for this expiry. Please re-select from dropdown.", "labels": [], "P":[]})
-
-        # 3. Build Strike Map correctly handling Fyers date strings (e.g. NIFTY2630224000CE -> 24000)
-        strike_map = {}
-        for k in instruments:
-            if k.endswith('CE') or k.endswith('PE'):
-                # Fyers string: 2 digits(YY) + 3 Alphanumeric(M DD/MMM) + Strike + CE/PE
-                match = re.search(r'\d{2}[A-Z0-9]{3}(\d+(\.\d+)?)(?:CE|PE)$', k)
-                if match:
-                    strike_map[k] = float(match.group(1))
-                else:
-                    # Fallback
-                    match2 = re.search(r'(\d+(\.\d+)?)(?:CE|PE)$', k)
-                    if match2:
-                        strike_map[k] = float(match2.group(1))
-                
-        if not strike_map:
-             return JSONResponse({"error": "No options available to build ATM map.", "labels":[], "P":[]})
+                # Fallback: Find first key that is NOT an option
+                others = [k for k in instruments if not k.endswith('CE') and not k.endswith('PE')]
+                ref_instrument = others[0] if others else instruments[0]
 
-        # 4. Call Postgres with parsed Strike Map
+        # 3. Call Postgres (Logic is now 100% inside DB)
+        # We pass empty dict for p_strike_map as it is handled in SQL now
         params = {
             "p_root": root,
             "p_expiry": expiry,
@@ -190,7 +176,7 @@ def fetch_series(
             "p_end_time": t_end,
             "p_ref_instrument": ref_instrument,
             "p_atm_range": atm_range,
-            "p_strike_map": strike_map
+            "p_strike_map": {} 
         }
         records = sb_rpc("get_advanced_chart_data", params)
     
@@ -209,13 +195,14 @@ def fetch_series(
         records = sb_rpc("get_normal_chart_data", params)
 
     if not records or (isinstance(records, dict) and records.get("error")):
-         return JSONResponse({"error": "No DB records found. Time range might be empty.", "labels":[], "P":[]})
+         # Handle case where Time range exists but maybe reference instrument had no ticks
+         return JSONResponse({"error": "No valid data found in range.", "labels":[], "P":[]})
 
     df = pd.DataFrame(records)
     if df.empty:
         return JSONResponse({"error": "Dataframe Empty", "labels": [], "P":[]})
 
-    # Rename RPC column outputs to match Standard UI format
+    # Rename columns to match standard
     df.rename(columns={
         "tick_ts": "ts",
         "b_qty": "buy_qty",
@@ -226,6 +213,7 @@ def fetch_series(
     df['ts'] = pd.to_datetime(df['ts'])
     df.set_index('ts', inplace=True)
     
+    # Resample Logic
     tf_map = {
         "1min": "1min", "3min": "3min", "5min": "5min", 
         "15min": "15min", "30min": "30min", "1hour": "1h"
@@ -233,24 +221,27 @@ def fetch_series(
     panda_tf = tf_map.get(timeframe, "1min")
     
     agg_dict = {
-        "price": "last", "volume": "last", "oi": "last",
+        "price": "last", "volume": "sum", "oi": "last", # Vol should be sum for aggregations usually
         "buy_qty": "mean", "sell_qty": "mean",
         "cb": "mean", "cs": "mean", "pb": "mean", "ps": "mean"
     }
     
-    resampled = df.resample(panda_tf).agg(agg_dict).ffill().fillna(0)
+    # Only aggregate columns that actually exist
+    existing_cols = {k: v for k, v in agg_dict.items() if k in df.columns}
+    
+    resampled = df.resample(panda_tf).agg(existing_cols).ffill().fillna(0)
     
     response_data = {
         "labels": resampled.index.strftime('%H:%M').tolist(),
-        "P": resampled['price'].tolist(),
-        "B": resampled['buy_qty'].tolist(),
-        "S": resampled['sell_qty'].tolist(),
-        "V": resampled['volume'].tolist(),
-        "OI": resampled['oi'].tolist(),
-        "CB": resampled['cb'].tolist(),
-        "CS": resampled['cs'].tolist(),
-        "PB": resampled['pb'].tolist(),
-        "PS": resampled['ps'].tolist()
+        "P": resampled['price'].tolist() if 'price' in resampled else [],
+        "B": resampled['buy_qty'].tolist() if 'buy_qty' in resampled else [],
+        "S": resampled['sell_qty'].tolist() if 'sell_qty' in resampled else [],
+        "V": resampled['volume'].tolist() if 'volume' in resampled else [],
+        "OI": resampled['oi'].tolist() if 'oi' in resampled else [],
+        "CB": resampled['cb'].tolist() if 'cb' in resampled else [],
+        "CS": resampled['cs'].tolist() if 'cs' in resampled else [],
+        "PB": resampled['pb'].tolist() if 'pb' in resampled else [],
+        "PS": resampled['ps'].tolist() if 'ps' in resampled else []
     }
     
     return JSONResponse(response_data)