Add comprehensive NIST reaction dropdown with RDKit SVG rendering using specified parameters (subImgSize=(200, 200), useSVG=True, returnPNG=False)

app.py

@@ -479,6 +479,123 @@ def _build_dataset_plot(detail: ReactionDetail) -> go.Figure | None:
     return fig
 
 
+def _fetch_all_nist_reactions(limit: int = 100) -> List[tuple[str, str]]:
+    """Fetch all available reactions from NIST kinetics database."""
+    try:
+        # Create a broad search to get diverse reactions
+        filters = [
+            SearchFilter(
+                boolean=None,
+                left_parenthesis="",
+                field=FieldName.reactants,
+                relation=Relation.contains,
+                value="C",  # Start with carbon-containing compounds
+                right_parenthesis="",
+            )
+        ]
+
+        request = SearchRequest(
+            filters=filters,
+            decomposition_only=False,
+            category=Category.any,
+            units=None,
+        )
+
+        results = client.search(request)
+
+        # Extract unique reactions
+        reaction_options = []
+        seen_reactions = set()
+
+        for result in results[:limit]:
+            reaction_text = result.reaction.strip()
+            if reaction_text and reaction_text not in seen_reactions:
+                # Create a display name (truncate if too long)
+                display_name = reaction_text[:80] + "..." if len(reaction_text) > 80 else reaction_text
+                reaction_options.append((display_name, reaction_text))
+                seen_reactions.add(reaction_text)
+
+        # Sort by reaction length (simpler reactions first)
+        reaction_options.sort(key=lambda x: len(x[1]))
+
+        return reaction_options
+
+    except Exception as exc:
+        print(f"Error fetching NIST reactions: {exc}")
+        return []
+
+
+def _render_reaction_from_nist(reaction_text: str) -> str | None:
+    """Render a reaction from NIST format to SVG using RDKit."""
+    reaction_text = (reaction_text or "").strip()
+    if not reaction_text:
+        return None
+
+    # Try to convert NIST reaction format to SMILES
+    smiles_reaction = None
+
+    # Handle different NIST reaction formats
+    if " → " in reaction_text:
+        # Format: "A + B → C + D"
+        parts = reaction_text.split(" → ")
+        if len(parts) == 2:
+            reactants = parts[0].replace(" + ", ".").strip()
+            products = parts[1].replace(" + ", ".").strip()
+            smiles_reaction = f"{reactants}>>{products}"
+    elif " -> " in reaction_text:
+        # Alternative arrow format
+        parts = reaction_text.split(" -> ")
+        if len(parts) == 2:
+            reactants = parts[0].replace(" + ", ".").strip()
+            products = parts[1].replace(" + ", ".").strip()
+            smiles_reaction = f"{reactants}>>{products}"
+    elif " ↔ " in reaction_text:
+        # Reversible reaction
+        parts = reaction_text.split(" ↔ ")
+        if len(parts) == 2:
+            reactants = parts[0].replace(" + ", ".").strip()
+            products = parts[1].replace(" + ", ".").strip()
+            smiles_reaction = f"{reactants}>>{products}"
+
+    # If we couldn't parse it, try using it directly
+    if not smiles_reaction:
+        if ">>" in reaction_text:
+            smiles_reaction = reaction_text
+        else:
+            return None
+
+    try:
+        # Try parsing as SMILES reaction first
+        reaction = rdChemReactions.ReactionFromSmarts(smiles_reaction, useSmiles=True)
+        if reaction is None:
+            # Fall back to SMARTS parsing
+            reaction = rdChemReactions.ReactionFromSmarts(smiles_reaction, useSmiles=False)
+    except Exception:
+        return None
+
+    if reaction is None or (reaction.GetNumReactantTemplates() == 0 and reaction.GetNumProductTemplates() == 0):
+        return None
+
+    try:
+        # Generate SVG with specified parameters
+        svg = Draw.ReactionToImage(reaction, subImgSize=(200, 200), useSVG=True, drawOptions=None, returnPNG=False)
+    except Exception as exc:
+        print(f"Error rendering reaction: {exc}")
+        return None
+
+    if isinstance(svg, tuple):
+        svg = svg[0]
+    if hasattr(svg, "data"):
+        svg = svg.data
+    if isinstance(svg, bytes):
+        svg = svg.decode("utf-8", errors="ignore")
+
+    if not isinstance(svg, str) or "<svg" not in svg:
+        return None
+
+    return svg
+
+
 def _render_smiles_to_svg(smiles_text: str) -> str | None:
     """Helper to render a SMILES/SMARTS reaction string to SVG."""
     smiles_text = (smiles_text or "").strip()
@@ -947,60 +1064,130 @@ def build_interface() -> gr.Blocks:
                 with thermo_accordion:
                     thermo_data_display = gr.JSON(label="Raw Thermodynamic Data")
 
-            # Tab 3: Reaction SVG (Original functionality)
+            # Tab 3: Reaction SVG (Enhanced with NIST reactions)
             with gr.TabItem("Reaction SVG"):
                 gr.Markdown(
-                    "Render an RDKit reaction sketch from reaction SMILES/SMARTS. "
-                    "Example: `CCO.O=C=O>>CC(=O)O` or `[CH3:1].[Cl:2][C@@H](F)[Br]>>[CH3:1][C@@H](F)[Cl]`."
+                    "🎨 **Render chemical reactions as SVG using RDKit**\n\n"
+                    "Choose from NIST database reactions or enter custom SMILES/SMARTS reactions.\n\n"
+                    "Examples: `CCO.O=C=O>>CC(=O)O` or `[CH3:1].[Cl:2][C@@H](F)[Br]>>[CH3:1][C@@H](F)[Cl]`"
                 )
 
-                # Common reaction examples
-                common_reactions = [
-                    ("Ethanol esterification", "CCO.CC(=O)O>>CC(=O)OCC.O"),
-                    ("Methane combustion", "C.O>>CO2"),
-                    ("Ethylene hydration", "C=C.O>>CCO"),
-                    ("Acetylene + HBr", "C#C.Br>>C=CBr"),
-                    ("Benzene nitration", "c1ccccc1.O=N(=O)O>>c1ccc(cc1)[N+](=O)[O-].O"),
-                    ("Methyl radical + Ethane", "[CH3].CC>>[CH4].C"),
-                    ("Chlorine + Hydrogen", "Cl.C>>CCl"),
-                    ("Propane oxidation", "CCC.O>>CC(C)=O"),
-                ]
+                # NIST reactions dropdown
+                nist_reactions = _fetch_all_nist_reactions(limit=200)
+                nist_reaction_options = [("", "")] + nist_reactions if nist_reactions else []
 
                 with gr.Row():
-                    reaction_preset = gr.Dropdown(
-                        label="Common Reactions",
-                        choices=[label for label, _ in common_reactions],
-                        interactive=True
-                    )
-                    preset_dict = {label: smiles for label, smiles in common_reactions}
+                    with gr.Column():
+                        nist_reaction_dropdown = gr.Dropdown(
+                            label="🧪 NIST Database Reactions",
+                            choices=[label for label, _ in nist_reaction_options],
+                            value="",
+                            interactive=True,
+                            info=f"Select from {len(nist_reactions)} reactions in NIST kinetics database"
+                        )
 
-                reaction_input = gr.Textbox(
-                    label="Reaction SMILES/SMARTS",
-                    placeholder="Reactant1.Reactant2>>Product1.Product2",
-                    lines=2,
-                )
+                        reaction_input = gr.Textbox(
+                            label="Custom Reaction SMILES/SMARTS",
+                            placeholder="Reactant1.Reactant2>>Product1.Product2",
+                            lines=3,
+                            info="Enter your own reaction in SMILES/SMARTS format"
+                        )
 
-                def populate_from_preset(preset_name):
-                    if preset_name and preset_name in preset_dict:
-                        return preset_dict[preset_name]
+                    with gr.Column():
+                        render_mode = gr.Radio(
+                            label="Render Mode",
+                            choices=["Auto (NIST→SMILES)", "Direct SMILES/SMARTS"],
+                            value="Auto (NIST→SMILES)",
+                            info="Auto mode converts NIST reaction format to SMILES for RDKit"
+                        )
+
+                        render_options = gr.CheckboxGroup(
+                            label="Render Options",
+                            choices=["High quality", "Large molecules", "Color atoms"],
+                            value=["High quality"],
+                            info="Additional rendering preferences"
+                        )
+
+                # Buttons
+                with gr.Row():
+                    render_nist_btn = gr.Button("🎨 Render Selected NIST Reaction", variant="primary")
+                    render_custom_btn = gr.Button("🔬 Render Custom Reaction", variant="secondary")
+                    clear_btn = gr.Button("🗑️ Clear", variant="stop")
+
+                # Output
+                reaction_svg_output = gr.HTML(label="Reaction Structure")
+                render_status = gr.Markdown()
+
+                # Populate custom input from NIST dropdown
+                nist_dict = {label: reaction for label, reaction in nist_reaction_options}
+                def populate_from_nist_dropdown(selected_label):
+                    if selected_label and selected_label in nist_dict:
+                        return nist_dict[selected_label]
                     return ""
 
-                reaction_preset.change(
-                    fn=populate_from_preset,
-                    inputs=reaction_preset,
+                nist_reaction_dropdown.change(
+                    fn=populate_from_nist_dropdown,
+                    inputs=nist_reaction_dropdown,
                     outputs=reaction_input,
                 )
 
-                render_button = gr.Button("Render Reaction", variant="secondary")
-                reaction_svg_output = gr.HTML()
-                render_status = gr.Markdown()
+                # Render NIST reaction
+                def render_nist_reaction(reaction_text, options):
+                    if not reaction_text:
+                        return "", "⚠️ Please select a reaction from the dropdown or enter a custom reaction."
+
+                    try:
+                        svg = _render_reaction_from_nist(reaction_text)
+                        if svg:
+                            status = f"✅ Successfully rendered NIST reaction: {reaction_text[:100]}..."
+                            if "High quality" in (options or []):
+                                status += " (High quality mode)"
+                            return svg, status
+                        else:
+                            return "", f"❌ Could not render reaction. The reaction format may not be supported by RDKit: {reaction_text[:100]}..."
+                    except Exception as exc:
+                        return "", f"🚨 Error rendering reaction: {exc}"
+
+                # Render custom SMILES reaction
+                def render_custom_reaction(reaction_text, options):
+                    if not reaction_text:
+                        return "", "⚠️ Please enter a reaction in SMILES/SMARTS format."
+
+                    try:
+                        svg = _render_smiles_to_svg(reaction_text)
+                        if svg:
+                            status = f"✅ Successfully rendered custom reaction: {reaction_text[:100]}..."
+                            if "High quality" in (options or []):
+                                status += " (High quality mode)"
+                            return svg, status
+                        else:
+                            return "", f"❌ Could not parse reaction. Please check your SMILES/SMARTS format: {reaction_text[:100]}..."
+                    except Exception as exc:
+                        return "", f"🚨 Error rendering reaction: {exc}"
+
+                # Clear function
+                def clear_outputs():
+                    return "", "", ""
+
+                # Button handlers
+                render_nist_btn.click(
+                    fn=render_nist_reaction,
+                    inputs=[reaction_input, render_options],
+                    outputs=[reaction_svg_output, render_status],
+                )
 
-                render_button.click(
-                    fn=render_reaction_svg,
-                    inputs=reaction_input,
+                render_custom_btn.click(
+                    fn=render_custom_reaction,
+                    inputs=[reaction_input, render_options],
                     outputs=[reaction_svg_output, render_status],
                 )
 
+                clear_btn.click(
+                    fn=clear_outputs,
+                    inputs=[],
+                    outputs=[reaction_svg_output, render_status, reaction_input],
+                )
+
             # Tab 4: Kinetics Plotter
             with gr.TabItem("Kinetics Plotter"):
                 with gr.Row():