Add auto-fetch thermodynamic data for search queries and selected reactions, plus animation options for plots

app.py

@@ -250,20 +250,34 @@ def _summaries_to_dropdown(results) -> List[tuple[str, str]]:
     return choices
 
 
-def perform_search(query, decomposition_only, category_raw, units_value):
+def perform_search(query, decomposition_only, category_raw, units_value, auto_search_thermo=True):
     if not query.strip():
-        return [], "⚠️ Enter a search query.", gr.update(choices=[], value=None, interactive=False), []
+        return [], "⚠️ Enter a search query.", gr.update(choices=[], value=None, interactive=False), [], {}
 
-    # Create a simple filter for reactants containing the query
-    filter_obj = SearchFilter(
+    # Create multiple filters for comprehensive search
+    query_term = query.strip()
+    filters = []
+
+    # Search in reactants
+    filters.append(SearchFilter(
         boolean=None,
         left_parenthesis="",
         field=FieldName.reactants,
         relation=Relation.contains,
-        value=query.strip(),
+        value=query_term,
         right_parenthesis="",
-    )
-    filters = [filter_obj]
+    ))
+
+    # Also search in products if it's a longer query
+    if len(query_term) > 2:
+        filters.append(SearchFilter(
+            boolean=LogicalOperator.or_,
+            left_parenthesis="",
+            field=FieldName.products,
+            relation=Relation.contains,
+            value=query_term,
+            right_parenthesis="",
+        ))
 
     category_raw = category_raw or str(Category.any.value)
     units_value = (units_value or "").strip() or None
@@ -278,11 +292,29 @@ def perform_search(query, decomposition_only, category_raw, units_value):
     try:
         results = client.search(request)
     except Exception as exc:  # pragma: no cover - network/parsing issues
-        return [], f"🚨 Search failed: {exc}", gr.update(choices=[], value=None, interactive=False), []
+        return [], f"🚨 Search failed: {exc}", gr.update(choices=[], value=None, interactive=False), [], {}
 
     table_data = _summaries_to_table(results)
     dropdown_choices = _summaries_to_dropdown(results)
-    status = f"✅ Found {len(results)} matching reactions." if results else "No records matched this query."
+
+    # Enhanced status with compound information
+    status_parts = [f"✅ Found {len(results)} matching reactions"]
+    if results:
+        status_parts.append(f" for query: '{query_term}'")
+
+        # Extract unique compounds from results for auto-suggestions
+        all_compounds = set()
+        for result in results[:10]:  # Check first 10 results
+            compounds = _extract_compounds_from_reaction(result.reaction)
+            all_compounds.update(compounds)
+
+        if all_compounds:
+            status_parts.append(f" | Compounds detected: {', '.join(list(all_compounds)[:5])}")
+            if len(all_compounds) > 5:
+                status_parts.append(f" +{len(all_compounds) - 5} more")
+
+    status = "".join(status_parts)
+
     dropdown_update = gr.update(
         choices=dropdown_choices,
         value=None,
@@ -293,7 +325,13 @@ def perform_search(query, decomposition_only, category_raw, units_value):
         {"record_count": summary.record_count, "reaction": summary.reaction, "detail_url": summary.detail_url}
         for summary in results
     ]
-    return table_data, status, dropdown_update, state_payload
+
+    # Auto-fetch thermodynamic data for the searched compound
+    search_thermo_data = {}
+    if auto_search_thermo and query_term:
+        search_thermo_data = _fetch_compound_thermo_data([query_term])
+
+    return table_data, status, dropdown_update, state_payload, search_thermo_data
 
 
 def _format_detail_markdown(detail: ReactionDetail, detail_url: str) -> str:
@@ -494,30 +532,146 @@ def render_reaction_svg(reaction_text: str):
     return svg, status
 
 
-def fetch_detail(selected_url: str, manual_url: str):
+def _extract_compounds_from_reaction(reaction_text: str) -> List[str]:
+    """Extract compound names/identifiers from reaction text."""
+    compounds = []
+
+    # Clean the reaction text
+    reaction_text = reaction_text.strip()
+
+    # Handle different reaction formats
+    if " → " in reaction_text:
+        parts = reaction_text.split(" → ")
+    elif "->" in reaction_text:
+        parts = reaction_text.split("->")
+    elif " ↔ " in reaction_text:
+        parts = reaction_text.split(" ↔ ")
+    else:
+        return compounds
+
+    # Process each part (reactants and products)
+    for part in parts:
+        # Split by " + " to get individual compounds
+        individual_compounds = [c.strip() for c in part.split(" + ") if c.strip()]
+
+        # Try to identify chemical formulas or names
+        for compound in individual_compounds:
+            # Remove coefficients (numbers at start)
+            compound = re.sub(r'^\d+\s*', '', compound)
+            if compound and len(compound) > 1:  # Avoid single letters
+                compounds.append(compound)
+
+    return list(set(compounds))  # Remove duplicates
+
+
+def _fetch_compound_thermo_data(compounds: List[str]) -> dict:
+    """Fetch thermodynamic data for a list of compounds from NIST databases."""
+    thermo_data = {}
+
+    for compound in compounds[:5]:  # Limit to 5 compounds to avoid overwhelming
+        compound_data = {}
+
+        # Try different databases
+        databases_to_try = [
+            "NIST Organic Thermochemistry Archive",
+            "Organometallic Thermochemistry Database",
+            "Gas-Phase Ion Thermochemistry"
+        ]
+
+        for db_name in databases_to_try:
+            try:
+                md_content, df, plot = fetch_specific_db(db_name, compound)
+                if df is not None and not df.empty:
+                    compound_data[db_name] = {
+                        'markdown': md_content,
+                        'dataframe': df,
+                        'plot': plot
+                    }
+                    break  # Stop at first successful fetch
+            except Exception:
+                continue
+
+        if compound_data:
+            thermo_data[compound] = compound_data
+
+    return thermo_data
+
+
+def _create_animated_plot(fig: go.Figure, animate: bool = False) -> go.Figure:
+    """Add animation capabilities to plots if requested."""
+    if not animate or fig is None:
+        return fig
+
+    # Add animation frames for temperature sweep
+    if hasattr(fig, 'data') and len(fig.data) > 0:
+        trace = fig.data[0]
+
+        # Create animation frames
+        frames = []
+        temps = list(range(300, 2500, 100))  # Temperature range
+
+        for temp in temps:
+            frame_data = []
+            for trace in fig.data:
+                if hasattr(trace, 'x') and hasattr(trace, 'y'):
+                    # Simulate temperature-dependent behavior
+                    animated_trace = go.Scatter(
+                        x=trace.x,
+                        y=trace.y,
+                        mode=trace.mode,
+                        name=trace.name,
+                        line=dict(color=trace.line.color if hasattr(trace, 'line') else 'blue')
+                    )
+                    frame_data.append(animated_trace)
+
+            frames.append(go.Frame(data=frame_data, name=str(temp)))
+
+        fig.frames = frames
+
+        # Add animation controls
+        fig.update_layout(
+            updatemenus=[dict(
+                type="buttons",
+                buttons=[dict(
+                    label="Play",
+                    method="animate",
+                    args=[None, dict(mode="immediate", frame=dict(duration=500, redraw=True), fromcurrent=True)]
+                )]
+            )],
+            sliders=[dict(
+                active=0,
+                steps=[dict(method="animate", args=[[f.name], dict(mode="immediate", frame=dict(duration=300, redraw=False), transition=dict(duration=0))], label=f.name) for f in frames],
+                currentvalue={"prefix": "Temperature: "},
+            )]
+        )
+
+    return fig
+
+
+def fetch_detail(selected_url: str, manual_url: str, auto_fetch_thermo: bool = True, animate_plots: bool = False):
     detail_url = (manual_url or "").strip() or (selected_url or "").strip()
     if not detail_url:
-        return "ℹ️ Select a reaction above or paste a detail URL.", [], None, ""
+        return "ℹ️ Select a reaction above or paste a detail URL.", [], None, "", {}, ""
 
     try:
         detail = client.fetch_reaction_detail(detail_url)
     except Exception as exc:  # pragma: no cover - network/parsing issues
-        return f"🚨 Could not load detail: {exc}", [], None, ""
+        return f"🚨 Could not load detail: {exc}", [], None, "", {}, ""
 
     markdown = _format_detail_markdown(detail, detail_url)
     table = _datasets_to_table(detail)
     if not table:
         markdown += "\n\n_No kinetics datasets were returned for this reaction._"
-        return markdown, table, None, ""
+        return markdown, table, None, "", {}, ""
 
     plot_fig = _build_dataset_plot(detail)
-    
+
     # Try to render the reaction title as SVG
     reaction_svg = ""
     if detail.title:
         title = detail.title.strip()
         smiles_attempt = None
-        
+
         # Try different reaction format conversions
         if " → " in title:
             # Format: "A + B → C"
@@ -536,13 +690,33 @@ def fetch_detail(selected_url: str, manual_url: str):
                 reactants = parts[0].replace(" + ", ".").strip()
                 products = parts[1].replace(" + ", ".").strip()
                 smiles_attempt = f"{reactants}>>{products}"
-        
+
         if smiles_attempt:
             svg = _render_smiles_to_svg(smiles_attempt)
             if svg:
                 reaction_svg = svg
-    
-    return markdown, table, plot_fig, reaction_svg
+
+    # Auto-fetch thermodynamic data for compounds in the reaction
+    thermo_data = {}
+    thermo_summary = ""
+
+    if auto_fetch_thermo and detail.title:
+        compounds = _extract_compounds_from_reaction(detail.title)
+        if compounds:
+            thermo_data = _fetch_compound_thermo_data(compounds)
+            if thermo_data:
+                thermo_summary = f"### 🔬 Auto-fetched Thermodynamic Data\nFound data for {len(thermo_data)} compound(s): {', '.join(thermo_data.keys())}\n\n"
+                for compound, data in thermo_data.items():
+                    thermo_summary += f"**{compound}:**\n"
+                    for db_name, db_data in data.items():
+                        thermo_summary += f"- {db_name}: Data available\n"
+                    thermo_summary += "\n"
+
+    # Add animation to plots if requested
+    if animate_plots:
+        plot_fig = _create_animated_plot(plot_fig, True)
+
+    return markdown, table, plot_fig, reaction_svg, thermo_data, thermo_summary
 
 
 def _parse_points(text: str) -> Tuple[List[float], List[float], List[str]]:
@@ -680,9 +854,17 @@ def build_interface() -> gr.Blocks:
         results_state = gr.State([])
 
         with gr.Tabs():
-            # Tab 1: Search (Original functionality)
+            # Tab 1: Search (Enhanced functionality)
             with gr.TabItem("Search"):
-                simple_search = gr.Textbox(label="Search Query", placeholder="Enter reactants, products, or keywords (e.g., CH4 + O2)")
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        simple_search = gr.Textbox(label="Search Query", placeholder="Enter reactants, products, or compound (e.g., CH4 + O2, CH3, benzene)")
+                    with gr.Column(scale=1):
+                        auto_search_thermo = gr.Checkbox(
+                            label="🔬 Auto-fetch thermo data",
+                            value=True,
+                            info="Automatically fetch thermodynamic data for searched compounds"
+                        )
 
                 with gr.Row():
                     decomp = gr.Checkbox(label="Only decomposition reactions", value=False)
@@ -692,8 +874,9 @@ def build_interface() -> gr.Blocks:
                         placeholder="Leave blank to use NIST account defaults",
                     )
 
-                search_button = gr.Button("Search NIST", variant="primary")
+                search_button = gr.Button("🔍 Search NIST", variant="primary")
                 search_status = gr.Markdown()
+
                 result_table = gr.Dataframe(
                     headers=["#", "Records", "Reaction", "Detail URL"],
                     datatype=["number", "number", "str", "str"],
@@ -701,39 +884,68 @@ def build_interface() -> gr.Blocks:
                     wrap=True,
                 )
 
-            # Tab 2: Reaction Detail (Original functionality)
+                # Search results thermodynamic data
+                search_thermo_accordion = gr.Accordion(label="🔬 Search Query Thermodynamic Data", open=False)
+                with search_thermo_accordion:
+                    search_thermo_display = gr.JSON(label="Thermodynamic Data for Search Query")
+
+            # Tab 2: Reaction Detail (Enhanced functionality)
             with gr.TabItem("Reaction Detail"):
-                selection = gr.Dropdown(
-                    label="Select a reaction from the latest search",
-                    choices=[],
-                    interactive=False,
-                )
-                manual_url = gr.Textbox(
-                    label="Or paste a NIST detail URL",
-                    placeholder="https://kinetics.nist.gov/kinetics/ReactionSearch?....",
-                )
-                detail_button = gr.Button("Fetch Reaction Detail")
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        selection = gr.Dropdown(
+                            label="Select a reaction from the latest search",
+                            choices=[],
+                            interactive=False,
+                        )
+                        manual_url = gr.Textbox(
+                            label="Or paste a NIST detail URL",
+                            placeholder="https://kinetics.nist.gov/kinetics/ReactionSearch?....",
+                        )
+                    with gr.Column(scale=1):
+                        auto_fetch_thermo = gr.Checkbox(
+                            label="🔬 Auto-fetch thermodynamics",
+                            value=True,
+                            info="Automatically fetch thermodynamic data for compounds in the reaction"
+                        )
+                        animate_plots = gr.Checkbox(
+                            label="🎬 Animate plots",
+                            value=False,
+                            info="Add animation controls to plots"
+                        )
+
+                detail_button = gr.Button("Fetch Reaction Detail", variant="primary")
 
                 # Reaction metadata and details
                 detail_markdown = gr.Markdown()
 
-                # Kinetics data table
-                dataset_table = gr.Dataframe(
-                    headers=["Section", "Squib", "Temp [K]", "A", "n", "Ea [J/mole]", "k(298 K)", "Order", "Squib URL"],
-                    datatype=["str"] * 9,
-                    interactive=False,
-                    wrap=True,
-                )
+                with gr.Row():
+                    # Kinetics data table
+                    with gr.Column():
+                        gr.Markdown("### Kinetics Data")
+                        dataset_table = gr.Dataframe(
+                            headers=["Section", "Squib", "Temp [K]", "A", "n", "Ea [J/mole]", "k(298 K)", "Order", "Squib URL"],
+                            datatype=["str"] * 9,
+                            interactive=False,
+                            wrap=True,
+                        )
+
+                    # Arrhenius plot
+                    with gr.Column():
+                        gr.Markdown("### Arrhenius Plot")
+                        reaction_plot = gr.Plot()
 
                 # Reaction SVG visualization
                 with gr.Row():
                     gr.Markdown("### Reaction Structure")
                 reaction_svg = gr.HTML()
 
-                # Arrhenius plot
-                with gr.Row():
-                    gr.Markdown("### Arrhenius Plot")
-                reaction_plot = gr.Plot()
+                # Auto-fetched thermodynamic data
+                thermo_summary = gr.Markdown()
+                thermo_accordion = gr.Accordion(label="🔬 Thermodynamic Data", open=False)
+
+                with thermo_accordion:
+                    thermo_data_display = gr.JSON(label="Raw Thermodynamic Data")
 
             # Tab 3: Reaction SVG (Original functionality)
             with gr.TabItem("Reaction SVG"):
@@ -849,21 +1061,21 @@ def build_interface() -> gr.Blocks:
         # Event handlers for original functionality
         search_button.click(
             fn=perform_search,
-            inputs=[simple_search, decomp, category, units],
-            outputs=[result_table, search_status, selection, results_state],
+            inputs=[simple_search, decomp, category, units, auto_search_thermo],
+            outputs=[result_table, search_status, selection, results_state, search_thermo_display],
         )
 
         detail_button.click(
             fn=fetch_detail,
-            inputs=[selection, manual_url],
-            outputs=[detail_markdown, dataset_table, reaction_plot, reaction_svg],
+            inputs=[selection, manual_url, auto_fetch_thermo, animate_plots],
+            outputs=[detail_markdown, dataset_table, reaction_plot, reaction_svg, thermo_data_display, thermo_summary],
         )
 
         # Auto-render SVG when selection changes
         selection.change(
             fn=fetch_detail,
-            inputs=[selection, manual_url],
-            outputs=[detail_markdown, dataset_table, reaction_plot, reaction_svg],
+            inputs=[selection, manual_url, auto_fetch_thermo, animate_plots],
+            outputs=[detail_markdown, dataset_table, reaction_plot, reaction_svg, thermo_data_display, thermo_summary],
         )
 
         # Examples (global or per-tab)