Fix NIST reaction rendering: Add comprehensive SMILES mapping for radicals, cyclic compounds, and complex formulas like C2H3, c-C3H2, etc. Handle spaces in formulas and special notation.

app.py

@@ -525,6 +525,139 @@ def _fetch_all_nist_reactions(limit: int = 100) -> List[tuple[str, str]]:
         return []
 
 
+def _clean_chemical_formula(formula: str) -> str:
+    """Clean and normalize chemical formulas from NIST format."""
+    if not formula:
+        return ""
+
+    # Remove extra spaces within formulas (C 2 H 3 -> C2H3)
+    import re
+
+    # Pattern to match element symbols followed by numbers with spaces
+    # This will convert "C 2 H 3" to "C2H3"
+    cleaned = re.sub(r'([A-Z][a-z]?)(\s+)(\d+)', r'\1\3', formula)
+
+    # Handle radicals and special notation
+    cleaned = cleaned.replace("·", "")  # Remove radical dots
+    cleaned = cleaned.replace("•", "")  # Remove alternative radical notation
+
+    # Keep c- prefix for cyclic compounds, remove other lowercase prefixes
+    if not cleaned.startswith(('c-', 'C-')):
+        cleaned = re.sub(r'^[a-z]-', '', cleaned)
+
+    return cleaned.strip()
+
+
+def _nist_formula_to_smiles(formula: str) -> str | None:
+    """Convert NIST chemical formula to SMILES string for RDKit."""
+    if not formula:
+        return None
+
+    formula = _clean_chemical_formula(formula)
+
+    # Dictionary of common NIST formulas to SMILES
+    # This is a lookup table for frequently encountered species
+    nist_to_smiles = {
+        # Simple molecules
+        "H2": "[H][H]",
+        "O2": "O=O",
+        "N2": "N#N",
+        "CO": "[C-]#[O+]",
+        "CO2": "O=C=O",
+        "H2O": "O",
+        "CH4": "C",
+        "C2H6": "CC",
+        "C2H4": "C=C",
+        "C2H2": "C#C",
+        "C3H8": "CCC",
+        "C3H6": "C=CC",
+        "C6H6": "c1ccccc1",
+
+        # Radicals (simplified representations)
+        "H": "[H]",
+        "CH3": "[CH3]",
+        "C2H5": "C[CH2]",
+        "C2H3": "C=C[CH2]",  # Propargyl radical
+        "C3H3": "C#CC",       # Propynyl radical
+        "C": "[C]",           # Carbon atom
+        "OH": "[OH]",
+        "O": "[O]",
+        "HO2": "O[O]",
+        "CH2": "[CH2]",
+
+        # Cyclic compounds
+        "c-C3H2": "C1=CC1",   # Cyclopropenylidene (simplified)
+
+        # More complex species
+        "CH2O": "C=O",
+        "CH3OH": "CO",
+        "C2H5OH": "CCO",
+        "HCO": "[CH]=O",
+        "CH3CHO": "CC=O",
+        "C2H4O": "C=CO",
+
+        # Ions (simplified)
+        "H+": "[H+]",
+        "OH-": "[OH-]",
+        "O2-": "[O-][O]",
+
+        # Specific compounds from the failing reaction
+        "C2H3": "C=C[CH2]",   # Propargyl radical C2H3
+        "c-C3H2": "C1=CC1",   # Cyclopropenyl radical (c-C3H2)
+        "CC3H2": "C1=CC1",    # Alternative notation
+    }
+
+    # Direct lookup
+    if formula in nist_to_smiles:
+        return nist_to_smiles[formula]
+
+    # Try to generate SMILES for simple hydrocarbons
+    if re.match(r'^C\d+H\d*$', formula):
+        # Parse C_nH_m
+        c_match = re.search(r'C(\d+)', formula)
+        h_match = re.search(r'H(\d+)', formula)
+
+        if c_match and h_match:
+            c_count = int(c_match.group(1))
+            h_count = int(h_match.group(1))
+
+            if c_count == 1 and h_count == 4:
+                return "C"  # CH4
+            elif c_count == 2 and h_count == 6:
+                return "CC"  # C2H6
+            elif c_count == 2 and h_count == 4:
+                return "C=C"  # C2H4
+            elif c_count == 2 and h_count == 2:
+                return "C#C"  # C2H2
+            elif c_count == 3 and h_count == 8:
+                return "CCC"  # C3H8
+            elif c_count == 3 and h_count == 6:
+                return "C=CC"  # C3H6
+
+    # For unknown formulas, try to create a simple representation
+    # This is a fallback that may not be chemically accurate
+    if re.match(r'^[A-Z][a-z]?\d*$', formula):
+        # Single atom with number (like O2, N2)
+        element_match = re.match(r'^([A-Z][a-z]?)(\d*)$', formula)
+        if element_match:
+            element = element_match.group(1)
+            count = element_match.group(2)
+
+            if count and int(count) > 1:
+                # For diatomic molecules
+                if element in ['O', 'N', 'H']:
+                    if element == 'O':
+                        return "O=O"
+                    elif element == 'N':
+                        return "N#N"
+                    elif element == 'H':
+                        return "[H][H]"
+            else:
+                return f"[{element}]"
+
+    return None  # Could not convert
+
+
 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()
@@ -535,34 +668,54 @@ def _render_reaction_from_nist(reaction_text: str) -> str | None:
     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
+    separators = [" → ", " -> ", " ↔ ", " ⇌ ", " →", " ->", " ⇌"]
+
+    parts = None
+    for sep in separators:
+        if sep in reaction_text:
+            parts = reaction_text.split(sep, 1)
+            break
+
+    if parts and len(parts) == 2:
+        reactants_text = parts[0].strip()
+        products_text = parts[1].strip()
+
+        # Split reactants and products by " + "
+        reactants = [r.strip() for r in reactants_text.split(" + ") if r.strip()]
+        products = [p.strip() for p in products_text.split(" + ") if p.strip()]
+
+        # Convert each compound to SMILES
+        reactant_smiles = []
+        product_smiles = []
+
+        for reactant in reactants:
+            smiles = _nist_formula_to_smiles(reactant)
+            if smiles:
+                reactant_smiles.append(smiles)
+
+        for product in products:
+            smiles = _nist_formula_to_smiles(product)
+            if smiles:
+                product_smiles.append(smiles)
+
+        # Only proceed if we have at least one reactant and one product
+        if reactant_smiles and product_smiles:
+            reactants_smiles_str = ".".join(reactant_smiles)
+            products_smiles_str = ".".join(product_smiles)
+            smiles_reaction = f"{reactants_smiles_str}>>{products_smiles_str}"
+
+    # If we couldn't parse it with separators, try using it directly
     if not smiles_reaction:
         if ">>" in reaction_text:
             smiles_reaction = reaction_text
         else:
-            return None
+            # Last resort: try to clean the entire reaction text
+            cleaned = _clean_chemical_formula(reaction_text)
+            if ">>" in cleaned:
+                smiles_reaction = cleaned
+
+    if not smiles_reaction:
+        return None
 
     try:
         # Try parsing as SMILES reaction first
@@ -570,7 +723,8 @@ def _render_reaction_from_nist(reaction_text: str) -> str | None:
         if reaction is None:
             # Fall back to SMARTS parsing
             reaction = rdChemReactions.ReactionFromSmarts(smiles_reaction, useSmiles=False)
-    except Exception:
+    except Exception as exc:
+        print(f"RDKit parsing error for '{smiles_reaction}': {exc}")
         return None
 
     if reaction is None or (reaction.GetNumReactantTemplates() == 0 and reaction.GetNumProductTemplates() == 0):
@@ -580,7 +734,7 @@ def _render_reaction_from_nist(reaction_text: str) -> str | None:
         # 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}")
+        print(f"Error rendering reaction '{smiles_reaction}': {exc}")
         return None
 
     if isinstance(svg, tuple):