Create app.py

app.py

@@ -0,0 +1,312 @@
+import json
+import html
+import datetime as dt
+from typing import Dict, List, Tuple
+
+import feedparser
+import gradio as gr
+import plotly.graph_objects as go
+import requests
+
+# -----------------------------
+# Config
+# -----------------------------
+BASE_RSS = "https://sachet.ndma.gov.in/cap_public_website/rss"
+UA = "SachetMapRSS/1.0 (+https://huggingface.co/spaces)"
+
+# Known tricky slugs or long names -> explicit mapping to RSS file names (without '.xml')
+MANUAL_SLUGS: Dict[str, str] = {
+    "andaman and nicobar islands": "andaman_and_nicobar_islands",
+    "dadra and nagar haveli and daman and diu": "dadra_and_nagar_haveli_and_daman_and_diu",
+    "jammu and kashmir": "jammu_and_kashmir",
+    "nct of delhi": "delhi",
+    "delhi": "delhi",
+    "daman and diu": "dadra_and_nagar_haveli_and_daman_and_diu",  # legacy handle
+    "ladakh": "ladakh",
+    "lakshadweep": "lakshadweep",
+    "puducherry": "puducherry",
+    "dadra and nagar haveli": "dadra_and_nagar_haveli_and_daman_and_diu",
+}
+
+# State/UT centroids (approx.) for click targets (lat, lon).
+# 36 entities: 28 States + 8 UTs
+STATES = [
+    ("Andhra Pradesh", 15.9, 79.7),
+    ("Arunachal Pradesh", 28.1, 94.6),
+    ("Assam", 26.1, 92.9),
+    ("Bihar", 25.9, 85.2),
+    ("Chhattisgarh", 21.3, 82.0),
+    ("Goa", 15.3, 74.0),
+    ("Gujarat", 22.3, 70.8),
+    ("Haryana", 29.1, 76.0),
+    ("Himachal Pradesh", 31.8, 77.2),
+    ("Jharkhand", 23.7, 85.5),
+    ("Karnataka", 14.5, 75.8),
+    ("Kerala", 10.3, 76.5),
+    ("Madhya Pradesh", 23.8, 78.8),
+    ("Maharashtra", 19.7, 75.7),
+    ("Manipur", 24.7, 93.8),
+    ("Meghalaya", 25.5, 91.3),
+    ("Mizoram", 23.2, 92.8),
+    ("Nagaland", 26.1, 94.3),
+    ("Odisha", 20.5, 84.4),
+    ("Punjab", 31.0, 75.4),
+    ("Rajasthan", 26.9, 73.9),
+    ("Sikkim", 27.6, 88.5),
+    ("Tamil Nadu", 11.1, 78.6),
+    ("Telangana", 17.9, 79.6),
+    ("Tripura", 23.8, 91.3),
+    ("Uttar Pradesh", 27.0, 80.9),
+    ("Uttarakhand", 30.1, 79.0),
+    ("West Bengal", 23.2, 87.9),
+    # UTs
+    ("Andaman and Nicobar Islands", 11.7, 92.7),
+    ("Chandigarh", 30.7, 76.8),
+    ("Dadra and Nagar Haveli and Daman and Diu", 20.3, 73.0),
+    ("Delhi", 28.6, 77.2),
+    ("Jammu and Kashmir", 33.2, 75.0),
+    ("Ladakh", 34.2, 77.6),
+    ("Lakshadweep", 10.8, 72.6),
+    ("Puducherry", 11.9, 79.8),
+]
+
+NATIONAL_FEED = f"{BASE_RSS}/rss_india.xml"
+
+
+# -----------------------------
+# Helpers
+# -----------------------------
+def _slugify(name: str) -> str:
+    key = name.strip().lower()
+    if key in MANUAL_SLUGS:
+        return MANUAL_SLUGS[key]
+    # Generic rule: replace non-alnum with underscores; collapse repeats
+    import re
+    s = re.sub(r"[^a-z0-9]+", "_", key).strip("_")
+    return s
+
+def state_to_feed(name: str, mapping_override: Dict[str, str] | None = None) -> str:
+    """
+    Build a candidate RSS URL for a state/UT. Accepts optional overrides:
+    {'Tamil Nadu': 'https://.../rss_tamil_nadu.xml'}
+    """
+    if mapping_override and name in mapping_override:
+        return mapping_override[name].strip()
+
+    slug = _slugify(name)
+    return f"{BASE_RSS}/rss_{slug}.xml"
+
+def fetch_bytes(url: str, timeout: int = 12) -> bytes:
+    r = requests.get(url, headers={"User-Agent": UA}, timeout=timeout)
+    r.raise_for_status()
+    return r.content
+
+def iso_utc(t) -> str:
+    if not t:
+        return ""
+    try:
+        return dt.datetime(*t[:6], tzinfo=dt.timezone.utc).isoformat().replace("+00:00", "Z")
+    except Exception:
+        return ""
+
+def parse_feed(url: str, max_items: int = 20) -> Tuple[str, List[Dict]]:
+    """
+    Returns (feed_title, items)
+    items: [{title, link, time, summary}]
+    """
+    raw = fetch_bytes(url)
+    parsed = feedparser.parse(raw)
+
+    feed_title = parsed.feed.get("title") or "Feed"
+    items = []
+    for e in parsed.entries[:max_items]:
+        title = e.get("title", "Untitled")
+        link = e.get("link", "#")
+        t = iso_utc(e.get("published_parsed") or e.get("updated_parsed"))
+        summary = e.get("summary", "") or e.get("description", "")
+        items.append({
+            "title": title,
+            "link": link,
+            "time": t,
+            "summary": " ".join(summary.split())
+        })
+    return feed_title, items
+
+def render_items_html(feed_title: str, items: List[Dict]) -> str:
+    out = [f"<div class='hdr'>{html.escape(feed_title)}</div>"]
+    if not items:
+        out.append("<div class='empty'>No items found.</div>")
+        return "\n".join(out)
+
+    out.append("<ul class='list'>")
+    for it in items:
+        t = f"<div class='time'>{html.escape(it['time'])}</div>" if it["time"] else ""
+        s = f"<div class='sum'>{html.escape(it['summary'][:500])}</div>" if it["summary"] else ""
+        out.append(
+            "<li class='card'>"
+            f"<a class='ttl' href='{html.escape(it['link'])}' target='_blank' rel='noopener noreferrer'>{html.escape(it['title'])}</a>"
+            f"{t}{s}"
+            "</li>"
+        )
+    out.append("</ul>")
+    return "\n".join(out)
+
+
+# -----------------------------
+# Plotly Map
+# -----------------------------
+def make_map() -> go.Figure:
+    lats = [lat for _, lat, _ in STATES]
+    lons = [lon for _, _, lon in STATES]
+    names = [name for name, _, _ in STATES]
+
+    fig = go.Figure(
+        data=go.Scattergeo(
+            lat=lats,
+            lon=lons,
+            text=names,
+            customdata=names,   # we read this on click
+            mode="markers+text",
+            textposition="top center",
+            marker=dict(size=8),
+            hovertemplate="%{customdata}<extra></extra>",
+        )
+    )
+    fig.update_geos(
+        scope="asia",
+        projection_type="natural earth",
+        showcountries=True,
+        countrycolor="rgba(120,120,120,0.4)",
+        showsubunits=False,
+        lataxis_showgrid=True,
+        lonaxis_showgrid=True,
+        fitbounds="locations",
+        visible=True,
+        resolution=110
+    )
+    # Center roughly over India
+    fig.update_geos(center=dict(lat=22.5, lon=80.0), lataxis_range=[6, 36], lonaxis_range=[68, 98])
+    fig.update_layout(
+        margin=dict(l=20, r=20, t=10, b=10),
+        dragmode=False
+    )
+    return fig
+
+
+# -----------------------------
+# Gradio App
+# -----------------------------
+CSS = """
+:root { --fg:#111; --muted:#666; --bg:#fff; --card:#fafafa; --link:#0b57d0; }
+@media (prefers-color-scheme: dark) {
+  :root { --fg:#eee; --muted:#aaa; --bg:#0b0b0b; --card:#141414; --link:#7fb0ff; }
+}
+.wrap { max-width: 1100px; margin: 0 auto; }
+.feedbox { background: var(--card); border: 1px solid rgba(127,127,127,.25); border-radius: 12px; padding: 12px 14px; }
+.hdr { font-weight: 700; font-size: 18px; margin-bottom: 8px; color: var(--fg); }
+.list { list-style: none; padding: 0; margin: 0; }
+.card { padding: 10px 0; border-top: 1px solid rgba(127,127,127,.2); }
+.card:first-child { border-top: none; }
+.ttl { color: var(--link); text-decoration: none; font-weight: 600; }
+.ttl:hover { text-decoration: underline; }
+.time { color: var(--muted); font-size: 12px; margin-top: 2px; }
+.sum { margin-top: 6px; color: var(--fg); white-space: pre-wrap; }
+.empty { color: var(--muted); }
+.err { color: #b00020; }
+.badge { display:inline-block; padding:2px 8px; border:1px solid rgba(127,127,127,.25); border-radius:999px; font-size:12px; color:var(--muted); }
+"""
+
+with gr.Blocks(css=CSS, fill_height=True, theme=gr.themes.Soft()) as demo:
+    gr.Markdown("## SACHET — India Map of State/UT RSS Feeds (Minimal)")
+
+    with gr.Row():
+        map_plot = gr.Plot(value=make_map(), label="Click a marker to load the state/UT feed")
+        with gr.Column(scale=1, min_width=300):
+            selected = gr.Textbox(label="Selected State/UT", interactive=False)
+            feed_url_box = gr.Textbox(label="Resolved Feed URL", interactive=False)
+            max_items = gr.Slider(5, 50, value=20, step=1, label="Items")
+            refresh = gr.Button("Refresh")
+            gr.Markdown(
+                "### Optional: Custom mapping\n"
+                "Paste JSON as `{ \"Tamil Nadu\": \"https://.../rss_tamil_nadu.xml\", ... }`"
+            )
+            mapping_json = gr.Code(language="json", value="", lines=6)
+            error_box = gr.Markdown(elem_classes=["err"])
+
+    with gr.Row():
+        with gr.Column():
+            feed_html = gr.HTML(elem_classes=["feedbox"])
+
+    def resolve_and_render(state_click_payload, items_n, mapping_text):
+        """
+        state_click_payload: Plotly 'selected' or 'click' data
+        """
+        # Extract the state name from click payload
+        state = None
+        try:
+            # Gradio 4: for .select the payload is dict with 'points'
+            if isinstance(state_click_payload, dict) and "points" in state_click_payload and state_click_payload["points"]:
+                state = state_click_payload["points"][0].get("customdata") or state_click_payload["points"][0].get("text")
+            # Some Gradio variants may send just the label
+            elif isinstance(state_click_payload, str):
+                state = state_click_payload
+        except Exception:
+            state = None
+
+        if not state:
+            return gr.update(value=""), gr.update(value=""), gr.update(value=""), "<div class='badge'>Select a marker on the map.</div>"
+
+        # Optional mapping overrides (user input)
+        overrides = {}
+        if mapping_text:
+            try:
+                overrides = json.loads(mapping_text)
+                if not isinstance(overrides, dict):
+                    overrides = {}
+            except Exception:
+                overrides = {}
+
+        # Resolve URL
+        url = state_to_feed(state, overrides)
+
+        # Try fetch and parse; fall back to national feed if 404
+        try:
+            title, items = parse_feed(url, max_items=int(items_n))
+            html_out = render_items_html(f"{state} — {title}", items)
+            return state, url, "", html_out
+        except Exception as e:
+            # Try a secondary slug variant: remove underscores
+            alt_url = url.replace("_", "")
+            try:
+                title, items = parse_feed(alt_url, max_items=int(items_n))
+                html_out = render_items_html(f"{state} — {title}", items)
+                return state, alt_url, f"Note: primary URL failed, used fallback.", html_out
+            except Exception as e2:
+                # Fall back to national feed to keep UI useful
+                try:
+                    title, items = parse_feed(NATIONAL_FEED, max_items=int(items_n))
+                    html_out = (
+                        f"<div class='badge'>Could not load <code>{html.escape(url)}</code>. "
+                        f"Showing national feed instead.</div>"
+                    ) + render_items_html(f"India — {title}", items)
+                    return state, url, f"⚠️ {type(e2).__name__}: {e2}", html_out
+                except Exception as e3:
+                    return state, url, f"⚠️ {type(e3).__name__}: {e3}", "<div class='empty'>No data.</div>"
+
+    # Initial: show national feed
+    def initial_load(n_items):
+        try:
+            title, items = parse_feed(NATIONAL_FEED, max_items=int(n_items))
+            return render_items_html(f"India — {title}", items)
+        except Exception as e:
+            return f"<div class='empty'>Could not load national feed. {html.escape(str(e))}</div>"
+
+    demo.load(lambda n: initial_load(n), [max_items], [feed_html])
+
+    # Wire both click and select events for robustness
+    map_plot.select(resolve_and_render, [map_plot, max_items, mapping_json], [selected, feed_url_box, error_box, feed_html])
+    map_plot.click(resolve_and_render, [map_plot, max_items, mapping_json], [selected, feed_url_box, error_box, feed_html])
+    refresh.click(resolve_and_render, [map_plot, max_items, mapping_json], [selected, feed_url_box, error_box, feed_html])
+
+if __name__ == "__main__":
+    demo.launch()