memra 0.2.13__py3-none-any.whl → 0.2.15__py3-none-any.whl

memra-sdk/memra/tool_registry.py

@@ -1,343 +0,0 @@
-import importlib
-import logging
-import sys
-import os
-import httpx
-from typing import Dict, Any, List, Optional, Callable
-from pathlib import Path
-
-logger = logging.getLogger(__name__)
-
-class ToolRegistry:
-    """Registry for managing and executing tools via API calls only"""
-    
-    def __init__(self):
-        self.tools: Dict[str, Dict[str, Any]] = {}
-        self._register_known_tools()
-    
-    def _register_known_tools(self):
-        """Register known tools with their metadata (no actual implementations)"""
-        # Server-hosted tools (executed via Memra API)
-        server_tools = [
-            ("DatabaseQueryTool", "Query database schemas and data"),
-            ("PDFProcessor", "Process PDF files and extract content"),
-            ("OCRTool", "Perform OCR on images and documents"),
-            ("InvoiceExtractionWorkflow", "Extract structured data from invoices"),
-            ("FileReader", "Read files from the filesystem"),
-            ("FileDiscovery", "Discover and list files in directories"),
-            ("FileCopy", "Copy files to standard processing directories"),
-        ]
-        
-        for tool_name, description in server_tools:
-            self.register_tool(tool_name, None, "memra", description)
-        
-        # MCP-hosted tools (executed via MCP bridge)
-        mcp_tools = [
-            ("DataValidator", "Validate data against schemas"),
-            ("PostgresInsert", "Insert data into PostgreSQL database"),
-            ("TextToSQL", "Convert natural language questions to SQL queries and execute them"),
-            ("SQLExecutor", "Execute SQL queries against PostgreSQL database"),
-            ("TextToSQLGenerator", "Generate SQL from natural language questions"),
-        ]
-        
-        for tool_name, description in mcp_tools:
-            self.register_tool(tool_name, None, "mcp", description)
-        
-        logger.info(f"Registered {len(self.tools)} tool definitions")
-    
-    def register_tool(self, name: str, tool_class: Optional[type], hosted_by: str, description: str):
-        """Register a tool in the registry (metadata only)"""
-        self.tools[name] = {
-            "class": tool_class,  # Will be None for API-based tools
-            "hosted_by": hosted_by,
-            "description": description
-        }
-        logger.debug(f"Registered tool: {name} (hosted by {hosted_by})")
-    
-    def discover_tools(self, hosted_by: Optional[str] = None) -> List[Dict[str, Any]]:
-        """Discover available tools, optionally filtered by host"""
-        tools = []
-        for name, info in self.tools.items():
-            if hosted_by is None or info["hosted_by"] == hosted_by:
-                tools.append({
-                    "name": name,
-                    "hosted_by": info["hosted_by"],
-                    "description": info["description"]
-                })
-        return tools
-    
-    def execute_tool(self, tool_name: str, hosted_by: str, input_data: Dict[str, Any], 
-                    config: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        """Execute a tool - handles MCP tools via bridge, rejects direct server tool execution"""
-        if hosted_by == "mcp":
-            return self._execute_mcp_tool(tool_name, input_data, config)
-        else:
-            logger.warning(f"Direct tool execution attempted for {tool_name}. Use API client instead.")
-            return {
-                "success": False,
-                "error": "Direct tool execution not supported. Use API client for tool execution."
-            }
-    
-    def _execute_mcp_tool(self, tool_name: str, input_data: Dict[str, Any], 
-                         config: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        """Execute an MCP tool via the bridge"""
-        try:
-            # Debug logging
-            logger.info(f"Executing MCP tool {tool_name} with config: {config}")
-            
-            # Get bridge configuration
-            if not config:
-                logger.error(f"MCP tool {tool_name} requires bridge configuration")
-                return {
-                    "success": False,
-                    "error": "MCP bridge configuration required"
-                }
-            
-            bridge_url = config.get("bridge_url", "http://localhost:8081")
-            bridge_secret = config.get("bridge_secret")
-            
-            if not bridge_secret:
-                logger.error(f"MCP tool {tool_name} requires bridge_secret in config")
-                return {
-                    "success": False,
-                    "error": "MCP bridge secret required"
-                }
-            
-            # Try different endpoint patterns that might exist
-            endpoints_to_try = [
-                f"{bridge_url}/execute_tool",
-                f"{bridge_url}/tool/{tool_name}",
-                f"{bridge_url}/mcp/execute",
-                f"{bridge_url}/api/execute"
-            ]
-            
-            # Prepare request
-            payload = {
-                "tool_name": tool_name,
-                "input_data": input_data
-            }
-            
-            headers = {
-                "Content-Type": "application/json",
-                "X-Bridge-Secret": bridge_secret
-            }
-            
-            # Try each endpoint
-            logger.info(f"Executing MCP tool {tool_name} via bridge at {bridge_url}")
-            
-            last_error = None
-            for endpoint in endpoints_to_try:
-                try:
-                    with httpx.Client(timeout=60.0) as client:
-                        response = client.post(endpoint, json=payload, headers=headers)
-                        
-                        if response.status_code == 200:
-                            result = response.json()
-                            logger.info(f"MCP tool {tool_name} executed successfully via {endpoint}")
-                            return result
-                        elif response.status_code == 404:
-                            continue  # Try next endpoint
-                        else:
-                            response.raise_for_status()
-                            
-                except httpx.HTTPStatusError as e:
-                    if e.response.status_code == 404:
-                        continue  # Try next endpoint
-                    last_error = e
-                    continue
-                except Exception as e:
-                    last_error = e
-                    continue
-            
-            # If we get here, none of the endpoints worked
-            # For now, return mock data to keep the workflow working
-            logger.warning(f"MCP bridge endpoints not available, returning mock data for {tool_name}")
-            
-            if tool_name == "DataValidator":
-                return {
-                    "success": True,
-                    "data": {
-                        "is_valid": True,
-                        "validation_errors": [],
-                        "validated_data": input_data.get("invoice_data", {}),
-                        "_mock": True
-                    }
-                }
-            elif tool_name == "PostgresInsert":
-                return {
-                    "success": True,
-                    "data": {
-                        "success": True,
-                        "record_id": 999,  # Mock ID
-                        "database_table": "invoices",
-                        "inserted_data": input_data.get("invoice_data", {}),
-                        "_mock": True
-                    }
-                }
-            elif tool_name == "FileDiscovery":
-                # Mock file discovery - in real implementation, would scan directories
-                directory = input_data.get("directory", "invoices")
-                file_pattern = input_data.get("pattern", "*.pdf")
-                
-                # Simulate finding files in the directory
-                mock_files = [
-                    {
-                        "filename": "10352259310.PDF",
-                        "path": f"{directory}/10352259310.PDF",
-                        "size": "542KB",
-                        "modified": "2024-05-28",
-                        "type": "PDF"
-                    }
-                ]
-                
-                return {
-                    "success": True,
-                    "data": {
-                        "directory": directory,
-                        "pattern": file_pattern,
-                        "files_found": len(mock_files),
-                        "files": mock_files,
-                        "message": f"Found {len(mock_files)} files in {directory}/ directory"
-                    }
-                }
-                
-            elif tool_name == "FileCopy":
-                # Mock file copy - in real implementation, would copy files
-                source_path = input_data.get("source_path", "")
-                destination_dir = input_data.get("destination_dir", "invoices")
-                
-                if not source_path:
-                    return {
-                        "success": False,
-                        "error": "Source path is required"
-                    }
-                
-                # Extract filename from path
-                import os
-                filename = os.path.basename(source_path)
-                destination_path = f"{destination_dir}/{filename}"
-                
-                return {
-                    "success": True,
-                    "data": {
-                        "source_path": source_path,
-                        "destination_path": destination_path,
-                        "message": f"File copied from {source_path} to {destination_path}",
-                        "file_size": "245KB",
-                        "operation": "copy_completed"
-                    }
-                }
-            elif tool_name == "TextToSQL":
-                # Mock text-to-SQL - in real implementation, would use LLM to generate SQL
-                question = input_data.get("question", "")
-                schema = input_data.get("schema", {})
-                
-                if not question:
-                    return {
-                        "success": False,
-                        "error": "Question is required for text-to-SQL conversion"
-                    }
-                
-                # Simulate SQL generation and execution
-                mock_sql = "SELECT vendor_name, invoice_number, total_amount FROM invoices WHERE vendor_name ILIKE '%air liquide%' ORDER BY invoice_date DESC LIMIT 5;"
-                mock_results = [
-                    {
-                        "vendor_name": "Air Liquide Canada Inc.",
-                        "invoice_number": "INV-12345",
-                        "total_amount": 1234.56
-                    },
-                    {
-                        "vendor_name": "Air Liquide Canada Inc.", 
-                        "invoice_number": "INV-67890",
-                        "total_amount": 2345.67
-                    }
-                ]
-                
-                return {
-                    "success": True,
-                    "data": {
-                        "question": question,
-                        "generated_sql": mock_sql,
-                        "results": mock_results,
-                        "row_count": len(mock_results),
-                        "message": f"Found {len(mock_results)} results for: {question}",
-                        "_mock": True
-                    }
-                }
-            elif tool_name == "SQLExecutor":
-                # Mock SQL execution
-                sql_query = input_data.get("sql_query", "")
-                
-                if not sql_query:
-                    return {
-                        "success": False,
-                        "error": "SQL query is required"
-                    }
-                
-                # Mock results based on query type
-                if sql_query.upper().startswith("SELECT"):
-                    mock_results = [
-                        {"vendor_name": "Air Liquide Canada Inc.", "invoice_number": "INV-12345", "total_amount": 1234.56},
-                        {"vendor_name": "Air Liquide Canada Inc.", "invoice_number": "INV-67890", "total_amount": 2345.67}
-                    ]
-                    return {
-                        "success": True,
-                        "data": {
-                            "query": sql_query,
-                            "results": mock_results,
-                            "row_count": len(mock_results),
-                            "columns": ["vendor_name", "invoice_number", "total_amount"],
-                            "_mock": True
-                        }
-                    }
-                else:
-                    return {
-                        "success": True,
-                        "data": {
-                            "query": sql_query,
-                            "affected_rows": 1,
-                            "message": "Query executed successfully",
-                            "_mock": True
-                        }
-                    }
-            elif tool_name == "TextToSQLGenerator":
-                # Mock SQL generation
-                question = input_data.get("question", "")
-                
-                if not question:
-                    return {
-                        "success": False,
-                        "error": "Question is required for SQL generation"
-                    }
-                
-                # Generate mock SQL based on question
-                mock_sql = "SELECT * FROM invoices WHERE vendor_name ILIKE '%air liquide%'"
-                
-                return {
-                    "success": True,
-                    "data": {
-                        "question": question,
-                        "generated_sql": mock_sql,
-                        "explanation": "Generated SQL query based on natural language question",
-                        "confidence": "medium",
-                        "_mock": True
-                    }
-                }
-            else:
-                return {
-                    "success": False,
-                    "error": f"MCP bridge not available and no mock data for {tool_name}"
-                }
-                
-        except httpx.TimeoutException:
-            logger.error(f"MCP tool {tool_name} execution timed out")
-            return {
-                "success": False,
-                "error": f"MCP tool execution timed out after 60 seconds"
-            }
-        except Exception as e:
-            logger.error(f"MCP tool execution failed for {tool_name}: {str(e)}")
-            return {
-                "success": False,
-                "error": str(e)
-            } 

memra-sdk/memra/tool_registry_client.py

@@ -1,106 +0,0 @@
-import httpx
-import logging
-import os
-from typing import Dict, Any, List, Optional
-import asyncio
-
-logger = logging.getLogger(__name__)
-
-class ToolRegistryClient:
-    """Client-side registry that calls Memra API for tool execution"""
-    
-    def __init__(self):
-        self.api_base = os.getenv("MEMRA_API_URL", "https://api.memra.co")
-        self.api_key = os.getenv("MEMRA_API_KEY")
-        self.tools_cache = None
-        
-        if not self.api_key:
-            raise ValueError(
-                "MEMRA_API_KEY environment variable is required. "
-                "Please contact info@memra.co for an API key."
-            )
-    
-    def discover_tools(self, hosted_by: Optional[str] = None) -> List[Dict[str, Any]]:
-        """Discover available tools from the API"""
-        try:
-            # Use sync httpx for compatibility with existing sync code
-            with httpx.Client(timeout=30.0) as client:
-                response = client.get(
-                    f"{self.api_base}/tools/discover",
-                    headers={"X-API-Key": self.api_key}
-                )
-                response.raise_for_status()
-                
-                data = response.json()
-                tools = data.get("tools", [])
-                
-                # Filter by hosted_by if specified
-                if hosted_by:
-                    tools = [t for t in tools if t.get("hosted_by") == hosted_by]
-                
-                self.tools_cache = tools
-                logger.info(f"Discovered {len(tools)} tools from API")
-                return tools
-                
-        except Exception as e:
-            logger.error(f"Failed to discover tools from API: {e}")
-            # Return empty list if API is unavailable
-            return []
-    
-    def execute_tool(self, tool_name: str, hosted_by: str, input_data: Dict[str, Any], 
-                    config: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        """Execute a tool via the API"""
-        try:
-            logger.info(f"Executing tool {tool_name} via API")
-            
-            # Prepare request payload
-            payload = {
-                "tool_name": tool_name,
-                "hosted_by": hosted_by,
-                "input_data": input_data,
-                "config": config
-            }
-            
-            # Make API call
-            with httpx.Client(timeout=120.0) as client:  # Longer timeout for tool execution
-                response = client.post(
-                    f"{self.api_base}/tools/execute",
-                    headers={
-                        "X-API-Key": self.api_key,
-                        "Content-Type": "application/json"
-                    },
-                    json=payload
-                )
-                response.raise_for_status()
-                
-                result = response.json()
-                logger.info(f"Tool {tool_name} executed successfully via API")
-                return result
-                
-        except httpx.TimeoutException:
-            logger.error(f"Tool {tool_name} execution timed out")
-            return {
-                "success": False,
-                "error": f"Tool execution timed out after 120 seconds"
-            }
-        except httpx.HTTPStatusError as e:
-            logger.error(f"API error for tool {tool_name}: {e.response.status_code}")
-            return {
-                "success": False,
-                "error": f"API error: {e.response.status_code} - {e.response.text}"
-            }
-        except Exception as e:
-            logger.error(f"Tool execution failed for {tool_name}: {str(e)}")
-            return {
-                "success": False,
-                "error": str(e)
-            }
-    
-    def health_check(self) -> bool:
-        """Check if the API is available"""
-        try:
-            with httpx.Client(timeout=10.0) as client:
-                response = client.get(f"{self.api_base}/health")
-                return response.status_code == 200
-        except:
-            return False 

memra-sdk/scripts/release.py

@@ -1,133 +0,0 @@
-#!/usr/bin/env python3
-"""
-Release script for Memra SDK
-Builds and uploads the package to PyPI
-"""
-
-import os
-import sys
-import subprocess
-import shutil
-from pathlib import Path
-
-def run_command(cmd, description):
-    """Run a command and handle errors"""
-    print(f"🔄 {description}...")
-    result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
-    if result.returncode != 0:
-        print(f"❌ {description} failed:")
-        print(result.stderr)
-        sys.exit(1)
-    print(f"✅ {description} completed")
-    return result.stdout
-
-def clean_build_artifacts():
-    """Clean up build artifacts"""
-    print("🧹 Cleaning build artifacts...")
-    
-    # Remove build directories
-    for dir_name in ['build', 'dist', 'memra.egg-info']:
-        if os.path.exists(dir_name):
-            shutil.rmtree(dir_name)
-            print(f"   Removed {dir_name}/")
-    
-    # Remove __pycache__ directories
-    for root, dirs, files in os.walk('.'):
-        for dir_name in dirs:
-            if dir_name == '__pycache__':
-                pycache_path = os.path.join(root, dir_name)
-                shutil.rmtree(pycache_path)
-                print(f"   Removed {pycache_path}")
-    
-    print("✅ Build artifacts cleaned")
-
-def run_tests():
-    """Run tests before release"""
-    print("🧪 Running tests...")
-    
-    # Check if pytest is available
-    try:
-        subprocess.run(['pytest', '--version'], check=True, capture_output=True)
-        run_command('pytest tests/', 'Running pytest')
-    except (subprocess.CalledProcessError, FileNotFoundError):
-        print("⚠️  pytest not found, skipping tests")
-    
-    # Run basic import test
-    run_command('python -c "import memra; print(f\'Memra SDK version: {memra.__version__ if hasattr(memra, \"__version__\") else \"unknown\"}\')"', 'Testing basic import')
-
-def build_package():
-    """Build the package"""
-    print("📦 Building package...")
-    
-    # Install build dependencies
-    run_command('pip install build twine', 'Installing build tools')
-    
-    # Build the package
-    run_command('python -m build', 'Building wheel and source distribution')
-    
-    # Check the package
-    run_command('twine check dist/*', 'Checking package')
-
-def upload_package(test=False):
-    """Upload package to PyPI"""
-    if test:
-        print("🚀 Uploading to Test PyPI...")
-        run_command('twine upload --repository testpypi dist/*', 'Uploading to Test PyPI')
-        print("📍 Package uploaded to Test PyPI: https://test.pypi.org/project/memra/")
-    else:
-        print("🚀 Uploading to PyPI...")
-        run_command('twine upload dist/*', 'Uploading to PyPI')
-        print("📍 Package uploaded to PyPI: https://pypi.org/project/memra/")
-
-def main():
-    """Main release process"""
-    print("🎯 Memra SDK Release Process")
-    print("=" * 40)
-    
-    # Parse arguments
-    test_release = '--test' in sys.argv
-    skip_tests = '--skip-tests' in sys.argv
-    
-    if test_release:
-        print("🧪 Test release mode enabled")
-    
-    # Ensure we're in the right directory
-    if not os.path.exists('setup.py'):
-        print("❌ setup.py not found. Please run from the project root.")
-        sys.exit(1)
-    
-    try:
-        # Clean up
-        clean_build_artifacts()
-        
-        # Run tests
-        if not skip_tests:
-            run_tests()
-        else:
-            print("⚠️  Skipping tests")
-        
-        # Build package
-        build_package()
-        
-        # Upload package
-        upload_package(test=test_release)
-        
-        print("\n🎉 Release completed successfully!")
-        
-        if test_release:
-            print("\n📋 Next steps:")
-            print("1. Test the package: pip install -i https://test.pypi.org/simple/ memra")
-            print("2. If everything works, run: python scripts/release.py")
-        else:
-            print("\n📋 Package is now available on PyPI!")
-            print("Install with: pip install memra")
-        
-    except KeyboardInterrupt:
-        print("\n❌ Release cancelled by user")
-        sys.exit(1)
-    except Exception as e:
-        print(f"\n❌ Release failed: {e}")
-        sys.exit(1)
-
-if __name__ == '__main__':
-    main() 

memra-sdk/setup.py

@@ -1,52 +0,0 @@
-from setuptools import setup, find_packages
-
-with open("README.md", "r", encoding="utf-8") as fh:
-    long_description = fh.read()
-
-setup(
-    name="memra",
-    version="0.2.4",
-    author="Memra",
-    author_email="support@memra.com",
-    description="Declarative framework for enterprise workflows with MCP integration - Client SDK",
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    url="https://github.com/memra/memra-sdk",
-    packages=find_packages(include=['memra', 'memra.*']),
-    classifiers=[
-        "Development Status :: 3 - Alpha",
-        "Intended Audience :: Developers",
-        "License :: OSI Approved :: MIT License",
-        "Operating System :: OS Independent",
-        "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.8",
-        "Programming Language :: Python :: 3.9",
-        "Programming Language :: Python :: 3.10",
-        "Programming Language :: Python :: 3.11",
-    ],
-    python_requires=">=3.8",
-    install_requires=[
-        "pydantic>=1.8.0",
-        "httpx>=0.24.0",
-        "typing-extensions>=4.0.0",
-        "aiohttp>=3.8.0",
-        "aiohttp-cors>=0.7.0",
-    ],
-    extras_require={
-        "dev": [
-            "pytest>=6.0",
-            "pytest-asyncio",
-            "black",
-            "flake8",
-        ],
-        "mcp": [
-            "psycopg2-binary>=2.9.0",
-        ],
-    },
-    entry_points={
-        "console_scripts": [
-            "memra=memra.cli:main",
-        ],
-    },
-)
-