aiecs 1.0.1__py3-none-any.whl → 1.7.17__py3-none-any.whl

aiecs/core/interface/execution_interface.py

@@ -9,12 +9,10 @@ class IToolProvider(ABC):
     @abstractmethod
     def get_tool(self, tool_name: str) -> Any:
         """Get tool instance"""
-        pass
 
     @abstractmethod
     def has_tool(self, tool_name: str) -> bool:
         """Check if tool exists"""
-        pass
 
 
 class IToolExecutor(ABC):
@@ -23,32 +21,33 @@ class IToolExecutor(ABC):
     @abstractmethod
     def execute(self, tool: Any, operation_name: str, **params) -> Any:
         """Execute tool operation synchronously"""
-        pass
 
     @abstractmethod
     async def execute_async(self, tool: Any, operation_name: str, **params) -> Any:
         """Execute tool operation asynchronously"""
-        pass
 
 
 class ICacheProvider(ABC):
     """Cache provider interface - Domain layer abstraction"""
 
     @abstractmethod
-    def generate_cache_key(self, operation_type: str, user_id: str, task_id: str,
-                          args: tuple, kwargs: Dict[str, Any]) -> str:
+    def generate_cache_key(
+        self,
+        operation_type: str,
+        user_id: str,
+        task_id: str,
+        args: tuple,
+        kwargs: Dict[str, Any],
+    ) -> str:
         """Generate cache key"""
-        pass
 
     @abstractmethod
     def get_from_cache(self, cache_key: str) -> Optional[Any]:
         """Get data from cache"""
-        pass
 
     @abstractmethod
     def add_to_cache(self, cache_key: str, value: Any) -> None:
         """Add data to cache"""
-        pass
 
 
 class IOperationExecutor(ABC):
@@ -57,25 +56,25 @@ class IOperationExecutor(ABC):
     @abstractmethod
     async def execute_operation(self, operation_spec: str, params: Dict[str, Any]) -> Any:
         """Execute single operation"""
-        pass
 
     @abstractmethod
     async def batch_execute_operations(self, operations: List[Dict[str, Any]]) -> List[Any]:
         """Batch execute operations"""
-        pass
 
     @abstractmethod
-    async def execute_operations_sequence(self, operations: List[Dict[str, Any]],
-                                        user_id: str, task_id: str,
-                                        stop_on_failure: bool = False,
-                                        save_callback: Optional[Callable] = None) -> List[TaskStepResult]:
+    async def execute_operations_sequence(
+        self,
+        operations: List[Dict[str, Any]],
+        user_id: str,
+        task_id: str,
+        stop_on_failure: bool = False,
+        save_callback: Optional[Callable] = None,
+    ) -> List[TaskStepResult]:
         """Execute operations sequence sequentially"""
-        pass
 
     @abstractmethod
     async def execute_parallel_operations(self, operations: List[Dict[str, Any]]) -> List[TaskStepResult]:
         """Execute operations in parallel"""
-        pass
 
 
 class ExecutionInterface(ABC):
@@ -96,10 +95,14 @@ class ExecutionInterface(ABC):
         Returns:
             Any: Operation result
         """
-        pass
 
     @abstractmethod
-    async def execute_task(self, task_name: str, input_data: Dict[str, Any], context: Dict[str, Any]) -> Any:
+    async def execute_task(
+        self,
+        task_name: str,
+        input_data: Dict[str, Any],
+        context: Dict[str, Any],
+    ) -> Any:
         """
         Execute a single task (e.g., service task).
 
@@ -111,7 +114,6 @@ class ExecutionInterface(ABC):
         Returns:
             Any: Task result
         """
-        pass
 
     @abstractmethod
     async def batch_execute_operations(self, operations: List[Dict[str, Any]]) -> List[Any]:
@@ -124,7 +126,6 @@ class ExecutionInterface(ABC):
         Returns:
             List[Any]: List of operation results
         """
-        pass
 
     @abstractmethod
     async def batch_execute_tasks(self, tasks: List[Dict[str, Any]]) -> List[Any]:
@@ -137,7 +138,6 @@ class ExecutionInterface(ABC):
         Returns:
             List[Any]: List of task results
         """
-        pass
 
     def register_executor(self, executor_type: str, executor_instance: Any) -> None:
         """

aiecs/core/interface/storage_interface.py

@@ -7,208 +7,157 @@ as other core interfaces, enabling dependency inversion and clean architecture.
 
 from abc import ABC, abstractmethod
 from typing import Dict, Any, Optional, List
-from datetime import datetime
 
 
 class ISessionStorage(ABC):
     """Session storage interface - Domain layer abstraction"""
-    
+
     @abstractmethod
-    async def create_session(
-        self,
-        session_id: str,
-        user_id: str,
-        metadata: Dict[str, Any] = None
-    ) -> Dict[str, Any]:
+    async def create_session(self, session_id: str, user_id: str, metadata: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
         """Create a new session."""
-        pass
-    
+
     @abstractmethod
     async def get_session(self, session_id: str) -> Optional[Dict[str, Any]]:
         """Get session by ID."""
-        pass
-    
+
     @abstractmethod
     async def update_session(
         self,
         session_id: str,
-        updates: Dict[str, Any] = None,
+        updates: Optional[Dict[str, Any]] = None,
         increment_requests: bool = False,
         add_processing_time: float = 0.0,
-        mark_error: bool = False
+        mark_error: bool = False,
     ) -> bool:
         """Update session with activity and metrics."""
-        pass
-    
+
     @abstractmethod
     async def end_session(self, session_id: str, status: str = "completed") -> bool:
         """End a session and update metrics."""
-        pass
 
 
 class IConversationStorage(ABC):
     """Conversation storage interface - Domain layer abstraction"""
-    
+
     @abstractmethod
     async def add_conversation_message(
         self,
         session_id: str,
         role: str,
         content: str,
-        metadata: Dict[str, Any] = None
+        metadata: Optional[Dict[str, Any]] = None,
     ) -> bool:
         """Add message to conversation history."""
-        pass
-    
+
     @abstractmethod
-    async def get_conversation_history(
-        self,
-        session_id: str,
-        limit: int = 50
-    ) -> List[Dict[str, Any]]:
+    async def get_conversation_history(self, session_id: str, limit: int = 50) -> List[Dict[str, Any]]:
         """Get conversation history for a session."""
-        pass
 
 
 class ICheckpointStorage(ABC):
     """Checkpoint storage interface - Domain layer abstraction"""
-    
+
     @abstractmethod
     async def store_checkpoint(
         self,
         thread_id: str,
         checkpoint_id: str,
         checkpoint_data: Dict[str, Any],
-        metadata: Dict[str, Any] = None
+        metadata: Optional[Dict[str, Any]] = None,
     ) -> bool:
         """Store checkpoint data."""
-        pass
-    
+
     @abstractmethod
-    async def get_checkpoint(
-        self,
-        thread_id: str,
-        checkpoint_id: str = None
-    ) -> Optional[Dict[str, Any]]:
+    async def get_checkpoint(self, thread_id: str, checkpoint_id: Optional[str] = None) -> Optional[Dict[str, Any]]:
         """Get checkpoint data. If checkpoint_id is None, get the latest."""
-        pass
-    
+
     @abstractmethod
-    async def list_checkpoints(
-        self,
-        thread_id: str,
-        limit: int = 10
-    ) -> List[Dict[str, Any]]:
+    async def list_checkpoints(self, thread_id: str, limit: int = 10) -> List[Dict[str, Any]]:
         """List checkpoints for a thread, ordered by creation time."""
-        pass
 
 
 class ITaskContextStorage(ABC):
     """Task context storage interface - Domain layer abstraction"""
-    
+
     @abstractmethod
     async def get_task_context(self, session_id: str) -> Optional[Any]:
         """Get TaskContext for a session."""
-        pass
-    
+
     @abstractmethod
     async def store_task_context(self, session_id: str, context: Any) -> bool:
         """Store TaskContext for a session."""
-        pass
 
 
 class IStorageBackend(
     ISessionStorage,
     IConversationStorage,
     ICheckpointStorage,
-    ITaskContextStorage
+    ITaskContextStorage,
 ):
     """
     Unified storage backend interface - Domain layer abstraction
-    
+
     This interface combines all storage capabilities and follows the same
     pattern as other core interfaces in the middleware architecture.
     """
-    
+
     @abstractmethod
     async def initialize(self) -> bool:
         """Initialize the storage backend."""
-        pass
-    
+
     @abstractmethod
     async def close(self):
         """Close the storage backend."""
-        pass
-    
+
     @abstractmethod
     async def health_check(self) -> Dict[str, Any]:
         """Perform health check."""
-        pass
-    
+
     @abstractmethod
     async def get_metrics(self) -> Dict[str, Any]:
         """Get comprehensive metrics."""
-        pass
-    
+
     @abstractmethod
     async def cleanup_expired_sessions(self, max_idle_hours: int = 24) -> int:
         """Clean up expired sessions and associated data."""
-        pass
 
 
 class ICheckpointerBackend(ABC):
     """
     Checkpointer backend interface for LangGraph integration.
-    
+
     This interface defines the minimal contract needed by BaseServiceCheckpointer
     to work with any storage backend, following dependency inversion principle.
     """
-    
+
     @abstractmethod
     async def put_checkpoint(
         self,
         thread_id: str,
         checkpoint_id: str,
         checkpoint_data: Dict[str, Any],
-        metadata: Dict[str, Any] = None
+        metadata: Optional[Dict[str, Any]] = None,
     ) -> bool:
         """Store a checkpoint for LangGraph workflows."""
-        pass
-    
+
     @abstractmethod
-    async def get_checkpoint(
-        self,
-        thread_id: str,
-        checkpoint_id: str = None
-    ) -> Optional[Dict[str, Any]]:
+    async def get_checkpoint(self, thread_id: str, checkpoint_id: Optional[str] = None) -> Optional[Dict[str, Any]]:
         """Retrieve a checkpoint for LangGraph workflows."""
-        pass
-    
+
     @abstractmethod
-    async def list_checkpoints(
-        self,
-        thread_id: str,
-        limit: int = 10
-    ) -> List[Dict[str, Any]]:
+    async def list_checkpoints(self, thread_id: str, limit: int = 10) -> List[Dict[str, Any]]:
         """List checkpoints for LangGraph workflows."""
-        pass
-    
+
     @abstractmethod
     async def put_writes(
         self,
         thread_id: str,
         checkpoint_id: str,
         task_id: str,
-        writes_data: List[tuple]
+        writes_data: List[tuple],
     ) -> bool:
         """Store intermediate writes for a checkpoint."""
-        pass
-    
+
     @abstractmethod
-    async def get_writes(
-        self,
-        thread_id: str,
-        checkpoint_id: str
-    ) -> List[tuple]:
+    async def get_writes(self, thread_id: str, checkpoint_id: str) -> List[tuple]:
         """Get intermediate writes for a checkpoint."""
-        pass

aiecs/core/registry/__init__.py

@@ -0,0 +1,31 @@
+"""
+Service Registry Module
+
+Provides service registration and discovery for AIECS.
+This is a core infrastructure module with no dependencies on other AIECS modules.
+
+Usage:
+    from aiecs.core.registry import register_ai_service, get_ai_service
+
+    @register_ai_service("execute", "openai")
+    class OpenAIExecuteService:
+        pass
+
+    service_cls = get_ai_service("execute", "openai")
+"""
+
+from .service_registry import (
+    AI_SERVICE_REGISTRY,
+    register_ai_service,
+    get_ai_service,
+    list_registered_services,
+    clear_registry,
+)
+
+__all__ = [
+    "AI_SERVICE_REGISTRY",
+    "register_ai_service",
+    "get_ai_service",
+    "list_registered_services",
+    "clear_registry",
+]

aiecs/core/registry/service_registry.py

@@ -0,0 +1,92 @@
+"""
+Service Registry - Core Infrastructure
+
+This module provides service registration and discovery functionality.
+It has ZERO dependencies on other AIECS modules to prevent circular imports.
+
+This is part of the core infrastructure layer and should never import from
+upper layers (domain, application, etc.).
+"""
+
+from typing import Dict, Tuple, Type, Any
+
+# Global registry: maps (mode, service) -> service class
+AI_SERVICE_REGISTRY: Dict[Tuple[str, str], Type[Any]] = {}
+
+
+def register_ai_service(mode: str, service: str):
+    """
+    Decorator for registering a service class to the registry.
+
+    Args:
+        mode: Service mode (e.g., "execute", "analyze")
+        service: Service name (e.g., "openai", "custom")
+
+    Returns:
+        Decorator function that registers the class
+
+    Example:
+        @register_ai_service("execute", "openai")
+        class OpenAIExecuteService:
+            pass
+    """
+
+    def decorator(cls: Type[Any]) -> Type[Any]:
+        key = (mode, service)
+        AI_SERVICE_REGISTRY[key] = cls
+        return cls
+
+    return decorator
+
+
+def get_ai_service(mode: str, service: str) -> Type[Any]:
+    """
+    Retrieve a registered service class.
+
+    Args:
+        mode: Service mode
+        service: Service name
+
+    Returns:
+        The registered service class
+
+    Raises:
+        ValueError: If no service is registered for the given mode and service
+
+    Example:
+        service_cls = get_ai_service("execute", "openai")
+        service_instance = service_cls()
+    """
+    key = (mode, service)
+    if key not in AI_SERVICE_REGISTRY:
+        raise ValueError(f"No registered service for mode '{mode}', service '{service}'. " f"Available services: {list(AI_SERVICE_REGISTRY.keys())}")
+    return AI_SERVICE_REGISTRY[key]
+
+
+def list_registered_services() -> Dict[Tuple[str, str], Type[Any]]:
+    """
+    List all registered services.
+
+    Returns:
+        Dictionary mapping (mode, service) tuples to service classes
+
+    Example:
+        services = list_registered_services()
+        for (mode, name), cls in services.items():
+            print(f"{mode}/{name}: {cls.__name__}")
+    """
+    return AI_SERVICE_REGISTRY.copy()
+
+
+def clear_registry() -> None:
+    """
+    Clear all registered services.
+
+    Primarily used for testing purposes to reset the registry state
+    between tests.
+
+    Example:
+        # In test setup or teardown
+        clear_registry()
+    """
+    AI_SERVICE_REGISTRY.clear()