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

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/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)