camel-ai 0.1.5.6__py3-none-any.whl → 0.1.6.1__py3-none-any.whl

camel/configs/openai_config.py

@@ -13,18 +13,14 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from __future__ import annotations
 
-from dataclasses import asdict, dataclass, field
-from typing import TYPE_CHECKING, Optional, Sequence
+from typing import Optional, Sequence, Union
 
 from openai._types import NOT_GIVEN, NotGiven
+from pydantic import Field
 
 from camel.configs.base_config import BaseConfig
 
-if TYPE_CHECKING:
-    from camel.functions import OpenAIFunction
 
-
-@dataclass(frozen=True)
 class ChatGPTConfig(BaseConfig):
     r"""Defines the parameters for generating chat completions using the
     OpenAI API.
@@ -105,29 +101,19 @@ class ChatGPTConfig(BaseConfig):
     top_p: float = 1.0
     n: int = 1
     stream: bool = False
-    stop: str | Sequence[str] | NotGiven = NOT_GIVEN
-    max_tokens: int | NotGiven = NOT_GIVEN
+    stop: Union[str, Sequence[str], NotGiven] = NOT_GIVEN
+    max_tokens: Union[int, NotGiven] = NOT_GIVEN
     presence_penalty: float = 0.0
-    response_format: dict | NotGiven = NOT_GIVEN
+    response_format: Union[dict, NotGiven] = NOT_GIVEN
     frequency_penalty: float = 0.0
-    logit_bias: dict = field(default_factory=dict)
+    logit_bias: dict = Field(default_factory=dict)
     user: str = ""
-    tools: Optional[list[OpenAIFunction]] = None
-    tool_choice: Optional[dict[str, str] | str] = None
-
-    def __post_init__(self):
-        if self.tools is not None:
-            object.__setattr__(
-                self,
-                'tools',
-                [tool.get_openai_tool_schema() for tool in self.tools],
-            )
+    tool_choice: Optional[Union[dict[str, str], str]] = None
 
 
-OPENAI_API_PARAMS = {param for param in asdict(ChatGPTConfig()).keys()}
+OPENAI_API_PARAMS = {param for param in ChatGPTConfig.model_fields.keys()}
 
 
-@dataclass(frozen=True)
 class OpenSourceConfig(BaseConfig):
     r"""Defines parameters for setting up open-source models and includes
     parameters to be passed to chat completion function of OpenAI API.
@@ -141,6 +127,9 @@ class OpenSourceConfig(BaseConfig):
             contain the arguments to be passed to OpenAI API.
     """
 
+    # Maybe the param needs to be renamed.
+    # Warning: Field "model_path" has conflict with protected namespace
+    # "model_".
     model_path: str
     server_url: str
-    api_params: ChatGPTConfig = field(default_factory=ChatGPTConfig)
+    api_params: ChatGPTConfig = Field(default_factory=ChatGPTConfig)

camel/configs/vllm_config.py

@@ -0,0 +1,102 @@
+# =========== 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. ===========
+from __future__ import annotations
+
+from typing import Sequence, Union
+
+from openai._types import NOT_GIVEN, NotGiven
+from pydantic import Field
+
+from camel.configs.base_config import BaseConfig
+
+
+# flake8: noqa: E501
+class VLLMConfig(BaseConfig):
+    r"""Defines the parameters for generating chat completions using the
+    OpenAI API.
+
+    Reference: https://docs.vllm.ai/en/latest/serving/openai_compatible_server.html
+
+    Args:
+        temperature (float, optional): Sampling temperature to use, between
+            :obj:`0` and :obj:`2`. Higher values make the output more random,
+            while lower values make it more focused and deterministic.
+            (default: :obj:`0.2`)
+        top_p (float, optional): An alternative to sampling with temperature,
+            called nucleus sampling, where the model considers the results of
+            the tokens with top_p probability mass. So :obj:`0.1` means only
+            the tokens comprising the top 10% probability mass are considered.
+            (default: :obj:`1.0`)
+        n (int, optional): How many chat completion choices to generate for
+            each input message. (default: :obj:`1`)
+        response_format (object, optional): An object specifying the format
+            that the model must output. Compatible with GPT-4 Turbo and all
+            GPT-3.5 Turbo models newer than gpt-3.5-turbo-1106. Setting to
+            {"type": "json_object"} enables JSON mode, which guarantees the
+            message the model generates is valid JSON. Important: when using
+            JSON mode, you must also instruct the model to produce JSON
+            yourself via a system or user message. Without this, the model
+            may generate an unending stream of whitespace until the generation
+            reaches the token limit, resulting in a long-running and seemingly
+            "stuck" request. Also note that the message content may be
+            partially cut off if finish_reason="length", which indicates the
+            generation exceeded max_tokens or the conversation exceeded the
+            max context length.
+        stream (bool, optional): If True, partial message deltas will be sent
+            as data-only server-sent events as they become available.
+            (default: :obj:`False`)
+        stop (str or list, optional): Up to :obj:`4` sequences where the API
+            will stop generating further tokens. (default: :obj:`None`)
+        max_tokens (int, optional): The maximum number of tokens to generate
+            in the chat completion. The total length of input tokens and
+            generated tokens is limited by the model's context length.
+            (default: :obj:`None`)
+        presence_penalty (float, optional): Number between :obj:`-2.0` and
+            :obj:`2.0`. Positive values penalize new tokens based on whether
+            they appear in the text so far, increasing the model's likelihood
+            to talk about new topics. See more information about frequency and
+            presence penalties. (default: :obj:`0.0`)
+        frequency_penalty (float, optional): Number between :obj:`-2.0` and
+            :obj:`2.0`. Positive values penalize new tokens based on their
+            existing frequency in the text so far, decreasing the model's
+            likelihood to repeat the same line verbatim. See more information
+            about frequency and presence penalties. (default: :obj:`0.0`)
+        logit_bias (dict, optional): Modify the likelihood of specified tokens
+            appearing in the completion. Accepts a json object that maps tokens
+            (specified by their token ID in the tokenizer) to an associated
+            bias value from :obj:`-100` to :obj:`100`. Mathematically, the bias
+            is added to the logits generated by the model prior to sampling.
+            The exact effect will vary per model, but values between:obj:` -1`
+            and :obj:`1` should decrease or increase likelihood of selection;
+            values like :obj:`-100` or :obj:`100` should result in a ban or
+            exclusive selection of the relevant token. (default: :obj:`{}`)
+        user (str, optional): A unique identifier representing your end-user,
+            which can help OpenAI to monitor and detect abuse.
+            (default: :obj:`""`)
+    """
+
+    temperature: float = 0.2  # openai default: 1.0
+    top_p: float = 1.0
+    n: int = 1
+    stream: bool = False
+    stop: Union[str, Sequence[str], NotGiven] = NOT_GIVEN
+    max_tokens: Union[int, NotGiven] = NOT_GIVEN
+    presence_penalty: float = 0.0
+    response_format: Union[dict, NotGiven] = NOT_GIVEN
+    frequency_penalty: float = 0.0
+    logit_bias: dict = Field(default_factory=dict)
+    user: str = ""
+
+
+VLLM_API_PARAMS = {param for param in VLLMConfig.model_fields.keys()}

camel/configs/zhipuai_config.py

@@ -13,18 +13,13 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from __future__ import annotations
 
-from dataclasses import asdict, dataclass
-from typing import TYPE_CHECKING, Optional, Sequence
+from typing import Optional, Sequence, Union
 
 from openai._types import NOT_GIVEN, NotGiven
 
 from camel.configs.base_config import BaseConfig
 
-if TYPE_CHECKING:
-    from camel.functions import OpenAIFunction
 
-
-@dataclass(frozen=True)
 class ZhipuAIConfig(BaseConfig):
     r"""Defines the parameters for generating chat completions using OpenAI
     compatibility
@@ -69,10 +64,9 @@ class ZhipuAIConfig(BaseConfig):
     temperature: float = 0.2
     top_p: float = 0.6
     stream: bool = False
-    stop: str | Sequence[str] | NotGiven = NOT_GIVEN
-    max_tokens: int | NotGiven = NOT_GIVEN
-    tools: Optional[list[OpenAIFunction]] = None
-    tool_choice: Optional[dict[str, str] | str] = None
+    stop: Union[str, Sequence[str], NotGiven] = NOT_GIVEN
+    max_tokens: Union[int, NotGiven] = NOT_GIVEN
+    tool_choice: Optional[Union[dict[str, str], str]] = None
 
 
-ZHIPUAI_API_PARAMS = {param for param in asdict(ZhipuAIConfig()).keys()}
+ZHIPUAI_API_PARAMS = {param for param in ZhipuAIConfig.model_fields.keys()}

camel/embeddings/__init__.py

@@ -12,6 +12,7 @@
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from .base import BaseEmbedding
+from .mistral_embedding import MistralEmbedding
 from .openai_embedding import OpenAIEmbedding
 from .sentence_transformers_embeddings import SentenceTransformerEncoder
 from .vlm_embedding import VisionLanguageEmbedding
@@ -21,4 +22,5 @@ __all__ = [
     "OpenAIEmbedding",
     "SentenceTransformerEncoder",
     "VisionLanguageEmbedding",
+    "MistralEmbedding",
 ]

camel/embeddings/mistral_embedding.py

@@ -0,0 +1,89 @@
+# =========== 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. ===========
+from __future__ import annotations
+
+import os
+from typing import Any
+
+from camel.embeddings.base import BaseEmbedding
+from camel.types import EmbeddingModelType
+from camel.utils import api_keys_required
+
+
+class MistralEmbedding(BaseEmbedding[str]):
+    r"""Provides text embedding functionalities using Mistral's models.
+
+    Args:
+        model_type (EmbeddingModelType, optional): The model type to be
+            used for text embeddings.
+            (default: :obj:`MISTRAL_EMBED`)
+        api_key (str, optional): The API key for authenticating with the
+            Mistral service. (default: :obj:`None`)
+        dimensions (int, optional): The text embedding output dimensions.
+            (default: :obj:`None`)
+
+    Raises:
+        RuntimeError: If an unsupported model type is specified.
+    """
+
+    def __init__(
+        self,
+        model_type: EmbeddingModelType = (EmbeddingModelType.MISTRAL_EMBED),
+        api_key: str | None = None,
+        dimensions: int | None = None,
+    ) -> None:
+        from mistralai.client import MistralClient
+
+        if not model_type.is_mistral:
+            raise ValueError("Invalid Mistral embedding model type.")
+        self.model_type = model_type
+        if dimensions is None:
+            self.output_dim = model_type.output_dim
+        else:
+            assert isinstance(dimensions, int)
+            self.output_dim = dimensions
+        self._api_key = api_key or os.environ.get("MISTRAL_API_KEY")
+        self._client = MistralClient(api_key=self._api_key)
+
+    @api_keys_required("MISTRAL_API_KEY")
+    def embed_list(
+        self,
+        objs: list[str],
+        **kwargs: Any,
+    ) -> list[list[float]]:
+        r"""Generates embeddings for the given texts.
+
+        Args:
+            objs (list[str]): The texts for which to generate the embeddings.
+            **kwargs (Any): Extra kwargs passed to the embedding API.
+
+        Returns:
+            list[list[float]]: A list that represents the generated embedding
+                as a list of floating-point numbers.
+        """
+        # TODO: count tokens
+        response = self._client.embeddings(
+            input=objs,
+            model=self.model_type.value,
+            **kwargs,
+        )
+        return [data.embedding for data in response.data]
+
+    def get_output_dim(self) -> int:
+        r"""Returns the output dimension of the embeddings.
+
+        Returns:
+            int: The dimensionality of the embedding for the current model.
+        """
+        return self.output_dim

camel/human.py

@@ -135,4 +135,4 @@ class Human:
         human_input = self.get_input()
         content = self.parse_input(human_input)
         message = meta_chat_message.create_new_instance(content)
-        return ChatAgentResponse([message], terminated=False, info={})
+        return ChatAgentResponse(msgs=[message], terminated=False, info={})

camel/interpreters/__init__.py

@@ -16,6 +16,7 @@ from .base import BaseInterpreter
 from .docker_interpreter import DockerInterpreter
 from .internal_python_interpreter import InternalPythonInterpreter
 from .interpreter_error import InterpreterError
+from .ipython_interpreter import JupyterKernelInterpreter
 from .subprocess_interpreter import SubprocessInterpreter
 
 __all__ = [
@@ -24,4 +25,5 @@ __all__ = [
     'InternalPythonInterpreter',
     'SubprocessInterpreter',
     'DockerInterpreter',
+    'JupyterKernelInterpreter',
 ]

camel/interpreters/ipython_interpreter.py

@@ -0,0 +1,167 @@
+# =========== 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 queue
+import re
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+from camel.interpreters.base import BaseInterpreter
+from camel.interpreters.interpreter_error import InterpreterError
+
+if TYPE_CHECKING:
+    from jupyter_client import BlockingKernelClient, KernelManager
+
+TIMEOUT = 30
+
+
+class JupyterKernelInterpreter(BaseInterpreter):
+    r"""A class for executing code strings in a Jupyter Kernel.
+
+    Args:
+        require_confirm (bool, optional): If `True`, prompt user before
+            running code strings for security. Defaults to `True`.
+        print_stdout (bool, optional): If `True`, print the standard
+            output of the executed code. Defaults to `False`.
+        print_stderr (bool, optional): If `True`, print the standard error
+            of the executed code. Defaults to `True`.
+    """
+
+    def __init__(
+        self,
+        require_confirm: bool = True,
+        print_stdout: bool = False,
+        print_stderr: bool = True,
+    ) -> None:
+        self.require_confirm = require_confirm
+        self.print_stdout = print_stdout
+        self.print_stderr = print_stderr
+
+        self.kernel_manager: Optional[KernelManager] = None
+        self.client: Optional[BlockingKernelClient] = None
+
+    def __del__(self) -> None:
+        r"""Clean up the kernel and client."""
+
+        if self.kernel_manager:
+            self.kernel_manager.shutdown_kernel()
+        if self.client:
+            self.client.stop_channels()
+
+    def _initialize_if_needed(self) -> None:
+        r"""Initialize the kernel manager and client if they are not already
+        initialized.
+        """
+
+        if self.kernel_manager is not None:
+            return
+
+        from jupyter_client.manager import start_new_kernel
+
+        self.kernel_manager, self.client = start_new_kernel()
+
+    @staticmethod
+    def _clean_ipython_output(output: str) -> str:
+        r"""Remove ANSI escape sequences from the output."""
+
+        ansi_escape = re.compile(r'\x1B[@-_][0-?]*[ -/]*[@-~]')
+        return ansi_escape.sub('', output)
+
+    def _execute(self, code: str, timeout: float) -> str:
+        r"""Execute the code in the Jupyter kernel and return the result."""
+
+        if not self.kernel_manager or not self.client:
+            raise InterpreterError("Jupyter client is not initialized.")
+
+        self.client.execute(code)
+        outputs = []
+        while True:
+            try:
+                msg = self.client.get_iopub_msg(timeout=timeout)
+                msg_content = msg["content"]
+                msg_type = msg.get("msg_type", None)
+
+                if msg_content.get("execution_state", None) == "idle":
+                    break
+
+                if msg_type == "error":
+                    print(msg_content.keys())
+                    print(msg_content)
+                    traceback = "\n".join(msg_content["traceback"])
+                    outputs.append(traceback)
+                elif msg_type == "stream":
+                    outputs.append(msg_content["text"])
+                elif msg_type in ["execute_result", "display_data"]:
+                    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"
+                        )
+            except queue.Empty:
+                outputs.append("Time out")
+                break
+            except Exception as e:
+                outputs.append(f"Exception occurred: {e!s}")
+                break
+
+        exec_result = "\n".join(outputs)
+        return self._clean_ipython_output(exec_result)
+
+    def run(self, code: str, code_type: str) -> str:
+        r"""Executes the given code in the Jupyter kernel.
+
+        Args:
+            code (str): The code string to execute.
+            code_type (str): The type of code to execute (e.g., 'python',
+                'bash').
+
+        Returns:
+            str: A string containing the captured result of the
+                executed code.
+
+        Raises:
+            InterpreterError: If there is an error when doing code execution.
+        """
+        self._initialize_if_needed()
+
+        if code_type == "bash":
+            code = f"%%bash\n({code})"
+        try:
+            result = self._execute(code, timeout=TIMEOUT)
+        except Exception as e:
+            raise InterpreterError(f"Execution failed: {e!s}")
+
+        return result
+
+    def supported_code_types(self) -> List[str]:
+        r"""Provides supported code types by the interpreter.
+
+        Returns:
+            List[str]: Supported code types.
+        """
+        return ["python", "bash"]
+
+    def update_action_space(self, action_space: Dict[str, Any]) -> None:
+        r"""Updates the action space for the interpreter.
+
+        Args:
+            action_space (Dict[str, Any]): A dictionary representing the
+                new or updated action space.
+
+        Raises:
+            RuntimeError: Always raised because `JupyterKernelInterpreter`
+                does not support updating the action space.
+        """
+        raise RuntimeError(
+            "SubprocessInterpreter doesn't support " "`action_space`."
+        )

camel/loaders/__init__.py

@@ -13,6 +13,7 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 
 from .base_io import File, read_file
+from .firecrawl_reader import Firecrawl
 from .jina_url_reader import JinaURLReader
 from .unstructured_io import UnstructuredIO
 
@@ -21,4 +22,5 @@ __all__ = [
     'read_file',
     'UnstructuredIO',
     'JinaURLReader',
+    'Firecrawl',
 ]