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

rowan_mcp/functions/molecular_dynamics.py

@@ -1,191 +0,0 @@
-"""
-Rowan molecular dynamics function for MCP tool integration.
-"""
-
-from typing import Any, Dict, List, Optional
-import rowan
-
-def rowan_molecular_dynamics(
-    name: str,
-    molecule: str,
-    ensemble: str = "nvt",
-    initialization: str = "random",
-    timestep: float = 1.0,
-    num_steps: int = 500,
-    save_interval: int = 10,
-    temperature: float = 300.0,
-    pressure: Optional[float] = None,
-    langevin_thermostat_timescale: float = 100.0,
-    berendsen_barostat_timescale: float = 1000.0,
-    constraints: Optional[List[Dict[str, Any]]] = None,
-    confining_constraint: Optional[Dict[str, Any]] = None,
-    # Calculation settings parameters
-    method: Optional[str] = None,
-    basis_set: Optional[str] = None,
-    engine: Optional[str] = None,
-    charge: int = 0,
-    multiplicity: int = 1,
-    # Workflow control parameters
-    folder_uuid: Optional[str] = None,
-    blocking: bool = True,
-    ping_interval: int = 5
-) -> str:
-    """Run molecular dynamics simulations following Rowan's MolecularDynamicsWorkflow.
-    
-    Performs MD simulations to study molecular dynamics, conformational sampling, 
-    and thermal properties using various thermodynamic ensembles.
-    
-    Args:
-        name: Name for the calculation
-        molecule: Molecule SMILES string or common name
-        ensemble: Thermodynamic ensemble ("nvt", "npt", "nve")
-        initialization: Initial velocities ("random", "quasiclassical", "read")
-        timestep: Integration timestep in femtoseconds
-        num_steps: Number of MD steps to run
-        save_interval: Save trajectory every N steps
-        temperature: Temperature in Kelvin
-        pressure: Pressure in atm (required for NPT)
-        langevin_thermostat_timescale: Thermostat coupling timescale in fs
-        berendsen_barostat_timescale: Barostat coupling timescale in fs
-        constraints: List of pairwise harmonic constraints
-        confining_constraint: Spherical harmonic constraint
-        method: QM method for force calculation
-        basis_set: Basis set for force calculation
-        engine: Computational engine for force calculation
-        charge: Molecular charge
-        multiplicity: Spin multiplicity
-        folder_uuid: Optional folder UUID for organization
-        blocking: Whether to wait for completion
-        ping_interval: Check status interval in seconds
-    
-    Example:
-        result = rowan_molecular_dynamics(
-            name="ethanol_md_simulation",
-            molecule="ethanol",
-            ensemble="NVT",
-            temperature=298,
-            num_steps=1000,
-            blocking=False
-        )
-    
-    Returns:
-        Molecular dynamics workflow result
-    """
-    # Parameter validation
-    valid_ensembles = ["nvt", "npt", "nve"]
-    valid_initializations = ["random", "quasiclassical", "read"]
-    
-    # Validate ensemble
-    ensemble_lower = ensemble.lower()
-    if ensemble_lower not in valid_ensembles:
-        return f" Error: Invalid ensemble '{ensemble}'. Valid options: {', '.join(valid_ensembles)}"
-    
-    # Validate initialization
-    initialization_lower = initialization.lower()
-    if initialization_lower not in valid_initializations:
-        return f" Error: Invalid initialization '{initialization}'. Valid options: {', '.join(valid_initializations)}"
-    
-    # Validate numeric parameters
-    if timestep <= 0:
-        return f" Error: timestep must be positive (got {timestep})"
-    if num_steps <= 0:
-        return f" Error: num_steps must be positive (got {num_steps})"
-    if save_interval <= 0:
-        return f" Error: save_interval must be positive (got {save_interval})"
-    if temperature <= 0:
-        return f" Error: temperature must be positive (got {temperature})"
-    
-    # Validate NPT ensemble requirements
-    if ensemble_lower == "npt" and pressure is None:
-        return f" Error: NPT ensemble requires pressure to be specified"
-    if pressure is not None and pressure <= 0:
-        return f" Error: pressure must be positive (got {pressure})"
-    
-    # Convert molecule name to SMILES using lookup system
-    try:
-        from .molecule_lookup import get_lookup_instance
-        lookup = get_lookup_instance()
-        smiles, source, metadata = lookup.get_smiles(molecule)
-        if smiles:
-            resolved_smiles = smiles
-        else:
-            resolved_smiles = molecule  # Fallback to original
-    except Exception:
-        resolved_smiles = molecule  # Fallback if lookup fails
-    
-    # Apply smart defaults for MD calculations
-    if engine is None:
-        engine = "xtb"  # Default to xTB for fast MD forces
-    if method is None and engine.lower() == "xtb":
-        method = "gfn2-xtb"  # Default xTB method
-    elif method is None and engine.lower() != "xtb":
-        method = "b3lyp"  # Default DFT method for other engines
-    if basis_set is None and engine.lower() != "xtb":
-        basis_set = "def2-svp"  # Default basis set for non-xTB engines
-    
-    # Build MD settings
-    md_settings = {
-        "ensemble": ensemble_lower,
-        "initialization": initialization_lower,
-        "timestep": timestep,
-        "num_steps": num_steps,
-        "save_interval": save_interval,
-        "temperature": temperature,
-        "langevin_thermostat_timescale": langevin_thermostat_timescale,
-        "berendsen_barostat_timescale": berendsen_barostat_timescale,
-    }
-    
-    # Add optional fields if provided
-    if pressure is not None:
-        md_settings["pressure"] = pressure
-    
-    if constraints:
-        md_settings["constraints"] = constraints
-        
-    if confining_constraint:
-        md_settings["confining_constraint"] = confining_constraint
-    
-    # Build calc_settings
-    calc_settings = {
-        "charge": charge,
-        "multiplicity": multiplicity,
-        "engine": engine.lower()
-    }
-    
-    # Add method if specified
-    if method:
-        calc_settings["method"] = method.lower()
-    
-    # Add basis_set if specified (not needed for xTB)
-    if basis_set and engine.lower() != "xtb":
-        calc_settings["basis_set"] = basis_set.lower()
-    
-    # Build parameters for Rowan API
-    workflow_params = {
-        "name": name,
-        "molecule": resolved_smiles,
-        "workflow_type": "molecular_dynamics",
-        "settings": md_settings,
-        "calc_settings": calc_settings,
-        "folder_uuid": folder_uuid,
-        "blocking": blocking,
-        "ping_interval": ping_interval
-    }
-    
-    # Add calc_engine at top level
-    if engine:
-        workflow_params["calc_engine"] = engine.lower()
-    
-    try:
-        # Submit molecular dynamics calculation to Rowan
-        result = rowan.compute(**workflow_params)
-        return str(result)
-    except Exception as e:
-        error_response = {
-            "success": False,
-            "error": f"Molecular dynamics calculation failed: {str(e)}",
-            "name": name,
-            "molecule": molecule,
-            "resolved_smiles": resolved_smiles
-        }
-        return str(error_response)

rowan_mcp/functions/molecule_lookup.py

@@ -1,57 +0,0 @@
-from urllib.request import urlopen
-from urllib.parse import quote
-
-
-def CIRconvert(ids):
-    """
-    Convert molecule name/identifier to SMILES using Chemical Identifier Resolver.
-    
-    Args:
-        ids (str): Molecule name or identifier (e.g., 'Aspirin', '3-Methylheptane', CAS numbers)
-    
-    Returns:
-        str: SMILES string if found, 'Did not work' if failed
-    """
-    try:
-        url = 'http://cactus.nci.nih.gov/chemical/structure/' + quote(ids) + '/smiles'
-        ans = urlopen(url).read().decode('utf8')
-        return ans
-    except:
-        return 'Did not work'
-
-
-def rowan_molecule_lookup(molecule_name: str) -> str:
-    """
-    Convert a molecule name to SMILES using Chemical Identifier Resolver.
-    
-    Args:
-        molecule_name (str): Name of the molecule (e.g., 'aspirin', 'benzene')
-    
-    Returns:
-        str: SMILES notation, or error message if not found
-    """
-    smiles = CIRconvert(molecule_name)
-    
-    if smiles == 'Did not work':
-        return f"{molecule_name}: Not found"
-    else:
-        return smiles.strip()  # Remove any trailing newlines
-
-
-def batch_convert(identifiers):
-    """
-    Convert multiple molecule identifiers to SMILES.
-    
-    Args:
-        identifiers (list): List of molecule names/identifiers
-    
-    Returns:
-        dict: Dictionary mapping identifiers to SMILES
-    """
-    results = {}
-    
-    for ids in identifiers:
-        results[ids] = CIRconvert(ids)
-    
-    return results 
-

rowan_mcp/functions/multistage_opt.py

@@ -1,171 +0,0 @@
-"""
-Rowan multistage optimization function for geometry optimization.
-"""
-
-import os
-import logging
-import time
-from typing import Optional, List, Dict, Any
-
-try:
-    import rowan
-except ImportError:
-    rowan = None
-
-# Setup logging
-logger = logging.getLogger(__name__)
-
-# Setup API key
-api_key = os.getenv("ROWAN_API_KEY")
-if rowan and api_key:
-    rowan.api_key = api_key
-
-def log_rowan_api_call(workflow_type: str, **kwargs):
-    """Log Rowan API calls with detailed parameters."""
-    
-    # Special handling for long-running calculations
-    if workflow_type in ["multistage_opt", "conformer_search"]:
-        ping_interval = kwargs.get('ping_interval', 5)
-        blocking = kwargs.get('blocking', True)
-        if blocking:
-            if workflow_type == "multistage_opt":
-                logger.info(f" Multi-stage optimization may take several minutes...")
-            else:
-                logger.info(f" Conformer search may take several minutes...")
-            logger.info(f" Progress will be checked every {ping_interval} seconds")
-        else:
-            logger.info(f" {workflow_type.replace('_', ' ').title()} submitted without waiting")
-    
-    try:
-        start_time = time.time()
-        result = rowan.compute(workflow_type=workflow_type, **kwargs)
-        api_time = time.time() - start_time
-        
-        if isinstance(result, dict) and 'uuid' in result:
-            job_status = result.get('status', result.get('object_status', 'Unknown'))
-            status_names = {0: "Queued", 1: "Running", 2: "Completed", 3: "Failed", 4: "Stopped", 5: "Awaiting Queue"}
-            status_text = status_names.get(job_status, f"Unknown ({job_status})")
-        
-        return result
-        
-    except Exception as e:
-        api_time = time.time() - start_time
-        raise e
-
-def rowan_multistage_opt(
-    name: str,
-    molecule: str,
-    mode: str = "rapid",
-    solvent: Optional[str] = None,
-    xtb_preopt: bool = False,
-    constraints: Optional[List[Dict[str, Any]]] = None,
-    transition_state: bool = False,
-    frequencies: bool = False,
-    folder_uuid: Optional[str] = None,
-    blocking: bool = True,
-    ping_interval: int = 30
-) -> str:
-    """Run multi-level geometry optimization using stjames MultiStageOptWorkflow.
-    
-    Performs hierarchical optimization using multiple levels of theory based on mode. There are only four valid modes:
-    
-    **RAPID** (default): GFN2-xTB optimization → r²SCAN-3c single point
-    **RECKLESS**: GFN-FF optimization → GFN2-xTB single point  
-    **CAREFUL**: GFN2-xTB preopt → r²SCAN-3c optimization → ωB97X-3c single point
-    **METICULOUS**: GFN2-xTB preopt → r²SCAN-3c opt → ωB97X-3c opt → ωB97M-D3BJ/def2-TZVPPD single point
-    
-    This follows the exact stjames MultiStageOptWorkflow implementation for:
-    - High accuracy final structures
-    - Efficient computational cost  
-    - Reliable convergence across chemical space
-    
-    Args:
-        name: Name for the calculation
-        molecule: Molecule SMILES string
-        mode: Optimization mode - "rapid", "reckless", "careful", or "meticulous" (default: "rapid")
-        solvent: Solvent for single point calculation (e.g., "water", "dmso", "acetone")
-        xtb_preopt: Whether to include xTB pre-optimization step (default: False)
-        constraints: List of optimization constraints (default: None)
-        transition_state: Whether this is a transition state optimization (default: False)
-        frequencies: Whether to calculate vibrational frequencies (default: False)
-        folder_uuid: Optional folder UUID for organization
-        blocking: Whether to wait for completion (default: True)
-        ping_interval: Check status interval in seconds (default: 30)
-    
-    Returns:
-        Comprehensive optimization results following MultiStageOptWorkflow format
-        
-    Example:
-        # Basic optimization
-        result = rowan_multistage_opt("aspirin_opt", "CC(=O)Oc1ccccc1C(=O)O")
-        
-        # With solvent and frequency analysis
-        result = rowan_multistage_opt(
-            "aspirin_water", 
-            "CC(=O)Oc1ccccc1C(=O)O",
-            mode="careful",
-            solvent="water",
-            frequencies=True
-        )
-    """
-    
-    # Validate mode parameter - only allow Rowan's supported modes
-    valid_modes = ["rapid", "reckless", "careful", "meticulous"]
-    if mode.lower() not in valid_modes:
-        error_msg = f"Invalid mode '{mode}'. Must be one of: {', '.join(valid_modes)}"
-        logger.error(f"Mode validation failed: {error_msg}")
-        return f"Error: {error_msg}"
-    
-    # Prepare parameters following stjames MultiStageOptWorkflow structure
-    params = {
-        "name": name,
-        "molecule": molecule,
-        "initial_molecule": molecule,  # Required by MultiStageOptWorkflow
-        "mode": mode.lower(),
-        "folder_uuid": folder_uuid,
-        "blocking": blocking,
-        "ping_interval": ping_interval
-    }
-    
-    # Add optional parameters if specified
-    if solvent:
-        params["solvent"] = solvent
-        
-    if xtb_preopt:
-        params["xtb_preopt"] = xtb_preopt
-        
-    if constraints:
-        params["constraints"] = constraints
-        
-    if transition_state:
-        params["transition_state"] = transition_state
-        
-    if frequencies:
-        params["frequencies"] = frequencies
-    
-    # Submit to Rowan using multistage_opt workflow
-    result = log_rowan_api_call(
-        workflow_type="multistage_opt",
-        **params
-    )
-    return str(result)
-
-def test_rowan_multistage_opt():
-    """Test the rowan_multistage_opt function with stjames parameters."""
-    try:
-        # Test with stjames-compatible parameters
-        result = rowan_multistage_opt(
-            name="test_stjames_opt", 
-            molecule="CCO", 
-            mode="rapid",
-            blocking=False
-        )
-        print("✅ Multistage optimization test successful!")
-        print(f"Result length: {len(result)} characters")
-        return True
-    except Exception as e:
-        print(f"Multistage optimization test failed: {e}")
-        return False
-
-if __name__ == "__main__":
-    test_rowan_multistage_opt() 

rowan_mcp/functions/pdb_handler.py

@@ -1,200 +0,0 @@
-"""
-PDB handler for Rowan docking - attempts to handle PDB input intelligently
-"""
-
-import os
-import logging
-import requests
-from typing import Optional, Dict, Any, Tuple
-import rowan
-
-logger = logging.getLogger(__name__)
-
-def parse_pdb_content(pdb_content: str) -> Dict[str, Any]:
-    """
-    Parse PDB content into a structured format that might work with Rowan.
-    
-    This attempts to extract key information from PDB files that the 
-    Rowan API might accept.
-    """
-    lines = pdb_content.split('\n')
-    
-    # Extract basic information
-    header = ""
-    title = ""
-    atoms = []
-    
-    for line in lines:
-        if line.startswith("HEADER"):
-            header = line[10:50].strip()
-        elif line.startswith("TITLE"):
-            title += line[10:].strip() + " "
-        elif line.startswith("ATOM") or line.startswith("HETATM"):
-            atoms.append(line)
-    
-    # Try to create a structure that might work with Rowan's PDB format
-    pdb_data = {
-        "description": {
-            "title": title.strip() or header,
-            "classification": header
-        },
-        "experiment": {
-            "technique": "X-RAY DIFFRACTION"  # Default assumption
-        },
-        "geometry": {},
-        "contents": pdb_content,  # Keep full content
-        "name": f"pdb_upload_{len(pdb_content)}"
-    }
-    
-    return pdb_data
-
-def attempt_pdb_upload(pdb_id: str, pdb_content: str, folder_uuid: Optional[str] = None) -> Tuple[Optional[str], str]:
-    """
-    Attempt to upload PDB content to Rowan.
-    
-    Returns:
-        Tuple of (uuid or None, status message)
-    """
-    try:
-        # First, try the Protein.create method if it exists
-        if hasattr(rowan, 'Protein') and hasattr(rowan.Protein, 'create'):
-            logger.info(f"Attempting to create protein from PDB {pdb_id}")
-            result = rowan.Protein.create(
-                name=f"{pdb_id}_upload",
-                pdb_content=pdb_content,
-                folder_uuid=folder_uuid
-            )
-            if result and 'uuid' in result:
-                return result['uuid'], f"Successfully uploaded PDB {pdb_id}"
-        
-        # Try alternative upload methods
-        if hasattr(rowan, 'upload_pdb'):
-            result = rowan.upload_pdb(pdb_content, name=pdb_id)
-            if result and 'uuid' in result:
-                return result['uuid'], f"Successfully uploaded PDB {pdb_id}"
-        
-        # Try to create a file upload
-        if hasattr(rowan, 'File') and hasattr(rowan.File, 'create'):
-            result = rowan.File.create(
-                name=f"{pdb_id}.pdb",
-                content=pdb_content,
-                file_type="pdb",
-                folder_uuid=folder_uuid
-            )
-            if result and 'uuid' in result:
-                return result['uuid'], f"Uploaded PDB {pdb_id} as file"
-                
-    except Exception as e:
-        logger.error(f"Failed to upload PDB {pdb_id}: {str(e)}")
-    
-    return None, f"Cannot upload PDB through API - manual upload required"
-
-def handle_pdb_input(pdb_input: str, folder_uuid: Optional[str] = None) -> Dict[str, Any]:
-    """
-    Handle PDB input (either PDB ID or UUID) and return information for docking.
-    
-    Args:
-        pdb_input: Either a PDB ID (like "4Z18") or a UUID
-        folder_uuid: Optional folder for uploads
-        
-    Returns:
-        Dictionary with:
-        - success: bool
-        - uuid: str (if successful)
-        - message: str (status/error message)
-        - pdb_id: str (if it was a PDB ID)
-        - instructions: str (what to do next)
-    """
-    # Check if it's a UUID (36 chars with dashes)
-    if len(pdb_input) == 36 and pdb_input.count('-') == 4:
-        return {
-            "success": True,
-            "uuid": pdb_input,
-            "message": "Using provided protein UUID",
-            "instructions": None
-        }
-    
-    # Assume it's a PDB ID
-    pdb_id = pdb_input.upper()
-    
-    # Fetch PDB content
-    try:
-        url = f"https://files.rcsb.org/download/{pdb_id}.pdb"
-        response = requests.get(url, timeout=30)
-        response.raise_for_status()
-        pdb_content = response.text
-        logger.info(f"Successfully fetched PDB {pdb_id} ({len(pdb_content)} characters)")
-    except Exception as e:
-        return {
-            "success": False,
-            "uuid": None,
-            "message": f"Failed to fetch PDB {pdb_id}: {str(e)}",
-            "pdb_id": pdb_id,
-            "instructions": "Please verify the PDB ID is correct"
-        }
-    
-    # Attempt to upload
-    uuid, upload_status = attempt_pdb_upload(pdb_id, pdb_content, folder_uuid)
-    
-    if uuid:
-        return {
-            "success": True,
-            "uuid": uuid,
-            "message": upload_status,
-            "pdb_id": pdb_id,
-            "instructions": None
-        }
-    
-    # Upload failed - provide instructions
-    instructions = f"""
-To use PDB {pdb_id} for docking:
-
-1. Download the PDB file:
-   https://files.rcsb.org/download/{pdb_id}.pdb
-
-2. Upload to your Rowan account:
-   https://labs.rowansci.com
-
-3. Get the protein UUID from your account
-
-4. Use the UUID in your docking call:
-   rowan_docking(
-       target_uuid="your-protein-uuid-here",
-       ...
-   )
-"""
-    
-    return {
-        "success": False,
-        "uuid": None,
-        "message": upload_status,
-        "pdb_id": pdb_id,
-        "instructions": instructions
-    }
-
-def enhance_docking_with_pdb_handler(
-    target_input: Optional[str] = None,
-    target_uuid: Optional[str] = None,
-    **kwargs
-) -> Tuple[Optional[str], str]:
-    """
-    Enhanced target handling for docking that accepts PDB IDs.
-    
-    Returns:
-        Tuple of (target_uuid or None, message)
-    """
-    # If UUID already provided, use it
-    if target_uuid:
-        return target_uuid, "Using provided target UUID"
-    
-    # If target_input provided, try to handle it
-    if target_input:
-        result = handle_pdb_input(target_input, kwargs.get('folder_uuid'))
-        
-        if result['success']:
-            return result['uuid'], result['message']
-        else:
-            # Return None but with helpful message
-            return None, result['instructions'] or result['message']
-    
-    return None, "No protein target specified"