PraisonAI 3.0.0__py3-none-any.whl

praisonai/scheduler.py

@@ -0,0 +1,194 @@
+"""
+DEPRECATED: This module is deprecated. Use praisonai.scheduler instead.
+
+This file is kept for backward compatibility only.
+All new code should import from praisonai.scheduler.
+"""
+
+import warnings
+import logging
+import threading
+import time
+from typing import Optional, Dict, Any
+from abc import ABC, abstractmethod
+
+logger = logging.getLogger(__name__)
+
+# Issue deprecation warning
+warnings.warn(
+    "praisonai.scheduler module (root level) is deprecated. "
+    "Use 'from praisonai.scheduler import ...' instead.",
+    DeprecationWarning,
+    stacklevel=2
+)
+
+# Import from new scheduler module for backward compatibility
+from .scheduler.base import ScheduleParser
+
+# Keep old classes for backward compatibility
+class DeployerInterface(ABC):
+    """Abstract interface for deployers to ensure provider compatibility."""
+    
+    @abstractmethod
+    def deploy(self) -> bool:
+        """Execute deployment. Returns True on success, False on failure."""
+        pass
+
+class CloudDeployerAdapter(DeployerInterface):
+    """Adapter for existing CloudDeployer to match interface."""
+    
+    def __init__(self):
+        from .deploy import CloudDeployer
+        self._deployer = CloudDeployer()
+    
+    def deploy(self) -> bool:
+        """Execute deployment using CloudDeployer."""
+        try:
+            self._deployer.run_commands()
+            return True
+        except Exception as e:
+            logger.error(f"Deployment failed: {e}")
+            return False
+
+class DeploymentScheduler:
+    """
+    Minimal deployment scheduler with provider-agnostic design.
+    
+    Features:
+    - Simple interval-based scheduling
+    - Thread-safe operation
+    - Extensible deployer factory pattern
+    - Minimal dependencies
+    """
+    
+    def __init__(self, schedule_config: Optional[Dict[str, Any]] = None):
+        self.config = schedule_config or {}
+        self.is_running = False
+        self._stop_event = threading.Event()
+        self._thread = None
+        self._deployer = None
+        
+    def set_deployer(self, deployer: DeployerInterface):
+        """Set custom deployer implementation."""
+        self._deployer = deployer
+        
+    def _get_deployer(self) -> DeployerInterface:
+        """Get deployer instance using factory pattern."""
+        if self._deployer:
+            return self._deployer
+        
+        # Default to CloudDeployer for backward compatibility
+        return CloudDeployerAdapter()
+    
+    def start(self, schedule_expr: str, max_retries: int = 3) -> bool:
+        """
+        Start scheduled deployment.
+        
+        Args:
+            schedule_expr: Schedule expression (e.g., "daily", "*/6h", "3600")
+            max_retries: Maximum retry attempts on failure
+            
+        Returns:
+            True if scheduler started successfully
+        """
+        if self.is_running:
+            logger.warning("Scheduler is already running")
+            return False
+            
+        try:
+            interval = ScheduleParser.parse(schedule_expr)
+            self.is_running = True
+            self._stop_event.clear()
+            
+            self._thread = threading.Thread(
+                target=self._run_schedule,
+                args=(interval, max_retries),
+                daemon=True
+            )
+            self._thread.start()
+            
+            logger.info(f"Deployment scheduler started with {interval}s interval")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Failed to start scheduler: {e}")
+            self.is_running = False
+            return False
+    
+    def stop(self) -> bool:
+        """Stop the scheduler."""
+        if not self.is_running:
+            return True
+            
+        self._stop_event.set()
+        if self._thread and self._thread.is_alive():
+            self._thread.join(timeout=5)
+            
+        self.is_running = False
+        logger.info("Deployment scheduler stopped")
+        return True
+    
+    def _run_schedule(self, interval: int, max_retries: int):
+        """Internal method to run scheduled deployments."""
+        deployer = self._get_deployer()
+        
+        while not self._stop_event.is_set():
+            logger.info("Starting scheduled deployment")
+            
+            success = False
+            for attempt in range(max_retries):
+                try:
+                    if deployer.deploy():
+                        logger.info(f"Deployment successful on attempt {attempt + 1}")
+                        success = True
+                        break
+                    else:
+                        logger.warning(f"Deployment failed on attempt {attempt + 1}")
+                except Exception as e:
+                    logger.error(f"Deployment error on attempt {attempt + 1}: {e}")
+                
+                if attempt < max_retries - 1:
+                    time.sleep(30)  # Wait before retry
+            
+            if not success:
+                logger.error(f"Deployment failed after {max_retries} attempts")
+            
+            # Wait for next scheduled time
+            self._stop_event.wait(interval)
+    
+    def deploy_once(self) -> bool:
+        """Execute a single deployment immediately."""
+        deployer = self._get_deployer()
+        try:
+            return deployer.deploy()
+        except Exception as e:
+            logger.error(f"One-time deployment failed: {e}")
+            return False
+
+def create_scheduler(provider: str = "gcp", config: Optional[Dict[str, Any]] = None) -> DeploymentScheduler:
+    """
+    Factory function to create scheduler for different providers.
+    
+    Args:
+        provider: Deployment provider ("gcp", "aws", "azure", etc.)
+        config: Optional configuration dict
+        
+    Returns:
+        Configured DeploymentScheduler instance
+    """
+    scheduler = DeploymentScheduler(config)
+    
+    # Provider-specific deployer setup can be added here
+    if provider == "gcp":
+        # Default CloudDeployer for GCP
+        pass
+    elif provider == "aws":
+        # Future: AWS deployer implementation
+        logger.warning("AWS provider not yet implemented, using default")
+    elif provider == "azure":
+        # Future: Azure deployer implementation  
+        logger.warning("Azure provider not yet implemented, using default")
+    else:
+        logger.warning(f"Unknown provider {provider}, using default")
+    
+    return scheduler

praisonai/setup/__init__.py

@@ -0,0 +1 @@
+

praisonai/setup/build.py

@@ -0,0 +1,21 @@
+import subprocess
+import sys
+import os
+
+def build(setup_kwargs):
+    try:
+        # Get the directory of the current script
+        script_dir = os.path.dirname(os.path.abspath(__file__))
+        
+        # Construct the path to post_install.py
+        post_install_script = os.path.join(script_dir, 'post_install.py')
+        
+        # Run the post_install.py script
+        subprocess.check_call([sys.executable, post_install_script])
+    except subprocess.CalledProcessError as e:
+        print(f"Error occurred while running the post-install script: {e}")
+        sys.exit(1)
+    return setup_kwargs
+
+if __name__ == "__main__":
+    build({})

praisonai/setup/post_install.py

@@ -0,0 +1,23 @@
+import os
+import sys
+import subprocess
+import logging
+
+def install_playwright():
+    """Install playwright browsers."""
+    try:
+        subprocess.run([sys.executable, "-m", "playwright", "install"], check=True)
+        logging.info("Playwright browsers installed successfully")
+    except subprocess.CalledProcessError as e:
+        logging.error(f"Failed to install playwright browsers: {e}")
+    except Exception as e:
+        logging.error(f"Unexpected error installing playwright browsers: {e}")
+
+def main():
+    """Post-installation script."""
+    # Check if this is a chat or code installation
+    if any(extra in sys.argv for extra in ['chat', 'code']):
+        install_playwright()
+
+if __name__ == "__main__":
+    main()

praisonai/setup/setup_conda_env.py

@@ -0,0 +1,25 @@
+import subprocess
+import os
+import sys
+import platform
+
+def main():
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    script_path = os.path.join(script_dir, 'setup_conda_env.sh')
+    
+    if platform.system() == 'Windows':
+        print("Windows detected. Please run the setup_conda_env.sh script manually in Git Bash or WSL.")
+        print(f"Script location: {script_path}")
+        sys.exit(1)
+    
+    try:
+        subprocess.check_call(['bash', script_path])
+    except subprocess.CalledProcessError as e:
+        print(f"Error occurred while running the setup script: {e}")
+        print("Setup failed. Please check the error message above and try to resolve the issue.")
+        sys.exit(1)
+    
+    print("Conda environment setup completed successfully!")
+
+if __name__ == "__main__":
+    main()

praisonai/setup.py

@@ -0,0 +1,16 @@
+from setuptools import setup
+from setuptools.command.install import install
+import subprocess
+import sys
+
+class PostInstallCommand(install):
+    def run(self):
+        install.run(self)
+        # Install Playwright browsers
+        subprocess.check_call([sys.executable, '-m', 'playwright', 'install'])
+
+setup(
+    cmdclass={
+        'install': PostInstallCommand,
+    }
+) 

praisonai/templates/__init__.py

@@ -0,0 +1,116 @@
+"""
+PraisonAI Templates Module
+
+Provides template loading, caching, and resolution for Agent/Workflow configurations.
+All imports are lazy to ensure zero performance impact when not used.
+"""
+
+__all__ = [
+    "TemplateLoader",
+    "TemplateResolver",
+    "TemplateCache",
+    "TemplateRegistry",
+    "TemplateSecurity",
+    "TemplateDiscovery",
+    "DiscoveredTemplate",
+    "DependencyChecker",
+    "StrictModeError",
+    "ToolsDoctor",
+    "ToolOverrideLoader",
+    "SecurityError",
+    "load_template",
+    "list_templates",
+    "search_templates",
+    "install_template",
+    "clear_cache",
+    "discover_templates",
+    "find_template_path",
+]
+
+# Lazy loading implementation
+_module_cache = {}
+
+
+def __getattr__(name):
+    """Lazy load template components to avoid import overhead."""
+    if name in _module_cache:
+        return _module_cache[name]
+    
+    if name == "TemplateLoader":
+        from .loader import TemplateLoader
+        _module_cache[name] = TemplateLoader
+        return TemplateLoader
+    elif name == "TemplateResolver":
+        from .resolver import TemplateResolver
+        _module_cache[name] = TemplateResolver
+        return TemplateResolver
+    elif name == "TemplateCache":
+        from .cache import TemplateCache
+        _module_cache[name] = TemplateCache
+        return TemplateCache
+    elif name == "TemplateRegistry":
+        from .registry import TemplateRegistry
+        _module_cache[name] = TemplateRegistry
+        return TemplateRegistry
+    elif name == "TemplateSecurity":
+        from .security import TemplateSecurity
+        _module_cache[name] = TemplateSecurity
+        return TemplateSecurity
+    elif name == "load_template":
+        from .loader import load_template
+        _module_cache[name] = load_template
+        return load_template
+    elif name == "list_templates":
+        from .registry import list_templates
+        _module_cache[name] = list_templates
+        return list_templates
+    elif name == "search_templates":
+        from .registry import search_templates
+        _module_cache[name] = search_templates
+        return search_templates
+    elif name == "install_template":
+        from .registry import install_template
+        _module_cache[name] = install_template
+        return install_template
+    elif name == "clear_cache":
+        from .cache import clear_cache
+        _module_cache[name] = clear_cache
+        return clear_cache
+    elif name == "TemplateDiscovery":
+        from .discovery import TemplateDiscovery
+        _module_cache[name] = TemplateDiscovery
+        return TemplateDiscovery
+    elif name == "DiscoveredTemplate":
+        from .discovery import DiscoveredTemplate
+        _module_cache[name] = DiscoveredTemplate
+        return DiscoveredTemplate
+    elif name == "discover_templates":
+        from .discovery import discover_templates
+        _module_cache[name] = discover_templates
+        return discover_templates
+    elif name == "find_template_path":
+        from .discovery import find_template_path
+        _module_cache[name] = find_template_path
+        return find_template_path
+    elif name == "DependencyChecker":
+        from .dependency_checker import DependencyChecker
+        _module_cache[name] = DependencyChecker
+        return DependencyChecker
+    elif name == "StrictModeError":
+        from .dependency_checker import StrictModeError
+        _module_cache[name] = StrictModeError
+        return StrictModeError
+    elif name == "ToolsDoctor":
+        from .tools_doctor import ToolsDoctor
+        _module_cache[name] = ToolsDoctor
+        return ToolsDoctor
+    elif name == "ToolOverrideLoader":
+        from .tool_override import ToolOverrideLoader
+        _module_cache[name] = ToolOverrideLoader
+        return ToolOverrideLoader
+    elif name == "SecurityError":
+        from .tool_override import SecurityError
+        _module_cache[name] = SecurityError
+        return SecurityError
+    
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")