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

rowan_mcp/functions/folder_management.py

@@ -0,0 +1,130 @@
+"""
+Folder management operations for Rowan API.
+"""
+
+import os
+import rowan
+from typing import Optional
+
+# Set up logging
+import logging
+logger = logging.getLogger(__name__)
+
+
+
+def rowan_folder_management(
+    action: str,
+    folder_uuid: Optional[str] = None,
+    name: Optional[str] = None,
+    parent_uuid: Optional[str] = None,
+    notes: Optional[str] = None,
+    starred: Optional[bool] = None,
+    public: Optional[bool] = None,
+    created_at: Optional[str] = None,
+    updated_at: Optional[str] = None,
+    is_root: Optional[bool] = None,
+    uuid: Optional[str] = None,
+    name_contains: Optional[str] = None,
+    page: int = 0,
+    size: int = 50
+) -> str:
+    """Unified folder management tool for all folder operations. Available actions: create, retrieve, update, delete, list.
+    
+    **Available Actions:**
+    - **create**: Create a new folder (requires: name, optional: parent_uuid, notes, starred, public)
+    - **retrieve**: Get folder details (requires: folder_uuid)
+    - **update**: Update folder properties (requires: folder_uuid, optional: name, parent_uuid, notes, starred, public)
+    - **delete**: Delete a folder (requires: folder_uuid)
+    - **list**: List folders with filters (optional: name_contains, parent_uuid, starred, public, page, size)
+    
+    Args:
+        action: Action to perform ('create', 'retrieve', 'update', 'delete', 'list')
+        folder_uuid: UUID of the folder (required for retrieve, update, delete)
+        name: Folder name (required for create, optional for update)
+        parent_uuid: Parent folder UUID (optional for create/update, if not provided creates in root)
+        notes: Folder notes (optional for create/update)
+        starred: Star the folder (optional for create/update)
+        public: Make folder public (optional for create/update)
+        created_at: The date and time at which this folder was created
+        updated_at: The date and time at which this folder was most recently updated
+        is_root: Whether or not this folder is the user's root folder
+        uuid: The UUID of this folder
+        name_contains: Filter by name containing text (optional for list)
+        page: Page number for pagination (default: 1, for list)
+        size: Results per page (default: 50, for list)
+    
+    Returns:
+        Results of the folder operation
+    """
+    
+    action = action.lower()
+    
+    try:
+        if action == "create":
+            if not name:
+                return "Error: 'name' is required for creating a folder"
+            
+            return rowan.Folder.create(
+                name=name,
+                parent_uuid=parent_uuid,
+                notes=notes or "",
+                starred=starred or False,
+                public=public or False
+            )
+            
+        elif action == "retrieve":
+            if not folder_uuid:
+                return "Error: 'folder_uuid' is required for retrieving a folder"
+            
+            return rowan.Folder.retrieve(uuid=folder_uuid)
+            
+        elif action == "update":
+            if not folder_uuid:
+                return "Error: 'folder_uuid' is required for updating a folder"
+
+            return rowan.Folder.update(
+                uuid=folder_uuid,
+                name=name,
+                notes=notes,
+                starred=starred,
+                public=public,
+                parent_uuid=parent_uuid
+                
+            )
+            
+        elif action == "delete":
+            if not folder_uuid:
+                return "Error: 'folder_uuid' is required for deleting a folder"
+            
+            rowan.Folder.delete(uuid=folder_uuid)
+            return "Folder deleted successfully"
+            
+        elif action == "list":
+            return rowan.Folder.list(
+                name_contains=name_contains,
+                parent_uuid=parent_uuid,
+                starred=starred,
+                public=public,
+                page=page,
+                size=size
+            )
+              
+    except Exception as e:
+        return f"Error in folder {action}: {str(e)}"
+
+
+def test_rowan_folder_management():
+    """Test the rowan_folder_management function."""
+    try:
+        # Test listing folders
+        result = rowan_folder_management(action="list", size=5)
+        print("Folder management test successful!")
+        print(f"Result: {result[:200]}...")  # Show first 200 chars
+        return True
+    except Exception as e:
+        print(f"Folder management test failed: {e}")
+        return False
+
+
+if __name__ == "__main__":
+    test_rowan_folder_management() 

rowan_mcp/functions/fukui.py

@@ -0,0 +1,216 @@
+"""
+Fukui Analysis for Rowan MCP Server
+
+This module provides Fukui indices calculations for reactivity prediction including:
+- f(+) indices for electrophilic attack sites
+- f(-) indices for nucleophilic attack sites  
+- f(0) indices for radical attack sites
+- Global electrophilicity index
+"""
+
+import os
+import logging
+import time
+from typing import Any, Dict, List, Optional
+
+try:
+    import rowan
+except ImportError:
+    rowan = None
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+
+def log_rowan_api_call(workflow_type: str, **kwargs):
+    """Log Rowan API calls with detailed parameters."""
+    
+    try:
+        start_time = time.time()
+        
+        if not rowan:
+            raise ImportError("Rowan package not available - please install with 'pip install rowan'")
+        
+        logger.info(f"Calling Rowan {workflow_type} workflow")
+        for key, value in kwargs.items():
+            if key != 'ping_interval':
+                logger.info(f"  {key}: {value}")
+        
+        result = rowan.compute(workflow_type=workflow_type, **kwargs)
+        
+        end_time = time.time()
+        duration = end_time - start_time
+        logger.info(f"Rowan {workflow_type} completed in {duration:.2f} seconds")
+        
+        return result
+        
+    except Exception as e:
+        logger.error(f"Rowan {workflow_type} failed: {str(e)}")
+        raise e
+
+def lookup_molecule_smiles(molecule_name: str) -> str:
+    """Look up canonical SMILES using the advanced molecule_lookup system.
+    
+    Uses PubChemPy + SQLite caching + RDKit validation for scalable molecule lookup.
+    """
+    try:
+        # Import the advanced molecule lookup system
+        from .molecule_lookup import get_lookup_instance
+        
+        lookup = get_lookup_instance()
+        smiles, source, metadata = lookup.get_smiles(molecule_name)
+        
+        if smiles:
+            logger.info(f"Molecule lookup successful: '{molecule_name}' → '{smiles}' (source: {source})")
+            return smiles
+        else:
+            logger.warning(f"Molecule lookup failed for '{molecule_name}': {metadata.get('error', 'Unknown error')}")
+            # Return original input as fallback (might be valid SMILES)
+            return molecule_name
+            
+    except ImportError as e:
+        logger.error(f"Could not import molecule_lookup: {e}")
+        # Fallback: return original input
+        return molecule_name
+    except Exception as e:
+        logger.error(f"Molecule lookup error for '{molecule_name}': {e}")
+        # Fallback: return original input
+        return molecule_name
+
+def rowan_fukui(
+    name: str,
+    molecule: str,
+    optimize: bool = True,
+    opt_method: Optional[str] = None,
+    opt_basis_set: Optional[str] = None,
+    opt_engine: Optional[str] = None,
+    fukui_method: str = "gfn1_xtb",
+    fukui_basis_set: Optional[str] = None,
+    fukui_engine: Optional[str] = None,
+    charge: int = 0,
+    multiplicity: int = 1,
+    folder_uuid: Optional[str] = None,
+    blocking: bool = True,
+    ping_interval: int = 5
+) -> str:
+    """Calculate Fukui indices for reactivity prediction with comprehensive control.
+    
+    Predicts sites of chemical reactivity by analyzing electron density changes upon
+    gaining/losing electrons. Uses a two-step process: optimization + Fukui calculation.
+    
+    ** Fukui Index Types:**
+    - **f(+)**: Electrophilic attack sites (nucleophile reactivity)
+    - **f(-)**: Nucleophilic attack sites (electrophile reactivity)  
+    - **f(0)**: Radical attack sites (average of f(+) and f(-))
+    - **Global Electrophilicity Index**: Overall electrophilic character
+    
+    ** Key Features:**
+    - Optional geometry optimization before Fukui calculation
+    - Separate control over optimization and Fukui calculation methods
+    - Per-atom reactivity indices for site-specific analysis
+    - Global reactivity descriptors
+    
+    **Molecule Lookup**: Uses advanced PubChemPy + SQLite caching + RDKit validation system
+    for robust molecule identification and SMILES canonicalization.
+    
+    Args:
+        name: Name for the calculation
+        molecule: Molecule name (e.g., "aspirin", "taxol") or SMILES string
+        optimize: Whether to optimize geometry before Fukui calculation (default: True)
+        opt_method: Method for optimization (default: None, uses engine default)
+        opt_basis_set: Basis set for optimization (default: None, uses engine default)
+        opt_engine: Engine for optimization (default: None, auto-selected)
+        fukui_method: Method for Fukui calculation (default: "gfn1_xtb")
+        fukui_basis_set: Basis set for Fukui calculation (default: None, uses method default)
+        fukui_engine: Engine for Fukui calculation (default: None, auto-selected)
+        charge: Molecular charge (default: 0)
+        multiplicity: Spin multiplicity (default: 1)
+        folder_uuid: Optional folder UUID for organization
+        blocking: Whether to wait for completion (default: True)
+        ping_interval: Check status interval in seconds (default: 5)
+    
+    Returns:
+        Fukui indices and reactivity analysis with per-atom and global descriptors
+    """
+    # Look up SMILES if a common name was provided
+    canonical_smiles = lookup_molecule_smiles(molecule)
+    
+    # Build optimization settings if requested
+    opt_settings = None
+    if optimize:
+        opt_settings = {
+            "charge": charge,
+            "multiplicity": multiplicity
+        }
+        
+        # Add optimization method/basis/engine if specified
+        if opt_method:
+            opt_settings["method"] = opt_method.lower()
+        if opt_basis_set:
+            opt_settings["basis_set"] = opt_basis_set.lower()
+        
+        # Default to fast optimization if no engine specified
+        if not opt_engine and not opt_method:
+            opt_settings["method"] = "gfn2_xtb"  # Fast optimization
+            logger.info(f"No optimization method specified, defaulting to GFN2-xTB")
+    
+    # Build Fukui calculation settings
+    fukui_settings = {
+        "method": fukui_method.lower(),
+        "charge": charge,
+        "multiplicity": multiplicity
+    }
+    
+    # Add Fukui basis set if specified
+    if fukui_basis_set:
+        fukui_settings["basis_set"] = fukui_basis_set.lower()
+    
+    # Validate Fukui method
+    valid_fukui_methods = ["gfn1_xtb", "gfn2_xtb", "hf", "b3lyp", "pbe", "m06-2x"]
+    if fukui_method.lower() not in valid_fukui_methods:
+        pass  # Warning already logged by cleanup script
+    
+    # Build parameters for Rowan API
+    fukui_params = {
+        "name": name,
+        "molecule": canonical_smiles,
+        "fukui_settings": fukui_settings,
+        "folder_uuid": folder_uuid,
+        "blocking": blocking,
+        "ping_interval": ping_interval
+    }
+    
+    # Add optimization settings if enabled
+    if optimize and opt_settings:
+        fukui_params["opt_settings"] = opt_settings
+        
+    # Add engines if specified
+    if opt_engine:
+        fukui_params["opt_engine"] = opt_engine.lower()
+    if fukui_engine:
+        fukui_params["fukui_engine"] = fukui_engine.lower()
+    
+    try:
+        result = log_rowan_api_call(
+            workflow_type="fukui",
+            **fukui_params
+        )
+        
+        return result
+            
+    except Exception as e:
+        return f"Fukui analysis failed: {str(e)}"
+
+def test_fukui():
+    """Test the fukui function."""
+    return rowan_fukui(
+        name="test_fukui",
+        molecule="benzene",
+        fukui_method="gfn1_xtb",
+        blocking=True
+    )
+
+if __name__ == "__main__":
+    print(test_fukui()) 

rowan_mcp/functions/hydrogen_bond_basicity.py

@@ -0,0 +1,87 @@
+"""
+Calculate hydrogen bond basicity (pKBHX) values for molecules to predict H-bond acceptor strength - useful for queries about pyridine/imine nitrogen basicity, comparing acceptor sites, or understanding binding selectivity. Input: molecule (SMILES string).
+"""
+
+import os
+import rowan
+from typing import Optional
+
+# Set up logging
+import logging
+logger = logging.getLogger(__name__)
+
+
+
+def log_rowan_api_call(workflow_type: str, **kwargs):
+    """Log Rowan API calls and let Rowan handle its own errors."""
+    
+    # Simple logging for calculations
+    logger.info(f" Starting {workflow_type.replace('_', ' ')}...")
+    
+    # Let Rowan handle everything - no custom error handling
+    return rowan.compute(workflow_type=workflow_type, **kwargs)
+
+def rowan_hydrogen_bond_basicity(
+    name: str,
+    molecule: str,
+    do_csearch: bool = True,
+    do_optimization: bool = True,
+    folder_uuid: Optional[str] = None,
+    blocking: bool = True,
+    ping_interval: int = 5
+) -> str:
+    """Calculate hydrogen bond basicity (pKBHX) values for molecules.
+    
+    Args:
+        name: Name for the calculation
+        molecule: Molecule SMILES string
+        do_csearch: Whether to perform conformational search (default: True)
+        do_optimization: Whether to perform optimization (default: True)
+        folder_uuid: UUID of folder to organize calculation in
+        blocking: Whether to wait for completion (default: True)
+        ping_interval: How often to check status in seconds (default: 5)
+    
+    Returns:
+        Hydrogen bond basicity calculation results with pKBHX values
+    """
+    try:
+        result = log_rowan_api_call(
+            workflow_type="hydrogen_bond_basicity",
+            name=name,
+            molecule=molecule,
+            do_csearch=do_csearch,
+            do_optimization=do_optimization,
+            folder_uuid=folder_uuid,
+            blocking=blocking,
+            ping_interval=ping_interval
+        )
+        
+        return str(result)
+        
+    except Exception as e:
+        error_response = {
+            "error": f"Hydrogen bond basicity calculation failed: {str(e)}",
+            "name": name,
+            "molecule": molecule
+        }
+        return str(error_response)
+
+
+def test_rowan_hydrogen_bond_basicity():
+    """Test the rowan_hydrogen_bond_basicity function."""
+    try:
+        # Test with pyridine
+        result = rowan_hydrogen_bond_basicity(
+            name="test_pyridine_basicity",
+            molecule="c1ccncc1"
+        )
+        print("✅ Hydrogen bond basicity test successful!")
+        print(f"Result: {result}")
+        return True
+    except Exception as e:
+        print(f"Hydrogen bond basicity test failed: {e}")
+        return False
+
+
+if __name__ == "__main__":
+    test_rowan_hydrogen_bond_basicity()

rowan_mcp/functions/irc.py

@@ -0,0 +1,125 @@
+"""
+Rowan IRC (Intrinsic Reaction Coordinate) function for MCP tool integration.
+"""
+
+from typing import Any, Dict, List, Optional
+import rowan
+import logging
+import os
+
+# Set up logger
+logger = logging.getLogger(__name__)
+
+# Get API key from environment
+api_key = os.environ.get("ROWAN_API_KEY")
+if api_key:
+    rowan.api_key = api_key
+else:
+    logger.warning("ROWAN_API_KEY not found in environment")
+
+def rowan_irc(
+    name: str,
+    molecule: str,
+    mode: str = "rapid",
+    solvent: Optional[str] = None,
+    preopt: bool = False,
+    max_irc_steps: int = 10,
+    step_size: float = 0.05,
+    starting_ts: Optional[str] = None,
+    # Workflow parameters
+    folder_uuid: Optional[str] = None,
+    blocking: bool = True,
+    ping_interval: int = 5
+) -> str:
+    """Follow intrinsic reaction coordinates from transition states.
+    
+    Traces reaction pathways from transition states to reactants and products.
+    
+    Args:
+        name: Name for the calculation
+        molecule: Molecule SMILES string (should be a transition state)
+        mode: Calculation mode ("rapid", "careful", "meticulous")
+        solvent: Solvent for the calculation (optional)
+        preopt: Whether to pre-optimize the structure before IRC (default: False)
+        max_irc_steps: Maximum number of IRC steps to take (default: 10)
+        step_size: Step size for IRC in Angstroms (default: 0.05, range: 0.001-0.1)
+        starting_ts: UUID of a previous transition state calculation (optional)
+        folder_uuid: Optional folder UUID for organization
+        blocking: Whether to wait for completion (default: True)
+        ping_interval: Check status interval in seconds (default: 5)
+    
+    Returns:
+        IRC pathway results
+    """
+    # Parameter validation
+    valid_modes = ["rapid", "careful", "meticulous"]
+    mode_lower = mode.lower()
+    if mode_lower not in valid_modes:
+        return f"Error: Invalid mode '{mode}'. Valid options: {', '.join(valid_modes)}"
+    
+    # Validate step size (0.001 <= step_size <= 0.1)
+    if step_size < 0.001 or step_size > 0.1:
+        return f"Error: step_size must be between 0.001 and 0.1 Å (got {step_size})"
+    
+    if max_irc_steps <= 0:
+        return f"Error: max_irc_steps must be positive (got {max_irc_steps})"
+    
+    try:
+        # Build basic parameters for rowan.compute
+        compute_params = {
+            "name": name,
+            "molecule": molecule,
+            "workflow_type": "irc",
+            "mode": mode_lower,
+            "preopt": preopt,
+            "max_irc_steps": max_irc_steps,
+            "step_size": step_size,
+            "folder_uuid": folder_uuid,
+            "blocking": blocking,
+            "ping_interval": ping_interval
+        }
+        
+        # Add optional parameters
+        if solvent:
+            compute_params["solvent"] = solvent
+            
+        if starting_ts:
+            compute_params["starting_ts"] = starting_ts
+        
+        # Submit IRC calculation
+        result = rowan.compute(**compute_params)
+        
+        # Format results
+        uuid = result.get('uuid', 'N/A')
+        status = result.get('status', 'unknown')
+        
+        if blocking:
+            if status == "success":
+                return f"IRC calculation '{name}' completed successfully!\nUUID: {uuid}"
+            else:
+                return f"IRC calculation failed\nUUID: {uuid}\nStatus: {status}"
+        else:
+            return f"IRC calculation '{name}' submitted!\nUUID: {uuid}\nStatus: Running..."
+            
+    except Exception as e:
+        logger.error(f"Error in rowan_irc: {str(e)}")
+        return f"IRC calculation failed: {str(e)}"
+
+def test_rowan_irc():
+    """Test the rowan_irc function."""
+    try:
+        result = rowan_irc(
+            name="test_irc",
+            molecule="C=C",
+            mode="rapid",
+            max_irc_steps=5,
+            blocking=False
+        )
+        print(f"IRC test result: {result}")
+        return True
+    except Exception as e:
+        print(f"IRC test failed: {e}")
+        return False
+
+if __name__ == "__main__":
+    test_rowan_irc()

rowan_mcp/functions/macropka.py

@@ -0,0 +1,120 @@
+"""MacropKa workflow function for MCP server."""
+
+import os
+import logging
+from typing import Optional, Union, List
+
+import rowan
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+# Get API key from environment
+api_key = os.environ.get("ROWAN_API_KEY")
+if api_key:
+    rowan.api_key = api_key
+else:
+    logger.warning("ROWAN_API_KEY not found in environment")
+
+
+def log_rowan_api_call(func_name: str, **kwargs):
+    """Log Rowan API calls for debugging."""
+    logger.debug(f"Calling {func_name} with args: {kwargs}")
+
+
+def rowan_macropka(
+    name: str,
+    molecule: str,
+    min_pH: float = 0.0,
+    max_pH: float = 14.0,
+    max_charge: int = 2,
+    min_charge: int = -2,
+    compute_aqueous_solubility: bool = False,
+    compute_solvation_energy: bool = True,
+    folder_uuid: Optional[str] = None,
+    blocking: bool = True,
+    ping_interval: int = 5
+) -> str:
+    """
+    Calculate macroscopic pKa values and related properties for a molecule.
+    
+    This workflow computes pKa values, microstates, isoelectric point, and optionally
+    solvation energy and aqueous solubility across different pH values.
+    
+    Args:
+        name: Name for the calculation
+        molecule: SMILES string of the molecule
+        min_pH: Minimum pH for calculations (default: 0.0)
+        max_pH: Maximum pH for calculations (default: 14.0)
+        max_charge: Maximum charge to consider for microstates (default: 2)
+        min_charge: Minimum charge to consider for microstates (default: -2)
+        compute_aqueous_solubility: Whether to compute aqueous solubility by pH (default: False)
+        compute_solvation_energy: Whether to compute solvation energy for Kpuu (default: True)
+        folder_uuid: UUID of folder to save results in
+        blocking: Wait for calculation to complete (default: True)
+        ping_interval: How often to check status in blocking mode (default: 5 seconds)
+        
+    Returns:
+        String with workflow UUID or results depending on blocking mode
+    """
+    try:
+        # Validate pH range
+        if min_pH >= max_pH:
+            return "Error: min_pH must be less than max_pH"
+        
+        # Validate charge range  
+        if min_charge >= max_charge:
+            return "Error: min_charge must be less than max_charge"
+            
+        # Log the API call
+        log_rowan_api_call(
+            "rowan.compute",
+            workflow_type="macropka",
+            name=name,
+            molecule=molecule,
+            min_pH=min_pH,
+            max_pH=max_pH,
+            max_charge=max_charge,
+            min_charge=min_charge,
+            compute_aqueous_solubility=compute_aqueous_solubility,
+            compute_solvation_energy=compute_solvation_energy,
+            folder_uuid=folder_uuid,
+            blocking=blocking,
+            ping_interval=ping_interval
+        )
+        
+        # Submit calculation
+        result = rowan.compute(
+            workflow_type="macropka",
+            name=name,
+            molecule=molecule,  # Required by rowan.compute() API
+            folder_uuid=folder_uuid,
+            blocking=blocking,
+            ping_interval=ping_interval,
+            # Workflow-specific parameters for MacropKaWorkflow
+            initial_smiles=molecule,  # Required by MacropKaWorkflow Pydantic model
+            min_pH=min_pH,
+            max_pH=max_pH,
+            max_charge=max_charge,
+            min_charge=min_charge,
+            compute_aqueous_solubility=compute_aqueous_solubility,
+            compute_solvation_energy=compute_solvation_energy
+        )
+        
+        return result
+            
+    except Exception as e:
+        logger.error(f"Error in rowan_macropka: {str(e)}")
+        return f"MacropKa calculation failed: {str(e)}"
+
+
+# Test function
+if __name__ == "__main__":
+    # Test with ethanol
+    result = rowan_macropka(
+        name="Ethanol MacropKa Test",
+        molecule="CCO",
+        compute_aqueous_solubility=True,
+        blocking=True
+    )
+    print(result)