camel-ai 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

camel/models/qwen_model.py

@@ -0,0 +1,139 @@
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+# Licensed under the Apache License, Version 2.0 (the “License”);
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an “AS IS” BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+
+import os
+from typing import Any, Dict, List, Optional, Union
+
+from openai import OpenAI, Stream
+
+from camel.configs import QWEN_API_PARAMS, QwenConfig
+from camel.messages import OpenAIMessage
+from camel.models import BaseModelBackend
+from camel.types import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    ModelType,
+)
+from camel.utils import (
+    BaseTokenCounter,
+    OpenAITokenCounter,
+    api_keys_required,
+)
+
+
+class QwenModel(BaseModelBackend):
+    r"""Qwen API in a unified BaseModelBackend interface.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created, one of Qwen series.
+        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
+            that will be fed into:obj:`openai.ChatCompletion.create()`. If
+            :obj:`None`, :obj:`QwenConfig().as_dict()` will be used.
+            (default: :obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating with
+            the Qwen service. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the Qwen service.
+            (default: :obj:`https://dashscope.aliyuncs.com/compatible-mode/v1`)
+        token_counter (Optional[BaseTokenCounter], optional): Token counter to
+            use for the model. If not provided, :obj:`OpenAITokenCounter(
+            ModelType.GPT_4O_MINI)` will be used.
+            (default: :obj:`None`)
+    """
+
+    def __init__(
+        self,
+        model_type: Union[ModelType, str],
+        model_config_dict: Optional[Dict[str, Any]] = None,
+        api_key: Optional[str] = None,
+        url: Optional[str] = None,
+        token_counter: Optional[BaseTokenCounter] = None,
+    ) -> None:
+        if model_config_dict is None:
+            model_config_dict = QwenConfig().as_dict()
+        api_key = api_key or os.environ.get("QWEN_API_KEY")
+        url = url or os.environ.get(
+            "QWEN_API_BASE_URL",
+            "https://dashscope.aliyuncs.com/compatible-mode/v1",
+        )
+        super().__init__(
+            model_type, model_config_dict, api_key, url, token_counter
+        )
+        self._client = OpenAI(
+            timeout=60,
+            max_retries=3,
+            api_key=self._api_key,
+            base_url=self._url,
+        )
+
+    @api_keys_required("QWEN_API_KEY")
+    def run(
+        self,
+        messages: List[OpenAIMessage],
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        r"""Runs inference of Qwen chat completion.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+
+        Returns:
+            Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+                `ChatCompletion` in the non-stream mode, or
+                `Stream[ChatCompletionChunk]` in the stream mode.
+        """
+        response = self._client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+            **self.model_config_dict,
+        )
+        return response
+
+    @property
+    def token_counter(self) -> BaseTokenCounter:
+        r"""Initialize the token counter for the model backend.
+
+        Returns:
+            OpenAITokenCounter: The token counter following the model's
+                tokenization style.
+        """
+
+        if not self._token_counter:
+            self._token_counter = OpenAITokenCounter(ModelType.GPT_4O_MINI)
+        return self._token_counter
+
+    def check_model_config(self):
+        r"""Check whether the model configuration contains any
+        unexpected arguments to Qwen API.
+
+        Raises:
+            ValueError: If the model configuration dictionary contains any
+                unexpected arguments to Qwen API.
+        """
+        for param in self.model_config_dict:
+            if param not in QWEN_API_PARAMS:
+                raise ValueError(
+                    f"Unexpected argument `{param}` is "
+                    "input into Qwen model backend."
+                )
+
+    @property
+    def stream(self) -> bool:
+        r"""Returns whether the model is in stream mode, which sends partial
+        results each time.
+
+        Returns:
+            bool: Whether the model is in stream mode.
+        """
+        return self.model_config_dict.get('stream', False)

camel/models/yi_model.py

@@ -0,0 +1,138 @@
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+# Licensed under the Apache License, Version 2.0 (the “License”);
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an “AS IS” BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+
+import os
+from typing import Any, Dict, List, Optional, Union
+
+from openai import OpenAI, Stream
+
+from camel.configs import YI_API_PARAMS, YiConfig
+from camel.messages import OpenAIMessage
+from camel.models import BaseModelBackend
+from camel.types import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    ModelType,
+)
+from camel.utils import (
+    BaseTokenCounter,
+    OpenAITokenCounter,
+    api_keys_required,
+)
+
+
+class YiModel(BaseModelBackend):
+    r"""Yi API in a unified BaseModelBackend interface.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created, one of Yi series.
+        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
+            that will be fed into:obj:`openai.ChatCompletion.create()`. If
+            :obj:`None`, :obj:`YiConfig().as_dict()` will be used.
+            (default: :obj:`None`)
+        api_key (Optional[str], optional): The API key for authenticating with
+            the Yi service. (default: :obj:`None`)
+        url (Optional[str], optional): The url to the Yi service.
+            (default: :obj:`https://api.lingyiwanwu.com/v1`)
+        token_counter (Optional[BaseTokenCounter], optional): Token counter to
+            use for the model. If not provided, :obj:`OpenAITokenCounter(
+            ModelType.GPT_4O_MINI)` will be used.
+            (default: :obj:`None`)
+    """
+
+    def __init__(
+        self,
+        model_type: Union[ModelType, str],
+        model_config_dict: Optional[Dict[str, Any]] = None,
+        api_key: Optional[str] = None,
+        url: Optional[str] = None,
+        token_counter: Optional[BaseTokenCounter] = None,
+    ) -> None:
+        if model_config_dict is None:
+            model_config_dict = YiConfig().as_dict()
+        api_key = api_key or os.environ.get("YI_API_KEY")
+        url = url or os.environ.get(
+            "YI_API_BASE_URL", "https://api.lingyiwanwu.com/v1"
+        )
+        super().__init__(
+            model_type, model_config_dict, api_key, url, token_counter
+        )
+        self._client = OpenAI(
+            timeout=60,
+            max_retries=3,
+            api_key=self._api_key,
+            base_url=self._url,
+        )
+
+    @api_keys_required("YI_API_KEY")
+    def run(
+        self,
+        messages: List[OpenAIMessage],
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        r"""Runs inference of Yi chat completion.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+
+        Returns:
+            Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+                `ChatCompletion` in the non-stream mode, or
+                `Stream[ChatCompletionChunk]` in the stream mode.
+        """
+        response = self._client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+            **self.model_config_dict,
+        )
+        return response
+
+    @property
+    def token_counter(self) -> BaseTokenCounter:
+        r"""Initialize the token counter for the model backend.
+
+        Returns:
+            OpenAITokenCounter: The token counter following the model's
+                tokenization style.
+        """
+
+        if not self._token_counter:
+            self._token_counter = OpenAITokenCounter(ModelType.GPT_4O_MINI)
+        return self._token_counter
+
+    def check_model_config(self):
+        r"""Check whether the model configuration contains any
+        unexpected arguments to Yi API.
+
+        Raises:
+            ValueError: If the model configuration dictionary contains any
+                unexpected arguments to Yi API.
+        """
+        for param in self.model_config_dict:
+            if param not in YI_API_PARAMS:
+                raise ValueError(
+                    f"Unexpected argument `{param}` is "
+                    "input into Yi model backend."
+                )
+
+    @property
+    def stream(self) -> bool:
+        r"""Returns whether the model is in stream mode, which sends partial
+        results each time.
+
+        Returns:
+            bool: Whether the model is in stream mode.
+        """
+        return self.model_config_dict.get('stream', False)

camel/prompts/image_craft.py

@@ -18,6 +18,14 @@ from camel.types import RoleType
 
 
 class ImageCraftPromptTemplateDict(TextPromptDict):
+    r"""A dictionary containing :obj:`TextPrompt` used in the `ImageCraft`
+    task.
+
+    Attributes:
+        ASSISTANT_PROMPT (TextPrompt): A prompt for the AI assistant to create
+            an original image based on the provided descriptive captions.
+    """
+
     ASSISTANT_PROMPT = TextPrompt(
         """You are tasked with creating an original image based on
         the provided descriptive captions. Use your imagination

camel/prompts/video_description_prompt.py

@@ -19,6 +19,14 @@ from camel.types import RoleType
 
 # flake8: noqa :E501
 class VideoDescriptionPromptTemplateDict(TextPromptDict):
+    r"""A dictionary containing :obj:`TextPrompt` used in the `VideoDescription`
+    task.
+
+    Attributes:
+        ASSISTANT_PROMPT (TextPrompt): A prompt for the AI assistant to
+            provide a shot description of the content of the current video.
+    """
+
     ASSISTANT_PROMPT = TextPrompt(
         """You are a master of video analysis. 
         Please provide a shot description of the content of the current video."""

camel/retrievers/vector_retriever.py

@@ -76,6 +76,7 @@ class VectorRetriever(BaseRetriever):
         max_characters: int = 500,
         embed_batch: int = 50,
         should_chunk: bool = True,
+        extra_info: Optional[dict] = None,
         **kwargs: Any,
     ) -> None:
         r"""Processes content from local file path, remote URL, string
@@ -93,6 +94,8 @@ class VectorRetriever(BaseRetriever):
             embed_batch (int): Size of batch for embeddings. Defaults to `50`.
             should_chunk (bool): If True, divide the content into chunks,
                 otherwise skip chunking. Defaults to True.
+            extra_info (Optional[dict]): Extra information to be added
+                to the payload. Defaults to None.
             **kwargs (Any): Additional keyword arguments for content parsing.
         """
         from unstructured.documents.elements import Element
@@ -153,12 +156,13 @@ class VectorRetriever(BaseRetriever):
                     chunk_metadata = {"metadata": chunk.metadata.to_dict()}
                     # Remove the 'orig_elements' key if it exists
                     chunk_metadata["metadata"].pop("orig_elements", "")
-
+                    extra_info = extra_info or {}
                     chunk_text = {"text": str(chunk)}
                     combined_dict = {
                         **content_path_info,
                         **chunk_metadata,
                         **chunk_text,
+                        **extra_info,
                     }
 
                     records.append(

camel/societies/role_playing.py

@@ -23,10 +23,10 @@ from camel.agents import (
 from camel.generators import SystemMessageGenerator
 from camel.human import Human
 from camel.messages import BaseMessage
-from camel.models import BaseModelBackend
+from camel.models import BaseModelBackend, ModelFactory
 from camel.prompts import TextPrompt
 from camel.responses import ChatAgentResponse
-from camel.types import RoleType, TaskType
+from camel.types import ModelPlatformType, ModelType, RoleType, TaskType
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.WARNING)
@@ -55,7 +55,8 @@ class RolePlaying:
             If not specified, set the criteria to improve task performance.
         model (BaseModelBackend, optional): The model backend to use for
             generating responses. If specified, it will override the model in
-            all agents. (default: :obj:`None`)
+            all agents if not specified in agent-specific kwargs. (default:
+            :obj:`OpenAIModel` with `GPT_4O_MINI`)
         task_type (TaskType, optional): The type of task to perform.
             (default: :obj:`TaskType.AI_SOCIETY`)
         assistant_agent_kwargs (Dict, optional): Additional arguments to pass
@@ -103,16 +104,21 @@ class RolePlaying:
     ) -> None:
         if model is not None:
             logger.warning(
-                "The provided model will override the model settings in "
-                "all agents, including any configurations passed "
-                "through assistant_agent_kwargs, user_agent_kwargs, and "
-                "other agent-specific kwargs."
+                "Model provided globally is set for all agents if not"
+                " already specified in agent_kwargs."
             )
 
         self.with_task_specify = with_task_specify
         self.with_task_planner = with_task_planner
         self.with_critic_in_the_loop = with_critic_in_the_loop
-        self.model = model
+        self.model: BaseModelBackend = (
+            model
+            if model is not None
+            else ModelFactory.create(
+                model_platform=ModelPlatformType.DEFAULT,
+                model_type=ModelType.DEFAULT,
+            )
+        )
         self.task_type = task_type
         self.task_prompt = task_prompt
 
@@ -204,8 +210,9 @@ class RolePlaying:
             task_specify_meta_dict.update(extend_task_specify_meta_dict or {})
             if self.model is not None:
                 if task_specify_agent_kwargs is None:
-                    task_specify_agent_kwargs = {}
-                task_specify_agent_kwargs.update(dict(model=self.model))
+                    task_specify_agent_kwargs = {'model': self.model}
+                elif 'model' not in task_specify_agent_kwargs:
+                    task_specify_agent_kwargs.update(dict(model=self.model))
             task_specify_agent = TaskSpecifyAgent(
                 task_type=self.task_type,
                 output_language=output_language,
@@ -237,8 +244,9 @@ class RolePlaying:
         if self.with_task_planner:
             if self.model is not None:
                 if task_planner_agent_kwargs is None:
-                    task_planner_agent_kwargs = {}
-                task_planner_agent_kwargs.update(dict(model=self.model))
+                    task_planner_agent_kwargs = {'model': self.model}
+                elif 'model' not in task_planner_agent_kwargs:
+                    task_planner_agent_kwargs.update(dict(model=self.model))
             task_planner_agent = TaskPlannerAgent(
                 output_language=output_language,
                 **(task_planner_agent_kwargs or {}),
@@ -332,11 +340,13 @@ class RolePlaying:
         """
         if self.model is not None:
             if assistant_agent_kwargs is None:
-                assistant_agent_kwargs = {}
-            assistant_agent_kwargs.update(dict(model=self.model))
+                assistant_agent_kwargs = {'model': self.model}
+            elif 'model' not in assistant_agent_kwargs:
+                assistant_agent_kwargs.update(dict(model=self.model))
             if user_agent_kwargs is None:
-                user_agent_kwargs = {}
-            user_agent_kwargs.update(dict(model=self.model))
+                user_agent_kwargs = {'model': self.model}
+            elif 'model' not in user_agent_kwargs:
+                user_agent_kwargs.update(dict(model=self.model))
 
         self.assistant_agent = ChatAgent(
             init_assistant_sys_msg,
@@ -394,8 +404,9 @@ class RolePlaying:
                 )
                 if self.model is not None:
                     if critic_kwargs is None:
-                        critic_kwargs = {}
-                    critic_kwargs.update(dict(model=self.model))
+                        critic_kwargs = {'model': self.model}
+                    elif 'model' not in critic_kwargs:
+                        critic_kwargs.update(dict(model=self.model))
                 self.critic = CriticAgent(
                     self.critic_sys_msg,
                     **(critic_kwargs or {}),

camel/societies/workforce/base.py

@@ -19,6 +19,12 @@ from camel.societies.workforce.utils import check_if_running
 
 
 class BaseNode(ABC):
+    r"""Base class for all nodes in the workforce.
+
+    Args:
+        description (str): Description of the node.
+    """
+
     def __init__(self, description: str) -> None:
         self.node_id = str(id(self))
         self.description = description
@@ -27,7 +33,7 @@ class BaseNode(ABC):
 
     @check_if_running(False)
     def reset(self, *args: Any, **kwargs: Any) -> Any:
-        """Resets the node to its initial state."""
+        r"""Resets the node to its initial state."""
         self._channel = TaskChannel()
         self._running = False
 

camel/societies/workforce/task_channel.py

@@ -84,6 +84,9 @@ class TaskChannel:
         self._task_dict: Dict[str, Packet] = {}
 
     async def get_returned_task_by_publisher(self, publisher_id: str) -> Task:
+        r"""Get a task from the channel that has been returned by the
+        publisher.
+        """
         async with self._condition:
             while True:
                 for task_id in self._task_id_list:
@@ -96,6 +99,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.
+        """
         async with self._condition:
             while True:
                 for task_id in self._task_id_list:
@@ -147,12 +153,14 @@ class TaskChannel:
             self._condition.notify_all()
 
     async def remove_task(self, task_id: str) -> None:
+        r"""Remove a task from the channel."""
         async with self._condition:
             self._task_id_list.remove(task_id)
             self._task_dict.pop(task_id)
             self._condition.notify_all()
 
     async def get_dependency_ids(self) -> List[str]:
+        r"""Get the IDs of all dependencies in the channel."""
         async with self._condition:
             dependency_ids = []
             for task_id in self._task_id_list:
@@ -162,11 +170,13 @@ class TaskChannel:
             return dependency_ids
 
     async def get_task_by_id(self, task_id: str) -> Task:
+        r"""Get a task from the channel by its ID."""
         async with self._condition:
             if task_id not in self._task_id_list:
                 raise ValueError(f"Task {task_id} not found.")
             return self._task_dict[task_id].task
 
     async def get_channel_debug_info(self) -> str:
+        r"""Get the debug information of the channel."""
         async with self._condition:
             return str(self._task_dict) + '\n' + str(self._task_id_list)

camel/societies/workforce/utils.py

@@ -18,6 +18,8 @@ from pydantic import BaseModel, Field
 
 
 class WorkerConf(BaseModel):
+    r"""The configuration of a worker."""
+
     role: str = Field(
         description="The role of the agent working in the work node."
     )
@@ -31,6 +33,8 @@ class WorkerConf(BaseModel):
 
 
 class TaskResult(BaseModel):
+    r"""The result of a task."""
+
     content: str = Field(description="The result of the task.")
     failed: bool = Field(
         description="Flag indicating whether the task processing failed."
@@ -38,6 +42,8 @@ class TaskResult(BaseModel):
 
 
 class TaskAssignResult(BaseModel):
+    r"""The result of task assignment."""
+
     assignee_id: str = Field(
         description="The ID of the workforce that is assigned to the task."
     )

camel/societies/workforce/worker.py

@@ -110,9 +110,11 @@ class Worker(BaseNode, ABC):
 
     @check_if_running(False)
     async def start(self):
+        r"""Start the worker."""
         await self._listen_to_channel()
 
     @check_if_running(True)
     def stop(self):
+        r"""Stop the worker."""
         self._running = False
         return