Merge pull request #298 from ReactionMechanismGenerator/update_django

Update to Python=3.9 and update Django

Author: jonwzheng

.gitignore

@@ -44,9 +44,6 @@ rmgweb/media/rmg/tools/*
 .pydevproject
 .settings/*
 
-# WSGI
-apache/django.wsgi
-
 # VS Code related files
 .history/*
 

environment.yml

@@ -1,19 +1,11 @@
 # First, install a conda environment with RMG-Py.
 # Then, update the environment using the constraints in this environment file.
 
-name: rmg_env
+name: rmg_website
 channels:
-  - rmg
   - conda-forge
-  - cantera
-  - fhvermei
 dependencies:
-  - docutils
-  - django =2.2
-  - lxml
-  - pip
-  - pip:
-      - git+https://github.com/bp-kelley/descriptastorus@2.5.0
-  - python >=3.7
-  - solprop_ml >=1.2
+  - django==4.2
+  - python>=3.9
   - xlsxwriter
+  - cantera==2.6.0*

microservices/solprop/Dockerfile

@@ -0,0 +1,14 @@
+FROM continuumio/miniconda3:latest
+
+WORKDIR /app
+
+RUN conda create -n solprop conda-forge::python=3.7 fhvermei::solprop_ml "conda-forge::scipy<1.11" && \
+    conda install -n solprop rmg::descriptastorus && \
+    conda install -n solprop conda-forge::fastapi conda-forge::uvicorn conda-forge::pydantic conda-forge::requests && \
+    conda clean -a -y
+
+COPY server.py .
+
+EXPOSE 8081
+
+CMD ["conda", "run", "--no-capture-output", "-n", "solprop", "uvicorn", "server:app", "--host", "0.0.0.0", "--port", "8081"]

microservices/solprop/README.md

@@ -0,0 +1,7 @@
+Wraps the solprop package into a callable microservice.
+
+With docker installed, run `docker build -t solprop_service .` in this directory to build the image.
+After, run `docker run -d -p 8081:8081 --name solprop solprop_service` to start the server.
+You can check the server outputs with `docker logs solprop`.
+
+A prebuilt version of this image is also available on the ReactionMechanismGenerator DockerHub, which you can download and run to avoid building it yourself: https://hub.docker.com/layers/reactionmechanismgenerator/solprop_microservice/1.0.0/images/sha256-ca48dc8d0b0759a9a750c747758c5e095bf0dfcaae8fe0f64912ce8a91c764ff

microservices/solprop/server.py

@@ -0,0 +1,149 @@
+from fastapi import FastAPI
+from pydantic import BaseModel
+import pandas as pd
+import numpy as np
+from typing import Optional
+
+from chemprop_solvation.solvation_estimator import load_DirectML_Gsolv_estimator, load_DirectML_Hsolv_estimator, load_SoluteML_estimator
+from solvation_predictor.solubility.solubility_calculator import SolubilityCalculations
+from solvation_predictor.solubility.solubility_predictions import SolubilityPredictions
+from solvation_predictor.solubility.solubility_data import SolubilityData
+from solvation_predictor.solubility.solubility_models import SolubilityModels
+
+
+class SolubilityDataWrapper:
+    """
+    Class for storing the input data for solubility prediction
+    """
+    def __init__(self, solvent_smiles=None, solute_smiles=None, temp=None, ref_solub=None, ref_solv=None):
+        self.smiles_pairs = [(solvent_smiles, solute_smiles)]
+        self.temperatures = np.array([temp]) if temp is not None else None
+        self.reference_solubility = np.array([ref_solub]) if ref_solub is not None else None
+        self.reference_solvents = np.array([ref_solv]) if ref_solv is not None else None
+
+
+app = FastAPI()
+
+dGsolv_estimator = None
+dHsolv_estimator = None
+SoluteML_estimator = None
+solub_models = None
+
+@app.on_event("startup")
+def load_models():
+    global dGsolv_estimator, dHsolv_estimator, SoluteML_estimator, solub_models
+    
+    print("Loading models...")
+    
+    dGsolv_estimator = load_DirectML_Gsolv_estimator()
+    dHsolv_estimator = load_DirectML_Hsolv_estimator()
+    
+    solub_models = SolubilityModels(
+        load_g=True, load_h=True,
+        reduced_number=False, load_saq=True,
+        load_solute=True, logger=None, verbose=False
+    )
+    
+    SoluteML_estimator = load_SoluteML_estimator()
+    
+    print("Models loaded.")
+
+class SolubilityRequest(BaseModel):
+    solvent_smiles: Optional[str] = None
+    solute_smiles: Optional[str] = None
+    temperature: Optional[float] = None
+    reference_solvent: Optional[str] = None
+    reference_solubility: Optional[float] = None
+    hsub298: Optional[float] = None
+    cp_gas_298: Optional[float] = None
+    cp_solid_298: Optional[float] = None
+    use_reference: bool = False
+    
+@app.post("/dGsolv_estimator")
+def _dGsolv_estimator(req: SolubilityRequest):
+    result = dGsolv_estimator([[req.solvent_smiles, req.solute_smiles]])
+    return {
+        "avg_pred": result[0],
+        "epi_unc": result[1],
+        "valid_indices": result[2]
+    }
+
+@app.post("/dHsolv_estimator")
+def _dHsolv_estimator(req: SolubilityRequest):
+    result = dHsolv_estimator([[req.solvent_smiles, req.solute_smiles]])
+    return {
+        "avg_pred": result[0],
+        "epi_unc": result[1],
+        "valid_indices": result[2]
+    }
+
+@app.post("/SoluteML_estimator")
+def _SoluteML_estimator(req: SolubilityRequest):
+    result = SoluteML_estimator([[req.solute_smiles]])
+    return {
+        "avg_pred": result[0],
+        "epi_unc": result[1],
+        "valid_indices": result[2]
+    }
+
+@app.post("/calc_solubility_no_ref")
+def _calc_solubility_no_ref(req: SolubilityRequest):
+    """
+    Calculate solubility with no reference solvent and reference solubility
+    """
+    hsubl_298 = np.array([req.hsub298]) if req.hsub298 is not None else None
+    Cp_solid = np.array([req.cp_solid_298]) if req.cp_solid_298 is not None else None
+    Cp_gas = np.array([req.cp_gas_298]) if req.cp_gas_298 is not None else None
+
+    solub_data = SolubilityDataWrapper(solvent_smiles=req.solvent_smiles, solute_smiles=req.solute_smiles, temp=req.temperature)
+    predictions = SolubilityPredictions(solub_data, solub_models, predict_aqueous=True,
+                                        predict_reference_solvents=False, predict_t_dep=True,
+                                        predict_solute_parameters=True, verbose=False)
+    calculations = SolubilityCalculations(predictions, calculate_aqueous=True,
+                                          calculate_reference_solvents=False, calculate_t_dep=True,
+                                          calculate_t_dep_with_t_dep_hdiss=True, verbose=False,
+                                          hsubl_298=hsubl_298, Cp_solid=Cp_solid, Cp_gas=Cp_gas)
+    
+    return {
+        "logsT_method1": calculations.logs_T_with_const_hdiss_from_aq[0],
+        "logsT_method2": calculations.logs_T_with_T_dep_hdiss_from_aq[0],
+        "gsolv_T": calculations.gsolv_T[0],
+        "hsolv_T": calculations.hsolv_T[0],
+        "ssolv_T": calculations.ssolv_T[0],
+        "hsubl_298": calculations.hsubl_298[0],
+        "Cp_gas": calculations.Cp_gas[0],
+        "Cp_solid": calculations.Cp_solid[0],
+        "logs_T_with_T_dep_hdiss_error_message": None if calculations.logs_T_with_T_dep_hdiss_error_message is None else calculations.logs_T_with_T_dep_hdiss_error_message[0],
+    }
+
+
+@app.post("/calc_solubility_with_ref")
+def _calc_solubility_with_ref(req: SolubilityRequest):
+    """
+    Calculate solubility with a reference solvent and reference solubility
+    """
+    hsubl_298 = np.array([req.hsub298]) if req.hsub298 is not None else None
+    Cp_solid = np.array([req.cp_solid_298]) if req.cp_solid_298 is not None else None
+    Cp_gas = np.array([req.cp_gas_298]) if req.cp_gas_298 is not None else None
+
+    solub_data = SolubilityDataWrapper(solvent_smiles=req.solvent_smiles, solute_smiles=req.solute_smiles, temp=req.temperature,
+                                ref_solub=req.reference_solubility, ref_solv=req.reference_solvent)
+    predictions = SolubilityPredictions(solub_data, solub_models, predict_aqueous=False,
+                                        predict_reference_solvents=True, predict_t_dep=True,
+                                        predict_solute_parameters=True, verbose=False)
+    calculations = SolubilityCalculations(predictions, calculate_aqueous=False,
+                                          calculate_reference_solvents=True, calculate_t_dep=True,
+                                          calculate_t_dep_with_t_dep_hdiss=True, verbose=False,
+                                          hsubl_298=hsubl_298, Cp_solid=Cp_solid, Cp_gas=Cp_gas)
+
+    return {
+        "logsT_method1": calculations.logs_T_with_const_hdiss_from_ref[0],
+        "logsT_method2": calculations.logs_T_with_T_dep_hdiss_from_ref[0],
+        "gsolv_T": calculations.gsolv_T[0],
+        "hsolv_T": calculations.hsolv_T[0],
+        "ssolv_T": calculations.ssolv_T[0],
+        "hsubl_298": calculations.hsubl_298[0],
+        "Cp_gas": calculations.Cp_gas[0],
+        "Cp_solid": calculations.Cp_solid[0],
+        "logs_T_with_T_dep_hdiss_error_message": None if calculations.logs_T_with_T_dep_hdiss_error_message is None else calculations.logs_T_with_T_dep_hdiss_error_message[0],
+    }

microservices/solprop/test.py

@@ -0,0 +1,134 @@
+import requests
+
+# The base URL where your server is running.
+# Change this if running on a different port or host.
+BASE_URL = "http://localhost:8081"
+
+# ---------------------------------------------------------
+# Test Data Constants
+# ---------------------------------------------------------
+TEST_SOLVENT = "CCO"  # Ethanol
+TEST_SOLUTE = "CC(=O)O" # Acetic Acid
+
+# ---------------------------------------------------------
+# Tests for DirectML and SoluteML Estimators
+# ---------------------------------------------------------
+
+def test_dGsolv_estimator_success():
+    payload = {
+        "solvent_smiles": TEST_SOLVENT,
+        "solute_smiles": TEST_SOLUTE
+    }
+    
+    response = requests.post(f"{BASE_URL}/dGsolv_estimator", json=payload)
+    
+    # Verify the HTTP response
+    assert response.status_code == 200
+    
+    # Verify the JSON payload structure
+    data = response.json()
+    assert "avg_pred" in data
+    assert "epi_unc" in data
+    assert "valid_indices" in data
+
+
+def test_dHsolv_estimator_success():
+    payload = {
+        "solvent_smiles": TEST_SOLVENT,
+        "solute_smiles": TEST_SOLUTE
+    }
+    
+    response = requests.post(f"{BASE_URL}/dHsolv_estimator", json=payload)
+    
+    assert response.status_code == 200
+    
+    data = response.json()
+    assert "avg_pred" in data
+    assert "epi_unc" in data
+    assert "valid_indices" in data
+
+
+def test_SoluteML_estimator_success():
+    payload = {
+        "solute_smiles": TEST_SOLUTE
+    }
+    
+    response = requests.post(f"{BASE_URL}/SoluteML_estimator", json=payload)
+    
+    assert response.status_code == 200
+    
+    data = response.json()
+    assert "avg_pred" in data
+    assert "epi_unc" in data
+    assert "valid_indices" in data
+
+
+def test_invalid_payload_fails():
+    # Sending a bad type (like string instead of float for temperature)
+    # should raise a 422 Unprocessable Entity from Pydantic
+    payload = {
+        "temperature": "not_a_number"
+    }
+    response = requests.post(f"{BASE_URL}/dGsolv_estimator", json=payload)
+    assert response.status_code == 422
+
+
+# ---------------------------------------------------------
+# Tests for the Solubility Calculators
+# ---------------------------------------------------------
+
+def test_calc_solubility_no_ref():
+    payload = {
+        "solvent_smiles": TEST_SOLVENT,
+        "solute_smiles": TEST_SOLUTE,
+        "temperature": 298.15
+    }
+    
+    response = requests.post(f"{BASE_URL}/calc_solubility_no_ref", json=payload)
+    
+    assert response.status_code == 200
+    
+    data = response.json()
+    
+    # based on the previous version from rmg.mit.edu
+    assert round(data["logsT_method1"], 3) == 1.146
+    assert round(data["logsT_method2"], 3) == 1.146
+    assert round(data["gsolv_T"], 2) == -7.12
+    assert round(data["hsolv_T"], 2) == -12.08
+    assert round(data["ssolv_T"] * 1000, 2) == -16.62
+    assert round(data["hsubl_298"], 2) == 14.86
+    assert round(data["Cp_gas"], 2) == 15.93
+    assert round(data["Cp_solid"], 2) == 22.18
+
+
+def test_calc_solubility_with_ref():
+    payload = {
+        "solvent_smiles": TEST_SOLVENT,
+        "solute_smiles": TEST_SOLUTE,
+        "temperature": 298.15,
+        "reference_solvent": "O", # Water
+        "reference_solubility": -1.5
+    }
+    
+    response = requests.post(f"{BASE_URL}/calc_solubility_with_ref", json=payload)
+    
+    assert response.status_code == 200
+    
+    data = response.json()
+    assert round(data["logsT_method1"], 3) == -1.223
+    assert round(data["logsT_method2"], 3) == -1.223
+    assert round(data["gsolv_T"], 2) == -7.12
+    assert round(data["hsolv_T"], 2) == -12.08
+    assert round(data["ssolv_T"] * 1000, 2) == -16.62
+    assert round(data["hsubl_298"], 2) == 14.86
+    assert round(data["Cp_gas"], 2) == 15.93
+    assert round(data["Cp_solid"], 2) == 22.18
+
+if __name__ == "__main__":
+    test_dGsolv_estimator_success()
+    test_dHsolv_estimator_success()
+    test_SoluteML_estimator_success()
+    test_invalid_payload_fails()
+    test_calc_solubility_no_ref()
+    test_calc_solubility_with_ref()
+    print("All tests passed!")