aiecs 1.3.8__py3-none-any.whl → 1.4.0__py3-none-any.whl

aiecs/domain/agent/tool_agent.py

@@ -0,0 +1,267 @@
+"""
+Tool Agent
+
+Agent implementation specialized in tool usage and execution.
+"""
+
+import logging
+from typing import Dict, List, Any, Optional
+from datetime import datetime
+
+from aiecs.tools import get_tool, BaseTool
+
+from .base_agent import BaseAIAgent
+from .models import AgentType, AgentConfiguration
+from .exceptions import TaskExecutionError, ToolAccessDeniedError
+
+logger = logging.getLogger(__name__)
+
+
+class ToolAgent(BaseAIAgent):
+    """
+    Agent specialized in tool selection and execution.
+
+    This agent can execute one or more tools to complete tasks.
+    """
+
+    def __init__(
+        self,
+        agent_id: str,
+        name: str,
+        tools: List[str],
+        config: AgentConfiguration,
+        description: Optional[str] = None,
+        version: str = "1.0.0",
+    ):
+        """
+        Initialize Tool agent.
+
+        Args:
+            agent_id: Unique agent identifier
+            name: Agent name
+            tools: List of tool names agent can use
+            config: Agent configuration
+            description: Optional description
+            version: Agent version
+        """
+        super().__init__(
+            agent_id=agent_id,
+            name=name,
+            agent_type=AgentType.TASK_EXECUTOR,
+            config=config,
+            description=description or "Tool-based task execution agent",
+            version=version,
+        )
+        
+        self._available_tools = tools
+        self._tool_instances: Dict[str, BaseTool] = {}
+        self._tool_usage_stats: Dict[str, Dict[str, int]] = {}
+
+        logger.info(f"ToolAgent initialized: {agent_id} with tools: {', '.join(tools)}")
+
+    async def _initialize(self) -> None:
+        """Initialize Tool agent - load tools."""
+        # Load tool instances
+        for tool_name in self._available_tools:
+            try:
+                self._tool_instances[tool_name] = get_tool(tool_name)
+                self._tool_usage_stats[tool_name] = {
+                    "success_count": 0,
+                    "failure_count": 0,
+                    "total_count": 0,
+                }
+                logger.debug(f"ToolAgent {self.agent_id} loaded tool: {tool_name}")
+            except Exception as e:
+                logger.warning(f"Failed to load tool {tool_name}: {e}")
+
+        logger.info(f"ToolAgent {self.agent_id} initialized with {len(self._tool_instances)} tools")
+
+    async def _shutdown(self) -> None:
+        """Shutdown Tool agent."""
+        self._tool_instances.clear()
+        logger.info(f"ToolAgent {self.agent_id} shut down")
+
+    async def execute_task(
+        self,
+        task: Dict[str, Any],
+        context: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Execute a task using tools.
+
+        Args:
+            task: Task specification with 'tool', 'operation', and 'parameters'
+            context: Execution context
+
+        Returns:
+            Execution result with 'output', 'tool_used', 'execution_time'
+
+        Raises:
+            TaskExecutionError: If task execution fails
+        """
+        start_time = datetime.utcnow()
+
+        try:
+            # Extract tool and operation
+            tool_name = task.get('tool')
+            operation = task.get('operation')
+            parameters = task.get('parameters', {})
+
+            if not tool_name:
+                raise TaskExecutionError(
+                    "Task must contain 'tool' field",
+                    agent_id=self.agent_id
+                )
+
+            # Check tool access
+            if tool_name not in self._available_tools:
+                raise ToolAccessDeniedError(self.agent_id, tool_name)
+
+            # Transition to busy state
+            self._transition_state(self.state.__class__.BUSY)
+            self._current_task_id = task.get('task_id')
+
+            # Execute tool
+            result = await self._execute_tool(tool_name, operation, parameters)
+
+            # Calculate execution time
+            execution_time = (datetime.utcnow() - start_time).total_seconds()
+
+            # Update metrics
+            self.update_metrics(
+                execution_time=execution_time,
+                success=True,
+                tool_calls=1,
+            )
+
+            # Update tool usage stats
+            self._update_tool_stats(tool_name, success=True)
+
+            # Transition back to active
+            self._transition_state(self.state.__class__.ACTIVE)
+            self._current_task_id = None
+            self.last_active_at = datetime.utcnow()
+
+            return {
+                "success": True,
+                "output": result,
+                "tool_used": tool_name,
+                "operation": operation,
+                "execution_time": execution_time,
+                "timestamp": datetime.utcnow().isoformat(),
+            }
+
+        except Exception as e:
+            logger.error(f"Task execution failed for {self.agent_id}: {e}")
+            
+            # Update metrics for failure
+            execution_time = (datetime.utcnow() - start_time).total_seconds()
+            self.update_metrics(execution_time=execution_time, success=False)
+
+            # Update tool stats if tool was specified
+            if tool_name:
+                self._update_tool_stats(tool_name, success=False)
+
+            # Transition to error state
+            self._transition_state(self.state.__class__.ERROR)
+            self._current_task_id = None
+
+            raise TaskExecutionError(
+                f"Task execution failed: {str(e)}",
+                agent_id=self.agent_id,
+                task_id=task.get('task_id')
+            )
+
+    async def process_message(
+        self,
+        message: str,
+        sender_id: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Process an incoming message.
+
+        For ToolAgent, this is limited - it's designed for direct tool execution.
+
+        Args:
+            message: Message content
+            sender_id: Optional sender identifier
+
+        Returns:
+            Response dictionary
+        """
+        return {
+            "response": f"ToolAgent {self.name} received message but requires explicit tool tasks. "
+                       f"Available tools: {', '.join(self._available_tools)}",
+            "available_tools": self._available_tools,
+        }
+
+    async def _execute_tool(
+        self,
+        tool_name: str,
+        operation: Optional[str],
+        parameters: Dict[str, Any]
+    ) -> Any:
+        """
+        Execute a tool operation.
+
+        Args:
+            tool_name: Tool name
+            operation: Operation name (optional for tools with single operation)
+            parameters: Operation parameters
+
+        Returns:
+            Tool execution result
+        """
+        tool = self._tool_instances.get(tool_name)
+        if not tool:
+            raise ValueError(f"Tool {tool_name} not loaded")
+
+        # Execute tool
+        if operation:
+            result = await tool.run_async(operation, **parameters)
+        else:
+            # If no operation specified, try to call the tool directly
+            if hasattr(tool, 'run_async'):
+                result = await tool.run_async(**parameters)
+            else:
+                raise ValueError(f"Tool {tool_name} requires operation to be specified")
+
+        return result
+
+    def _update_tool_stats(self, tool_name: str, success: bool) -> None:
+        """Update tool usage statistics."""
+        if tool_name not in self._tool_usage_stats:
+            self._tool_usage_stats[tool_name] = {
+                "success_count": 0,
+                "failure_count": 0,
+                "total_count": 0,
+            }
+
+        stats = self._tool_usage_stats[tool_name]
+        stats["total_count"] += 1
+        if success:
+            stats["success_count"] += 1
+        else:
+            stats["failure_count"] += 1
+
+    def get_tool_stats(self) -> Dict[str, Dict[str, int]]:
+        """Get tool usage statistics."""
+        return self._tool_usage_stats.copy()
+
+    def get_available_tools(self) -> List[str]:
+        """Get list of available tools."""
+        return self._available_tools.copy()
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "ToolAgent":
+        """
+        Deserialize ToolAgent from dictionary.
+
+        Args:
+            data: Dictionary representation
+
+        Returns:
+            ToolAgent instance
+        """
+        raise NotImplementedError("ToolAgent.from_dict not fully implemented yet")
+

aiecs/domain/agent/tools/__init__.py

@@ -0,0 +1,13 @@
+"""
+Tool Integration
+
+Tool schema generation and integration with AIECS tools.
+"""
+
+from .schema_generator import ToolSchemaGenerator, generate_tool_schema
+
+__all__ = [
+    "ToolSchemaGenerator",
+    "generate_tool_schema",
+]
+

aiecs/domain/agent/tools/schema_generator.py

@@ -0,0 +1,222 @@
+"""
+Tool Schema Generator
+
+Generate OpenAI-style function schemas from AIECS tools.
+"""
+
+import inspect
+import logging
+from typing import Dict, Any, List, Optional, get_type_hints
+from aiecs.tools import BaseTool, get_tool
+
+logger = logging.getLogger(__name__)
+
+
+class ToolSchemaGenerator:
+    """
+    Generates OpenAI-style function calling schemas from AIECS tools.
+
+    Example:
+        generator = ToolSchemaGenerator()
+        schema = generator.generate_schema("search_tool", "search")
+    """
+
+    @staticmethod
+    def generate_schema(
+        tool_name: str,
+        operation: Optional[str] = None,
+        description: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Generate OpenAI function schema for a tool operation.
+
+        Args:
+            tool_name: Tool name
+            operation: Optional operation name
+            description: Optional custom description
+
+        Returns:
+            OpenAI function schema dictionary
+        """
+        try:
+            tool = get_tool(tool_name)
+        except Exception as e:
+            logger.error(f"Failed to get tool {tool_name}: {e}")
+            raise
+
+        # Generate function name
+        if operation:
+            function_name = f"{tool_name}_{operation}"
+        else:
+            function_name = tool_name
+
+        # Get operation method if specified
+        if operation:
+            if not hasattr(tool, operation):
+                raise ValueError(f"Tool {tool_name} has no operation '{operation}'")
+            method = getattr(tool, operation)
+        else:
+            # Default to 'run' method
+            method = getattr(tool, 'run', None)
+            if method is None:
+                raise ValueError(f"Tool {tool_name} has no 'run' method")
+
+        # Extract parameters
+        parameters = ToolSchemaGenerator._extract_parameters(method)
+
+        # Build schema
+        schema = {
+            "name": function_name,
+            "description": description or f"{tool_name} tool",
+            "parameters": {
+                "type": "object",
+                "properties": parameters,
+                "required": ToolSchemaGenerator._get_required_params(method),
+            },
+        }
+
+        return schema
+
+    @staticmethod
+    def _extract_parameters(method) -> Dict[str, Dict[str, Any]]:
+        """Extract parameter schemas from method."""
+        sig = inspect.signature(method)
+        parameters = {}
+
+        for param_name, param in sig.parameters.items():
+            # Skip 'self' and 'op' parameters
+            if param_name in ['self', 'op', 'cls']:
+                continue
+
+            param_schema = ToolSchemaGenerator._param_to_schema(param_name, param)
+            if param_schema:
+                parameters[param_name] = param_schema
+
+        return parameters
+
+    @staticmethod
+    def _param_to_schema(param_name: str, param: inspect.Parameter) -> Optional[Dict[str, Any]]:
+        """Convert parameter to JSON schema."""
+        schema: Dict[str, Any] = {}
+
+        # Try to infer type from annotation
+        if param.annotation != inspect.Parameter.empty:
+            schema.update(ToolSchemaGenerator._type_to_schema(param.annotation))
+
+        # Add default if present
+        if param.default != inspect.Parameter.empty:
+            schema["default"] = param.default
+
+        # If no type info, default to string
+        if "type" not in schema:
+            schema["type"] = "string"
+
+        return schema
+
+    @staticmethod
+    def _type_to_schema(type_hint) -> Dict[str, Any]:
+        """Convert Python type hint to JSON schema type."""
+        # Handle string annotations
+        if isinstance(type_hint, str):
+            if type_hint == "str":
+                return {"type": "string"}
+            elif type_hint == "int":
+                return {"type": "integer"}
+            elif type_hint == "float":
+                return {"type": "number"}
+            elif type_hint == "bool":
+                return {"type": "boolean"}
+            elif type_hint.startswith("List"):
+                return {"type": "array"}
+            elif type_hint.startswith("Dict"):
+                return {"type": "object"}
+            else:
+                return {"type": "string"}
+
+        # Handle actual types
+        if type_hint == str:
+            return {"type": "string"}
+        elif type_hint == int:
+            return {"type": "integer"}
+        elif type_hint == float:
+            return {"type": "number"}
+        elif type_hint == bool:
+            return {"type": "boolean"}
+        elif hasattr(type_hint, "__origin__"):
+            # Generic types (List, Dict, etc.)
+            origin = type_hint.__origin__
+            if origin == list:
+                return {"type": "array"}
+            elif origin == dict:
+                return {"type": "object"}
+            else:
+                return {"type": "string"}
+        else:
+            return {"type": "string"}
+
+    @staticmethod
+    def _get_required_params(method) -> List[str]:
+        """Get list of required parameter names."""
+        sig = inspect.signature(method)
+        required = []
+
+        for param_name, param in sig.parameters.items():
+            # Skip 'self' and 'op' parameters
+            if param_name in ['self', 'op', 'cls']:
+                continue
+
+            # Required if no default value
+            if param.default == inspect.Parameter.empty:
+                required.append(param_name)
+
+        return required
+
+    @staticmethod
+    def generate_schemas_for_tools(
+        tool_names: List[str],
+        operations: Optional[Dict[str, List[str]]] = None
+    ) -> List[Dict[str, Any]]:
+        """
+        Generate schemas for multiple tools.
+
+        Args:
+            tool_names: List of tool names
+            operations: Optional dict mapping tool names to operations
+
+        Returns:
+            List of function schemas
+        """
+        schemas = []
+        operations = operations or {}
+
+        for tool_name in tool_names:
+            tool_ops = operations.get(tool_name, [None])
+            
+            for op in tool_ops:
+                try:
+                    schema = ToolSchemaGenerator.generate_schema(tool_name, op)
+                    schemas.append(schema)
+                except Exception as e:
+                    logger.warning(f"Failed to generate schema for {tool_name}.{op}: {e}")
+
+        return schemas
+
+
+def generate_tool_schema(
+    tool_name: str,
+    operation: Optional[str] = None,
+    description: Optional[str] = None
+) -> Dict[str, Any]:
+    """
+    Convenience function to generate tool schema.
+
+    Args:
+        tool_name: Tool name
+        operation: Optional operation name
+        description: Optional custom description
+
+    Returns:
+        OpenAI function schema dictionary
+    """
+    return ToolSchemaGenerator.generate_schema(tool_name, operation, description)
+

aiecs/main.py

@@ -142,7 +142,7 @@ async def lifespan(app: FastAPI):
 app = FastAPI(
     title="AIECS - AI Execute Services",
     description="Middleware service for AI-powered task execution and tool orchestration",
-    version="1.3.8",    
+    version="1.4.0",    
     lifespan=lifespan
 )
 
@@ -167,7 +167,7 @@ async def health_check():
     return {
         "status": "healthy",
         "service": "aiecs",
-        "version": "1.3.8"
+        "version": "1.4.0"
     }
 
 

{aiecs-1.3.8.dist-info → aiecs-1.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiecs
-Version: 1.3.8
+Version: 1.4.0
 Summary: AI Execute Services - A middleware framework for AI-powered task execution and tool orchestration
 Author-email: AIECS Team <iretbl@gmail.com>
 License-Expression: MIT

{aiecs-1.3.8.dist-info → aiecs-1.4.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
-aiecs/__init__.py,sha256=iF-mqJnpmlecw7m_TFxVkpdFxs2IpOq9H4NZrOngh3U,1859
+aiecs/__init__.py,sha256=VdY9z5KOk6Ln2WD0We4kcYDufBZiCSN8RoAuxRl-_fM,1859
 aiecs/__main__.py,sha256=AfQpzy3SgwWuP4DuymYcm4MISMuzqwhxxGSYo53PBvY,1035
 aiecs/aiecs_client.py,sha256=gIqecRBBH_bYIWhqiHCemdVgmGb9Jqdxf1b6RoqXWlQ,17276
-aiecs/main.py,sha256=emllmgosKXpDsa5pxqeAMSOCSjIXdZxS6AsGQ9vxIqM,10837
+aiecs/main.py,sha256=GfKAtdvRYrGeK3II2eQGMkMTys6ozu4zDSL83hTu69w,10837
 aiecs/application/__init__.py,sha256=NkmrUH1DqxJ3vaVC8QwscNdlWqHfC7ZagL4k3nZ_qz4,192
 aiecs/application/executors/__init__.py,sha256=WIl7L9HBsEhNfbNtJdvBvFUJXzESvNZVaiAA6tdtJcs,191
 aiecs/application/executors/operation_executor.py,sha256=-7mFo1hUnWdehVPg0fnSiRhW3LACpIiyLSH-iu7bX4U,13818
@@ -12,7 +12,34 @@ aiecs/core/__init__.py,sha256=H0ZIk96q0KHKivcobnUCVJdJZmewucVJ9MKhRgUxmk0,1037
 aiecs/core/interface/__init__.py,sha256=soI7zdoN3eQynVb9uiwmgXkM5E75JYffTILktHb48x8,688
 aiecs/core/interface/execution_interface.py,sha256=6bXruts8dyAg647lxPDQkF-cdJG1W8ZqpxFQ6hjVrd4,4810
 aiecs/core/interface/storage_interface.py,sha256=F7GQEZ_ZiRWeen7oZO6A4S0nW0VORYsygk2BYLw5aiY,5680
-aiecs/domain/__init__.py,sha256=8Oa2nluu-ch1dzlC75qdIeMOExxteUrBv41dvQO5oWo,3646
+aiecs/domain/__init__.py,sha256=3JX4h1svFew0Zsy2_tMO2UxTUsSyzXywC-K_ooovjtk,6687
+aiecs/domain/agent/__init__.py,sha256=pbg7QM__ZzdTdAzf9-CaeQd-rQwEZM0jq0kswwoGfRI,3725
+aiecs/domain/agent/base_agent.py,sha256=wDQ6KuSjn-yTb6rv2iKv9SLBliMLyltc0a1uQLXCUD8,21995
+aiecs/domain/agent/exceptions.py,sha256=PkPqFXdhPSN5Fe7Q6tH3mxl8GGlUsPRIWh1JwOiEV5g,2961
+aiecs/domain/agent/hybrid_agent.py,sha256=CaC4VQHrRHpac00kgNEltoJRduqeyH5cXx7oYNtX7qA,17132
+aiecs/domain/agent/lifecycle.py,sha256=2E4B1L1-ZTu6exMsW_lXZN8ammKqFS_g4lsaVfVfnrE,8858
+aiecs/domain/agent/llm_agent.py,sha256=qVYetEZ6KdUm3sgQd9wIF1QCKC3wNIz3DybsIAcd30Y,10073
+aiecs/domain/agent/models.py,sha256=m3sKJrUpF3qkEduTRs3RcwGjm0zE_xsF-LMkzQj2CS4,10404
+aiecs/domain/agent/observability.py,sha256=z7ZEzZaEn_4cI18QTKyTmCvBcp6rak8hPg_riseZ6EY,11823
+aiecs/domain/agent/persistence.py,sha256=RBv5zACZTXrz7_p04PFopYhMYk7osN24myVglND5DWA,8783
+aiecs/domain/agent/registry.py,sha256=My0yiAqQbP2ha9PNS5iwYCZv6fuNJbGTAEt3y_-9o5U,6988
+aiecs/domain/agent/tool_agent.py,sha256=TDou3QFfR0_jluqB7hU9JjuZZlW4e5JQHksUdnM7Gqo,8426
+aiecs/domain/agent/integration/__init__.py,sha256=-YqOJXXcc7vK6w51riv-Q548ol1Rs7XZ1NGreUdStUc,591
+aiecs/domain/agent/integration/context_compressor.py,sha256=Rbt6DoAyBP2QSDRXwsZRoVy5LJ0eQF_1-a1uNdxQ_b0,6593
+aiecs/domain/agent/integration/context_engine_adapter.py,sha256=_lCZaqWy70px_kReZkCiIZNUCRtUya4B873F2tTJqlE,8608
+aiecs/domain/agent/integration/retry_policy.py,sha256=qR5kndCz1pyadZYq7X1cWA6CyWDQlBLyHwmQ91jhg2A,6220
+aiecs/domain/agent/integration/role_config.py,sha256=Tl51HNTu_VHhjugGoSUIrVtoybLej9jRbKRMwMnc8Ys,6674
+aiecs/domain/agent/memory/__init__.py,sha256=faF8Mohlih5e0ZyjzGM8qiHE-jOzCRzMaJ_P2zL21K8,185
+aiecs/domain/agent/memory/conversation.py,sha256=OLDnMxUNWEgVMYXe3vQRyzO2hgkf6-TZteqQ7X__YCk,6168
+aiecs/domain/agent/migration/__init__.py,sha256=WSFQijiy8Z7hXVjsJcQPGvTP5I_iey20AuvnSaWN80s,321
+aiecs/domain/agent/migration/conversion.py,sha256=EMMuLQ_sjzb4_EkEuF-ZAlBfvpZOgPXJKwhzo43iawI,4477
+aiecs/domain/agent/migration/legacy_wrapper.py,sha256=I7CA0B-nAlxpB2vPPga7AUIIebyZfVVbKcXhcc5817A,2958
+aiecs/domain/agent/prompts/__init__.py,sha256=M9wb69MkZawysZWnL4Sam3FmNm29AktTw6eUHQGyyGg,572
+aiecs/domain/agent/prompts/builder.py,sha256=vYjCLGMdifpe-jdpy71FoLo6U3lxrMEkn7yX6cpBSkM,4094
+aiecs/domain/agent/prompts/formatters.py,sha256=CYva2umS6G-82B1JgRGbwlSOMqOaK3S4-DRHZ4HxsSM,4605
+aiecs/domain/agent/prompts/template.py,sha256=jk_k-z9Hz5lr7shQwv4qfiFBXMWXq_ZxGuxSapfodjs,7543
+aiecs/domain/agent/tools/__init__.py,sha256=hQVIzYR1TK-tf3f7GBG4EkPBqoWU2tywJ1wwYofGbJY,227
+aiecs/domain/agent/tools/schema_generator.py,sha256=pFShusTPLZPZ3meBoswzQsesYFrn8HpXW6Or2npJVfg,6863
 aiecs/domain/community/__init__.py,sha256=SxP6IVtG6ZO5LSwzFEzOKAWjjsKO91s2Xgbp92L4R2I,3606
 aiecs/domain/community/agent_adapter.py,sha256=QAIex0ftCSNlyC9eZPAOLtwCsX6kJrxGoC6rMq0gqgc,16070
 aiecs/domain/community/analytics.py,sha256=M7uwkS5DLSYc4OA3H26CkHJigj7BG7aMtihO8piLZLw,18316
@@ -168,9 +195,9 @@ aiecs/utils/prompt_loader.py,sha256=cBS2bZXpYQOWSiOGkhwIzyy3_bETqwIblRi_9qQT9iQ,
 aiecs/utils/token_usage_repository.py,sha256=1xjenLYwC0YT6lKZFEGO4scRCXLuWdec2MWjzih5SZY,10210
 aiecs/ws/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 aiecs/ws/socket_server.py,sha256=j_9idVY_rWlTsF51FgmuhWCWFVt7_gAHL8vNg3IxV5g,1476
-aiecs-1.3.8.dist-info/licenses/LICENSE,sha256=_1YRaIS0eZu1pv6xfz245UkU0i1Va2B841hv3OWRwqg,12494
-aiecs-1.3.8.dist-info/METADATA,sha256=hwbEpECNoFi-BV_9iTlCcn3TiW9v-gKR1jkzukDbuvQ,16635
-aiecs-1.3.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aiecs-1.3.8.dist-info/entry_points.txt,sha256=TfLBuwLOfgQqKvnoF1sgTS19-Hgl0aWvCZjIdblIiig,667
-aiecs-1.3.8.dist-info/top_level.txt,sha256=22IlUlOqh9Ni3jXlQNMNUqzbW8dcxXPeR_EQ-BJVcV8,6
-aiecs-1.3.8.dist-info/RECORD,,
+aiecs-1.4.0.dist-info/licenses/LICENSE,sha256=_1YRaIS0eZu1pv6xfz245UkU0i1Va2B841hv3OWRwqg,12494
+aiecs-1.4.0.dist-info/METADATA,sha256=KKow5_VX9OHucyFLUF_ULhv7IdYuWloDhyJECchLYWM,16635
+aiecs-1.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aiecs-1.4.0.dist-info/entry_points.txt,sha256=TfLBuwLOfgQqKvnoF1sgTS19-Hgl0aWvCZjIdblIiig,667
+aiecs-1.4.0.dist-info/top_level.txt,sha256=22IlUlOqh9Ni3jXlQNMNUqzbW8dcxXPeR_EQ-BJVcV8,6
+aiecs-1.4.0.dist-info/RECORD,,