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

rowan_mcp/functions/electronic_properties.py

@@ -1,205 +0,0 @@
-"""
-Electronic Properties Analysis for Rowan MCP Server
-
-This module provides electronic structure property calculations including:
-- HOMO/LUMO energies and molecular orbitals
-- Electron density and electrostatic potential
-- Population analysis and bond orders
-- Orbital visualization data
-"""
-
-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__)
-
-# Setup API key
-api_key = os.getenv("ROWAN_API_KEY")
-if api_key and rowan:
-    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()
-        
-        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_electronic_properties(
-    name: str,
-    molecule: str,
-    # Settings parameters (quantum chemistry calculation settings)
-    method: Optional[str] = None,
-    basis_set: Optional[str] = None,
-    engine: Optional[str] = None,
-    charge: int = 0,
-    multiplicity: int = 1,
-    # Cube computation control parameters
-    compute_density_cube: bool = True,
-    compute_electrostatic_potential_cube: bool = True,
-    compute_num_occupied_orbitals: int = 1,
-    compute_num_virtual_orbitals: int = 1,
-    # Workflow control parameters
-    mode: Optional[str] = None,
-    folder_uuid: Optional[str] = None,
-    blocking: bool = True,
-    ping_interval: int = 5
-) -> str:
-    """Calculate comprehensive electronic structure properties using Rowan's ElectronicPropertiesWorkflow.
-    
-    Implements the ElectronicPropertiesWorkflow class for computing detailed electronic properties including:
-    - **Molecular Orbitals**: HOMO/LUMO energies, orbital cubes, occupation numbers
-    - **Electron Density**: Total, α/β spin densities, spin density differences
-    - **Electrostatic Properties**: Dipole moments, quadrupole moments, electrostatic potential
-    - **Population Analysis**: Mulliken charges, Löwdin charges
-    - **Bond Analysis**: Wiberg bond orders, Mayer bond orders
-    - **Visualization Data**: Cube files for density, ESP, and molecular orbitals
-    
-    **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
-        method: QM method (default: b3lyp for electronic properties)
-        basis_set: Basis set (default: def2-svp for balanced accuracy)
-        engine: Computational engine (default: psi4)
-        charge: Molecular charge (default: 0)
-        multiplicity: Spin multiplicity (default: 1 for singlet)
-        compute_density_cube: Generate electron density cube (default: True)
-        compute_electrostatic_potential_cube: Generate ESP cube (default: True)
-        compute_num_occupied_orbitals: Number of occupied MOs to save (default: 1)
-        compute_num_virtual_orbitals: Number of virtual MOs to save (default: 1)
-        mode: Calculation mode/precision (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:
-        Comprehensive electronic properties results following ElectronicPropertiesWorkflow format
-    """
-    # Look up canonical SMILES using advanced molecule lookup (PubChemPy + caching + RDKit)
-    canonical_smiles = lookup_molecule_smiles(molecule)
-    
-    # Apply smart defaults for electronic properties calculations
-    if method is None:
-        method = "b3lyp"  # Good for electronic properties
-    if basis_set is None:
-        basis_set = "def2-svp"  # Balanced accuracy/cost for properties
-    if engine is None:
-        engine = "psi4"  # Robust for electronic properties
-    
-    # Validate orbital count parameters
-    if compute_num_occupied_orbitals < 0:
-        return f"compute_num_occupied_orbitals must be non-negative (got {compute_num_occupied_orbitals})"
-    if compute_num_virtual_orbitals < 0:
-        return f"compute_num_virtual_orbitals must be non-negative (got {compute_num_virtual_orbitals})"
-    
-    # Build parameters following ElectronicPropertiesWorkflow specification
-    electronic_params = {
-        "name": name,
-        "molecule": canonical_smiles,  # API interface requirement
-        "initial_molecule": canonical_smiles,  # ElectronicPropertiesWorkflow requirement
-        # Settings (quantum chemistry parameters) - exactly as in ElectronicPropertiesWorkflow
-        "settings": {
-            "method": method.lower(),
-            "basis_set": basis_set.lower(),
-            "engine": engine.lower(),
-            "charge": charge,
-            "multiplicity": multiplicity
-        },
-        # Cube computation control - exactly as in ElectronicPropertiesWorkflow
-        "compute_density_cube": compute_density_cube,
-        "compute_electrostatic_potential_cube": compute_electrostatic_potential_cube,
-        "compute_num_occupied_orbitals": compute_num_occupied_orbitals,
-        "compute_num_virtual_orbitals": compute_num_virtual_orbitals,
-        # Workflow parameters
-        "folder_uuid": folder_uuid,
-        "blocking": blocking,
-        "ping_interval": ping_interval
-    }
-    
-    # Add mode if specified (optional in ElectronicPropertiesWorkflow)
-    if mode:
-        electronic_params["mode"] = mode
-    
-    try:
-        result = log_rowan_api_call(
-            workflow_type="electronic_properties",
-            **electronic_params
-        )
-        
-        return result
-            
-    except Exception as e:
-        return f"Electronic properties calculation failed: {str(e)}"
-
-def test_electronic_properties():
-    """Test the electronic properties function with advanced molecule lookup."""
-    return rowan_electronic_properties(
-        name="test_electronic_properties",
-        molecule="aspirin",  # Test advanced lookup with a pharmaceutical
-        method="hf",
-        basis_set="sto-3g",
-        blocking=True
-    )
-
-if __name__ == "__main__":
-    print(test_electronic_properties()) 

rowan_mcp/functions/folder_management.py

@@ -1,137 +0,0 @@
-"""
-Folder management operations for Rowan API.
-"""
-
-import os
-import rowan
-from typing import Optional
-
-# 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 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

@@ -1,219 +0,0 @@
-"""
-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__)
-
-# Setup API key
-api_key = os.getenv("ROWAN_API_KEY")
-if api_key and rowan:
-    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()
-        
-        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

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