Upload 4 files

Dockerfile.txt

@@ -0,0 +1,14 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+ENV PYTHONUNBUFFERED=1
+
+COPY requirements.txt /app/requirements.txt
+RUN pip install --no-cache-dir -r /app/requirements.txt
+
+COPY . /app
+
+EXPOSE 8501
+
+CMD ["streamlit", "run", "streamlit_app.py", "--server.address=0.0.0.0", "--server.port=8501"]

docker-compose.yml

@@ -0,0 +1,8 @@
+services:
+  app:
+    build: .
+    container_name: news-event-app
+    ports:
+      - "8501:8501"
+    volumes:
+      - ../data:/app/data

dockerignore.txt

@@ -0,0 +1,6 @@
+__pycache__/
+*.pyc
+.git
+.env
+.venv
+venv

streamlit_app.py

@@ -0,0 +1,412 @@
+# frontend/streamlit_app.py
+import json
+import os
+
+import pandas as pd
+import requests
+import streamlit as st
+
+
+st.set_page_config(
+    page_title="Green Energy News Event Dashboard",
+    page_icon="📰",
+    layout="wide",
+)
+
+API_BASE_URL = st.secrets.get(
+    "API_BASE_URL",
+    os.getenv("API_BASE_URL", "https://Signe22-Article-Data-API.hf.space"),
+)
+
+
+@st.cache_data(ttl=300)
+def load_classified_articles() -> pd.DataFrame:
+    try:
+        response = requests.get(
+            f"{API_BASE_URL}/articles",
+            params={"limit": 500},
+            timeout=30,
+        )
+        response.raise_for_status()
+        data = response.json()
+
+        df = pd.DataFrame(data)
+
+        if df.empty:
+            return df
+
+        df["published_at"] = pd.to_datetime(df.get("published_at"), errors="coerce", utc=True)
+        df["classified_at"] = pd.to_datetime(df.get("classified_at"), errors="coerce", utc=True)
+
+        df["published_date"] = df["published_at"].dt.date
+        df["published_day"] = df["published_at"].dt.strftime("%Y-%m-%d")
+
+        return df
+
+    except Exception as error:
+        st.error(f"Failed to load articles from API: {error}")
+        return pd.DataFrame()
+
+
+@st.cache_data(ttl=300)
+def load_daily_summary() -> dict:
+    try:
+        response = requests.get(f"{API_BASE_URL}/summary/daily", timeout=30)
+        response.raise_for_status()
+        summary = response.json()
+
+        if not isinstance(summary, dict):
+            return {}
+
+        return normalize_summary_payload(summary)
+
+    except Exception as error:
+        st.error(f"Failed to load daily summary: {error}")
+        return {}
+
+
+def normalize_summary_payload(summary: dict) -> dict:
+    """
+    Supports both the improved API shape and the previous legacy shape.
+
+    Preferred shape:
+    {
+        "summary_date": "...",
+        "generated_at": "...",
+        "executive_summary": "...",
+        "key_signal": "...",
+        "recommended_focus": "...",
+        "decision_implications": [...],
+        "watchlist": [...],
+        "top_stories": [...]
+    }
+
+    Legacy shape:
+    {
+        "summary_date": "...",
+        "short_summary": "...",
+        "key_focus": "...",
+        "top_stories": "{\"executive_summary\": ..., \"top_stories\": [...]}"
+    }
+    """
+    normalized = dict(summary)
+
+    nested_summary = summary.get("summary_json") or summary.get("top_stories")
+
+    if isinstance(nested_summary, str):
+        try:
+            parsed = json.loads(nested_summary)
+            if isinstance(parsed, dict):
+                normalized.update(parsed)
+        except Exception:
+            pass
+
+    elif isinstance(nested_summary, dict) and "top_stories" in nested_summary:
+        normalized.update(nested_summary)
+
+    normalized["executive_summary"] = (
+        normalized.get("executive_summary")
+        or normalized.get("short_summary")
+        or ""
+    )
+
+    normalized["recommended_focus"] = (
+        normalized.get("recommended_focus")
+        or normalized.get("key_focus")
+        or ""
+    )
+
+    if not isinstance(normalized.get("decision_implications"), list):
+        normalized["decision_implications"] = []
+
+    if not isinstance(normalized.get("watchlist"), list):
+        normalized["watchlist"] = []
+
+    if not isinstance(normalized.get("top_stories"), list):
+        normalized["top_stories"] = []
+
+    return normalized
+
+
+def apply_filters(df: pd.DataFrame) -> pd.DataFrame:
+    st.sidebar.header("Filters")
+
+    label_options = sorted(df["label"].dropna().unique().tolist()) if not df.empty else []
+    source_options = sorted(df["source"].dropna().unique().tolist()) if not df.empty else []
+
+    default_labels = [
+        label
+        for label in label_options
+        if label != "not relevant to field"
+    ]
+
+    selected_labels = st.sidebar.multiselect(
+        "Action categories",
+        options=label_options,
+        default=default_labels,
+    )
+
+    selected_sources = st.sidebar.multiselect(
+        "Sources",
+        options=source_options,
+        default=[],
+    )
+
+    min_date = df["published_date"].min() if not df.empty else None
+    max_date = df["published_date"].max() if not df.empty else None
+
+    date_range = None
+    if min_date and max_date:
+        date_range = st.sidebar.date_input(
+            "Date range",
+            value=(min_date, max_date),
+            min_value=min_date,
+            max_value=max_date,
+        )
+
+    search_term = st.sidebar.text_input("Search title or description")
+
+    filtered = df.copy()
+
+    if selected_labels:
+        filtered = filtered[filtered["label"].isin(selected_labels)]
+
+    if selected_sources:
+        filtered = filtered[filtered["source"].isin(selected_sources)]
+
+    if date_range and len(date_range) == 2:
+        start_date, end_date = date_range
+        filtered = filtered[
+            (filtered["published_date"] >= start_date)
+            & (filtered["published_date"] <= end_date)
+        ]
+
+    if search_term:
+        search_term = search_term.strip()
+
+        title_matches = filtered["title"].fillna("").str.contains(
+            search_term,
+            case=False,
+            na=False,
+            regex=False,
+        )
+
+        description_matches = filtered["description"].fillna("").str.contains(
+            search_term,
+            case=False,
+            na=False,
+            regex=False,
+        )
+
+        filtered = filtered[title_matches | description_matches]
+
+    return filtered
+
+
+def render_metrics(df: pd.DataFrame, filtered_df: pd.DataFrame) -> None:
+    c1, c2, c3, c4 = st.columns(4)
+
+    c1.metric("Articles", len(df))
+    c2.metric("Filtered", len(filtered_df))
+    c3.metric("Sources", df["source"].nunique() if "source" in df else 0)
+    c4.metric("Categories", df["label"].nunique() if "label" in df else 0)
+
+
+def render_bullet_list(items: list[str], empty_message: str) -> None:
+    if not items:
+        st.info(empty_message)
+        return
+
+    for item in items:
+        st.markdown(f"- {item}")
+
+
+def render_daily_summary(summary: dict) -> None:
+    st.subheader("Daily AI Summary")
+
+    if not summary:
+        st.info("No daily summary available yet.")
+        return
+
+    summary_date = summary.get("summary_date", "Unknown")
+    generated_at = summary.get("generated_at")
+
+    if generated_at:
+        st.caption(f"Summary date: {summary_date} · Generated at: {generated_at}")
+    else:
+        st.caption(f"Summary date: {summary_date}")
+
+    st.markdown("### Executive Summary")
+    st.write(summary.get("executive_summary") or "No summary available.")
+
+    st.markdown("### Key Signal")
+    st.write(summary.get("key_signal") or "No key signal available.")
+
+    st.markdown("### Recommended Focus")
+    st.write(summary.get("recommended_focus") or "No focus available.")
+
+    st.markdown("### Decision Implications")
+    render_bullet_list(
+        summary.get("decision_implications", []),
+        "No decision implications available.",
+    )
+
+    st.markdown("### Watchlist")
+    render_bullet_list(
+        summary.get("watchlist", []),
+        "No watchlist available.",
+    )
+
+    stories = summary.get("top_stories", [])
+
+    if not stories:
+        st.info("No top stories available.")
+        return
+
+    st.markdown("### Top Stories")
+
+    for story in stories:
+        if not isinstance(story, dict):
+            continue
+
+        title = story.get("title", "Untitled story")
+        label = story.get("label", "Unknown")
+        source = story.get("source", "Unknown source")
+        published_at = story.get("published_at")
+        description = story.get("description", "")
+        why_it_matters = story.get("why_it_matters", "")
+        decision_relevance = story.get("decision_relevance", "")
+        url = story.get("url")
+        article_id = story.get("article_id")
+
+        if pd.notnull(published_at):
+            published_at = pd.to_datetime(published_at, errors="coerce", utc=True)
+
+            if pd.notnull(published_at):
+                published_at = published_at.strftime("%Y-%m-%d %H:%M UTC")
+            else:
+                published_at = "Unknown date"
+        else:
+            published_at = "Unknown date"
+
+        with st.expander(title):
+            c1, c2, c3 = st.columns(3)
+            c1.markdown(f"**Category:** {label}")
+            c2.markdown(f"**Source:** {source}")
+            c3.markdown(f"**Published:** {published_at}")
+
+            if description:
+                st.markdown("**Description**")
+                st.write(description)
+
+            if why_it_matters:
+                st.markdown("**Why this matters**")
+                st.write(why_it_matters)
+
+            if decision_relevance:
+                st.markdown("**Decision relevance**")
+                st.write(decision_relevance)
+
+            if url:
+                st.markdown(f"[Open article]({url})")
+
+            if article_id:
+                st.caption(f"Article ID: {article_id}")
+
+
+def render_article_browser(df: pd.DataFrame) -> None:
+    st.subheader("Article Browser")
+
+    if df.empty:
+        st.info("No articles available for browsing.")
+        return
+
+    sort_option = st.selectbox(
+        "Sort articles by",
+        options=[
+            "Newest first",
+            "Oldest first",
+            "Action category",
+            "Source",
+        ],
+        index=0,
+    )
+
+    display_df = df.copy()
+
+    if sort_option == "Newest first":
+        display_df = display_df.sort_values("published_at", ascending=False)
+    elif sort_option == "Oldest first":
+        display_df = display_df.sort_values("published_at", ascending=True)
+    elif sort_option == "Action category":
+        display_df = display_df.sort_values(["label", "published_at"], ascending=[True, False])
+    elif sort_option == "Source":
+        display_df = display_df.sort_values(["source", "published_at"], ascending=[True, False])
+
+    max_rows = st.slider("Number of articles to display", 5, 100, 20)
+    display_df = display_df.head(max_rows)
+
+    for _, row in display_df.iterrows():
+        title = row.get("title", "Untitled article")
+
+        published_str = (
+            row["published_at"].strftime("%Y-%m-%d %H:%M UTC")
+            if pd.notnull(row.get("published_at"))
+            else "Unknown"
+        )
+
+        with st.expander(title):
+            meta1, meta2, meta3 = st.columns(3)
+            meta1.markdown(f"**Action:** {row.get('label', 'Unknown')}")
+            meta2.markdown(f"**Source:** {row.get('source', 'Unknown source')}")
+            meta3.markdown(f"**Published:** {published_str}")
+
+            description = row.get("description")
+            if pd.notnull(description) and str(description).strip():
+                st.markdown("**Description**")
+                st.write(description)
+
+            url = row.get("url")
+            if pd.notnull(url) and str(url).strip():
+                st.markdown(f"[Open article]({url})")
+
+            st.markdown("**More details**")
+
+            article_id = row.get("article_id")
+            if pd.notnull(article_id):
+                st.caption(f"Article ID: {article_id}")
+
+            raw_label = row.get("raw_label")
+            if pd.notnull(raw_label) and str(raw_label).strip():
+                st.caption(f"Model output: {raw_label}")
+
+
+def main() -> None:
+    st.title("📰 Green Energy News Event Dashboard")
+    st.write(
+        "This dashboard gives an overview of classified green energy and climate-tech news, "
+        "with filters for action categories, dates, sources, and search terms."
+    )
+
+    df = load_classified_articles()
+    summary = load_daily_summary()
+
+    if df.empty:
+        st.warning("No classified articles found yet. Check whether the API is live and returning data.")
+        return
+
+    filtered_df = apply_filters(df)
+
+    render_metrics(df, filtered_df)
+
+    tab1, tab2 = st.tabs(["Daily Summary", "Articles"])
+
+    with tab1:
+        render_daily_summary(summary)
+
+    with tab2:
+        render_article_browser(filtered_df)
+
+
+if __name__ == "__main__":
+    main()