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

rowan_mcp/functions/bde.py

@@ -1,113 +0,0 @@
-"""
-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__)
-
-# Configure rowan API key
-if not hasattr(rowan, 'api_key') or not rowan.api_key:
-    api_key = os.getenv("ROWAN_API_KEY")
-    if api_key:
-        rowan.api_key = api_key
-        logger.info("🔑 Rowan API key configured")
-    else:
-        logger.error("No ROWAN_API_KEY found in environment")
-
-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

@@ -1,89 +0,0 @@
-"""
-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

@@ -1,80 +0,0 @@
-"""
-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__)
-
-# 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 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

@@ -1,92 +0,0 @@
-"""
-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__)
-
-# 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."""
-    
-    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()