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

rowan_mcp/functions_v2/protein_management.py

@@ -0,0 +1,141 @@
+"""
+Rowan v2 API: Protein Management
+Tools for creating, retrieving, and managing protein structures.
+"""
+
+from typing import List, Dict, Any, Annotated
+import rowan
+
+
+def create_protein_from_pdb_id(
+    name: Annotated[str, "Name for the protein"],
+    code: Annotated[str, "PDB ID code (e.g., '1HCK')"]
+) -> Dict[str, Any]:
+    """Create a protein from a PDB ID.
+    
+    Args:
+        name: Name for the protein
+        code: PDB ID code (e.g., '1HCK')
+    
+    Returns:
+        Dictionary containing protein information
+    """
+    protein = rowan.create_protein_from_pdb_id(name=name, code=code)
+    
+    return {
+        "uuid": protein.uuid,
+        "name": protein.name,
+        "sanitized": protein.sanitized,
+        "created_at": str(protein.created_at) if protein.created_at else None
+    }
+
+
+def retrieve_protein(
+    uuid: Annotated[str, "UUID of the protein to retrieve"]
+) -> Dict[str, Any]:
+    """Retrieve a protein by UUID.
+    
+    Args:
+        uuid: UUID of the protein to retrieve
+    
+    Returns:
+        Dictionary containing the protein data
+    """
+    protein = rowan.retrieve_protein(uuid)
+    
+    return {
+        "uuid": protein.uuid,
+        "name": protein.name,
+        "sanitized": protein.sanitized,
+        "created_at": str(protein.created_at) if protein.created_at else None
+    }
+
+
+def list_proteins(
+    page: Annotated[int, "Page number (0-indexed)"] = 0,
+    size: Annotated[int, "Number per page"] = 20
+) -> List[Dict[str, Any]]:
+    """List proteins.
+    
+    Args:
+        page: Page number (0-indexed)
+        size: Number per page
+    
+    Returns:
+        List of protein dictionaries
+    """
+    proteins = rowan.list_proteins(page=page, size=size)
+    
+    return [
+        {
+            "uuid": p.uuid,
+            "name": p.name,
+            "sanitized": p.sanitized,
+            "created_at": str(p.created_at) if p.created_at else None
+        }
+        for p in proteins
+    ]
+
+
+def upload_protein(
+    name: Annotated[str, "Name for the protein"],
+    file_path: Annotated[str, "Path to PDB file"]
+) -> Dict[str, Any]:
+    """Upload a protein from a PDB file.
+    
+    Args:
+        name: Name for the protein
+        file_path: Path to PDB file
+    
+    Returns:
+        Dictionary containing protein information
+    """
+    from pathlib import Path
+    protein = rowan.upload_protein(name=name, file_path=Path(file_path))
+    
+    return {
+        "uuid": protein.uuid,
+        "name": protein.name,
+        "sanitized": protein.sanitized,
+        "created_at": str(protein.created_at) if protein.created_at else None
+    }
+
+
+def delete_protein(
+    uuid: Annotated[str, "UUID of the protein to delete"]
+) -> Dict[str, str]:
+    """Delete a protein.
+    
+    Args:
+        uuid: UUID of the protein to delete
+    
+    Returns:
+        Dictionary with confirmation message
+    """
+    protein = rowan.retrieve_protein(uuid)
+    protein.delete()
+    
+    return {
+        "message": f"Protein {uuid} deleted",
+        "uuid": uuid
+    }
+
+
+def sanitize_protein(
+    uuid: Annotated[str, "UUID of the protein to sanitize"]
+) -> Dict[str, Any]:
+    """Sanitize a protein for docking.
+    
+    Args:
+        uuid: UUID of the protein to sanitize
+    
+    Returns:
+        Dictionary with sanitization status
+    """
+    protein = rowan.retrieve_protein(uuid)
+    protein.sanitize()
+    
+    return {
+        "uuid": uuid,
+        "message": f"Protein {uuid} sanitized"
+    }

rowan_mcp/functions_v2/submit_basic_calculation_workflow.py

@@ -0,0 +1,195 @@
+"""
+Rowan v2 API: Basic Calculation Workflow
+Submit basic quantum chemistry calculations with various methods and tasks.
+"""
+
+# Simplified imports - no complex typing needed
+from typing import Annotated
+import rowan
+import stjames
+import json
+
+
+def submit_basic_calculation_workflow(
+    initial_molecule: Annotated[str, "SMILES string or molecule JSON for quantum chemistry calculation"],
+    method: Annotated[str, "Computational method (e.g., 'gfn2-xtb', 'uma_m_omol', 'b3lyp-d3bj')"] = "uma_m_omol",
+    tasks: Annotated[str, "JSON array or comma-separated list of tasks (e.g., '[\"optimize\"]', 'optimize, frequencies')"] = "",
+    mode: Annotated[str, "Calculation mode: 'rapid', 'careful', 'meticulous', or 'auto'"] = "auto", 
+    engine: Annotated[str, "Computational engine: 'omol25', 'xtb', 'psi4'"] = "omol25",
+    name: Annotated[str, "Workflow name for identification and tracking"] = "Basic Calculation 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 basic calculation workflow using Rowan v2 API.
+    
+    Performs fundamental quantum chemistry calculations with configurable methods
+    and computational tasks. Returns a workflow object for tracking progress.
+    
+    Examples:
+        # Simple water optimization with GFN2-xTB
+        result = submit_basic_calculation_workflow(
+            initial_molecule="O",
+            method="gfn2-xtb",
+            tasks=["optimize"],
+            engine="xtb",
+            name="Water Optimization"
+        )
+        
+        # Butane optimization from SMILES
+        result = submit_basic_calculation_workflow(
+            initial_molecule="CCCC",
+            method="gfn2-xtb",
+            tasks=["optimize"],
+            mode="rapid",
+            engine="xtb",
+            name="Butane Optimization"
+        )
+        
+        # Using a molecule dict (from data.json)
+        molecule_dict = {
+            "smiles": "CCCC",
+            "charge": 0,
+            "multiplicity": 1,
+            "atoms": [...]  # atomic positions
+        }
+        result = submit_basic_calculation_workflow(
+            initial_molecule=molecule_dict,
+            method="gfn2-xtb",
+            tasks=["optimize"],
+            engine="xtb"
+        )
+    """
+    
+    # Parse tasks parameter - handle string input
+    parsed_tasks = None
+    if tasks:  # If not empty string
+        tasks = tasks.strip()
+        if tasks.startswith('[') and tasks.endswith(']'):
+            # JSON array format like '["optimize"]'
+            try:
+                parsed_tasks = json.loads(tasks)
+            except (json.JSONDecodeError, ValueError):
+                # Failed to parse as JSON, try as comma-separated
+                tasks = tasks.strip('[]').replace('"', '').replace("'", "")
+                parsed_tasks = [t.strip() for t in tasks.split(',') if t.strip()]
+        elif ',' in tasks:
+            # Comma-separated format like 'optimize, frequencies'  
+            parsed_tasks = [t.strip() for t in tasks.split(',') if t.strip()]
+        else:
+            # Single task as string like 'optimize'
+            parsed_tasks = [tasks]
+    
+    
+    try:
+        # Handle initial_molecule parameter - could be JSON string, SMILES, or dict
+        if isinstance(initial_molecule, str):
+            # Check if it's a JSON string (starts with { or [)
+            initial_molecule_str = initial_molecule.strip()
+            if (initial_molecule_str.startswith('{') and initial_molecule_str.endswith('}')) or \
+               (initial_molecule_str.startswith('[') and initial_molecule_str.endswith(']')):
+                try:
+                    # Parse the JSON string to dict
+                    initial_molecule = json.loads(initial_molecule_str)
+                    
+                    # Now handle as dict (fall through to dict handling below)
+                    if isinstance(initial_molecule, dict) and 'smiles' in initial_molecule:
+                        smiles = initial_molecule.get('smiles')
+                        if smiles:
+                            try:
+                                initial_molecule = stjames.Molecule.from_smiles(smiles)
+                            except Exception as e:
+                                initial_molecule = smiles
+                except (json.JSONDecodeError, ValueError) as e:
+                    # Not valid JSON, treat as SMILES string
+                    try:
+                        initial_molecule = stjames.Molecule.from_smiles(initial_molecule)
+                    except Exception as e:
+                        pass
+            else:
+                # Regular SMILES string
+                try:
+                    initial_molecule = stjames.Molecule.from_smiles(initial_molecule)
+                except Exception as e:
+                    pass
+        elif isinstance(initial_molecule, dict) and 'smiles' in initial_molecule:
+            # If we have a dict with SMILES, extract and use just the SMILES
+            smiles = initial_molecule.get('smiles')
+            if smiles:
+                try:
+                    initial_molecule = stjames.Molecule.from_smiles(smiles)
+                except Exception as e:
+                    initial_molecule = smiles
+        
+        # Convert to appropriate format
+        if hasattr(initial_molecule, 'model_dump'):
+            initial_molecule_dict = initial_molecule.model_dump()
+        elif isinstance(initial_molecule, dict):
+            initial_molecule_dict = initial_molecule
+        else:
+            # Try to convert to StJamesMolecule if it's a string
+            try:
+                mol = stjames.Molecule.from_smiles(str(initial_molecule))
+                initial_molecule_dict = mol.model_dump()
+            except:
+                # If that fails, pass as-is
+                initial_molecule_dict = initial_molecule
+        
+        # Convert method string to Method object to get the correct name
+        if isinstance(method, str):
+            # Handle common method name variations
+            method_map = {
+                'gfn2_xtb': 'gfn2-xtb',
+                'gfn1_xtb': 'gfn1-xtb',
+                'gfn0_xtb': 'gfn0-xtb',
+                'r2scan_3c': 'r2scan-3c',
+                'wb97x_d3': 'wb97x-d3',
+                'wb97m_d3bj': 'wb97m-d3bj',
+                'b3lyp_d3bj': 'b3lyp-d3bj',
+                'uma_m_omol': 'uma_m_omol',  # This one stays the same
+            }
+            method = method_map.get(method, method)
+            
+            try:
+                method_obj = stjames.Method(method)
+                method_name = method_obj.name
+            except:
+                # If Method conversion fails, use the string as-is
+                method_name = method
+        else:
+            method_name = method
+        
+        # Use parsed tasks or default
+        final_tasks = parsed_tasks if parsed_tasks else ["optimize"]
+        
+        # Build workflow_data following the official API structure
+        workflow_data = {
+            "settings": {
+                "method": method_name,
+                "tasks": final_tasks,
+                "mode": mode,
+            },
+            "engine": engine,
+        }
+        
+        # Build the API request
+        data = {
+            "name": name,
+            "folder_uuid": folder_uuid if folder_uuid else None,
+            "workflow_type": "basic_calculation", 
+            "workflow_data": workflow_data,
+            "initial_molecule": initial_molecule_dict,
+            "max_credits": max_credits if max_credits > 0 else None,
+        }
+        
+        # Submit directly to API
+        from rowan.utils import api_client
+        from rowan import Workflow
+        
+        with api_client() as client:
+            response = client.post("/workflow", json=data)
+            response.raise_for_status()
+            return Workflow(**response.json())
+        
+    except Exception as e:
+        # Re-raise the exception so MCP can handle it
+        raise

rowan_mcp/functions_v2/submit_conformer_search_workflow.py

@@ -0,0 +1,158 @@
+"""
+Rowan v2 API: Conformer Search Workflow
+Search for low-energy molecular conformations using various methods.
+"""
+
+from typing import Any, Dict, Annotated
+import rowan
+import stjames
+
+def submit_conformer_search_workflow(
+    initial_molecule: Annotated[str, "SMILES string representing the initial structure"],
+    conf_gen_mode: Annotated[str, "Conformer generation mode: 'rapid' (fast), 'careful' (balanced), or 'meticulous' (thorough)"] = "rapid",
+    final_method: Annotated[str, "Final optimization method (e.g., 'aimnet2_wb97md3', 'r2scan_3c', 'wb97x-d3_def2-tzvp')"] = "aimnet2_wb97md3",
+    solvent: Annotated[str, "Solvent for implicit solvation (SMILES or name). Empty string for vacuum"] = "",
+    transition_state: Annotated[bool, "Whether to search for transition state conformers"] = False,
+    name: Annotated[str, "Workflow name for identification and tracking"] = "Conformer 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 conformer search workflow using Rowan v2 API.
+    
+    Args:
+        initial_molecule: SMILES string representing the initial structure
+        conf_gen_mode: Conformer generation mode: 'rapid' (fast), 'careful' (balanced), or 'meticulous' (thorough)
+        final_method: Final optimization method (e.g., 'aimnet2_wb97md3', 'r2scan_3c', 'wb97x-d3_def2-tzvp')
+        solvent: Solvent for implicit solvation (e.g., 'water', 'ethanol', 'dmso'). Empty string for gas phase.
+        transition_state: Whether to search for transition state conformers
+        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.
+    
+    Conformer Generation Modes:
+    - 'rapid': RDKit/MMFF, 300 conformers, 0.10 Å RMSD cutoff (recommended for most work)
+    - 'careful': CREST/GFN-FF quick mode, 150 conformers max
+    - 'meticulous': CREST/GFN2-xTB normal mode, 500 conformers max
+    
+    Returns:
+        Workflow object representing the submitted workflow
+        
+    Examples:
+        # Simple diethyl ether conformer search
+        result = submit_conformer_search_workflow(
+            initial_molecule="CCOCC"
+        )
+        
+        # Basic butane conformer search with rapid mode
+        result = submit_conformer_search_workflow(
+            initial_molecule="CCCC",
+            conf_gen_mode="rapid"
+        )
+        
+        # Careful search with solvent
+        result = submit_conformer_search_workflow(
+            initial_molecule="CC(C)CC(=O)O",
+            conf_gen_mode="careful",
+            solvent="water",
+            final_method="r2scan_3c"
+        )
+    """
+
+    try:
+        # Convert initial_molecule to appropriate format
+        if isinstance(initial_molecule, str):
+            # Try to parse as SMILES
+            try:
+                mol = stjames.Molecule.from_smiles(initial_molecule)
+                initial_molecule = mol.model_dump()
+            except Exception:
+                # If fails, pass as dict with smiles
+                initial_molecule = {"smiles": initial_molecule}
+        elif isinstance(initial_molecule, dict):
+            # Already in dict format
+            pass
+        elif hasattr(initial_molecule, 'model_dump'):
+            # StJamesMolecule
+            initial_molecule = initial_molecule.model_dump()
+        else:
+            # Assume RdkitMol or similar
+            try:
+                from rdkit import Chem
+                mol = stjames.Molecule.from_rdkit(initial_molecule, cid=0)
+                initial_molecule = mol.model_dump()
+            except:
+                pass
+        
+        # Convert final_method to Method if it's a string
+        if isinstance(final_method, str):
+            final_method = stjames.Method(final_method)
+        
+        # Determine solvent model based on method
+        solvent_model = None
+        if solvent:
+            solvent_model = "alpb" if final_method in stjames.XTB_METHODS else "cpcm"
+        
+        # Create optimization settings following official API
+        opt_settings = stjames.Settings(
+            method=final_method,
+            tasks=["optimize"],
+            mode=stjames.Mode.AUTO,
+            solvent_settings={"solvent": solvent, "model": solvent_model} if solvent else None,
+            opt_settings={"transition_state": transition_state, "constraints": []},
+        )
+        
+        # Create MultiStageOptSettings
+        msos = stjames.MultiStageOptSettings(
+            mode=stjames.Mode.MANUAL,
+            xtb_preopt=True,
+            optimization_settings=[opt_settings],
+        )
+        
+        # Convert to dict and fix the soscf field
+        msos_dict = msos.model_dump()
+        
+        # Fix soscf: convert boolean to string enum
+        if 'optimization_settings' in msos_dict:
+            for opt_setting in msos_dict['optimization_settings']:
+                if 'scf_settings' in opt_setting and 'soscf' in opt_setting['scf_settings']:
+                    soscf_val = opt_setting['scf_settings']['soscf']
+                    if isinstance(soscf_val, bool):
+                        if soscf_val is False:
+                            opt_setting['scf_settings']['soscf'] = 'never'
+                        elif soscf_val is True:
+                            opt_setting['scf_settings']['soscf'] = 'always'
+                    elif soscf_val is None:
+                        # Default to smart behavior
+                        opt_setting['scf_settings']['soscf'] = 'upon_failure'
+        
+        # Build workflow_data
+        workflow_data = {
+            "multistage_opt_settings": msos_dict,
+            "conf_gen_mode": conf_gen_mode,
+            "mso_mode": "manual",
+            "solvent": solvent if solvent else None,
+            "transition_state": transition_state,
+        }
+        
+        # Build the API request
+        data = {
+            "name": name,
+            "folder_uuid": folder_uuid if folder_uuid else None,
+            "workflow_type": "conformer_search",
+            "workflow_data": workflow_data,
+            "initial_molecule": initial_molecule,
+            "max_credits": max_credits if max_credits > 0 else None,
+        }
+        
+        # Submit to API
+        from rowan.utils import api_client
+        from rowan import Workflow
+        
+        with api_client() as client:
+            response = client.post("/workflow", json=data)
+            response.raise_for_status()
+            return Workflow(**response.json())
+        
+    except Exception as e:
+        # Re-raise the exception so MCP can handle it
+        raise e

rowan_mcp/functions_v2/submit_descriptors_workflow.py

@@ -0,0 +1,52 @@
+"""
+Rowan v2 API: Descriptors Workflow
+Calculate molecular descriptors for QSAR and molecular analysis.
+"""
+
+from typing import Annotated
+import rowan
+import stjames
+
+
+def submit_descriptors_workflow(
+    initial_molecule: Annotated[str, "SMILES string of the molecule to calculate descriptors for"],
+    name: Annotated[str, "Workflow name for identification and tracking"] = "Descriptors 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 molecular descriptors calculation workflow using Rowan v2 API.
+    
+    Args:
+        initial_molecule: SMILES string or molecule object for descriptor calculation
+        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 a comprehensive set of molecular descriptors including:
+    - Physical properties (MW, logP, TPSA, etc.)
+    - Electronic properties (HOMO/LUMO, dipole moment, etc.)
+    - Structural features (rotatable bonds, H-bond donors/acceptors, etc.)
+    - Topological indices
+    
+    Returns:
+        Workflow object representing the submitted workflow
+        
+    Example:
+        # Basic descriptor calculation
+        result = submit_descriptors_workflow(
+            initial_molecule="CC(=O)Nc1ccc(O)cc1"
+        )
+        
+        # For complex molecule
+        result = submit_descriptors_workflow(
+            initial_molecule="CN1C=NC2=C1C(=O)N(C(=O)N2C)C",
+            name="Caffeine Descriptors"
+        )
+    """
+    
+    return rowan.submit_descriptors_workflow(
+        initial_molecule=stjames.Molecule.from_smiles(initial_molecule),
+        name=name,
+        folder_uuid=folder_uuid if folder_uuid else None,
+        max_credits=max_credits if max_credits > 0 else None
+    )