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

memra-ops/scripts/check_database.py

@@ -1,37 +0,0 @@
-import psycopg2
-from prettytable import PrettyTable
-import time
-
-def check_database():
-    # Connect to the Postgres database
-    conn = psycopg2.connect(
-        dbname="memra_invoice_db",
-        user="memra",          # From docker-compose.yml
-        password="memra123",   # From docker-compose.yml
-        host="localhost",
-        port=5432
-    )
-
-    # Create a cursor and run the query
-    cur = conn.cursor()
-    cur.execute("SELECT * FROM invoices ORDER BY created_at DESC LIMIT 10;")
-    rows = cur.fetchall()
-    columns = [desc[0] for desc in cur.description]
-
-    # Create and populate the pretty table
-    table = PrettyTable()
-    table.field_names = columns
-    for row in rows:
-        table.add_row(row)
-
-    # Print the table
-    print(f"\n📊 Current invoices in database (as of {time.strftime('%H:%M:%S')}):")
-    print(table)
-    print(f"Total rows: {len(rows)}")
-
-    # Clean up
-    cur.close()
-    conn.close()
-
-if __name__ == "__main__":
-    check_database() 

memra-ops/scripts/clear_database.py

@@ -1,48 +0,0 @@
-import psycopg2
-
-def clear_database():
-    """Clear all data from the invoices table"""
-    
-    # Connect to the Postgres database
-    conn = psycopg2.connect(
-        dbname="memra_invoice_db",
-        user="memra",          # From docker-compose.yml
-        password="memra123",   # From docker-compose.yml
-        host="localhost",
-        port=5432
-    )
-
-    try:
-        # Create a cursor and run the query
-        cur = conn.cursor()
-        
-        # First, let's see how many rows we have
-        cur.execute("SELECT COUNT(*) FROM invoices;")
-        count_before = cur.fetchone()[0]
-        print(f"📊 Current invoice count: {count_before}")
-        
-        if count_before > 0:
-            # Clear all data from the invoices table
-            cur.execute("DELETE FROM invoices;")
-            conn.commit()
-            
-            # Verify the deletion
-            cur.execute("SELECT COUNT(*) FROM invoices;")
-            count_after = cur.fetchone()[0]
-            
-            print(f"🗑️  Deleted {count_before} invoice records")
-            print(f"📊 New invoice count: {count_after}")
-            print("✅ Database cleared successfully!")
-        else:
-            print("📊 Database is already empty")
-        
-        cur.close()
-        
-    except Exception as e:
-        print(f"❌ Error: {e}")
-        conn.rollback()
-    finally:
-        conn.close()
-
-if __name__ == "__main__":
-    clear_database() 

memra-ops/scripts/monitor_database.py

@@ -1,67 +0,0 @@
-import psycopg2
-from prettytable import PrettyTable
-import time
-import os
-
-def monitor_database():
-    """Continuously monitor the database for new invoice rows"""
-    
-    # Connect to the Postgres database
-    conn = psycopg2.connect(
-        dbname="memra_invoice_db",
-        user="memra",          # From docker-compose.yml
-        password="memra123",   # From docker-compose.yml
-        host="localhost",
-        port=5432
-    )
-
-    print("🔍 Monitoring database for new invoice rows...")
-    print("Press Ctrl+C to stop monitoring\n")
-    
-    last_count = 0
-    
-    try:
-        while True:
-            # Create a cursor and run the query
-            cur = conn.cursor()
-            cur.execute("SELECT COUNT(*) FROM invoices;")
-            current_count = cur.fetchone()[0]
-            
-            # Get the latest invoices
-            cur.execute("SELECT id, invoice_number, vendor_name, total_amount, created_at FROM invoices ORDER BY created_at DESC LIMIT 5;")
-            rows = cur.fetchall()
-            
-            # Clear screen (works on Unix-like systems)
-            os.system('clear' if os.name == 'posix' else 'cls')
-            
-            print(f"📊 Database Monitor - {time.strftime('%Y-%m-%d %H:%M:%S')}")
-            print(f"Total invoices: {current_count}")
-            
-            if current_count > last_count:
-                print(f"🆕 New invoices detected! (+{current_count - last_count})")
-                last_count = current_count
-            
-            if rows:
-                # Create and populate the pretty table
-                table = PrettyTable()
-                table.field_names = ["ID", "Invoice #", "Vendor", "Amount", "Created"]
-                for row in rows:
-                    table.add_row(row)
-                print("\nLatest invoices:")
-                print(table)
-            else:
-                print("\nNo invoices found in database.")
-            
-            print(f"\nMonitoring... (refresh every 2 seconds)")
-            cur.close()
-            time.sleep(2)
-            
-    except KeyboardInterrupt:
-        print("\n\n🛑 Monitoring stopped by user.")
-    except Exception as e:
-        print(f"\n❌ Error: {e}")
-    finally:
-        conn.close()
-
-if __name__ == "__main__":
-    monitor_database() 

memra-ops/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-ops/scripts/reset_database.py

@@ -1,65 +0,0 @@
-import psycopg2
-
-def reset_database():
-    """Clear all data from the invoices table and reset the sequence"""
-    
-    # Connect to the Postgres database
-    conn = psycopg2.connect(
-        dbname="memra_invoice_db",
-        user="memra",          # From docker-compose.yml
-        password="memra123",   # From docker-compose.yml
-        host="localhost",
-        port=5432
-    )
-
-    try:
-        # Create a cursor and run the query
-        cur = conn.cursor()
-        
-        # First, let's see how many rows we have and current sequence value
-        cur.execute("SELECT COUNT(*) FROM invoices;")
-        count_before = cur.fetchone()[0]
-        
-        cur.execute("SELECT last_value FROM invoices_id_seq;")
-        sequence_before = cur.fetchone()[0]
-        
-        print(f"📊 Current invoice count: {count_before}")
-        print(f"🔢 Current sequence value: {sequence_before}")
-        
-        if count_before > 0:
-            # Clear all data from the invoices table
-            cur.execute("DELETE FROM invoices;")
-            
-            # Reset the sequence to start from 1
-            cur.execute("ALTER SEQUENCE invoices_id_seq RESTART WITH 1;")
-            
-            conn.commit()
-            
-            # Verify the deletion and sequence reset
-            cur.execute("SELECT COUNT(*) FROM invoices;")
-            count_after = cur.fetchone()[0]
-            
-            cur.execute("SELECT last_value FROM invoices_id_seq;")
-            sequence_after = cur.fetchone()[0]
-            
-            print(f"🗑️  Deleted {count_before} invoice records")
-            print(f"🔄 Reset sequence from {sequence_before} to {sequence_after}")
-            print(f"📊 New invoice count: {count_after}")
-            print("✅ Database reset successfully!")
-        else:
-            print("📊 Database is already empty")
-            # Still reset the sequence
-            cur.execute("ALTER SEQUENCE invoices_id_seq RESTART WITH 1;")
-            conn.commit()
-            print("🔄 Reset sequence to start from 1")
-        
-        cur.close()
-        
-    except Exception as e:
-        print(f"❌ Error: {e}")
-        conn.rollback()
-    finally:
-        conn.close()
-
-if __name__ == "__main__":
-    reset_database() 

memra-ops/scripts/start_memra.py

@@ -1,334 +0,0 @@
-#!/usr/bin/env python3
-"""
-Memra System Startup Script
-Starts all dependencies required for the Memra system to run
-"""
-
-import os
-import sys
-import time
-import subprocess
-import requests
-import signal
-from pathlib import Path
-
-# Add the project root to the path
-project_root = Path(__file__).parent.parent
-sys.path.insert(0, str(project_root))
-
-class MemraStartup:
-    def __init__(self):
-        self.project_root = project_root
-        self.docker_compose_file = project_root / "docker-compose.yml"
-        self.mcp_bridge_script = project_root / "mcp_bridge_server.py"
-        self.processes = []
-        
-    def print_banner(self):
-        """Print startup banner"""
-        print("=" * 60)
-        print("🚀 MEMRA SYSTEM STARTUP")
-        print("=" * 60)
-        print("Starting all dependencies for Memra AI workflow system...")
-        print()
-        
-    def check_conda_environment(self):
-        """Check if we're in the correct conda environment"""
-        print("🔍 Checking conda environment...")
-        
-        # Check if we're in the memra environment
-        conda_env = os.getenv('CONDA_DEFAULT_ENV')
-        if conda_env != 'memra':
-            print(f"❌ Warning: Not in 'memra' conda environment (current: {conda_env})")
-            print("   Please run: conda activate memra")
-            print("   Then run this script again.")
-            return False
-        
-        print(f"✅ Conda environment: {conda_env}")
-        return True
-        
-    def check_docker(self):
-        """Check if Docker is running"""
-        print("🐳 Checking Docker...")
-        try:
-            result = subprocess.run(['docker', 'info'], 
-                                  capture_output=True, text=True, timeout=10)
-            if result.returncode == 0:
-                print("✅ Docker is running")
-                return True
-            else:
-                print("❌ Docker is not running")
-                return False
-        except (subprocess.TimeoutExpired, FileNotFoundError):
-            print("❌ Docker is not running or not installed")
-            return False
-            
-    def start_postgresql(self):
-        """Start PostgreSQL using Docker Compose"""
-        print("🐘 Starting PostgreSQL...")
-        
-        try:
-            # Check if containers are already running
-            result = subprocess.run(['docker', 'ps', '--filter', 'name=memra-postgres'], 
-                                  capture_output=True, text=True)
-            
-            if 'memra-postgres' in result.stdout:
-                print("✅ PostgreSQL is already running")
-                return True
-                
-            # Start PostgreSQL
-            print("   Starting PostgreSQL container...")
-            result = subprocess.run(['docker-compose', 'up', '-d', 'postgres'], 
-                                  cwd=self.project_root, capture_output=True, text=True)
-            
-            if result.returncode == 0:
-                print("✅ PostgreSQL started successfully")
-                return True
-            else:
-                print(f"❌ Failed to start PostgreSQL: {result.stderr}")
-                return False
-                
-        except Exception as e:
-            print(f"❌ Error starting PostgreSQL: {e}")
-            return False
-            
-    def wait_for_postgresql(self, max_attempts=30):
-        """Wait for PostgreSQL to be ready"""
-        print("⏳ Waiting for PostgreSQL to be ready...")
-        
-        for attempt in range(max_attempts):
-            try:
-                # Try to connect to PostgreSQL
-                result = subprocess.run([
-                    'docker', 'exec', 'memra-postgres', 
-                    'pg_isready', '-U', 'memra', '-d', 'memra_invoice_db'
-                ], capture_output=True, text=True, timeout=5)
-                
-                if result.returncode == 0:
-                    print("✅ PostgreSQL is ready")
-                    return True
-                    
-            except (subprocess.TimeoutExpired, subprocess.CalledProcessError):
-                pass
-                
-            print(f"   Attempt {attempt + 1}/{max_attempts}...")
-            time.sleep(2)
-            
-        print("❌ PostgreSQL failed to start within timeout")
-        return False
-        
-    def check_memra_api_key(self):
-        """Check if MEMRA_API_KEY is set"""
-        print("🔑 Checking Memra API key...")
-        
-        api_key = os.getenv('MEMRA_API_KEY')
-        if not api_key:
-            print("❌ MEMRA_API_KEY environment variable is not set")
-            print("   Please set: export MEMRA_API_KEY='your-key-here'")
-            return False
-            
-        print(f"✅ Memra API key is set: {api_key[:8]}...")
-        return True
-        
-    def start_mcp_bridge(self):
-        """Start the MCP bridge server"""
-        print("🌉 Starting MCP Bridge Server...")
-        
-        try:
-            # Check if MCP bridge is already running
-            try:
-                response = requests.get('http://localhost:8081/health', timeout=5)
-                if response.status_code == 200:
-                    print("✅ MCP Bridge Server is already running")
-                    return True
-            except requests.RequestException:
-                pass
-                
-            # Start MCP bridge server in background
-            print("   Starting MCP bridge server...")
-            process = subprocess.Popen([
-                sys.executable, str(self.mcp_bridge_script)
-            ], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-            
-            self.processes.append(process)
-            
-            # Wait a moment for server to start
-            time.sleep(3)
-            
-            # Check if server started successfully
-            try:
-                response = requests.get('http://localhost:8081/health', timeout=5)
-                if response.status_code == 200:
-                    print("✅ MCP Bridge Server started successfully")
-                    return True
-                else:
-                    print(f"❌ MCP Bridge Server returned status {response.status_code}")
-                    return False
-            except requests.RequestException as e:
-                print(f"❌ MCP Bridge Server failed to start: {e}")
-                return False
-                
-        except Exception as e:
-            print(f"❌ Error starting MCP Bridge Server: {e}")
-            return False
-            
-    def test_memra_api(self):
-        """Test the Memra API connection"""
-        print("🌐 Testing Memra API connection...")
-        
-        try:
-            from memra import get_api_status
-            api_status = get_api_status()
-            
-            if api_status['api_healthy']:
-                print(f"✅ Memra API is healthy")
-                print(f"   URL: {api_status['api_url']}")
-                print(f"   Tools Available: {api_status['tools_available']}")
-                return True
-            else:
-                print("❌ Memra API is not healthy")
-                return False
-                
-        except Exception as e:
-            print(f"❌ Error testing Memra API: {e}")
-            return False
-            
-    def run_test_workflow(self):
-        """Run a quick test to verify everything works"""
-        print("🧪 Running system test...")
-        
-        try:
-            # Import and run a simple test
-            from memra import Agent, Department, LLM
-            from memra.execution import ExecutionEngine
-            
-            # Create a simple test agent
-            test_agent = Agent(
-                role="Test Agent",
-                job="Verify system is working",
-                llm=LLM(model="llama-3.2-11b-vision-preview", temperature=0.1),
-                sops=["Return a simple success message"],
-                output_key="test_result"
-            )
-            
-            # Create test department
-            test_dept = Department(
-                name="Test Department",
-                mission="Verify Memra system is working",
-                agents=[test_agent],
-                workflow_order=["Test Agent"]
-            )
-            
-            # Run test
-            engine = ExecutionEngine()
-            result = engine.execute_department(test_dept, {})
-            
-            if result.success:
-                print("✅ System test passed - Memra is ready!")
-                return True
-            else:
-                print(f"❌ System test failed: {result.error}")
-                return False
-                
-        except Exception as e:
-            print(f"❌ Error running system test: {e}")
-            return False
-            
-    def cleanup(self):
-        """Cleanup processes on exit"""
-        print("\n🧹 Cleaning up processes...")
-        for process in self.processes:
-            try:
-                process.terminate()
-                process.wait(timeout=5)
-            except:
-                try:
-                    process.kill()
-                except:
-                    pass
-                    
-    def signal_handler(self, signum, frame):
-        """Handle interrupt signals"""
-        print("\n🛑 Received interrupt signal, shutting down...")
-        self.cleanup()
-        sys.exit(0)
-        
-    def start(self):
-        """Main startup sequence"""
-        try:
-            self.print_banner()
-            
-            # Set up signal handlers
-            signal.signal(signal.SIGINT, self.signal_handler)
-            signal.signal(signal.SIGTERM, self.signal_handler)
-            
-            # Check environment
-            if not self.check_conda_environment():
-                return False
-                
-            # Check Docker
-            if not self.check_docker():
-                print("❌ Please start Docker Desktop and try again")
-                return False
-                
-            # Start PostgreSQL
-            if not self.start_postgresql():
-                return False
-                
-            if not self.wait_for_postgresql():
-                return False
-                
-            # Check API key
-            if not self.check_memra_api_key():
-                return False
-                
-            # Start MCP bridge
-            if not self.start_mcp_bridge():
-                return False
-                
-            # Test API
-            if not self.test_memra_api():
-                return False
-                
-            # Run system test
-            if not self.run_test_workflow():
-                return False
-                
-            print("\n" + "=" * 60)
-            print("🎉 MEMRA SYSTEM STARTED SUCCESSFULLY!")
-            print("=" * 60)
-            print("✅ All dependencies are running:")
-            print("   • PostgreSQL Database (Docker)")
-            print("   • MCP Bridge Server (localhost:8081)")
-            print("   • Memra API (https://api.memra.co)")
-            print()
-            print("🚀 Ready to run workflows!")
-            print("   Example: python3 examples/accounts_payable_client.py")
-            print()
-            print("💡 Keep this terminal open to maintain the MCP bridge server")
-            print("   Press Ctrl+C to stop all services")
-            print("=" * 60)
-            
-            # Keep the script running to maintain the MCP bridge server
-            try:
-                while True:
-                    time.sleep(1)
-            except KeyboardInterrupt:
-                print("\n🛑 Shutting down Memra system...")
-                self.cleanup()
-                print("✅ Memra system stopped")
-                
-        except Exception as e:
-            print(f"❌ Startup failed: {e}")
-            self.cleanup()
-            return False
-            
-        return True
-
-def main():
-    """Main entry point"""
-    startup = MemraStartup()
-    success = startup.start()
-    sys.exit(0 if success else 1)
-
-if __name__ == "__main__":
-    main()