camel-ai 0.2.65__py3-none-any.whl → 0.2.67__py3-none-any.whl

camel/societies/workforce/utils.py

@@ -12,14 +12,10 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from functools import wraps
-from typing import Callable
+from typing import Callable, List
 
 from pydantic import BaseModel, Field
 
-from camel.logger import get_logger
-
-logger = get_logger(__name__)
-
 
 class WorkerConf(BaseModel):
     r"""The configuration of a worker."""
@@ -45,80 +41,123 @@ class TaskResult(BaseModel):
     )
 
 
-class TaskAssignResult(BaseModel):
-    r"""The result of task assignment."""
+class TaskAssignment(BaseModel):
+    r"""An individual task assignment within a batch."""
 
+    task_id: str = Field(description="The ID of the task to be assigned.")
     assignee_id: str = Field(
-        description="The ID of the workforce that is assigned to the task."
+        description="The ID of the worker/workforce to assign the task to."
+    )
+    dependencies: List[str] = Field(
+        default_factory=list,
+        description="List of task IDs that must complete before this task.",
+    )
+
+
+class TaskAssignResult(BaseModel):
+    r"""The result of task assignment for both single and batch assignments."""
+
+    assignments: List[TaskAssignment] = Field(
+        description="List of task assignments."
     )
 
 
-def check_if_running(running: bool) -> Callable:
-    r"""Check if the workforce is (not) running, specified the boolean value.
-    If the workforce is not in the expected status, raise an exception.
+def check_if_running(
+    running: bool,
+    max_retries: int = 3,
+    retry_delay: float = 1.0,
+    handle_exceptions: bool = False,
+) -> Callable:
+    r"""Check if the workforce is (not) running, specified by the boolean
+    value. Provides fault tolerance through automatic retries and exception
+    handling.
+
+    Args:
+        running (bool): Expected running state (True or False).
+        max_retries (int, optional): Maximum number of retry attempts if the
+            operation fails. Set to 0 to disable retries. (default: :obj:`3`)
+        retry_delay (float, optional): Delay in seconds between retry attempts.
+            (default: :obj:`1.0`)
+        handle_exceptions (bool, optional): If True, catch and log exceptions
+            instead of propagating them. (default: :obj:`False`)
 
     Raises:
-        RuntimeError: If the workforce is not in the expected status.
+        RuntimeError: If the workforce is not in the expected status and
+            retries are exhausted or disabled.
+        Exception: Any exception raised by the decorated function if
+            handle_exceptions is False and retries are exhausted.
     """
+    import logging
+    import time
+
+    logger = logging.getLogger(__name__)
 
     def decorator(func):
         @wraps(func)
         def wrapper(self, *args, **kwargs):
-            if self._running != running:
-                status = "not running" if running else "running"
-                raise RuntimeError(
-                    f"The workforce is {status}. Cannot perform the "
-                    f"operation {func.__name__}."
+            retries = 0
+            last_exception = None
+
+            while retries <= max_retries:
+                try:
+                    # Check running state
+                    if self._running != running:
+                        status = "not running" if running else "running"
+                        error_msg = (
+                            f"The workforce is {status}. Cannot perform the "
+                            f"operation {func.__name__}."
+                        )
+
+                        # If we have retries left, wait and try again
+                        if retries < max_retries:
+                            logger.warning(
+                                f"{error_msg} Retrying in {retry_delay}s... "
+                                f"(Attempt {retries+1}/{max_retries})"
+                            )
+                            time.sleep(retry_delay)
+                            retries += 1
+                            continue
+                        else:
+                            raise RuntimeError(error_msg)
+
+                    return func(self, *args, **kwargs)
+
+                except Exception as e:
+                    last_exception = e
+
+                    if isinstance(e, RuntimeError) and "workforce is" in str(
+                        e
+                    ):
+                        raise
+
+                    if retries < max_retries:
+                        logger.warning(
+                            f"Exception in {func.__name__}: {e}. "
+                            f"Retrying in {retry_delay}s... "
+                            f"(Attempt {retries+1}/{max_retries})"
+                        )
+                        time.sleep(retry_delay)
+                        retries += 1
+                    else:
+                        if handle_exceptions:
+                            logger.error(
+                                f"Failed to execute {func.__name__} after "
+                                f"{max_retries} retries: {e}"
+                            )
+                            return None
+                        else:
+                            # Re-raise the exception
+                            raise
+
+            # This should not be reached, but just in case
+            if handle_exceptions:
+                logger.error(
+                    f"Unexpected failure in {func.__name__}: {last_exception}"
                 )
-            return func(self, *args, **kwargs)
+                return None
+            else:
+                raise last_exception
 
         return wrapper
 
     return decorator
-
-
-def validate_task_content(
-    content: str, task_id: str = "unknown", min_length: int = 10
-) -> bool:
-    r"""Validates task result content to avoid silent failures.
-    It performs basic checks to ensure the content meets minimum
-    quality standards.
-
-    Args:
-        content (str): The task result content to validate.
-        task_id (str): Task ID for logging purposes.
-            (default: :obj:`"unknown"`)
-        min_length (int): Minimum content length after stripping whitespace.
-            (default: :obj:`10`)
-
-    Returns:
-        bool: True if content passes validation, False otherwise.
-    """
-    # 1: Content must not be None
-    if content is None:
-        logger.warning(f"Task {task_id}: None content rejected")
-        return False
-
-    # 2: Content must not be empty after stripping whitespace
-    stripped_content = content.strip()
-    if not stripped_content:
-        logger.warning(
-            f"Task {task_id}: Empty or whitespace-only content rejected."
-        )
-        return False
-
-    # 3: Content must meet minimum meaningful length
-    if len(stripped_content) < min_length:
-        logger.warning(
-            f"Task {task_id}: Content too short ({len(stripped_content)} "
-            f"chars < {min_length} minimum). Content preview: "
-            f"'{stripped_content[:50]}...'"
-        )
-        return False
-
-    # All validation checks passed
-    logger.debug(
-        f"Task {task_id}: Content validation passed "
-        f"({len(stripped_content)} chars)"
-    )
-    return True