Add FastAPI endpoints for NIST kinetics data access

API_README.md

@@ -0,0 +1,255 @@
+# NIST Chemical Kinetics API
+
+This application provides both a web interface (Gradio) and a REST API (FastAPI) for searching and analyzing the NIST Chemical Kinetics Database.
+
+## Access Points
+
+- **Web Interface**: `http://localhost:7860/` (or your deployed URL)
+- **API Documentation**: `http://localhost:7860/docs` (Swagger UI)
+- **Alternative API Docs**: `http://localhost:7860/redoc` (ReDoc)
+
+## API Endpoints
+
+### 1. Root Information
+```
+GET /
+```
+Returns basic API information and available endpoints.
+
+**Response:**
+```json
+{
+  "name": "NIST Chemical Kinetics API",
+  "version": "1.0.0",
+  "endpoints": {
+    "/search": "Search NIST kinetics database",
+    "/reaction/{url}": "Get detailed reaction information",
+    "/thermodynamic/{formula}": "Get thermodynamic data for a compound",
+    "/nist-reactions": "Get list of NIST reactions",
+    "/docs": "API documentation"
+  }
+}
+```
+
+### 2. Search Reactions
+```
+POST /search
+```
+Search the NIST Chemical Kinetics Database.
+
+**Parameters:**
+- `query` (required): Search query string (e.g., "CH4", "benzene")
+- `filters` (optional): Array of filter objects
+
+**Request Body Example:**
+```json
+{
+  "query": "CH4",
+  "filters": [
+    {
+      "field": "reactants",
+      "relation": "contains",
+      "value": "CH4"
+    }
+  ]
+}
+```
+
+**Response Example:**
+```json
+{
+  "query": "CH4",
+  "count": 10,
+  "results": [
+    {
+      "reaction": "CH4 + OH → CH3 + H2O",
+      "k_298": "6.3e-15",
+      "a": "2.45e-12",
+      "n": "0.0",
+      "ea": "1710",
+      "t_range": "200-500 K",
+      "p_range": "0.001-100 atm",
+      "bath_gas": "He",
+      "url": "https://kinetics.nist.gov/..."
+    }
+  ]
+}
+```
+
+### 3. Get Reaction Detail
+```
+GET /reaction?url={nist_url}
+```
+Get detailed information for a specific reaction.
+
+**Parameters:**
+- `url` (required): NIST reaction URL
+
+**Response Example:**
+```json
+{
+  "reaction": "CH4 + OH → CH3 + H2O",
+  "reactants": ["CH4", "OH"],
+  "products": ["CH3", "H2O"],
+  "rate_data": [
+    {
+      "k_298": "6.3e-15",
+      "a": "2.45e-12",
+      "n": "0.0",
+      "ea": "1710",
+      "t_range": "200-500 K",
+      "p_range": "0.001-100 atm",
+      "bath_gas": "He",
+      "reference": "Atkinson et al., 2004",
+      "squib": "2004ATK/BAU8400-8468"
+    }
+  ]
+}
+```
+
+### 4. Get Thermodynamic Data
+```
+GET /thermodynamic/{formula}?database={db_type}
+```
+Get thermodynamic data for a compound from NIST WebBook.
+
+**Parameters:**
+- `formula` (required): Chemical formula or name (e.g., "CH3", "benzene")
+- `database` (optional): Database type - "gas-phase", "ion-energetics", or "condensed-phase" (default: "gas-phase")
+
+**Response Example:**
+```json
+{
+  "formula": "CH3",
+  "database": "gas-phase",
+  "data": [
+    {
+      "Temperature (K)": 298.15,
+      "Cp (J/mol*K)": 38.70,
+      "S (J/mol*K)": 194.20,
+      "H-H298 (kJ/mol)": 0.0
+    }
+  ],
+  "summary": "# Thermodynamic Data for CH3\n..."
+}
+```
+
+### 5. Get NIST Reactions List
+```
+GET /nist-reactions?limit={number}
+```
+Get a list of reactions from the NIST database.
+
+**Parameters:**
+- `limit` (optional): Maximum number of reactions to return (default: 200)
+
+**Response Example:**
+```json
+{
+  "count": 200,
+  "reactions": [
+    {
+      "label": "CH4 + OH → CH3 + H2O",
+      "reaction": "CH4 + OH → CH3 + H2O"
+    }
+  ]
+}
+```
+
+## Using the API
+
+### cURL Examples
+
+**Search for reactions:**
+```bash
+curl -X POST "http://localhost:7860/search?query=CH4" \
+  -H "Content-Type: application/json"
+```
+
+**Get reaction details:**
+```bash
+curl "http://localhost:7860/reaction?url=https://kinetics.nist.gov/kinetics/Detail?id=1993DEA/SIB4517-4529:4"
+```
+
+**Get thermodynamic data:**
+```bash
+curl "http://localhost:7860/thermodynamic/CH3?database=gas-phase"
+```
+
+**Get NIST reactions list:**
+```bash
+curl "http://localhost:7860/nist-reactions?limit=50"
+```
+
+### Python Example
+
+```python
+import requests
+
+# Search for reactions
+response = requests.post(
+    "http://localhost:7860/search",
+    params={"query": "CH4"}
+)
+data = response.json()
+print(f"Found {data['count']} reactions")
+
+# Get thermodynamic data
+response = requests.get(
+    "http://localhost:7860/thermodynamic/benzene",
+    params={"database": "gas-phase"}
+)
+thermo_data = response.json()
+print(thermo_data)
+```
+
+### JavaScript Example
+
+```javascript
+// Search for reactions
+fetch('http://localhost:7860/search?query=CH4', {
+  method: 'POST',
+  headers: {
+    'Content-Type': 'application/json'
+  }
+})
+  .then(response => response.json())
+  .then(data => console.log(`Found ${data.count} reactions`));
+
+// Get thermodynamic data
+fetch('http://localhost:7860/thermodynamic/benzene?database=gas-phase')
+  .then(response => response.json())
+  .then(data => console.log(data));
+```
+
+## Running the Application
+
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Run the application
+python app.py
+```
+
+The application will start on `http://0.0.0.0:7860` by default. You can change the port by setting the `PORT` environment variable:
+
+```bash
+PORT=8000 python app.py
+```
+
+## Deployment
+
+For production deployment, consider using:
+- **Gunicorn** with Uvicorn workers
+- **Docker** for containerization
+- **Nginx** as a reverse proxy
+
+Example with Gunicorn:
+```bash
+gunicorn app:app -w 4 -k uvicorn.workers.UvicornWorker --bind 0.0.0.0:7860
+```
+
+## License
+
+Please refer to the NIST data usage policies and licensing terms when using this API.

app.py

@@ -1639,12 +1639,212 @@ def build_interface() -> gr.Blocks:
     return demo
 
 
+# Create FastAPI app
+app = FastAPI(
+    title="NIST Chemical Kinetics API",
+    description="API for searching and analyzing NIST Chemical Kinetics Database",
+    version="1.0.0"
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# API Endpoints
+@app.get("/")
+async def root():
+    """Root endpoint with API information"""
+    return {
+        "name": "NIST Chemical Kinetics API",
+        "version": "1.0.0",
+        "endpoints": {
+            "/search": "Search NIST kinetics database",
+            "/reaction/{url}": "Get detailed reaction information",
+            "/thermodynamic/{formula}": "Get thermodynamic data for a compound",
+            "/nist-reactions": "Get list of NIST reactions",
+            "/docs": "API documentation"
+        }
+    }
+
+@app.post("/search")
+async def search_nist(
+    query: str = Query(..., description="Search query (e.g., CH4, benzene)"),
+    filters: Optional[List[Dict[str, Any]]] = None
+):
+    """
+    Search the NIST Chemical Kinetics Database
+    
+    Args:
+        query: Search query string
+        filters: Optional list of search filters
+    
+    Returns:
+        List of search results with reaction details
+    """
+    try:
+        # Build search filters
+        search_filters = []
+        if filters:
+            for f in filters[:MAX_FILTERS]:
+                search_filters.append(SearchFilter(
+                    field=FieldName(f.get("field", "reactants")),
+                    relation=Relation(f.get("relation", "contains")),
+                    value=f.get("value", "")
+                ))
+        
+        # Perform search
+        request = SearchRequest(
+            category=Category.search,
+            filters=search_filters if search_filters else [
+                SearchFilter(
+                    field=FieldName.reactants,
+                    relation=Relation.contains,
+                    value=query
+                )
+            ]
+        )
+        
+        results = client.search_reactions(request)
+        
+        return {
+            "query": query,
+            "count": len(results),
+            "results": [
+                {
+                    "reaction": r.reaction,
+                    "k_298": r.k_298,
+                    "a": r.a,
+                    "n": r.n,
+                    "ea": r.ea,
+                    "t_range": r.t_range,
+                    "p_range": r.p_range,
+                    "bath_gas": r.bath_gas,
+                    "url": r.url
+                }
+                for r in results
+            ]
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/reaction")
+async def get_reaction_detail(url: str = Query(..., description="NIST reaction URL")):
+    """
+    Get detailed information for a specific reaction
+    
+    Args:
+        url: NIST reaction URL
+    
+    Returns:
+        Detailed reaction information including rate data and references
+    """
+    try:
+        detail = client.fetch_reaction_detail(url)
+        
+        if not detail:
+            raise HTTPException(status_code=404, detail="Reaction not found")
+        
+        return {
+            "reaction": detail.reaction,
+            "reactants": detail.reactants,
+            "products": detail.products,
+            "rate_data": [
+                {
+                    "k_298": rd.k_298,
+                    "a": rd.a,
+                    "n": rd.n,
+                    "ea": rd.ea,
+                    "t_range": rd.t_range,
+                    "p_range": rd.p_range,
+                    "bath_gas": rd.bath_gas,
+                    "reference": rd.reference,
+                    "squib": rd.squib
+                }
+                for rd in detail.rate_data
+            ]
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/thermodynamic/{formula}")
+async def get_thermodynamic_data(
+    formula: str,
+    database: str = Query("gas-phase", description="Database type: gas-phase, ion-energetics, or condensed-phase")
+):
+    """
+    Get thermodynamic data for a compound from NIST WebBook
+    
+    Args:
+        formula: Chemical formula or name (e.g., CH3, benzene)
+        database: Database to search (gas-phase, ion-energetics, condensed-phase)
+    
+    Returns:
+        Thermodynamic data including enthalpy, entropy, heat capacity
+    """
+    try:
+        if database == "gas-phase":
+            url = _build_webbook_url(formula, "gas-phase")
+        elif database == "ion-energetics":
+            url = _build_webbook_url(formula, "ion-energetics")
+        elif database == "condensed-phase":
+            url = _build_webbook_url(formula, "condensed-phase")
+        else:
+            raise HTTPException(status_code=400, detail="Invalid database type")
+        
+        md_content, df, plot_html = _fetch_and_parse_webbook(url, formula, database)
+        
+        if df is not None and not df.empty:
+            return {
+                "formula": formula,
+                "database": database,
+                "data": df.to_dict(orient="records"),
+                "summary": md_content
+            }
+        else:
+            raise HTTPException(status_code=404, detail=f"No data found for {formula} in {database}")
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/nist-reactions")
+async def get_nist_reactions(limit: int = Query(200, description="Maximum number of reactions to return")):
+    """
+    Get a list of reactions from the NIST database
+    
+    Args:
+        limit: Maximum number of reactions to return (default: 200)
+    
+    Returns:
+        List of reactions with labels
+    """
+    try:
+        reactions = _fetch_all_nist_reactions(limit=limit)
+        return {
+            "count": len(reactions),
+            "reactions": [
+                {"label": label, "reaction": reaction}
+                for label, reaction in reactions
+            ]
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+# Mount Gradio app
 demo = build_interface()
+app = gr.mount_gradio_app(app, demo, path="/")
 
 if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=int(os.environ.get("PORT", 7860)),
-        show_error=True,
-        share=False
+    import uvicorn
+    uvicorn.run(
+        app,
+        host="0.0.0.0",
+        port=int(os.environ.get("PORT", 7860))
     )