Update app/yahooinfo.py

app/yahooinfo.py

@@ -1,136 +1,168 @@
-# ======================================================
-# FINAL YAHOO FINANCE INFO PROCESSOR + RENDERER
-# ======================================================
-
+# ==============================
+# Imports
+# ==============================
 import yfinance as yf
 import pandas as pd
 import traceback
-import re
-from datetime import datetime, UTC
-from math import floor
-
-from .persist import exists, load, save
-
+import time
 
-# ======================================================
-# CONSTANTS
-# ======================================================
-CR  = 10_000_000
-KCR = 10_000_000_000
-LCR = 10_000_000_000_000
+from datetime import datetime, timezone
 
-DATE_KEYS = ("date", "timestamp", "time", "yearend")
+# persist helpers
+from .persist import exists, load, save
 
 
-# ======================================================
-# RAW YAHOO FETCH
-# ======================================================
+# ==============================
+# Yahoo Finance info fetch (RAW)
+# ==============================
 def yfinfo(symbol):
+    """
+    Low-level Yahoo Finance info fetch.
+    Returns raw dict or {"__error__": "..."}
+    """
     try:
         t = yf.Ticker(symbol + ".NS")
         info = t.info
-        return info if isinstance(info, dict) else {}
+        if not info or not isinstance(info, dict):
+            return {}
+        return info
     except Exception as e:
         return {"__error__": str(e)}
 
 
-# ======================================================
-# HELPERS
-# ======================================================
-def truncate(num, decimals=4):
-    f = 10 ** decimals
-    return floor(num * f) / f
-
-
-def compress_key(key, used):
-    if len(key) <= 10:
-        used.add(key)
-        return key
-
-    parts = re.findall(r"[A-Z][a-z]*|[a-z]+", key)
-    base = "".join(p[:3] for p in parts)
-
-    if base not in used:
-        used.add(base)
-        return base
-
-    i = 1
-    while f"{base}_{i}" in used:
-        i += 1
-
-    final = f"{base}_{i}"
-    used.add(final)
-    return final
-
-
-# ======================================================
-# CORE PROCESSOR
-# ======================================================
-def process_info(info):
-    main = {}
-    long_text = {}
-
-    new_to_old = {}
-    old_to_new = {}
+# ==============================
+# Icons
+# ==============================
+SUBGROUP_ICONS = {
+    "Live Price": "💹",
+    "Volume": "📊",
+    "Moving Avg": "📈",
+    "Range / Vol": "📉",
+    "Bid / Analyst": "📝",
+    "Other": "ℹ️"
+}
 
-    used_keys = set()
+MAIN_ICONS = {
+    "Price / Volume": "📈",
+    "Fundamentals": "📊",
+    "Company Profile": "🏢"
+}
 
-    for old_k, v in info.items():
-        lk = old_k.lower()
-        new_k = compress_key(old_k, used_keys)
 
-        new_to_old[new_k] = old_k
-        old_to_new[old_k] = new_k
+# ==============================
+# Responsive column layout
+# ==============================
+def column_layout(html, min_width=320):
+    return f"""
+    <div style="
+        display:grid;
+        grid-template-columns:repeat(auto-fit,minmax({min_width}px,1fr));
+        gap:10px;
+        align-items:start;
+    ">
+        {html}
+    </div>
+    """
+
+
+# ==============================
+# Card renderer
+# ==============================
+def html_card(title, body, mini=False, shade=0):
+    font = "12px" if mini else "14px"
+    pad  = "6px" if mini else "10px"
+
+    shades = ["#e6f0fa", "#d7e3f5", "#c8d6f0"]
+    grads = [
+        "linear-gradient(to right,#1a4f8a,#4a7ac7)",
+        "linear-gradient(to right,#1f5595,#5584d6)",
+        "linear-gradient(to right,#205ca0,#6192e0)"
+    ]
+
+    return f"""
+    <div style="
+        background:{shades[shade%3]};
+        border:1px solid #a3c0e0;
+        border-radius:8px;
+        padding:{pad};
+        font-size:{font};
+        box-shadow:0 2px 6px rgba(0,0,0,.08);
+    ">
+        <div style="
+            background:{grads[shade%3]};
+            color:white;
+            padding:4px 8px;
+            border-radius:6px;
+            font-weight:600;
+            margin-bottom:6px;
+        ">
+            {title}
+        </div>
+        {body}
+    </div>
+    """
+
+
+# ==============================
+# Formatting helpers
+# ==============================
+def format_number(x):
+    try:
+        x = float(x)
+        if abs(x) >= 100:
+            return f"{x:,.0f}"
+        if abs(x) >= 1:
+            return f"{x:,.2f}"
+        return f"{x:.4f}"
+    except:
+        return str(x)
 
-        # ---- Long text ----
-        if isinstance(v, str) and len(v) > 200:
-            long_text[new_k] = v
-            continue
 
-        # ---- Date conversion ----
-        if (
-            isinstance(v, int)
-            and v >= 1_000_000_000
-            and any(x in lk for x in DATE_KEYS)
-        ):
-            if v > 1_000_000_000_000:
-                v //= 1000
+# ==============================
+# Compact inline key:value view
+# ==============================
+def make_table(df):
+    rows = ""
+    for _, r in df.iterrows():
+        color = "#0d1f3c"
+        if any(x in r[0].lower() for x in ["chg", "%"]):
             try:
-                main[new_k] = datetime.fromtimestamp(v, UTC).strftime("%d-%m-%Y")
+                color = "#0a7d32" if float(r[1]) >= 0 else "#b00020"
             except:
-                main[new_k] = v
-            continue
-
-        # ---- Large numbers (Cr/KCr/LCr) ----
-        if isinstance(v, (int, float)) and abs(v) >= CR:
-            av = abs(v)
-            sign = -1 if v < 0 else 1
-
-            if av >= LCR:
-                main[new_k] = f"{sign * av / LCR:.2f} LCr"
-            elif av >= KCR:
-                main[new_k] = f"{sign * av / KCR:.2f} KCr"
-            else:
-                main[new_k] = f"{sign * av / CR:.2f} Cr"
-            continue
-
-        # ---- Float trimming ----
-        if isinstance(v, float):
-            main[new_k] = 0.0 if v == 0.0 else truncate(v)
-            continue
-
-        main[new_k] = v
-
-    return main, long_text, new_to_old, old_to_new
-
-
-# ======================================================
-# NOISE
-# ======================================================
+                pass
+
+        rows += f"""
+        <div style="
+            display:flex;
+            justify-content:space-between;
+            gap:6px;
+            padding:2px 0;
+            border-bottom:1px dashed #bcd0ea;
+        ">
+            <span style="color:#1a4f8a;font-weight:500;">
+                {r[0]}
+            </span>
+            <span style="
+                color:{color};
+                font-weight:600;
+                background:#f1f6ff;
+                padding:1px 6px;
+                border-radius:4px;
+            ">
+                {r[1]}
+            </span>
+        </div>
+        """
+    return f"<div>{rows}</div>"
+
+
+# ==============================
+# Noise filtering
+# ==============================
 NOISE_KEYS = {
-    "maxAge", "priceHint", "triggerable",
+    "maxAge","priceHint","triggerable",
     "customPriceAlertConfidence",
-    "sourceInterval", "exchangeDataDelayedBy",
+    "sourceInterval","exchangeDataDelayedBy",
     "esgPopulated"
 }
 
@@ -138,45 +170,63 @@ def is_noise(k):
     return k in NOISE_KEYS
 
 
-# ======================================================
-# DUPLICATE RESOLUTION (OLD KEYS)
-# ======================================================
+# ==============================
+# Duplicate resolver
+# ==============================
 DUPLICATE_PRIORITY = {
-    "price": ["regularMarketPrice", "currentPrice"],
-    "prev": ["regularMarketPreviousClose", "previousClose"],
-    "open": ["regularMarketOpen", "open"],
-    "high": ["regularMarketDayHigh", "dayHigh"],
-    "low": ["regularMarketDayLow", "dayLow"],
-    "volume": ["regularMarketVolume", "volume"],
+    "price": ["regularMarketPrice","currentPrice"],
+    "prev": ["regularMarketPreviousClose","previousClose"],
+    "open": ["regularMarketOpen","open"],
+    "high": ["regularMarketDayHigh","dayHigh"],
+    "low": ["regularMarketDayLow","dayLow"],
+    "volume": ["regularMarketVolume","volume"]
 }
 
-def resolve_duplicates(data, new_to_old):
-    resolved = {}
-    used_old = set()
-
+def resolve_duplicates(data):
+    resolved, used = {}, set()
     for keys in DUPLICATE_PRIORITY.values():
-        for old_k in keys:
-            for new_k, mapped_old in new_to_old.items():
-                if mapped_old == old_k and new_k in data:
-                    resolved[new_k] = data[new_k]
-                    used_old.update(keys)
-                    break
-            else:
-                continue
-            break
-
-    for new_k, v in data.items():
-        if new_to_old[new_k] not in used_old:
-            resolved[new_k] = v
-
+        for k in keys:
+            if k in data:
+                resolved[k] = data[k]
+                used.update(keys)
+                break
+    for k,v in data.items():
+        if k not in used:
+            resolved[k] = v
     return resolved
 
 
-# ======================================================
-# CLASSIFIERS (UNCHANGED – OLD KEYS ONLY)
-# ======================================================
-def classify_price_volume_subgroup(old_key):
-    k = old_key.lower()
+# ==============================
+# Short key names
+# ==============================
+SHORT_NAMES = {
+    "regularMarketPrice":"Price",
+    "regularMarketChange":"Chg",
+    "regularMarketChangePercent":"Chg%",
+    "regularMarketPreviousClose":"Prev",
+    "regularMarketOpen":"Open",
+    "regularMarketDayHigh":"High",
+    "regularMarketDayLow":"Low",
+    "regularMarketVolume":"Vol",
+    "averageDailyVolume10Day":"AvgV10",
+    "averageDailyVolume3Month":"AvgV3M",
+    "fiftyDayAverage":"50DMA",
+    "twoHundredDayAverage":"200DMA",
+    "fiftyTwoWeekLow":"52WL",
+    "fiftyTwoWeekHigh":"52WH",
+    "beta":"Beta",
+    "targetMeanPrice":"Target"
+}
+
+def pretty_key(k):
+    return SHORT_NAMES.get(k, k[:12])
+
+
+# ==============================
+# Classifiers
+# ==============================
+def classify_price_volume_subgroup(key):
+    k = key.lower()
     if "volume" in k: return "Volume"
     if "average" in k or "dma" in k: return "Moving Avg"
     if "week" in k or "beta" in k: return "Range / Vol"
@@ -184,114 +234,145 @@ def classify_price_volume_subgroup(old_key):
     return "Live Price"
 
 
-def classify_key(old_key, value):
-    k = old_key.lower()
-
-    if isinstance(value, (int, float)) and any(x in k for x in [
-        "price", "volume", "avg", "change", "percent",
-        "market", "week", "beta", "target"
+def classify_key(key, value):
+    k = key.lower()
+    if isinstance(value,(int,float)) and any(x in k for x in [
+        "price","volume","avg","change","percent","market","week","beta","target"
     ]):
         return "price_volume"
-
     if any(x in k for x in [
-        "revenue", "income", "profit", "margin",
-        "pe", "pb", "roe", "roa", "debt", "equity"
+        "revenue","income","profit","margin","pe","pb","roe","roa","debt","equity"
     ]):
         return "fundamental"
-
-    if isinstance(value, str) and len(value) > 80:
+    if isinstance(value,str) and len(value) > 80:
         return "long_text"
-
     return "profile"
 
 
-# ======================================================
-# GROUP BUILDER (KEY POINT)
-# ======================================================
-def build_grouped_info(info, new_to_old):
+# ==============================
+# Group builder
+# ==============================
+def build_grouped_info(info):
     groups = {
-        "price_volume": {},
-        "fundamental": {},
-        "profile": {},
-        "long_text": {},
+        "price_volume":{},
+        "fundamental":{},
+        "profile":{},
+        "long_text":{}
     }
-
-    for new_k, v in info.items():
-        if v in [None, "", [], {}]:
+    for k,v in info.items():
+        if v in [None,"",[],{}]:
             continue
-
-        old_k = new_to_old.get(new_k, new_k)
-        g = classify_key(old_k, v)
-        groups[g][new_k] = v
-
+        groups[classify_key(k,v)][k] = v
     return groups
 
 
-# ======================================================
-# FORMATTERS
-# ======================================================
-def format_number(x):
-    try:
-        x = float(x)
-        if abs(x) >= 100:
-            return f"{x:,.0f}"
-        if abs(x) >= 1:
-            return f"{x:,.2f}"
-        return f"{x:.4f}"
-    except:
-        return str(x)
+# ==============================
+# Column splitter
+# ==============================
+def split_df_evenly(df):
+    if df is None or df.empty:
+        return []
+    n = len(df)
+    cols = 1 if n <= 6 else 2 if n <= 14 else 3
+    chunk = (n + cols - 1) // cols
+    return [df.iloc[i:i+chunk] for i in range(0, n, chunk)]
 
 
+# ==============================
+# DataFrame builder
+# ==============================
 def build_df_from_dict(data):
     rows = []
-    for k, v in data.items():
+    for k,v in data.items():
         if is_noise(k):
             continue
-        if isinstance(v, (int, float)):
+        if isinstance(v,(int,float)):
             v = format_number(v)
-        rows.append([k, v])
-    return pd.DataFrame(rows, columns=["Field", "Value"])
+        rows.append([pretty_key(k), v])
+    return pd.DataFrame(rows, columns=["Field","Value"])
 
 
-# ======================================================
-# MAIN ENTRY (CACHED)
-# ======================================================
+# ==============================
+# MAIN FUNCTION (CACHED)
+# ==============================
 def fetch_info(symbol):
-    cache_key = f"info_{symbol}"
-
-    if exists(cache_key, "html"):
-        cached = load(cache_key, "html")
+    """
+    Cached Yahoo Finance info renderer
+    Cache validity: 1 hour
+    """
+    key = f"info_{symbol}"
+
+    if exists(key, "html"):
+        cached = load(key, "html")
         if cached:
             return cached
 
     try:
-        raw = yfinfo(symbol)
-        if not raw or "__error__" in raw:
+        info = yfinfo(symbol)
+        if not info or "__error__" in info:
             return "No data"
 
-        info, long_text, new_to_old, _ = process_info(raw)
-        groups = build_grouped_info(info, new_to_old)
-
+        groups = build_grouped_info(info)
         html = ""
 
-        # ---- PRICE / VOLUME ----
-        pv = resolve_duplicates(groups["price_volume"], new_to_old)
-        for new_k, v in pv.items():
-            html += f"<div><b>{new_k}</b> : {v}</div>"
-
-        # ---- FUNDAMENTALS ----
-        for new_k, v in groups["fundamental"].items():
-            html += f"<div><b>{new_k}</b> : {v}</div>"
-
-        # ---- PROFILE ----
-        for new_k, v in groups["profile"].items():
-            html += f"<div><b>{new_k}</b> : {v}</div>"
-
-        # ---- LONG TEXT ----
-        for v in long_text.values():
-            html += f"<div style='margin-top:8px'>{v}</div>"
+        # PRICE / VOLUME
+        pv = resolve_duplicates(groups["price_volume"])
+        sub = {}
+        for k,v in pv.items():
+            sg = classify_price_volume_subgroup(k)
+            sub.setdefault(sg,{})[k] = v
+
+        cards = ""
+        for i,(t,d) in enumerate(sub.items()):
+            df = build_df_from_dict(d)
+            if not df.empty:
+                cards += html_card(
+                    f"{SUBGROUP_ICONS.get(t,'ℹ️')} {t}",
+                    make_table(df),
+                    mini=True,
+                    shade=i
+                )
+
+        if cards:
+            html += html_card(
+                f"{MAIN_ICONS['Price / Volume']} Price / Volume",
+                column_layout(cards),
+                shade=0
+            )
+
+        # FUNDAMENTALS
+        if groups["fundamental"]:
+            chunks = split_df_evenly(build_df_from_dict(groups["fundamental"]))
+            cols = "".join(
+                html_card("📊 Fundamentals", make_table(c), mini=True, shade=i)
+                for i,c in enumerate(chunks)
+            )
+            html += html_card(
+                f"{MAIN_ICONS['Fundamentals']} Fundamentals",
+                column_layout(cols),
+                shade=1
+            )
+
+        # PROFILE
+        if groups["profile"]:
+            chunks = split_df_evenly(build_df_from_dict(groups["profile"]))
+            cols = "".join(
+                html_card("🏢 Profile", make_table(c), mini=True, shade=i)
+                for i,c in enumerate(chunks)
+            )
+            html += html_card(
+                f"{MAIN_ICONS['Company Profile']} Company Profile",
+                column_layout(cols),
+                shade=2
+            )
+
+        # LONG TEXT
+        for k,v in groups["long_text"].items():
+            html += html_card(pretty_key(k), v, shade=2)
+
+        if html.strip():
+            save(key, html, "html")
 
-        save(cache_key, html, "html")
         return html
 
     except Exception: