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

camel/generators.py

@@ -154,6 +154,21 @@ class SystemMessageGenerator:
 
 
 class RoleNameGenerator:
+    r"""Role name generator for role-playing workers.
+
+    Args:
+        assistant_role_names_path (str, optional): The path to the file
+            containing the assistant role names.
+            (default: :obj:`"data/ai_society/assistant_roles.txt"`)
+        user_role_names_path (str, optional): The path to the file
+            containing the user role names.
+            (default: :obj:`"data/ai_society/user_roles.txt"`)
+        assistant_role_names (Optional[List[str]], optional): The list of
+            assistant role names. (default: :obj:`None`)
+        user_role_names (Optional[List[str]], optional): The list of user role
+            names. (default: :obj:`None`)
+    """
+
     def __init__(
         self,
         assistant_role_names_path: str = "data/ai_society/assistant_roles.txt",
@@ -181,12 +196,25 @@ class RoleNameGenerator:
             self.user_role_names = user_role_names
 
     def from_role_files(self) -> Generator[Tuple, None, None]:
+        r"""Generate role names from the file.
+
+        Returns:
+            Generator[Tuple, None, None]: A generator that yields tuples of
+                assistant role names and user role names.
+        """
         for assistant_role_name in self.assistant_role_names:
             for user_role_name in self.user_role_names:
                 yield (assistant_role_name, user_role_name)
 
 
 class AISocietyTaskPromptGenerator:
+    r"""Task prompt generator for AI society tasks.
+
+    Args:
+        num_tasks (int, optional): The number of tasks to generate.
+            (default: :obj:`10`)
+    """
+
     def __init__(
         self,
         num_tasks: int = 10,
@@ -205,6 +233,20 @@ class AISocietyTaskPromptGenerator:
         assistant_role_names_path: str = "data/ai_society/assistant_roles.txt",
         user_role_names_path: str = "data/ai_society/user_roles.txt",
     ) -> Generator[Tuple[str, Tuple[str, str]], None, None]:
+        r"""Generate tasks from role files.
+
+        Args:
+            assistant_role_names_path (str, optional): The path to the file
+                containing the assistant role names.
+                (default: :obj:`"data/ai_society/assistant_roles.txt"`)
+            user_role_names_path (str, optional): The path to the file
+                containing the user role names.
+                (default: :obj:`"data/ai_society/user_roles.txt"`)
+
+        Returns:
+            Generator[Tuple[str, Tuple[str, str]], None, None]: A generator
+                that yields tuples of task prompts and role names.
+        """
         roles_generator = RoleNameGenerator(
             assistant_role_names_path, user_role_names_path
         ).from_role_files()
@@ -220,6 +262,16 @@ class AISocietyTaskPromptGenerator:
     def from_role_generator(
         self, role_generator: Generator[Tuple, None, None]
     ) -> Generator[Tuple[str, Tuple[str, str]], None, None]:
+        r"""Generate tasks from a role generator.
+
+        Args:
+            role_generator (Generator[Tuple, None, None]): A generator that
+                yields tuples of role names.
+
+        Returns:
+            Generator[Tuple[str, Tuple[str, str]], None, None]: A generator
+                that yields tuples of task prompts and role names.
+        """
         for role_1, role_2 in role_generator:
             generate_tasks_prompt = self.generate_tasks_prompt.format(
                 assistant_role=role_1,
@@ -231,6 +283,12 @@ class AISocietyTaskPromptGenerator:
 
 
 class SingleTxtGenerator:
+    r"""Single text generator for role-playing workers.
+
+    Args:
+        text_file_path (str): The path to the file containing the text data.
+    """
+
     def __init__(
         self,
         text_file_path: str,
@@ -242,11 +300,23 @@ class SingleTxtGenerator:
             ]
 
     def from_role_files(self) -> Generator[str, None, None]:
+        r"""Generate text from the file.
+
+        Returns:
+            Generator[str, None, None]: A generator that yields the text data.
+        """
         for data in self.data_list:
             yield data
 
 
 class CodeTaskPromptGenerator:
+    r"""Code task prompt generator for code tasks.
+
+    Args:
+        num_tasks (int, optional): The number of tasks to generate.
+            (default: :obj:`50`)
+    """
+
     def __init__(
         self,
         num_tasks: int = 50,
@@ -262,6 +332,19 @@ class CodeTaskPromptGenerator:
         languages_path: str = "data/code/languages.txt",
         domains_path: str = "data/code/domains.txt",
     ) -> Generator[Tuple[TextPrompt, str, str], None, None]:
+        r"""Generate tasks from role files.
+
+        Args:
+            languages_path (str, optional): The path to the file containing
+                the language names. (default: :obj:`"data/code/languages.txt"`)
+            domains_path (str, optional): The path to the file containing
+                the domain names. (default: :obj:`"data/code/domains.txt"`)
+
+        Returns:
+            Generator[Tuple[TextPrompt, str, str], None, None]: A generator
+                that yields tuples of task prompts, language names, and domain
+                names.
+        """
         language_generator = SingleTxtGenerator(
             languages_path
         ).from_role_files()
@@ -279,4 +362,14 @@ class CodeTaskPromptGenerator:
     def from_role_generator(
         self, role_generator: Generator[Tuple, None, None]
     ) -> Generator[str, None, None]:
+        r"""Generate tasks from a role generator.
+
+        Args:
+            role_generator (Generator[Tuple, None, None]): A generator that
+                yields tuples of role names.
+
+        Returns:
+            Generator[str, None, None]: A generator that yields the task
+                prompts.
+        """
         raise NotImplementedError

camel/interpreters/docker_interpreter.py

@@ -80,6 +80,11 @@ class DockerInterpreter(BaseInterpreter):
         self._container: Optional[Container] = None
 
     def __del__(self) -> None:
+        r"""Destructor for the DockerInterpreter class.
+
+        This method ensures that the Docker container is removed when the
+        interpreter is deleted.
+        """
         if self._container is not None:
             self._container.remove(force=True)
 

camel/interpreters/ipython_interpreter.py

@@ -105,7 +105,8 @@ class JupyterKernelInterpreter(BaseInterpreter):
                     outputs.append(msg_content["data"]["text/plain"])
                     if "image/png" in msg_content["data"]:
                         outputs.append(
-                            f"\n![image](data:image/png;base64,{msg_content['data']['image/png']})\n"
+                            f"\n![image](data:image/png;base64,"
+                            f"{msg_content['data']['image/png']})\n"
                         )
             except queue.Empty:
                 outputs.append("Time out")

camel/loaders/__init__.py

@@ -12,6 +12,7 @@
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 
+from .apify_reader import Apify
 from .base_io import File
 from .chunkr_reader import ChunkrReader
 from .firecrawl_reader import Firecrawl
@@ -23,5 +24,6 @@ __all__ = [
     'UnstructuredIO',
     'JinaURLReader',
     'Firecrawl',
+    'Apify',
     'ChunkrReader',
 ]

camel/loaders/apify_reader.py

@@ -0,0 +1,223 @@
+# =========== 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 TYPE_CHECKING, List, Optional
+
+if TYPE_CHECKING:
+    from apify_client.clients import DatasetClient
+
+from camel.utils import api_keys_required
+
+
+class Apify:
+    r"""Apify is a platform that allows you to automate any web workflow.
+
+    Args:
+        api_key (Optional[str]): API key for authenticating with the Apify API.
+    """
+
+    @api_keys_required("APIFY_API_KEY")
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+    ) -> None:
+        from apify_client import ApifyClient
+
+        self._api_key = api_key or os.environ.get("APIFY_API_KEY")
+        self.client = ApifyClient(token=self._api_key)
+
+    def run_actor(
+        self,
+        actor_id: str,
+        run_input: Optional[dict] = None,
+        content_type: Optional[str] = None,
+        build: Optional[str] = None,
+        max_items: Optional[int] = None,
+        memory_mbytes: Optional[int] = None,
+        timeout_secs: Optional[int] = None,
+        webhooks: Optional[list] = None,
+        wait_secs: Optional[int] = None,
+    ) -> Optional[dict]:
+        r"""Run an actor on the Apify platform.
+
+        Args:
+            actor_id (str): The ID of the actor to run.
+            run_input (Optional[dict]): The input data for the actor. Defaults
+                to `None`.
+            content_type (str, optional): The content type of the input.
+            build (str, optional): Specifies the Actor build to run. It can be
+                either a build tag or build number. By default, the run uses
+                the build specified in the default run configuration for the
+                Actor (typically latest).
+            max_items (int, optional): Maximum number of results that will be
+                returned by this run. If the Actor is charged per result, you
+                will not be charged for more results than the given limit.
+            memory_mbytes (int, optional): Memory limit for the run, in
+                megabytes. By default, the run uses a memory limit specified in
+                the default run configuration for the Actor.
+            timeout_secs (int, optional): Optional timeout for the run, in
+                seconds. By default, the run uses timeout specified in the
+                default run configuration for the Actor.
+            webhooks (list, optional): Optional webhooks
+                (https://docs.apify.com/webhooks) associated with the Actor
+                run, which can be used to receive a notification, e.g. when the
+                Actor finished or failed. If you already have a webhook set up
+                for the Actor, you do not have to add it again here.
+            wait_secs (int, optional): The maximum number of seconds the server
+                waits for finish. If not provided, waits indefinitely.
+
+        Returns:
+            Optional[dict]: The output data from the actor if successful.
+            # please use the 'defaultDatasetId' to get the dataset
+
+        Raises:
+            RuntimeError: If the actor fails to run.
+        """
+        try:
+            return self.client.actor(actor_id).call(
+                run_input=run_input,
+                content_type=content_type,
+                build=build,
+                max_items=max_items,
+                memory_mbytes=memory_mbytes,
+                timeout_secs=timeout_secs,
+                webhooks=webhooks,
+                wait_secs=wait_secs,
+            )
+        except Exception as e:
+            raise RuntimeError(f"Failed to run actor {actor_id}: {e}") from e
+
+    def get_dataset_client(
+        self,
+        dataset_id: str,
+    ) -> "DatasetClient":
+        r"""Get a dataset client from the Apify platform.
+
+        Args:
+            dataset_id (str): The ID of the dataset to get the client for.
+
+        Returns:
+            DatasetClient: The dataset client.
+
+        Raises:
+            RuntimeError: If the dataset client fails to be retrieved.
+        """
+        try:
+            return self.client.dataset(dataset_id)
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to get dataset {dataset_id}: {e}"
+            ) from e
+
+    def get_dataset(
+        self,
+        dataset_id: str,
+    ) -> Optional[dict]:
+        r"""Get a dataset from the Apify platform.
+
+        Args:
+            dataset_id (str): The ID of the dataset to get.
+
+        Returns:
+            dict: The dataset.
+
+        Raises:
+            RuntimeError: If the dataset fails to be retrieved.
+        """
+        try:
+            return self.get_dataset_client(dataset_id).get()
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to get dataset {dataset_id}: {e}"
+            ) from e
+
+    def update_dataset(
+        self,
+        dataset_id: str,
+        name: str,
+    ) -> dict:
+        r"""Update a dataset on the Apify platform.
+
+        Args:
+            dataset_id (str): The ID of the dataset to update.
+            name (str): The new name for the dataset.
+
+        Returns:
+            dict: The updated dataset.
+
+        Raises:
+            RuntimeError: If the dataset fails to be updated.
+        """
+        try:
+            return self.get_dataset_client(dataset_id).update(name=name)
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to update dataset {dataset_id}: {e}"
+            ) from e
+
+    def get_dataset_items(
+        self,
+        dataset_id: str,
+    ) -> List:
+        r"""Get items from a dataset on the Apify platform.
+
+        Args:
+            dataset_id (str): The ID of the dataset to get items from.
+
+        Returns:
+            list: The items in the dataset.
+
+        Raises:
+            RuntimeError: If the items fail to be retrieved.
+        """
+        try:
+            items = self.get_dataset_client(dataset_id).list_items().items
+            return items
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to get dataset items {dataset_id}: {e}"
+            ) from e
+
+    def get_datasets(
+        self,
+        unnamed: Optional[bool] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+        desc: Optional[bool] = None,
+    ) -> List[dict]:
+        r"""Get all named datasets from the Apify platform.
+
+        Args:
+            unnamed (bool, optional): Whether to include unnamed key-value
+                stores in the list
+            limit (int, optional): How many key-value stores to retrieve
+            offset (int, optional): What key-value store to include as first
+                when retrieving the list
+            desc (bool, optional): Whether to sort the key-value stores in
+                descending order based on their modification date
+
+        Returns:
+            List[dict]: The datasets.
+
+        Raises:
+            RuntimeError: If the datasets fail to be retrieved.
+        """
+        try:
+            return (
+                self.client.datasets()
+                .list(unnamed=unnamed, limit=limit, offset=offset, desc=desc)
+                .items
+            )
+        except Exception as e:
+            raise RuntimeError(f"Failed to get datasets: {e}") from e

camel/memories/agent_memories.py

@@ -106,7 +106,18 @@ class VectorDBMemory(AgentMemory):
 
 class LongtermAgentMemory(AgentMemory):
     r"""An implementation of the :obj:`AgentMemory` abstract base class for
-    augumenting ChatHistoryMemory with VectorDBMemory.
+    augmenting ChatHistoryMemory with VectorDBMemory.
+
+    Args:
+        context_creator (BaseContextCreator): A model context creator.
+        chat_history_block (Optional[ChatHistoryBlock], optional): A chat
+            history block. If `None`, a :obj:`ChatHistoryBlock` will be used.
+            (default: :obj:`None`)
+        vector_db_block (Optional[VectorDBBlock], optional): A vector database
+            block. If `None`, a :obj:`VectorDBBlock` will be used.
+            (default: :obj:`None`)
+        retrieve_limit (int, optional): The maximum number of messages
+            to be added into the context.  (default: :obj:`3`)
     """
 
     def __init__(
@@ -123,9 +134,21 @@ class LongtermAgentMemory(AgentMemory):
         self._current_topic: str = ""
 
     def get_context_creator(self) -> BaseContextCreator:
+        r"""Returns the context creator used by the memory.
+
+        Returns:
+            BaseContextCreator: The context creator used by the memory.
+        """
         return self._context_creator
 
     def retrieve(self) -> List[ContextRecord]:
+        r"""Retrieves context records from both the chat history and the vector
+        database.
+
+        Returns:
+            List[ContextRecord]: A list of context records retrieved from both
+                the chat history and the vector database.
+        """
         chat_history = self.chat_history_block.retrieve()
         vector_db_retrieve = self.vector_db_block.retrieve(
             self._current_topic, self.retrieve_limit

camel/messages/base.py

@@ -81,6 +81,25 @@ class BaseMessage:
             OpenAIVisionDetailType, str
         ] = OpenAIVisionDetailType.LOW,
     ) -> "BaseMessage":
+        r"""Create a new user message.
+
+        Args:
+            role_name (str): The name of the user role.
+            content (str): The content of the message.
+            meta_dict (Optional[Dict[str, str]]): Additional metadata
+                dictionary for the message.
+            video_bytes (Optional[bytes]): Optional bytes of a video
+                associated with the message.
+            image_list (Optional[List[Image.Image]]): Optional list of PIL
+                Image objects associated with the message.
+            image_detail (Union[OpenAIVisionDetailType, str]): Detail level of
+                the images associated with the message.
+            video_detail (Union[OpenAIVisionDetailType, str]): Detail level of
+                the videos associated with the message.
+
+        Returns:
+            BaseMessage: The new user message.
+        """
         return cls(
             role_name,
             RoleType.USER,
@@ -107,6 +126,25 @@ class BaseMessage:
             OpenAIVisionDetailType, str
         ] = OpenAIVisionDetailType.LOW,
     ) -> "BaseMessage":
+        r"""Create a new assistant message.
+
+        Args:
+            role_name (str): The name of the assistant role.
+            content (str): The content of the message.
+            meta_dict (Optional[Dict[str, str]]): Additional metadata
+                dictionary for the message.
+            video_bytes (Optional[bytes]): Optional bytes of a video
+                associated with the message.
+            image_list (Optional[List[Image.Image]]): Optional list of PIL
+                Image objects associated with the message.
+            image_detail (Union[OpenAIVisionDetailType, str]): Detail level of
+                the images associated with the message.
+            video_detail (Union[OpenAIVisionDetailType, str]): Detail level of
+                the videos associated with the message.
+
+        Returns:
+            BaseMessage: The new assistant message.
+        """
         return cls(
             role_name,
             RoleType.ASSISTANT,

camel/models/__init__.py

@@ -24,11 +24,13 @@ from .ollama_model import OllamaModel
 from .openai_audio_models import OpenAIAudioModels
 from .openai_compatible_model import OpenAICompatibleModel
 from .openai_model import OpenAIModel
+from .qwen_model import QwenModel
 from .reka_model import RekaModel
 from .samba_model import SambaModel
 from .stub_model import StubModel
 from .togetherai_model import TogetherAIModel
 from .vllm_model import VLLMModel
+from .yi_model import YiModel
 from .zhipuai_model import ZhipuAIModel
 
 __all__ = [
@@ -51,4 +53,6 @@ __all__ = [
     'RekaModel',
     'SambaModel',
     'TogetherAIModel',
+    'YiModel',
+    'QwenModel',
 ]

camel/models/model_factory.py

@@ -23,11 +23,13 @@ from camel.models.mistral_model import MistralModel
 from camel.models.ollama_model import OllamaModel
 from camel.models.openai_compatible_model import OpenAICompatibleModel
 from camel.models.openai_model import OpenAIModel
+from camel.models.qwen_model import QwenModel
 from camel.models.reka_model import RekaModel
 from camel.models.samba_model import SambaModel
 from camel.models.stub_model import StubModel
 from camel.models.togetherai_model import TogetherAIModel
 from camel.models.vllm_model import VLLMModel
+from camel.models.yi_model import YiModel
 from camel.models.zhipuai_model import ZhipuAIModel
 from camel.types import ModelPlatformType, ModelType, UnifiedModelType
 from camel.utils import BaseTokenCounter
@@ -106,6 +108,10 @@ class ModelFactory:
             model_class = MistralModel
         elif model_platform.is_reka and model_type.is_reka:
             model_class = RekaModel
+        elif model_platform.is_yi and model_type.is_yi:
+            model_class = YiModel
+        elif model_platform.is_qwen and model_type.is_qwen:
+            model_class = QwenModel
         elif model_type == ModelType.STUB:
             model_class = StubModel
 

camel/models/openai_model.py

@@ -123,7 +123,7 @@ class OpenAIModel(BaseModelBackend):
 
             self.model_config_dict["temperature"] = 1.0
             self.model_config_dict["top_p"] = 1.0
-            self.model_config_dict["n"] = 1.0
+            self.model_config_dict["n"] = 1
             self.model_config_dict["presence_penalty"] = 0.0
             self.model_config_dict["frequency_penalty"] = 0.0