camel-ai 0.2.67__py3-none-any.whl → 0.2.69a1__py3-none-any.whl

camel/societies/workforce/prompts.py

@@ -49,17 +49,6 @@ The information returned should be concise and clear.
 ASSIGN_TASK_PROMPT = TextPrompt(
     """You need to assign multiple tasks to worker nodes based on the information below.
 
-Here are the tasks to be assigned:
-==============================
-{tasks_info}
-==============================
-
-Following is the information of the existing worker nodes. The format is <ID>:<description>:<additional_info>. Choose the most capable worker node ID for each task.
-
-==============================
-{child_nodes_info}
-==============================
-
 For each task, you need to:
 1. Choose the most capable worker node ID for that task
 2. Identify any dependencies between tasks (if task B requires results from task A, then task A is a dependency of task B)
@@ -80,24 +69,37 @@ Example valid response:
   ]
 }}
 
-IMPORTANT: Only add dependencies when one task truly needs the output/result of another task to complete successfully. Don't add dependencies unless they are logically necessary.
+***CRITICAL: DEPENDENCY MANAGEMENT IS YOUR IMPORTANT RESPONSIBILITY.***
+Carefully analyze the sequence of tasks. A task's dependencies MUST include the IDs of all prior tasks whose outputs are necessary for its execution. For example, a task to 'Summarize Paper X' MUST depend on the task that 'Finds/Retrieves Paper X'. Similarly, a task that 'Compiles a report from summaries' MUST depend on all 'Summarize Paper X' tasks. **Incorrect or missing dependencies will lead to critical operational failures and an inability to complete the overall objective.** Be meticulous in defining these relationships.
 
 Do not include any other text, explanations, justifications, or conversational filler before or after the JSON object. Return ONLY the JSON object.
+
+Here are the tasks to be assigned:
+==============================
+{tasks_info}
+==============================
+
+Following is the information of the existing worker nodes. The format is <ID>:<description>:<additional_info>. Choose the most capable worker node ID for each task.
+
+==============================
+{child_nodes_info}
+==============================
 """
 )
 
 PROCESS_TASK_PROMPT = TextPrompt(
     """You need to process one given task.
-Here are results of some prerequisite tasks that you can refer to:
+
+Please keep in mind the task you are going to process, the content of the task that you need to do is:
 
 ==============================
-{dependency_tasks_info}
+{content}
 ==============================
 
-The content of the task that you need to do is:
+Here are results of some prerequisite tasks that you can refer to:
 
 ==============================
-{content}
+{dependency_tasks_info}
 ==============================
 
 Here are some additional information about the task:
@@ -182,11 +184,43 @@ Now you should summarize the scenario and return the result of the task.
 """
 )
 
-WF_TASK_DECOMPOSE_PROMPT = r"""You need to decompose the given task into subtasks according to the workers available in the group, following these important principles:
+WF_TASK_DECOMPOSE_PROMPT = r"""You need to decompose the given task into subtasks according to the workers available in the group, following these important principles to maximize efficiency and parallelism:
+
+1.  **Strategic Grouping for Sequential Work**:
+    *   If a series of steps must be done in order *and* can be handled by the same worker type, group them into a single subtask to maintain flow and minimize handoffs.
+
+2.  **Aggressive Parallelization**:
+    *   **Across Different Worker Specializations**: If distinct phases of the overall task require different types of workers (e.g., research by a 'SearchAgent', then content creation by a 'DocumentAgent'), define these as separate subtasks.
+    *   **Within a Single Phase (Data/Task Parallelism)**: If a phase involves repetitive operations on multiple items (e.g., processing 10 documents, fetching 5 web pages, analyzing 3 datasets):
+        *   Decompose this into parallel subtasks, one for each item or a small batch of items.
+        *   This applies even if the same type of worker handles these parallel subtasks. The goal is to leverage multiple available workers or allow concurrent processing.
+
+3.  **Subtask Design for Efficiency**:
+    *   **Actionable and Well-Defined**: Each subtask should have a clear, achievable goal.
+    *   **Balanced Granularity**: Make subtasks large enough to be meaningful but small enough to enable parallelism and quick feedback. Avoid overly large subtasks that hide parallel opportunities.
+    *   **Consider Dependencies**: While you list tasks sequentially, think about the true dependencies. The workforce manager will handle execution based on these implied dependencies and worker availability.
+
+These principles aim to reduce overall completion time by maximizing concurrent work and effectively utilizing all available worker capabilities.
+
+**EXAMPLE FORMAT ONLY** (DO NOT use this example content for actual task decomposition):
+
+If given a hypothetical task requiring research, analysis, and reporting with multiple items to process, you should decompose it to maximize parallelism:
+
+*   Poor decomposition (monolithic):
+    `<tasks><task>Do all research, analysis, and write final report.</task></tasks>`
+
+*   Better decomposition (parallel structure):
+    ```
+    <tasks>
+    <task>Subtask 1 (ResearchAgent): Gather initial data and resources.</task>
+    <task>Subtask 2.1 (AnalysisAgent): Analyze Item A from Subtask 1 results.</task>
+    <task>Subtask 2.2 (AnalysisAgent): Analyze Item B from Subtask 1 results.</task>
+    <task>Subtask 2.N (AnalysisAgent): Analyze Item N from Subtask 1 results.</task>
+    <task>Subtask 3 (ReportAgent): Compile all analyses into final report.</task>
+    </tasks>
+    ```
 
-1. Keep tasks that are sequential and require the same type of worker together in one subtask
-2. Only decompose tasks that can be handled in parallel and require different types of workers
-3. This ensures efficient execution by minimizing context switching between workers
+**END OF FORMAT EXAMPLE** - Now apply this structure to your actual task below.
 
 The content of the task is:
 
@@ -207,7 +241,7 @@ Following are the available workers, given in the format <ID>: <description>.
 {child_nodes_info}
 ==============================
 
-You must return the subtasks in the format of a numbered list within <tasks> tags, as shown below:
+You must return the subtasks as a list of individual subtasks within <tasks> tags. If your decomposition, following the principles and detailed example above (e.g., for summarizing multiple papers), results in several parallelizable actions, EACH of those actions must be represented as a separate <task> entry. For instance, the general format is:
 
 <tasks>
 <task>Subtask 1</task>

camel/societies/workforce/single_agent_worker.py

@@ -13,9 +13,12 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from __future__ import annotations
 
+import asyncio
 import datetime
 import json
-from typing import Any, List
+import time
+from collections import deque
+from typing import Any, List, Optional
 
 from colorama import Fore
 
@@ -26,36 +29,237 @@ from camel.societies.workforce.worker import Worker
 from camel.tasks.task import Task, TaskState, validate_task_content
 
 
+class AgentPool:
+    r"""A pool of agent instances for efficient reuse.
+
+    This pool manages a collection of pre-cloned agents. It supports
+    auto-scaling based ondemand and intelligent reuse of existing agents.
+
+    Args:
+        base_agent (ChatAgent): The base agent to clone from.
+        initial_size (int): Initial number of agents in the pool.
+            (default: :obj:`1`)
+        max_size (int): Maximum number of agents in the pool.
+            (default: :obj:`10`)
+        auto_scale (bool): Whether to automatically scale the pool size.
+            (default: :obj:`True`)
+        scale_factor (float): Factor by which to scale the pool when needed.
+            (default: :obj:`1.5`)
+        idle_timeout (float): Time in seconds after which idle agents are
+            removed. (default: :obj:`180.0`)
+    """
+
+    def __init__(
+        self,
+        base_agent: ChatAgent,
+        initial_size: int = 1,
+        max_size: int = 10,
+        auto_scale: bool = True,
+        scale_factor: float = 1.5,
+        idle_timeout: float = 180.0,  # 3 minutes
+    ):
+        self.base_agent = base_agent
+        self.max_size = max_size
+        self.auto_scale = auto_scale
+        self.scale_factor = scale_factor
+        self.idle_timeout = idle_timeout
+
+        # Pool management
+        self._available_agents: deque = deque()
+        self._in_use_agents: set = set()
+        self._agent_last_used: dict = {}
+        self._lock = asyncio.Lock()
+
+        # Statistics
+        self._total_borrows = 0
+        self._total_clones_created = 0
+        self._pool_hits = 0
+
+        # Initialize pool
+        self._initialize_pool(initial_size)
+
+    def _initialize_pool(self, size: int) -> None:
+        r"""Initialize the pool with the specified number of agents."""
+        for _ in range(min(size, self.max_size)):
+            agent = self._create_fresh_agent()
+            self._available_agents.append(agent)
+
+    def _create_fresh_agent(self) -> ChatAgent:
+        r"""Create a fresh agent instance."""
+        agent = self.base_agent.clone(with_memory=False)
+        self._total_clones_created += 1
+        return agent
+
+    async def get_agent(self) -> ChatAgent:
+        r"""Get an agent from the pool, creating one if necessary."""
+        async with self._lock:
+            self._total_borrows += 1
+
+            # Try to get from available agents first
+            if self._available_agents:
+                agent = self._available_agents.popleft()
+                self._in_use_agents.add(id(agent))
+                self._pool_hits += 1
+
+                # Reset the agent state
+                agent.reset()
+                return agent
+
+            # Check if we can create new agents
+            total_agents = len(self._available_agents) + len(
+                self._in_use_agents
+            )
+            if total_agents < self.max_size:
+                agent = self._create_fresh_agent()
+                self._in_use_agents.add(id(agent))
+                return agent
+
+            # Pool exhausted, wait and retry or create temporary agent
+            if self.auto_scale:
+                # Create a temporary agent that won't be returned to pool
+                return self._create_fresh_agent()
+            else:
+                # Wait for an agent to become available
+                while not self._available_agents:
+                    await asyncio.sleep(0.1)
+
+                agent = self._available_agents.popleft()
+                self._in_use_agents.add(id(agent))
+                agent.reset()
+                return agent
+
+    async def return_agent(self, agent: ChatAgent) -> None:
+        r"""Return an agent to the pool."""
+        async with self._lock:
+            agent_id = id(agent)
+
+            if agent_id in self._in_use_agents:
+                self._in_use_agents.remove(agent_id)
+
+                # Only return to pool if we're under max size
+                if len(self._available_agents) < self.max_size:
+                    # Reset agent state before returning to pool
+                    agent.reset()
+                    self._available_agents.append(agent)
+                    self._agent_last_used[agent_id] = time.time()
+
+    async def cleanup_idle_agents(self) -> None:
+        r"""Remove idle agents from the pool to free memory."""
+        if not self.auto_scale:
+            return
+
+        async with self._lock:
+            current_time = time.time()
+            agents_to_remove = []
+
+            for agent in list(self._available_agents):
+                agent_id = id(agent)
+                last_used = self._agent_last_used.get(agent_id, current_time)
+
+                if current_time - last_used > self.idle_timeout:
+                    agents_to_remove.append(agent)
+
+            for agent in agents_to_remove:
+                self._available_agents.remove(agent)
+                agent_id = id(agent)
+                self._agent_last_used.pop(agent_id, None)
+
+    def get_stats(self) -> dict:
+        r"""Get pool statistics."""
+        return {
+            "available_agents": len(self._available_agents),
+            "in_use_agents": len(self._in_use_agents),
+            "total_borrows": self._total_borrows,
+            "total_clones_created": self._total_clones_created,
+            "pool_hits": self._pool_hits,
+            "hit_rate": self._pool_hits / max(self._total_borrows, 1),
+        }
+
+
 class SingleAgentWorker(Worker):
     r"""A worker node that consists of a single agent.
 
     Args:
         description (str): Description of the node.
         worker (ChatAgent): Worker of the node. A single agent.
+        use_agent_pool (bool): Whether to use agent pool for efficiency.
+            (default: :obj:`True`)
+        pool_initial_size (int): Initial size of the agent pool.
+            (default: :obj:`1`)
+        pool_max_size (int): Maximum size of the agent pool.
+            (default: :obj:`10`)
+        auto_scale_pool (bool): Whether to auto-scale the agent pool.
+            (default: :obj:`True`)
     """
 
     def __init__(
         self,
         description: str,
         worker: ChatAgent,
+        use_agent_pool: bool = True,
+        pool_initial_size: int = 1,
+        pool_max_size: int = 10,
+        auto_scale_pool: bool = True,
     ) -> None:
         node_id = worker.agent_id
-        super().__init__(description, node_id=node_id)
+        super().__init__(
+            description,
+            node_id=node_id,
+        )
         self.worker = worker
+        self.use_agent_pool = use_agent_pool
+
+        self.agent_pool: Optional[AgentPool] = None
+        self._cleanup_task: Optional[asyncio.Task] = None
+        # Initialize agent pool if enabled
+        if self.use_agent_pool:
+            self.agent_pool = AgentPool(
+                base_agent=worker,
+                initial_size=pool_initial_size,
+                max_size=pool_max_size,
+                auto_scale=auto_scale_pool,
+            )
 
     def reset(self) -> Any:
         r"""Resets the worker to its initial state."""
         super().reset()
         self.worker.reset()
 
+        # Reset agent pool if it exists
+        if self.agent_pool:
+            # Stop cleanup task
+            if self._cleanup_task and not self._cleanup_task.done():
+                self._cleanup_task.cancel()
+
+            # Reinitialize pool
+            self.agent_pool = AgentPool(
+                base_agent=self.worker,
+            )
+
+    async def _get_worker_agent(self) -> ChatAgent:
+        r"""Get a worker agent, either from pool or by cloning."""
+        if self.use_agent_pool and self.agent_pool:
+            return await self.agent_pool.get_agent()
+        else:
+            # Fallback to original cloning approach
+            return self.worker.clone(with_memory=False)
+
+    async def _return_worker_agent(self, agent: ChatAgent) -> None:
+        r"""Return a worker agent to the pool if pooling is enabled."""
+        if self.use_agent_pool and self.agent_pool:
+            await self.agent_pool.return_agent(agent)
+        # If not using pool, agent will be garbage collected
+
     async def _process_task(
         self, task: Task, dependencies: List[Task]
     ) -> TaskState:
-        r"""Processes a task with its dependencies.
+        r"""Processes a task with its dependencies using an efficient agent
+        management system.
 
         This method asynchronously processes a given task, considering its
-        dependencies, by sending a generated prompt to a worker. It updates
-        the task's result based on the agent's response.
+        dependencies, by sending a generated prompt to a worker agent.
+        Uses an agent pool for efficiency when enabled, or falls back to
+        cloning when pool is disabled.
 
         Args:
             task (Task): The task to process, which includes necessary details
@@ -66,14 +270,18 @@ class SingleAgentWorker(Worker):
             TaskState: `TaskState.DONE` if processed successfully, otherwise
                 `TaskState.FAILED`.
         """
-        dependency_tasks_info = self._get_dep_tasks_info(dependencies)
-        prompt = PROCESS_TASK_PROMPT.format(
-            content=task.content,
-            dependency_tasks_info=dependency_tasks_info,
-            additional_info=task.additional_info,
-        )
+        # Get agent efficiently (from pool or by cloning)
+        worker_agent = await self._get_worker_agent()
+
         try:
-            response = await self.worker.astep(
+            dependency_tasks_info = self._get_dep_tasks_info(dependencies)
+            prompt = PROCESS_TASK_PROMPT.format(
+                content=task.content,
+                dependency_tasks_info=dependency_tasks_info,
+                additional_info=task.additional_info,
+            )
+
+            response = await worker_agent.astep(
                 prompt, response_format=TaskResult
             )
         except Exception as e:
@@ -82,6 +290,16 @@ class SingleAgentWorker(Worker):
                 f"\n{e}{Fore.RESET}"
             )
             return TaskState.FAILED
+        finally:
+            # Return agent to pool or let it be garbage collected
+            await self._return_worker_agent(worker_agent)
+
+        # Get actual token usage from the agent that processed this task
+        try:
+            _, total_token_count = worker_agent.memory.get_context()
+        except Exception:
+            # Fallback if memory context unavailable
+            total_token_count = 0
 
         # Populate additional_info with worker attempt details
         if task.additional_info is None:
@@ -90,14 +308,20 @@ class SingleAgentWorker(Worker):
         # Create worker attempt details with descriptive keys
         worker_attempt_details = {
             "agent_id": getattr(
+                worker_agent, "agent_id", worker_agent.role_name
+            ),
+            "original_worker_id": getattr(
                 self.worker, "agent_id", self.worker.role_name
             ),
             "timestamp": str(datetime.datetime.now()),
             "description": f"Attempt by "
-            f"{getattr(self.worker, 'agent_id', self.worker.role_name)} "
+            f"{getattr(worker_agent, 'agent_id', worker_agent.role_name)} "
+            f"(from pool/clone of "
+            f"{getattr(self.worker, 'agent_id', self.worker.role_name)}) "
             f"to process task {task.content}",
             "response_content": response.msg.content,
-            "tool_calls": response.info["tool_calls"],
+            "tool_calls": response.info.get("tool_calls"),
+            "total_token_count": total_token_count,
         }
 
         # Store the worker attempt in additional_info
@@ -105,6 +329,11 @@ class SingleAgentWorker(Worker):
             task.additional_info["worker_attempts"] = []
         task.additional_info["worker_attempts"].append(worker_attempt_details)
 
+        # Store the actual token usage for this specific task
+        task.additional_info["token_usage"] = {
+            "total_tokens": total_token_count
+        }
+
         print(f"======\n{Fore.GREEN}Reply from {self}:{Fore.RESET}")
 
         result_dict = json.loads(response.msg.content)
@@ -127,3 +356,34 @@ class SingleAgentWorker(Worker):
 
         task.result = task_result.content
         return TaskState.DONE
+
+    async def _listen_to_channel(self):
+        r"""Override to start cleanup task when pool is enabled."""
+        # Start cleanup task for agent pool
+        if self.use_agent_pool and self.agent_pool:
+            self._cleanup_task = asyncio.create_task(self._periodic_cleanup())
+
+        # Call parent implementation
+        await super()._listen_to_channel()
+
+        # Stop cleanup task
+        if self._cleanup_task and not self._cleanup_task.done():
+            self._cleanup_task.cancel()
+
+    async def _periodic_cleanup(self):
+        r"""Periodically clean up idle agents from the pool."""
+        while True:
+            try:
+                await asyncio.sleep(60)  # Cleanup every minute
+                if self.agent_pool:
+                    await self.agent_pool.cleanup_idle_agents()
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                print(f"Error in pool cleanup: {e}")
+
+    def get_pool_stats(self) -> Optional[dict]:
+        r"""Get agent pool statistics if pool is enabled."""
+        if self.use_agent_pool and self.agent_pool:
+            return self.agent_pool.get_stats()
+        return None

camel/societies/workforce/task_channel.py

@@ -23,6 +23,8 @@ class PacketStatus(Enum):
     states:
 
     - ``SENT``: The packet has been sent to a worker.
+    - ``PROCESSING``: The packet has been claimed by a worker and is being
+    processed.
     - ``RETURNED``: The packet has been returned by the worker, meaning that
       the status of the task inside has been updated.
     - ``ARCHIVED``: The packet has been archived, meaning that the content of
@@ -31,6 +33,7 @@ class PacketStatus(Enum):
     """
 
     SENT = "SENT"
+    PROCESSING = "PROCESSING"
     RETURNED = "RETURNED"
     ARCHIVED = "ARCHIVED"
 
@@ -97,8 +100,9 @@ class TaskChannel:
                 await self._condition.wait()
 
     async def get_assigned_task_by_assignee(self, assignee_id: str) -> Task:
-        r"""Get a task from the channel that has been assigned to the
-        assignee.
+        r"""Atomically get and claim a task from the channel that has been
+        assigned to the assignee. This prevents race conditions where multiple
+        concurrent calls might retrieve the same task.
         """
         async with self._condition:
             while True:
@@ -107,6 +111,9 @@ class TaskChannel:
                         packet.status == PacketStatus.SENT
                         and packet.assignee_id == assignee_id
                     ):
+                        # Atomically claim the task by changing its status
+                        packet.status = PacketStatus.PROCESSING
+                        self._condition.notify_all()
                         return packet.task
                 await self._condition.wait()
 

camel/societies/workforce/utils.py

@@ -50,7 +50,8 @@ class TaskAssignment(BaseModel):
     )
     dependencies: List[str] = Field(
         default_factory=list,
-        description="List of task IDs that must complete before this task.",
+        description="List of task IDs that must complete before this task. "
+        "This is critical for the task decomposition and execution.",
     )
 
 
@@ -156,7 +157,14 @@ def check_if_running(
                 )
                 return None
             else:
-                raise last_exception
+                raise (
+                    last_exception
+                    if last_exception
+                    else RuntimeError(
+                        f"Unexpected failure in {func.__name__} "
+                        "with no exception captured."
+                    )
+                )
 
         return wrapper
 

camel/societies/workforce/worker.py

@@ -13,9 +13,10 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from __future__ import annotations
 
+import asyncio
 import logging
 from abc import ABC, abstractmethod
-from typing import List, Optional
+from typing import List, Optional, Set
 
 from colorama import Fore
 
@@ -43,6 +44,7 @@ class Worker(BaseNode, ABC):
         node_id: Optional[str] = None,
     ) -> None:
         super().__init__(description, node_id=node_id)
+        self._active_task_ids: Set[str] = set()
 
     def __repr__(self):
         return f"Worker node {self.node_id} ({self.description})"
@@ -60,7 +62,7 @@ class Worker(BaseNode, ABC):
         pass
 
     async def _get_assigned_task(self) -> Task:
-        r"""Get the task assigned to this node from the channel."""
+        r"""Get a task assigned to this node from the channel."""
         return await self._channel.get_assigned_task_by_assignee(self.node_id)
 
     @staticmethod
@@ -77,20 +79,10 @@ class Worker(BaseNode, ABC):
     def set_channel(self, channel: TaskChannel):
         self._channel = channel
 
-    @check_if_running(False)
-    async def _listen_to_channel(self):
-        """Continuously listen to the channel, process the task that are
-        assigned to this node, and update the result and status of the task.
-
-        This method should be run in an event loop, as it will run
-            indefinitely.
-        """
-        self._running = True
-        logger.info(f"{self} started.")
-
-        while True:
-            # Get the earliest task assigned to this node
-            task = await self._get_assigned_task()
+    async def _process_single_task(self, task: Task) -> None:
+        r"""Process a single task and handle its completion/failure."""
+        try:
+            self._active_task_ids.add(task.id)
             print(
                 f"{Fore.YELLOW}{self} get task {task.id}: {task.content}"
                 f"{Fore.RESET}"
@@ -109,6 +101,72 @@ class Worker(BaseNode, ABC):
             task.set_state(task_state)
 
             await self._channel.return_task(task.id)
+        except Exception as e:
+            logger.error(f"Error processing task {task.id}: {e}")
+            task.set_state(TaskState.FAILED)
+            await self._channel.return_task(task.id)
+        finally:
+            self._active_task_ids.discard(task.id)
+
+    @check_if_running(False)
+    async def _listen_to_channel(self):
+        r"""Continuously listen to the channel and process assigned tasks.
+
+        This method supports parallel task execution without artificial limits.
+        """
+        self._running = True
+        logger.info(f"{self} started.")
+
+        # Keep track of running task coroutines
+        running_tasks: Set[asyncio.Task] = set()
+
+        while self._running:
+            try:
+                # Clean up completed tasks
+                completed_tasks = [t for t in running_tasks if t.done()]
+                for completed_task in completed_tasks:
+                    running_tasks.remove(completed_task)
+                    # Check for exceptions in completed tasks
+                    try:
+                        await completed_task
+                    except Exception as e:
+                        logger.error(f"Task processing failed: {e}")
+
+                # Try to get a new task (with short timeout to avoid blocking)
+                try:
+                    task = await asyncio.wait_for(
+                        self._get_assigned_task(), timeout=1.0
+                    )
+
+                    # Create and start processing task
+                    task_coroutine = asyncio.create_task(
+                        self._process_single_task(task)
+                    )
+                    running_tasks.add(task_coroutine)
+
+                except asyncio.TimeoutError:
+                    # No tasks available, continue loop
+                    if not running_tasks:
+                        # No tasks running and none available, short sleep
+                        await asyncio.sleep(0.1)
+                    continue
+
+            except Exception as e:
+                logger.error(
+                    f"Error in worker {self.node_id} listen loop: {e}"
+                )
+                await asyncio.sleep(0.1)
+                continue
+
+        # Wait for all remaining tasks to complete when stopping
+        if running_tasks:
+            logger.info(
+                f"{self} stopping, waiting for {len(running_tasks)} "
+                f"tasks to complete..."
+            )
+            await asyncio.gather(*running_tasks, return_exceptions=True)
+
+        logger.info(f"{self} stopped.")
 
     @check_if_running(False)
     async def start(self):