rowan-mcp 1.0.2__py3-none-any.whl → 2.0.1__py3-none-any.whl

rowan_mcp/functions_v2/submit_redox_potential_workflow.py

@@ -0,0 +1,55 @@
+"""
+Rowan v2 API: Redox Potential Workflow
+Calculate reduction and oxidation potentials for molecules.
+"""
+
+from typing import Annotated
+import rowan
+import stjames
+
+
+def submit_redox_potential_workflow(
+    initial_molecule: Annotated[str, "SMILES string for redox potential calculation"],
+    reduction: Annotated[bool, "Whether to calculate reduction potential (gaining electron)"] = False,
+    oxidization: Annotated[bool, "Whether to calculate oxidation potential (losing electron)"] = True,
+    mode: Annotated[str, "Calculation mode: 'rapid' (fast), 'careful' (balanced), or 'meticulous' (thorough)"] = "rapid",
+    name: Annotated[str, "Workflow name for identification and tracking"] = "Redox Potential Workflow",
+    folder_uuid: Annotated[str, "UUID of folder to organize this workflow. Empty string uses default folder"] = "",
+    max_credits: Annotated[int, "Maximum credits to spend on this calculation. 0 for no limit"] = 0
+):
+    """Submit a redox potential calculation workflow using Rowan v2 API.
+    
+    Args:
+        initial_molecule: SMILES string for redox potential calculation
+        reduction: Whether to calculate reduction potential (gaining electron)
+        oxidization: Whether to calculate oxidation potential (losing electron)
+        mode: Calculation mode: 'rapid' (fast), 'careful' (balanced), or 'meticulous' (thorough)
+        name: Workflow name for identification and tracking
+        folder_uuid: UUID of folder to organize this workflow. Empty string uses default folder.
+        max_credits: Maximum credits to spend on this calculation. 0 for no limit.
+    
+    Calculates reduction and/or oxidation potentials for a molecule using
+    quantum chemistry methods.
+    
+    Returns:
+        Workflow object representing the submitted workflow
+        
+    Example:
+        # Simple redox potential from SMILES
+        result = submit_redox_potential_workflow(
+            initial_molecule="Cc1ccccc1",  # Toluene
+            reduction=True,
+            oxidization=True,
+            name="Toluene Redox Potential"
+        )
+    """
+    
+    return rowan.submit_redox_potential_workflow(
+        initial_molecule=stjames.Molecule.from_smiles(initial_molecule),
+        reduction=reduction,
+        oxidization=oxidization,
+        mode=mode,
+        name=name,
+        folder_uuid=folder_uuid if folder_uuid else None,
+        max_credits=max_credits if max_credits > 0 else None
+    )

rowan_mcp/functions_v2/submit_scan_workflow.py

@@ -0,0 +1,82 @@
+"""
+Rowan v2 API: Scan Workflow
+Perform potential energy surface scans along molecular coordinates.
+"""
+
+from typing import Dict, Any, Annotated
+import rowan
+import stjames
+import json
+
+def submit_scan_workflow(
+    initial_molecule: Annotated[str, "SMILES string to scan"],
+    scan_settings: Annotated[str, "JSON string of scan parameters: '{\"type\": \"dihedral\"/\"bond\"/\"angle\", \"atoms\": [1-indexed], \"start\": value, \"stop\": value, \"num\": points}'"] = "",
+    calculation_engine: Annotated[str, "Computational engine: 'omol25', 'xtb', 'psi4'"] = "omol25",
+    calculation_method: Annotated[str, "Computational method (e.g., 'uma_m_omol', 'gfn2-xtb', 'b3lyp-d3bj')"] = "uma_m_omol",
+    wavefront_propagation: Annotated[bool, "Whether to use wavefront propagation for scan"] = True,
+    name: Annotated[str, "Workflow name for identification and tracking"] = "Scan Workflow",
+    folder_uuid: Annotated[str, "UUID of folder to organize this workflow. Empty string uses default folder"] = "",
+    max_credits: Annotated[int, "Maximum credits to spend on this calculation. 0 for no limit"] = 0
+):
+    """Submit a potential energy surface scan workflow using Rowan v2 API.
+    
+    Args:
+        initial_molecule: SMILES string to scan
+        scan_settings: JSON string of scan parameters: '{"type": "dihedral"/"bond"/"angle", "atoms": [1-indexed], "start": value, "stop": value, "num": points}'
+        calculation_engine: Computational engine: 'omol25', 'xtb', or 'psi4'
+        calculation_method: Calculation method (depends on engine): 'uma_m_omol', 'gfn2_xtb', 'r2scan_3c'
+        wavefront_propagation: Use previous scan point geometries as starting points for faster convergence
+        name: Workflow name for identification and tracking
+        folder_uuid: UUID of folder to organize this workflow. Empty string uses default folder.
+        max_credits: Maximum credits to spend on this calculation. 0 for no limit.
+    
+    Performs systematic scans along specified molecular coordinates (bonds, angles,
+    or dihedrals) to map the potential energy surface.
+    
+    Returns:
+        Workflow object representing the submitted workflow
+        
+    Example:
+        # Water angle scan
+        result = submit_scan_workflow(
+            initial_molecule="O",  # Water SMILES
+            name="Water Angle scan",
+            scan_settings='{"type": "angle", "atoms": [2, 1, 3], "start": 100, "stop": 110, "num": 5}',
+            calculation_method="GFN2-xTB",
+            calculation_engine="xtb"
+        )
+    """
+    # Parse scan_settings if provided
+    parsed_scan_settings = None
+    if scan_settings:
+        try:
+            parsed_scan_settings = json.loads(scan_settings)
+        except (json.JSONDecodeError, ValueError) as e:
+            raise ValueError(f"Invalid scan_settings format: {e}")
+    
+    # Validate and convert scan_settings
+    if parsed_scan_settings is not None:
+        # Convert step to num if step is provided instead of num
+        if 'step' in parsed_scan_settings and 'num' not in parsed_scan_settings:
+            start = parsed_scan_settings.get('start', 0)
+            stop = parsed_scan_settings.get('stop', 360)
+            step = parsed_scan_settings['step']
+            parsed_scan_settings['num'] = int((stop - start) / step) + 1
+            del parsed_scan_settings['step']  # Remove step as API doesn't accept it
+        
+        # Validate required fields
+        required_fields = ['type', 'atoms', 'start', 'stop', 'num']
+        missing_fields = [field for field in required_fields if field not in parsed_scan_settings]
+        if missing_fields:
+            raise ValueError(f"Missing required fields in scan_settings: {missing_fields}")
+    
+    return rowan.submit_scan_workflow(
+        initial_molecule=stjames.Molecule.from_smiles(initial_molecule),
+        scan_settings=parsed_scan_settings,
+        calculation_engine=calculation_engine,
+        calculation_method=calculation_method,
+        wavefront_propagation=wavefront_propagation,
+        name=name,
+        folder_uuid=folder_uuid if folder_uuid else None,
+        max_credits=max_credits if max_credits > 0 else None
+    )

rowan_mcp/functions_v2/submit_solubility_workflow.py

@@ -0,0 +1,157 @@
+"""
+Rowan v2 API: Solubility Workflow
+Predict molecular solubility in various solvents at different temperatures.
+"""
+
+from typing import List, Annotated
+import rowan
+import json
+
+
+def submit_solubility_workflow(
+    initial_smiles: Annotated[str, "SMILES string of the molecule for solubility prediction"],
+    solvents: Annotated[str, "JSON string list of solvents as SMILES or names (e.g., '[\"water\", \"ethanol\", \"CCO\"]'). Empty string uses defaults"] = "",
+    temperatures: Annotated[str, "JSON string list of temperatures in Kelvin (e.g., '[298.15, 310.15]'). Empty string uses default range"] = "",
+    name: Annotated[str, "Workflow name for identification and tracking"] = "Solubility Workflow",
+    folder_uuid: Annotated[str, "UUID of folder to organize this workflow. Empty string uses default folder"] = "",
+    max_credits: Annotated[int, "Maximum credits to spend on this calculation. 0 for no limit"] = 0
+):
+    """Submit a solubility prediction workflow using Rowan v2 API.
+    
+    Args:
+        initial_smiles: SMILES string of the molecule for solubility prediction
+        solvents: JSON string list of solvents as SMILES or names (e.g., '["water", "ethanol", "CCO"]'). Empty string uses defaults
+        temperatures: JSON string list of temperatures in Kelvin (e.g., '[298.15, 310.15]'). Empty string uses default range
+        name: Workflow name for identification and tracking
+        folder_uuid: UUID of folder to organize this workflow. Empty string uses default folder.
+        max_credits: Maximum credits to spend on this calculation. 0 for no limit.
+    
+    Predicts solubility (log S) of a molecule in multiple solvents at various temperatures
+    using machine learning models.
+    
+    Returns:
+        Workflow object representing the submitted workflow
+        
+    Example:
+        # Basic solubility prediction
+        result = submit_solubility_workflow(
+            initial_smiles="CC(=O)Nc1ccc(O)cc1",
+            solvents='["water", "ethanol"]',
+            temperatures='[298.15, 310.15]'
+        )
+        
+        # With SMILES solvents
+        result = submit_solubility_workflow(
+            initial_smiles="CC(=O)O",
+            solvents='["O", "CCO", "CCCCCC"]',
+            temperatures='[273.15, 298.15, 323.15]'
+        )
+    """
+    
+    # Parse solvents parameter - handle string input
+    parsed_solvents = None
+    if solvents:
+        # Handle various string formats
+        solvents = solvents.strip()
+        if solvents.startswith('[') and solvents.endswith(']'):
+            # JSON array format like '["water", "ethanol"]'
+            try:
+                parsed_solvents = json.loads(solvents)
+            except (json.JSONDecodeError, ValueError):
+                # Failed to parse as JSON, try as comma-separated
+                solvents = solvents.strip('[]').replace('"', '').replace("'", "")
+                parsed_solvents = [s.strip() for s in solvents.split(',') if s.strip()]
+        elif ',' in solvents:
+            # Comma-separated format like 'water, ethanol'
+            parsed_solvents = [s.strip() for s in solvents.split(',') if s.strip()]
+        else:
+            # Single solvent as string like 'water'
+            parsed_solvents = [solvents]
+        
+        # Convert solvent names to SMILES if needed
+        solvent_name_to_smiles = {
+            'water': 'O',
+            'ethanol': 'CCO',
+            'dmso': 'CS(=O)C',
+            'acetone': 'CC(=O)C',
+            'methanol': 'CO',
+            'chloroform': 'C(Cl)(Cl)Cl',
+            'dichloromethane': 'C(Cl)Cl',
+            'toluene': 'Cc1ccccc1',
+            'benzene': 'c1ccccc1',
+            'hexane': 'CCCCCC',
+            'ether': 'CCOCC',
+            'diethyl ether': 'CCOCC',
+            'thf': 'C1CCOC1',
+            'tetrahydrofuran': 'C1CCOC1',
+            'dioxane': 'C1COCCO1',
+            'acetonitrile': 'CC#N',
+            'pyridine': 'c1ccncc1'
+        }
+        
+        converted_solvents = []
+        for solvent in parsed_solvents:
+            solvent_lower = solvent.lower().strip()
+            if solvent_lower in solvent_name_to_smiles:
+                converted_solvents.append(solvent_name_to_smiles[solvent_lower])
+            else:
+                # Assume it's already a SMILES string or use as-is
+                converted_solvents.append(solvent)
+        parsed_solvents = converted_solvents
+        
+        # Validate the final solvent SMILES to catch issues early
+        try:
+            from rdkit import Chem
+            for i, solvent_smiles in enumerate(parsed_solvents):
+                mol = Chem.MolFromSmiles(solvent_smiles)
+                if mol is None:
+                    raise ValueError(f"Invalid solvent SMILES: '{solvent_smiles}' at position {i}")
+        except ImportError:
+            # RDKit not available for validation, proceed anyway
+            pass
+    
+    # Parse temperatures parameter - handle string input
+    parsed_temperatures = None
+    if temperatures:
+        # Handle various string formats
+        temperatures = temperatures.strip()
+        if temperatures.startswith('[') and temperatures.endswith(']'):
+            # JSON array format like '[298.15, 310.15]'
+            try:
+                parsed_temperatures = json.loads(temperatures)
+            except (json.JSONDecodeError, ValueError):
+                # Failed to parse as JSON, try as comma-separated
+                temperatures = temperatures.strip('[]').replace('"', '').replace("'", "")
+                parsed_temperatures = [float(t.strip()) for t in temperatures.split(',') if t.strip()]
+        elif ',' in temperatures:
+            # Comma-separated format like '298.15, 310.15'
+            parsed_temperatures = [float(t.strip()) for t in temperatures.split(',') if t.strip()]
+        else:
+            # Single temperature as string like '298.15'
+            parsed_temperatures = [float(temperatures)]
+    
+    # Validate the main SMILES string early to catch issues
+    try:
+        from rdkit import Chem
+        mol = Chem.MolFromSmiles(initial_smiles)
+        if mol is None:
+            raise ValueError(f"Invalid initial SMILES: '{initial_smiles}'")
+    except ImportError:
+        # RDKit not available for validation, proceed anyway
+        pass
+    
+    try:
+        result = rowan.submit_solubility_workflow(
+            initial_smiles=initial_smiles,
+            solvents=parsed_solvents,
+            temperatures=parsed_temperatures,
+            name=name,
+            folder_uuid=folder_uuid if folder_uuid else None,
+            max_credits=max_credits if max_credits > 0 else None
+        )
+        
+        return result
+        
+    except Exception as e:
+        # Re-raise the exception so MCP can handle it
+        raise

rowan_mcp/functions_v2/submit_tautomer_search_workflow.py

@@ -0,0 +1,51 @@
+"""
+Rowan v2 API: Tautomer Search Workflow
+Search for tautomeric forms of molecules.
+"""
+
+from typing import Annotated
+import rowan
+import stjames
+
+def submit_tautomer_search_workflow(
+    initial_molecule: Annotated[str, "SMILES string to search for tautomers"],
+    mode: Annotated[str, "Search mode: 'rapid' (fast), 'careful' (balanced), or 'meticulous' (thorough)"] = "careful",
+    name: Annotated[str, "Workflow name for identification and tracking"] = "Tautomer Search Workflow",
+    folder_uuid: Annotated[str, "UUID of folder to organize this workflow. Empty string uses default folder"] = "",
+    max_credits: Annotated[int, "Maximum credits to spend on this calculation. 0 for no limit"] = 0
+):
+    """Submit a tautomer search workflow using Rowan v2 API.
+    
+    Args:
+        initial_molecule: SMILES string to search for tautomers
+        mode: Search mode: 'rapid' (fast), 'careful' (balanced), or 'meticulous' (thorough)
+        name: Workflow name for identification and tracking
+        folder_uuid: UUID of folder to organize this workflow. Empty string uses default folder.
+        max_credits: Maximum credits to spend on this calculation. 0 for no limit.
+    
+    Searches for different tautomeric forms of a molecule and evaluates their
+    relative stabilities. Tautomers are structural isomers that readily interconvert.
+    
+    Returns:
+        Workflow object representing the submitted workflow
+        
+    Example:
+        # Basic tautomer search
+        result = submit_tautomer_search_workflow(
+            initial_molecule="CC(=O)CC(=O)C"
+        )
+        
+        # Meticulous search for complex molecule
+        result = submit_tautomer_search_workflow(
+            initial_molecule="c1ccc2c(c1)ncc(=O)[nH]2",
+            mode="meticulous"
+        )
+    """
+    
+    return rowan.submit_tautomer_search_workflow(
+        initial_molecule=stjames.Molecule.from_smiles(initial_molecule),
+        mode=mode,
+        name=name,
+        folder_uuid=folder_uuid if folder_uuid else None,
+        max_credits=max_credits if max_credits > 0 else None
+    )