Upload app.py with huggingface_hub

app.py

@@ -0,0 +1,440 @@
+"""
+Gradio UI for the Polymer Datasheet Crawler Agent.
+Deployable as a HuggingFace Space.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import tempfile
+from pathlib import Path
+
+import gradio as gr
+import pandas as pd
+
+from graph import (
+    build_graph,
+    db,
+    run_search,
+    run_upload,
+    search_database,
+    get_database_summary,
+)
+from pdf_extractor import extract_text_from_pdf
+from models import DatasheetRecord
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s | %(name)s | %(levelname)s | %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  Handler Functions
+# ══════════════════════════════════════════════════════════════════════════════
+
+def handle_search(
+    manufacturer: str,
+    polymer_family: str,
+    grade: str,
+    progress=gr.Progress(),
+) -> tuple[str, pd.DataFrame, str]:
+    """
+    Handle the 'Search & Add' tab: run the full LangGraph workflow
+    to search, parse, and store a datasheet.
+    """
+    if not manufacturer.strip() and not polymer_family.strip():
+        return (
+            "⚠️ Please provide at least a manufacturer or polymer family.",
+            pd.DataFrame(),
+            "",
+        )
+
+    progress(0.1, desc="Initializing search...")
+    try:
+        progress(0.3, desc="Searching the web with Tavily...")
+        result = run_search(
+            manufacturer=manufacturer.strip(),
+            polymer_family=polymer_family.strip(),
+            grade=grade.strip(),
+        )
+        progress(0.9, desc="Done!")
+
+        status = result.get("status", "unknown")
+        message = result.get("message", "")
+
+        # Build display dataframe from parsed record
+        parsed = result.get("parsed_datasheet")
+        display_df = pd.DataFrame()
+        json_output = ""
+
+        if parsed:
+            record = DatasheetRecord(**parsed) if isinstance(parsed, dict) else parsed
+            flat = record.to_flat_dict()
+            # Filter out empty values and metadata for display
+            display_data = {
+                k: v for k, v in flat.items()
+                if v and k not in ("id", "created_at")
+            }
+            display_df = pd.DataFrame(
+                list(display_data.items()),
+                columns=["Property", "Value"],
+            )
+            json_output = json.dumps(flat, indent=2)
+
+        status_icon = "✅" if status == "success" else "❌"
+        return f"{status_icon} {message}", display_df, json_output
+
+    except Exception as exc:
+        logger.exception("Search handler error")
+        return f"❌ Error: {exc}", pd.DataFrame(), ""
+
+
+def handle_upload(
+    file_obj,
+    progress=gr.Progress(),
+) -> tuple[str, pd.DataFrame, str]:
+    """
+    Handle the 'Upload Datasheet' tab: extract text from PDF,
+    then run the LangGraph workflow in upload mode.
+    """
+    if file_obj is None:
+        return "⚠️ Please upload a PDF file.", pd.DataFrame(), ""
+
+    progress(0.1, desc="Reading PDF...")
+    try:
+        # Gradio gives us a file path
+        file_path = file_obj.name if hasattr(file_obj, "name") else str(file_obj)
+        extracted_text = extract_text_from_pdf(file_path)
+
+        if not extracted_text.strip():
+            return (
+                "⚠️ Could not extract text from the PDF. "
+                "It may be image-based (scanned). Try a text-based PDF.",
+                pd.DataFrame(),
+                "",
+            )
+
+        progress(0.4, desc="Parsing with LLM...")
+        result = run_upload(uploaded_text=extracted_text)
+        progress(0.9, desc="Done!")
+
+        status = result.get("status", "unknown")
+        message = result.get("message", "")
+
+        parsed = result.get("parsed_datasheet")
+        display_df = pd.DataFrame()
+        json_output = ""
+
+        if parsed:
+            record = DatasheetRecord(**parsed) if isinstance(parsed, dict) else parsed
+            flat = record.to_flat_dict()
+            display_data = {
+                k: v for k, v in flat.items()
+                if v and k not in ("id", "created_at")
+            }
+            display_df = pd.DataFrame(
+                list(display_data.items()),
+                columns=["Property", "Value"],
+            )
+            json_output = json.dumps(flat, indent=2)
+
+        status_icon = "✅" if status == "success" else "❌"
+        return f"{status_icon} {message}", display_df, json_output
+
+    except Exception as exc:
+        logger.exception("Upload handler error")
+        return f"❌ Error: {exc}", pd.DataFrame(), ""
+
+
+def handle_db_search(
+    query: str,
+    manufacturer: str,
+    polymer_family: str,
+) -> pd.DataFrame:
+    """Search the database and return results."""
+    try:
+        df = search_database(
+            query=query.strip(),
+            manufacturer=manufacturer.strip(),
+            polymer_family=polymer_family.strip(),
+        )
+        if df.empty:
+            return pd.DataFrame({"Info": ["No matching records found."]})
+        return df
+    except Exception as exc:
+        logger.exception("DB search error")
+        return pd.DataFrame({"Error": [str(exc)]})
+
+
+def handle_db_summary() -> tuple[pd.DataFrame, str]:
+    """Get the full database summary."""
+    try:
+        df = get_database_summary()
+        count = db.count()
+        info = f"📊 Database contains {count} datasheet(s)."
+        if df.empty:
+            return pd.DataFrame({"Info": ["Database is empty."]}), info
+        return df, info
+    except Exception as exc:
+        logger.exception("DB summary error")
+        return pd.DataFrame({"Error": [str(exc)]}), f"❌ Error: {exc}"
+
+
+def handle_export_csv() -> str | None:
+    """Export the entire database to a CSV file for download."""
+    try:
+        df = db.get_all_dataframe()
+        if df.empty:
+            return None
+        tmp = tempfile.NamedTemporaryFile(
+            suffix=".csv", delete=False, mode="w", encoding="utf-8",
+        )
+        df.to_csv(tmp.name, index=False)
+        tmp.close()
+        return tmp.name
+    except Exception as exc:
+        logger.exception("Export error")
+        return None
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  Gradio App
+# ══════════════════════════════════════════════════════════════════════════════
+
+def create_app() -> gr.Blocks:
+    """Build the Gradio Blocks application."""
+
+    with gr.Blocks(
+        title="🧪 Polymer Datasheet Agent",
+        theme=gr.themes.Soft(),
+        css="""
+        .header { text-align: center; margin-bottom: 1em; }
+        .status-box { font-size: 1.1em; font-weight: 600; padding: 0.5em; }
+        """,
+    ) as app:
+
+        # ── Header ───────────────────────────────────────────────────────
+        gr.Markdown(
+            """
+            # 🧪 Polymer Datasheet Crawler Agent
+            **Build a searchable database of commercial polymer datasheets.**
+
+            This agent uses **Tavily** to search the web for technical datasheets,
+            **LLaMA 3.1** to extract structured properties, and stores results in
+            a local **SQLite** database.
+
+            ---
+            """,
+            elem_classes=["header"],
+        )
+
+        # ── Tab 1: Search & Add ──────────────────────────────────────────
+        with gr.Tab("🔍 Search & Add Datasheet"):
+            gr.Markdown(
+                "Enter a manufacturer and/or polymer family to search for "
+                "datasheets online and add them to the database."
+            )
+
+            with gr.Row():
+                manufacturer_input = gr.Textbox(
+                    label="Manufacturer",
+                    placeholder="e.g., SABIC, BASF, DuPont",
+                    scale=2,
+                )
+                polymer_input = gr.Textbox(
+                    label="Polymer Family",
+                    placeholder="e.g., Polycarbonate, Nylon 6,6, PEEK",
+                    scale=2,
+                )
+                grade_input = gr.Textbox(
+                    label="Grade (optional)",
+                    placeholder="e.g., Lexan 141R, Ultramid A3K",
+                    scale=2,
+                )
+
+            search_btn = gr.Button("🔍 Search & Add", variant="primary", size="lg")
+
+            search_status = gr.Textbox(
+                label="Status",
+                interactive=False,
+                elem_classes=["status-box"],
+            )
+
+            with gr.Accordion("Extracted Properties", open=True):
+                search_table = gr.Dataframe(
+                    label="Parsed Datasheet",
+                    interactive=False,
+                    wrap=True,
+                )
+
+            with gr.Accordion("Raw JSON Output", open=False):
+                search_json = gr.Code(
+                    label="JSON",
+                    language="json",
+                    interactive=False,
+                )
+
+            search_btn.click(
+                fn=handle_search,
+                inputs=[manufacturer_input, polymer_input, grade_input],
+                outputs=[search_status, search_table, search_json],
+            )
+
+        # ── Tab 2: Upload Datasheet ──────────────────────────────────────
+        with gr.Tab("📄 Upload Datasheet"):
+            gr.Markdown(
+                "Upload a PDF datasheet to extract properties and add to the database."
+            )
+
+            file_input = gr.File(
+                label="Upload PDF Datasheet",
+                file_types=[".pdf"],
+                type="filepath",
+            )
+            upload_btn = gr.Button("📄 Parse & Add", variant="primary", size="lg")
+
+            upload_status = gr.Textbox(
+                label="Status",
+                interactive=False,
+                elem_classes=["status-box"],
+            )
+
+            with gr.Accordion("Extracted Properties", open=True):
+                upload_table = gr.Dataframe(
+                    label="Parsed Datasheet",
+                    interactive=False,
+                    wrap=True,
+                )
+
+            with gr.Accordion("Raw JSON Output", open=False):
+                upload_json = gr.Code(
+                    label="JSON",
+                    language="json",
+                    interactive=False,
+                )
+
+            upload_btn.click(
+                fn=handle_upload,
+                inputs=[file_input],
+                outputs=[upload_status, upload_table, upload_json],
+            )
+
+        # ── Tab 3: Database Browser ──────────────────────────────────────
+        with gr.Tab("🗄️ Database Browser"):
+            gr.Markdown("Search and browse the existing datasheet database.")
+
+            with gr.Row():
+                db_query = gr.Textbox(
+                    label="Search query",
+                    placeholder="Free text search across all fields...",
+                    scale=3,
+                )
+                db_manufacturer = gr.Textbox(
+                    label="Filter: Manufacturer",
+                    placeholder="e.g., BASF",
+                    scale=2,
+                )
+                db_polymer = gr.Textbox(
+                    label="Filter: Polymer Family",
+                    placeholder="e.g., Polyamide",
+                    scale=2,
+                )
+
+            with gr.Row():
+                db_search_btn = gr.Button("🔍 Search Database", variant="primary")
+                db_refresh_btn = gr.Button("🔄 Show All Records")
+                db_export_btn = gr.Button("📥 Export to CSV")
+
+            db_info = gr.Textbox(label="Info", interactive=False)
+
+            db_results = gr.Dataframe(
+                label="Database Records",
+                interactive=False,
+                wrap=True,
+            )
+
+            export_file = gr.File(label="Download CSV", visible=True)
+
+            db_search_btn.click(
+                fn=handle_db_search,
+                inputs=[db_query, db_manufacturer, db_polymer],
+                outputs=[db_results],
+            )
+
+            db_refresh_btn.click(
+                fn=handle_db_summary,
+                inputs=[],
+                outputs=[db_results, db_info],
+            )
+
+            db_export_btn.click(
+                fn=handle_export_csv,
+                inputs=[],
+                outputs=[export_file],
+            )
+
+        # ── Tab 4: About / Help ──────────────────────────────────────────
+        with gr.Tab("ℹ️ About"):
+            gr.Markdown(
+                """
+                ## Architecture
+
+                This application is built with:
+
+                - **[LangGraph](https://github.com/langchain-ai/langgraph)** —
+                  Orchestrates the agent workflow as a directed state graph.
+                - **[Tavily](https://tavily.com)** —
+                  AI-optimized web search API for finding datasheets.
+                - **[LLaMA 3.1](https://huggingface.co/meta-llama/Meta-Llama-3.1-8B-Instruct)** —
+                  Open-source LLM via HuggingFace Inference API for structured extraction.
+                - **SQLite + SQLAlchemy** — Local relational database.
+                - **[Gradio](https://gradio.app)** — Web UI, deployable on HuggingFace Spaces.
+
+                ## Workflow
+
+                ```
+                User Input ──► Router ──► Web Search (Tavily) ──► LLM Parse (LLaMA 3.1) ──► Store DB ──► Output
+                                  │                                          ▲
+                                  └──► Process Upload (PDF) ─────────────────┘
+                ```
+
+                ## Property Categories
+
+                The agent extracts properties across these categories:
+                - **General**: Material name, trade name, manufacturer, grade, applications
+                - **Mechanical**: Tensile/flexural strength, modulus, impact, hardness
+                - **Thermal**: Tm, Tg, HDT, Vicat, CTE, thermal conductivity
+                - **Physical**: Density, MFI, water absorption, specific gravity
+                - **Electrical**: Dielectric strength/constant, resistivity
+                - **Chemical Resistance**: Acid, alkali, solvent, UV resistance
+                - **Regulatory**: FDA, RoHS, REACH, UL94
+
+                ## Data Sources
+
+                The crawler prioritizes trusted sources including:
+                MatWeb, Omnexus, UL Prospector, Campus Plastics,
+                and official manufacturer portals (SABIC, BASF, DuPont, Dow, etc.)
+
+                ---
+                *Built for Plinity — Infinite Recyclable Polymers Project*
+                """
+            )
+
+    return app
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  Main
+# ══════════════════════════════════════════════════════════════════════════════
+
+if __name__ == "__main__":
+    app = create_app()
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+    )