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

aiecs/domain/knowledge_graph/schema/type_enums.py

@@ -0,0 +1,209 @@
+"""
+Type Enums
+
+Dynamic enum generation for entity and relation types from schema.
+
+Phase: 3.4 - Type Enums
+Version: 1.0
+"""
+
+from enum import Enum
+from typing import Type, Dict
+from aiecs.domain.knowledge_graph.schema.graph_schema import GraphSchema
+
+
+class EntityTypeEnum(str, Enum):
+    """
+    Base class for entity type enums
+
+    Dynamically generated enums inherit from this class.
+    Enums are string-based for backward compatibility.
+
+    Example:
+        >>> PersonType = EntityTypeEnum("PersonType", {"PERSON": "Person"})
+        >>> PersonType.PERSON
+        'Person'
+        >>> str(PersonType.PERSON)
+        'Person'
+    """
+
+    def __str__(self) -> str:
+        """Return the enum value (for backward compatibility)"""
+        return self.value
+
+    def __repr__(self) -> str:
+        """Return the enum representation"""
+        return f"{self.__class__.__name__}.{self.name}"
+
+
+class RelationTypeEnum(str, Enum):
+    """
+    Base class for relation type enums
+
+    Dynamically generated enums inherit from this class.
+    Enums are string-based for backward compatibility.
+
+    Example:
+        >>> WorksForType = RelationTypeEnum("WorksForType", {"WORKS_FOR": "WORKS_FOR"})
+        >>> WorksForType.WORKS_FOR
+        'WORKS_FOR'
+        >>> str(WorksForType.WORKS_FOR)
+        'WORKS_FOR'
+    """
+
+    def __str__(self) -> str:
+        """Return the enum value (for backward compatibility)"""
+        return self.value
+
+    def __repr__(self) -> str:
+        """Return the enum representation"""
+        return f"{self.__class__.__name__}.{self.name}"
+
+
+class TypeEnumGenerator:
+    """
+    Utility for generating type enums from schema
+
+    Generates Python Enum classes for entity types and relation types
+    defined in a GraphSchema. The generated enums are string-based for
+    backward compatibility with existing code that uses string literals.
+
+    Example:
+        >>> generator = TypeEnumGenerator(schema)
+        >>> entity_enums = generator.generate_entity_type_enums()
+        >>> relation_enums = generator.generate_relation_type_enums()
+        >>>
+        >>> # Use generated enums
+        >>> PersonType = entity_enums["Person"]
+        >>> person_type = PersonType.PERSON  # "Person"
+    """
+
+    def __init__(self, schema: GraphSchema):
+        """
+        Initialize enum generator
+
+        Args:
+            schema: Graph schema to generate enums from
+        """
+        self.schema = schema
+
+    def generate_entity_type_enums(self) -> Dict[str, Type[EntityTypeEnum]]:
+        """
+        Generate entity type enums from schema
+
+        Creates an enum class for each entity type in the schema.
+        The enum name is the entity type name, and the enum value
+        is also the entity type name (for backward compatibility).
+
+        Returns:
+            Dictionary mapping entity type names to enum classes
+
+        Example:
+            >>> enums = generator.generate_entity_type_enums()
+            >>> PersonEnum = enums["Person"]
+            >>> PersonEnum.PERSON  # "Person"
+        """
+        enums = {}
+
+        for entity_type_name in self.schema.get_entity_type_names():
+            # Create enum name (convert to uppercase with underscores)
+            enum_member_name = self._to_enum_name(entity_type_name)
+
+            # Create enum class dynamically using type()
+            enum_class = type(
+                entity_type_name + "Enum",
+                (EntityTypeEnum,),
+                {enum_member_name: entity_type_name}
+            )
+
+            enums[entity_type_name] = enum_class
+
+        return enums
+
+    def generate_relation_type_enums(
+        self,
+    ) -> Dict[str, Type[RelationTypeEnum]]:
+        """
+        Generate relation type enums from schema
+
+        Creates an enum class for each relation type in the schema.
+        The enum name is the relation type name, and the enum value
+        is also the relation type name (for backward compatibility).
+
+        Returns:
+            Dictionary mapping relation type names to enum classes
+
+        Example:
+            >>> enums = generator.generate_relation_type_enums()
+            >>> WorksForEnum = enums["WORKS_FOR"]
+            >>> WorksForEnum.WORKS_FOR  # "WORKS_FOR"
+        """
+        enums = {}
+
+        for relation_type_name in self.schema.get_relation_type_names():
+            # Create enum name (convert to uppercase with underscores)
+            enum_member_name = self._to_enum_name(relation_type_name)
+
+            # Create enum class dynamically using type()
+            enum_class = type(
+                relation_type_name + "Enum",
+                (RelationTypeEnum,),
+                {enum_member_name: relation_type_name}
+            )
+
+            enums[relation_type_name] = enum_class
+
+        return enums
+
+    def generate_all_enums(self) -> Dict[str, Dict[str, Type[Enum]]]:
+        """
+        Generate all type enums from schema
+
+        Returns:
+            Dictionary with "entity_types" and "relation_types" keys,
+            each containing a dictionary of enum classes
+
+        Example:
+            >>> enums = generator.generate_all_enums()
+            >>> PersonEnum = enums["entity_types"]["Person"]
+            >>> WorksForEnum = enums["relation_types"]["WORKS_FOR"]
+        """
+        from typing import cast
+        return {
+            "entity_types": cast(Dict[str, Type[Enum]], self.generate_entity_type_enums()),
+            "relation_types": cast(Dict[str, Type[Enum]], self.generate_relation_type_enums()),
+        }
+
+    @staticmethod
+    def _to_enum_name(type_name: str) -> str:
+        """
+        Convert type name to enum member name
+
+        Converts CamelCase or snake_case to UPPER_CASE.
+
+        Args:
+            type_name: Type name to convert
+
+        Returns:
+            Enum member name in UPPER_CASE
+
+        Example:
+            >>> TypeEnumGenerator._to_enum_name("Person")
+            'PERSON'
+            >>> TypeEnumGenerator._to_enum_name("WorksFor")
+            'WORKS_FOR'
+            >>> TypeEnumGenerator._to_enum_name("WORKS_FOR")
+            'WORKS_FOR'
+        """
+        # If already uppercase, return as-is
+        if type_name.isupper():
+            return type_name
+
+        # Convert CamelCase to UPPER_CASE
+        result = []
+        for i, char in enumerate(type_name):
+            if char.isupper() and i > 0 and type_name[i - 1].islower():
+                result.append("_")
+            result.append(char.upper())
+
+        return "".join(result)

aiecs/domain/task/dsl_processor.py

@@ -1,8 +1,7 @@
 import re
 import json
 import logging
-import asyncio
-from typing import Dict, List, Any, Optional, Callable
+from typing import Dict, List, Any, Callable, Optional
 from aiecs.domain.execution.model import TaskStepResult, TaskStatus, ErrorCode
 
 logger = logging.getLogger(__name__)
@@ -20,21 +19,26 @@ class DSLProcessor:
             r"intent\.includes\('([^']+)'\)",
             r"context\.(\w+)\s*(==|!=|>|<|>=|<=)\s*(.+)",
             r"input\.(\w+)\s*(==|!=|>|<|>=|<=)\s*(.+)",
-            r"result\[(\d+)\]\.(\w+)\s*(==|!=|>|<|>=|<=)\s*(.+)"
+            r"result\[(\d+)\]\.(\w+)\s*(==|!=|>|<|>=|<=)\s*(.+)",
         ]
         # Condition check priority order
         self.condition_check_order = [
             "AND",  # Logical AND operation
-            "OR",   # Logical OR operation
+            "OR",  # Logical OR operation
             "intent.includes",  # Intent inclusion check
             "context",  # Context check
-            "input",    # Input check
-            "result"    # Result check
+            "input",  # Input check
+            "result",  # Result check
         ]
 
-    def evaluate_condition(self, condition: str, intent_categories: List[str],
-                          context: Dict[str, Any] = None, input_data: Dict[str, Any] = None,
-                          results: List[TaskStepResult] = None) -> bool:
+    def evaluate_condition(
+        self,
+        condition: str,
+        intent_categories: List[str],
+        context: Optional[Dict[str, Any]] = None,
+        input_data: Optional[Dict[str, Any]] = None,
+        results: Optional[List[TaskStepResult]] = None,
+    ) -> bool:
         """
         Evaluate condition expression, supporting multiple condition types
         Following optimized check order: AND -> OR -> intent.includes -> context -> input -> result
@@ -43,12 +47,30 @@ class DSLProcessor:
             # 1. Compound condition: support AND (highest priority)
             if " AND " in condition:
                 parts = condition.split(" AND ")
-                return all(self.evaluate_condition(part.strip(), intent_categories, context, input_data, results) for part in parts)
+                return all(
+                    self.evaluate_condition(
+                        part.strip(),
+                        intent_categories,
+                        context,
+                        input_data,
+                        results,
+                    )
+                    for part in parts
+                )
 
             # 2. Compound condition: support OR (second priority)
             if " OR " in condition:
                 parts = condition.split(" OR ")
-                return any(self.evaluate_condition(part.strip(), intent_categories, context, input_data, results) for part in parts)
+                return any(
+                    self.evaluate_condition(
+                        part.strip(),
+                        intent_categories,
+                        context,
+                        input_data,
+                        results,
+                    )
+                    for part in parts
+                )
 
             # 3. Intent condition: intent.includes('category')
             match = re.fullmatch(r"intent\.includes\('([^']+)'\)", condition)
@@ -152,9 +174,16 @@ class DSLProcessor:
 
         return False
 
-    async def execute_dsl_step(self, step: Dict, intent_categories: List[str], input_data: Dict,
-                              context: Dict, execute_single_task: Callable, execute_batch_task: Callable,
-                              results: List[TaskStepResult] = None) -> TaskStepResult:
+    async def execute_dsl_step(
+        self,
+        step: Dict,
+        intent_categories: List[str],
+        input_data: Dict,
+        context: Dict,
+        execute_single_task: Callable,
+        execute_batch_task: Callable,
+        results: Optional[List[TaskStepResult]] = None,
+    ) -> TaskStepResult:
         """
         Execute DSL step based on step type (if, parallel, task, sequence)
         """
@@ -164,18 +193,42 @@ class DSLProcessor:
 
         try:
             if "if" in step:
-                return await self._handle_if_step(step, intent_categories, input_data, context,
-                                                execute_single_task, execute_batch_task, span, results)
+                return await self._handle_if_step(
+                    step,
+                    intent_categories,
+                    input_data,
+                    context,
+                    execute_single_task,
+                    execute_batch_task,
+                    span,
+                    results,
+                )
             elif "parallel" in step:
                 return await self._handle_parallel_step(step, input_data, context, execute_batch_task, span)
             elif "sequence" in step:
-                return await self._handle_sequence_step(step, intent_categories, input_data, context,
-                                                      execute_single_task, execute_batch_task, span, results)
+                return await self._handle_sequence_step(
+                    step,
+                    intent_categories,
+                    input_data,
+                    context,
+                    execute_single_task,
+                    execute_batch_task,
+                    span,
+                    results,
+                )
             elif "task" in step:
                 return await self._handle_task_step(step, input_data, context, execute_single_task, span)
             elif "loop" in step:
-                return await self._handle_loop_step(step, intent_categories, input_data, context,
-                                                  execute_single_task, execute_batch_task, span, results)
+                return await self._handle_loop_step(
+                    step,
+                    intent_categories,
+                    input_data,
+                    context,
+                    execute_single_task,
+                    execute_batch_task,
+                    span,
+                    results,
+                )
             else:
                 if span:
                     span.set_tag("error", True)
@@ -187,15 +240,23 @@ class DSLProcessor:
                     message="Invalid DSL step",
                     status=TaskStatus.FAILED.value,
                     error_code=ErrorCode.EXECUTION_ERROR.value,
-                    error_message="Unknown DSL step type"
+                    error_message="Unknown DSL step type",
                 )
         finally:
             if span:
                 span.finish()
 
-    async def _handle_if_step(self, step: Dict, intent_categories: List[str], input_data: Dict,
-                             context: Dict, execute_single_task: Callable, execute_batch_task: Callable,
-                             span=None, results: List[TaskStepResult] = None) -> TaskStepResult:
+    async def _handle_if_step(
+        self,
+        step: Dict,
+        intent_categories: List[str],
+        input_data: Dict,
+        context: Dict,
+        execute_single_task: Callable,
+        execute_batch_task: Callable,
+        span=None,
+        results: Optional[List[TaskStepResult]] = None,
+    ) -> TaskStepResult:
         """Handle conditional 'if' step"""
         condition = step["if"]
         then_steps = step["then"]
@@ -213,8 +274,15 @@ class DSLProcessor:
 
                 step_results = []
                 for sub_step in then_steps:
-                    result = await self.execute_dsl_step(sub_step, intent_categories, input_data, context,
-                                                       execute_single_task, execute_batch_task, results)
+                    result = await self.execute_dsl_step(
+                        sub_step,
+                        intent_categories,
+                        input_data,
+                        context,
+                        execute_single_task,
+                        execute_batch_task,
+                        results,
+                    )
                     step_results.append(result)
                     if results is not None:
                         results.append(result)
@@ -224,7 +292,7 @@ class DSLProcessor:
                     result=[r.dict() for r in step_results],
                     completed=all(r.completed for r in step_results),
                     message=f"Condition '{condition}' evaluated to true",
-                    status=TaskStatus.COMPLETED.value if all(r.status == TaskStatus.COMPLETED.value for r in step_results) else TaskStatus.FAILED.value
+                    status=(TaskStatus.COMPLETED.value if all(r.status == TaskStatus.COMPLETED.value for r in step_results) else TaskStatus.FAILED.value),
                 )
             else:
                 if span:
@@ -233,8 +301,15 @@ class DSLProcessor:
                 if else_steps:
                     step_results = []
                     for sub_step in else_steps:
-                        result = await self.execute_dsl_step(sub_step, intent_categories, input_data, context,
-                                                           execute_single_task, execute_batch_task, results)
+                        result = await self.execute_dsl_step(
+                            sub_step,
+                            intent_categories,
+                            input_data,
+                            context,
+                            execute_single_task,
+                            execute_batch_task,
+                            results,
+                        )
                         step_results.append(result)
                         if results is not None:
                             results.append(result)
@@ -244,7 +319,7 @@ class DSLProcessor:
                         result=[r.dict() for r in step_results],
                         completed=all(r.completed for r in step_results),
                         message=f"Condition '{condition}' evaluated to false, executed else branch",
-                        status=TaskStatus.COMPLETED.value if all(r.status == TaskStatus.COMPLETED.value for r in step_results) else TaskStatus.FAILED.value
+                        status=(TaskStatus.COMPLETED.value if all(r.status == TaskStatus.COMPLETED.value for r in step_results) else TaskStatus.FAILED.value),
                     )
                 else:
                     return TaskStepResult(
@@ -252,7 +327,7 @@ class DSLProcessor:
                         result=None,
                         completed=True,
                         message=f"Condition '{condition}' evaluated to false, skipping",
-                        status=TaskStatus.COMPLETED.value
+                        status=TaskStatus.COMPLETED.value,
                     )
         except Exception as e:
             if span:
@@ -265,11 +340,17 @@ class DSLProcessor:
                 message="Failed to evaluate condition",
                 status=TaskStatus.FAILED.value,
                 error_code=ErrorCode.DSL_EVALUATION_ERROR.value,
-                error_message=str(e)
+                error_message=str(e),
             )
 
-    async def _handle_parallel_step(self, step: Dict, input_data: Dict, context: Dict,
-                                   execute_batch_task: Callable, span=None) -> TaskStepResult:
+    async def _handle_parallel_step(
+        self,
+        step: Dict,
+        input_data: Dict,
+        context: Dict,
+        execute_batch_task: Callable,
+        span=None,
+    ) -> TaskStepResult:
         """Handle parallel task execution"""
         task_names = step["parallel"]
         if span:
@@ -283,12 +364,20 @@ class DSLProcessor:
             result=[r.dict() for r in batch_results],
             completed=all(r.completed for r in batch_results),
             message=f"Completed parallel execution of {len(task_names)} tasks",
-            status=TaskStatus.COMPLETED.value if all(r.status == TaskStatus.COMPLETED.value for r in batch_results) else TaskStatus.FAILED.value
+            status=(TaskStatus.COMPLETED.value if all(r.status == TaskStatus.COMPLETED.value for r in batch_results) else TaskStatus.FAILED.value),
         )
 
-    async def _handle_sequence_step(self, step: Dict, intent_categories: List[str], input_data: Dict,
-                                   context: Dict, execute_single_task: Callable, execute_batch_task: Callable,
-                                   span=None, results: List[TaskStepResult] = None) -> TaskStepResult:
+    async def _handle_sequence_step(
+        self,
+        step: Dict,
+        intent_categories: List[str],
+        input_data: Dict,
+        context: Dict,
+        execute_single_task: Callable,
+        execute_batch_task: Callable,
+        span=None,
+        results: Optional[List[TaskStepResult]] = None,
+    ) -> TaskStepResult:
         """Handle sequential execution steps"""
         sequence_steps = step["sequence"]
         if span:
@@ -296,8 +385,15 @@ class DSLProcessor:
 
         step_results = []
         for i, sub_step in enumerate(sequence_steps):
-            result = await self.execute_dsl_step(sub_step, intent_categories, input_data, context,
-                                               execute_single_task, execute_batch_task, results)
+            result = await self.execute_dsl_step(
+                sub_step,
+                intent_categories,
+                input_data,
+                context,
+                execute_single_task,
+                execute_batch_task,
+                results,
+            )
             step_results.append(result)
             if results is not None:
                 results.append(result)
@@ -311,11 +407,17 @@ class DSLProcessor:
             result=[r.dict() for r in step_results],
             completed=all(r.completed for r in step_results),
             message=f"Completed sequence execution of {len(step_results)} steps",
-            status=TaskStatus.COMPLETED.value if all(r.status == TaskStatus.COMPLETED.value for r in step_results) else TaskStatus.FAILED.value
+            status=(TaskStatus.COMPLETED.value if all(r.status == TaskStatus.COMPLETED.value for r in step_results) else TaskStatus.FAILED.value),
         )
 
-    async def _handle_task_step(self, step: Dict, input_data: Dict, context: Dict,
-                               execute_single_task: Callable, span=None) -> TaskStepResult:
+    async def _handle_task_step(
+        self,
+        step: Dict,
+        input_data: Dict,
+        context: Dict,
+        execute_single_task: Callable,
+        span=None,
+    ) -> TaskStepResult:
         """Handle single task execution"""
         task_name = step["task"]
         task_params = step.get("params", {})
@@ -336,7 +438,7 @@ class DSLProcessor:
                     result=result,
                     completed=True,
                     message=f"Completed task {task_name}",
-                    status=TaskStatus.COMPLETED.value
+                    status=TaskStatus.COMPLETED.value,
                 )
         except Exception as e:
             if span:
@@ -349,12 +451,20 @@ class DSLProcessor:
                 message=f"Failed to execute task {task_name}",
                 status=TaskStatus.FAILED.value,
                 error_code=ErrorCode.EXECUTION_ERROR.value,
-                error_message=str(e)
+                error_message=str(e),
             )
 
-    async def _handle_loop_step(self, step: Dict, intent_categories: List[str], input_data: Dict,
-                               context: Dict, execute_single_task: Callable, execute_batch_task: Callable,
-                               span=None, results: List[TaskStepResult] = None) -> TaskStepResult:
+    async def _handle_loop_step(
+        self,
+        step: Dict,
+        intent_categories: List[str],
+        input_data: Dict,
+        context: Dict,
+        execute_single_task: Callable,
+        execute_batch_task: Callable,
+        span=None,
+        results: Optional[List[TaskStepResult]] = None,
+    ) -> TaskStepResult:
         """Handle loop step"""
         loop_config = step["loop"]
         loop_steps = loop_config["steps"]
@@ -376,8 +486,15 @@ class DSLProcessor:
             # Execute loop body
             iteration_step_results = []
             for sub_step in loop_steps:
-                result = await self.execute_dsl_step(sub_step, intent_categories, input_data, context,
-                                                   execute_single_task, execute_batch_task, results)
+                result = await self.execute_dsl_step(
+                    sub_step,
+                    intent_categories,
+                    input_data,
+                    context,
+                    execute_single_task,
+                    execute_batch_task,
+                    results,
+                )
                 iteration_step_results.append(result)
                 if results is not None:
                     results.append(result)
@@ -391,11 +508,10 @@ class DSLProcessor:
 
         return TaskStepResult(
             step=f"loop_{iteration}_iterations",
-            result=[{"iteration": i, "results": [r.dict() for r in iter_results]}
-                   for i, iter_results in enumerate(iteration_results)],
+            result=[{"iteration": i, "results": [r.dict() for r in iter_results]} for i, iter_results in enumerate(iteration_results)],
             completed=True,
             message=f"Completed loop with {iteration} iterations",
-            status=TaskStatus.COMPLETED.value
+            status=TaskStatus.COMPLETED.value,
         )
 
     def validate_dsl_step(self, step: Dict) -> List[str]:
@@ -444,7 +560,7 @@ class DSLProcessor:
                 "intent.includes('category')",
                 "context.field == value",
                 "input.field == value",
-                "result[index].field == value"
+                "result[index].field == value",
             ],
             "operators": ["==", "!=", ">", "<", ">=", "<="],
             "logical_operators": ["AND", "OR"],
@@ -455,6 +571,6 @@ class DSLProcessor:
                 "Use re.fullmatch instead of re.match for stricter matching",
                 "Optimize condition check order: AND -> OR -> intent.includes -> context -> input -> result",
                 "Enhance value parsing robustness, support null values",
-                "Add condition syntax validation method"
-            ]
+                "Add condition syntax validation method",
+            ],
         }

aiecs/domain/task/model.py

@@ -1,17 +1,23 @@
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, Optional
 from datetime import datetime
 
 
 class TaskContext:
     """Task context model"""
-    def __init__(self, user_id: str, task_id: str, session_id: Optional[str] = None,
-                 metadata: Optional[Dict[str, Any]] = None):
+
+    def __init__(
+        self,
+        user_id: str,
+        task_id: str,
+        session_id: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ):
         self.user_id = user_id
         self.task_id = task_id
         self.session_id = session_id
         self.metadata = metadata or {}
         self.created_at = datetime.now()
-        self.variables = {}  # Variable storage during task execution
+        self.variables: Dict[str, Any] = {}  # Variable storage during task execution
 
     def set_variable(self, key: str, value: Any):
         """Set task variable"""
@@ -28,14 +34,20 @@ class TaskContext:
             "session_id": self.session_id,
             "metadata": self.metadata,
             "created_at": self.created_at.isoformat(),
-            "variables": self.variables
+            "variables": self.variables,
         }
 
 
 class DSLStep:
     """DSL step model"""
-    def __init__(self, step_type: str, condition: Optional[str] = None,
-                 description: str = "", params: Optional[Dict[str, Any]] = None):
+
+    def __init__(
+        self,
+        step_type: str,
+        condition: Optional[str] = None,
+        description: str = "",
+        params: Optional[Dict[str, Any]] = None,
+    ):
         self.step_type = step_type
         self.condition = condition
         self.description = description
@@ -46,5 +58,5 @@ class DSLStep:
             "step_type": self.step_type,
             "condition": self.condition,
             "description": self.description,
-            "params": self.params
+            "params": self.params,
         }