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

rowan_mcp/functions/admet.py

@@ -0,0 +1,89 @@
+"""
+Rowan ADMET properties function for drug discovery.
+"""
+
+import os
+import logging
+import time
+import traceback
+from typing import Optional
+
+try:
+    import rowan
+except ImportError:
+    rowan = None
+
+# Setup logging
+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()
+        result = rowan.compute(workflow_type=workflow_type, **kwargs)
+        api_time = time.time() - start_time
+
+        return result
+        
+    except Exception as e:
+        api_time = time.time() - start_time
+
+        raise e
+
+
+def rowan_admet(
+    name: str,
+    molecule: str,
+    folder_uuid: Optional[str] = None,
+    blocking: bool = True,
+    ping_interval: int = 5
+) -> str:
+    """Predict ADME-Tox properties for drug discovery.
+    
+    ADMET (Absorption, Distribution, Metabolism, Excretion, Toxicity) properties are crucial
+    for drug development. This workflow predicts drug-like properties including:
+    - Bioavailability and permeability
+    - Metabolic stability and clearance
+    - Toxicity indicators and safety profiles
+    - Drug-likeness metrics
+    
+    Use this for: Drug discovery, pharmaceutical development, toxicity screening
+    
+    Args:
+        name: Name for the calculation
+        molecule: Molecule SMILES string
+        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:
+        ADMET prediction results
+    """
+    result = log_rowan_api_call(
+        workflow_type="admet",
+        name=name,
+        molecule=molecule,
+        folder_uuid=folder_uuid,
+        blocking=blocking,
+        ping_interval=ping_interval
+    )
+    return str(result)
+
+
+def test_rowan_admet():
+    """Test the rowan_admet function."""
+    try:
+        # Test with a simple molecule (non-blocking to avoid long wait)
+        result = rowan_admet("test_admet", "CCO", blocking=False)
+        print("ADMET test successful!")
+        print(f"Result length: {len(result)} characters")
+        return True
+    except Exception as e:
+        print(f"ADMET test failed: {e}")
+        return False
+
+
+if __name__ == "__main__":
+    test_rowan_admet() 

rowan_mcp/functions/bde.py

@@ -0,0 +1,106 @@
+"""
+Calculate bond dissociation energy (BDE) for molecules to determine bond strength - useful for reaction prediction, stability analysis, or understanding molecular fragmentation. Modes: reckless/rapid/careful/meticulous. Input: molecule (SMILES), optional atoms to break.
+"""
+
+import os
+import rowan
+from typing import Optional, List, Union
+
+# 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_bde(
+    name: str,
+    molecule: str,
+    mode: str = "rapid",
+    atoms: Optional[List[int]] = None,
+    optimize_fragments: Optional[bool] = None,
+    all_CH: bool = False,
+    all_CX: bool = False,
+    folder_uuid: Optional[str] = None,
+    blocking: bool = True,
+    ping_interval: int = 5
+) -> str:
+    """Calculate bond dissociation energy (BDE) for molecules.
+    
+    Args:
+        name: Name for the calculation
+        molecule: Molecule SMILES string
+        mode: Calculation mode - reckless/rapid/careful/meticulous (default: rapid)
+        atoms: Specific atoms to dissociate (1-indexed)
+        optimize_fragments: Whether to optimize fragments (default depends on mode)
+        all_CH: Dissociate all C-H bonds (default: False)
+        all_CX: Dissociate all C-X bonds where X is halogen (default: False)
+        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:
+        Bond dissociation energy calculation results
+    """
+    try:
+        # Build kwargs for API call
+        kwargs = {
+            "workflow_type": "bde",
+            "name": name,
+            "molecule": molecule,
+            "mode": mode.lower(),
+            "folder_uuid": folder_uuid,
+            "blocking": blocking,
+            "ping_interval": ping_interval
+        }
+        
+        # Add optional parameters only if specified
+        if atoms is not None:
+            kwargs["atoms"] = atoms
+        if optimize_fragments is not None:
+            kwargs["optimize_fragments"] = optimize_fragments
+        if all_CH:
+            kwargs["all_CH"] = all_CH
+        if all_CX:
+            kwargs["all_CX"] = all_CX
+        
+        result = log_rowan_api_call(**kwargs)
+        
+        return str(result)
+        
+    except Exception as e:
+        error_response = {
+            "error": f"BDE calculation failed: {str(e)}",
+            "name": name,
+            "molecule": molecule
+        }
+        return str(error_response)
+
+
+def test_rowan_bde():
+    """Test the rowan_bde function."""
+    try:
+        # Test with ethane C-C bond
+        result = rowan_bde(
+            name="test_ethane_CC",
+            molecule="CC",
+            mode="rapid"
+        )
+        print("✅ BDE test successful!")
+        print(f"Result: {result}")
+        return True
+    except Exception as e:
+        print(f"BDE test failed: {e}")
+        return False
+
+
+if __name__ == "__main__":
+    test_rowan_bde()

rowan_mcp/functions/calculation_retrieve.py

@@ -0,0 +1,89 @@
+"""
+Rowan calculation retrieval functions for MCP tool integration.
+"""
+
+from typing import Optional, Dict, Any
+import rowan
+
+def rowan_calculation_retrieve(calculation_uuid: str) -> str:
+    """Retrieve details of a specific calculation.
+    
+    Args:
+        calculation_uuid: UUID of the calculation to retrieve
+    
+    Returns:
+        Calculation details
+    """
+    
+    try:
+        calculation = rowan.Calculation.retrieve(uuid=calculation_uuid)
+        return format_calculation_details(calculation, calculation_uuid)
+                
+    except Exception as e:
+        return f" Error retrieving calculation: {str(e)}"
+
+# Fallback error handling removed - keeping function simple and focused
+
+def format_calculation_details(calculation: Dict[str, Any], calculation_uuid: str) -> str:
+    """Format calculation details for display."""
+    
+    formatted = f"⚙ **Calculation Details:**\n\n"
+    formatted += f" Name: {calculation.get('name', 'N/A')}\n"
+    formatted += f"UUID: {calculation_uuid}\n"
+    formatted += f" Status: {calculation.get('status', 'Unknown')}\n"
+    formatted += f" Elapsed: {calculation.get('elapsed', 0):.3f}s\n"
+    
+    # Settings information
+    settings = calculation.get('settings', {})
+    if settings:
+        formatted += f"\n⚙ **Settings:**\n"
+        formatted += f"   Method: {settings.get('method', 'N/A')}\n"
+        if settings.get('basis_set'):
+            formatted += f"   Basis Set: {settings.get('basis_set')}\n"
+        if settings.get('tasks'):
+            formatted += f"   Tasks: {', '.join(settings.get('tasks', []))}\n"
+    
+    # Molecule information
+    molecules = calculation.get('molecules', [])
+    if molecules:
+        formatted += f"\n **Molecules:** {len(molecules)} structure(s)\n"
+        if len(molecules) > 0 and isinstance(molecules[0], dict):
+            first_mol = molecules[0]
+            if 'smiles' in first_mol:
+                formatted += f"   Primary SMILES: {first_mol['smiles']}\n"
+    
+    # Results/output data
+    if 'output' in calculation:
+        output = calculation['output']
+        formatted += f"\n **Results Available:**\n"
+        if isinstance(output, dict):
+            for key, value in list(output.items())[:5]:  # Show first 5 items
+                if isinstance(value, (int, float)):
+                    formatted += f"   {key}: {value:.4f}\n"
+                elif isinstance(value, str) and len(value) < 50:
+                    formatted += f"   {key}: {value}\n"
+                elif isinstance(value, list) and len(value) < 10:
+                    formatted += f"   {key}: {value}\n"
+                else:
+                    formatted += f"   {key}: <complex data>\n"
+        else:
+            formatted += f"   Raw output: {str(output)[:200]}...\n"
+    
+    return formatted
+
+# Specialized object data formatting removed - keeping function simple
+
+def test_rowan_calculation_retrieve():
+    """Test the calculation retrieve function."""
+    try:
+        # Test with a dummy UUID to see error handling
+        result = rowan_calculation_retrieve("test-uuid-123")
+        print(" Calculation retrieve test successful!")
+        print(f"Sample result: {result[:200]}...")
+        return True
+    except Exception as e:
+        print(f" Calculation retrieve test failed: {e}")
+        return False
+
+if __name__ == "__main__":
+    test_rowan_calculation_retrieve() 

rowan_mcp/functions/conformers.py

@@ -0,0 +1,77 @@
+"""
+Rowan conformers function for conformational analysis.
+"""
+
+import os
+import logging
+import time
+from typing import Optional
+
+try:
+    import rowan
+except ImportError:
+    rowan = None
+
+# Setup 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 long-running calculations
+    if workflow_type in ["multistage_opt", "conformer_search"]:
+        blocking = kwargs.get('blocking', True)
+        if blocking:
+            logger.info(f" Starting {workflow_type.replace('_', ' ')}...")
+        else:
+            logger.info(f" Submitting {workflow_type.replace('_', ' ')} without waiting")
+    
+    # Let Rowan handle everything - no custom error handling
+    return rowan.compute(workflow_type=workflow_type, **kwargs)
+
+def rowan_conformers(
+    name: str,
+    molecule: str,
+    max_conformers: int = 50,
+    mode: str = "rapid",
+    folder_uuid: Optional[str] = None,
+    blocking: bool = True,
+    ping_interval: int = 5
+):
+    """Generate and optimize molecular conformers using Rowan's conformer_search workflow. Valid modes are "reckless", "rapid", "careful", and "meticulous", and default to using SMILES strings for the "molecule" parameter.
+    
+    Args:
+        name: Name for the calculation
+        molecule: Molecule SMILES string or common name
+        max_conformers: Maximum number of conformers to generate (default: 50)
+        mode: Conformer search mode - "reckless", "rapid", "careful", "meticulous" (default: "rapid")
+        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:
+        Conformer search results (actual results if blocking=True)
+    """
+    
+    # Validate mode parameter
+    valid_modes = ["reckless", "rapid", "careful", "meticulous"]
+    if mode not in valid_modes:
+        raise ValueError(
+            f"Invalid mode '{mode}'. Valid modes are: {', '.join(valid_modes)}"
+        )
+    
+    return log_rowan_api_call(
+        workflow_type="conformer_search",
+        name=name,
+        molecule=molecule,
+        mode=mode,
+        max_conformers=max_conformers,
+        folder_uuid=folder_uuid,
+        blocking=blocking,
+        ping_interval=ping_interval
+    )
+
+if __name__ == "__main__":
+    pass 

rowan_mcp/functions/descriptors.py

@@ -0,0 +1,89 @@
+"""
+Rowan molecular descriptors function for QSAR modeling.
+"""
+
+import os
+import logging
+import time
+from typing import Optional
+
+try:
+    import rowan
+except ImportError:
+    rowan = None
+
+# Setup logging
+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()
+        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_descriptors(
+    name: str,
+    molecule: str,
+    folder_uuid: Optional[str] = None,
+    blocking: bool = True,
+    ping_interval: int = 5
+) -> str:
+    """Calculate molecular descriptors for data science.
+    
+    Generates comprehensive molecular descriptors including:
+    - Topological and geometric descriptors
+    - Electronic and physicochemical properties
+    - Graph-based molecular features
+    - Machine learning ready feature vectors
+    
+    Use this for: QSAR modeling, machine learning, chemical space analysis
+    
+    Args:
+        name: Name for the calculation
+        molecule: Molecule SMILES string
+        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:
+        Molecular descriptors results
+    """
+    result = log_rowan_api_call(
+        workflow_type="descriptors",
+        name=name,
+        molecule=molecule,
+        folder_uuid=folder_uuid,
+        blocking=blocking,
+        ping_interval=ping_interval
+    )
+    return str(result)
+
+def test_rowan_descriptors():
+    """Test the rowan_descriptors function."""
+    try:
+        # Test with a simple molecule (non-blocking to avoid long wait)
+        result = rowan_descriptors("test_descriptors", "CCO", blocking=False)
+        print(" Descriptors test successful!")
+        print(f"Result length: {len(result)} characters")
+        return True
+    except Exception as e:
+        print(f" Descriptors test failed: {e}")
+        return False
+
+if __name__ == "__main__":
+    test_rowan_descriptors()