camel-ai 0.1.5.9__py3-none-any.whl → 0.1.6.2__py3-none-any.whl

camel/configs/__init__.py

@@ -13,19 +13,12 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from .anthropic_config import ANTHROPIC_API_PARAMS, AnthropicConfig
 from .base_config import BaseConfig
-from .gemini_config import (
-    Gemini_API_PARAMS,
-    GeminiConfig,
-)
+from .gemini_config import Gemini_API_PARAMS, GeminiConfig
 from .groq_config import GROQ_API_PARAMS, GroqConfig
 from .litellm_config import LITELLM_API_PARAMS, LiteLLMConfig
 from .mistral_config import MISTRAL_API_PARAMS, MistralConfig
 from .ollama_config import OLLAMA_API_PARAMS, OllamaConfig
-from .openai_config import (
-    OPENAI_API_PARAMS,
-    ChatGPTConfig,
-    OpenSourceConfig,
-)
+from .openai_config import OPENAI_API_PARAMS, ChatGPTConfig, OpenSourceConfig
 from .vllm_config import VLLM_API_PARAMS, VLLMConfig
 from .zhipuai_config import ZHIPUAI_API_PARAMS, ZhipuAIConfig
 

camel/configs/anthropic_config.py

@@ -13,14 +13,13 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from __future__ import annotations
 
-from dataclasses import asdict, dataclass
+from typing import List, Union
 
 from anthropic import NOT_GIVEN, NotGiven
 
 from camel.configs.base_config import BaseConfig
 
 
-@dataclass(frozen=True)
 class AnthropicConfig(BaseConfig):
     r"""Defines the parameters for generating chat completions using the
     Anthropic API.
@@ -62,12 +61,12 @@ class AnthropicConfig(BaseConfig):
     """
 
     max_tokens: int = 256
-    stop_sequences: list[str] | NotGiven = NOT_GIVEN
+    stop_sequences: Union[List[str], NotGiven] = NOT_GIVEN
     temperature: float = 1
-    top_p: float | NotGiven = NOT_GIVEN
-    top_k: int | NotGiven = NOT_GIVEN
+    top_p: Union[float, NotGiven] = NOT_GIVEN
+    top_k: Union[int, NotGiven] = NOT_GIVEN
     metadata: NotGiven = NOT_GIVEN
     stream: bool = False
 
 
-ANTHROPIC_API_PARAMS = {param for param in asdict(AnthropicConfig()).keys()}
+ANTHROPIC_API_PARAMS = {param for param in AnthropicConfig.model_fields.keys()}

camel/configs/base_config.py

@@ -14,9 +14,55 @@
 from __future__ import annotations
 
 from abc import ABC
-from dataclasses import dataclass
+from typing import Any, List, Optional
 
+from pydantic import BaseModel, ConfigDict, field_validator
 
-@dataclass(frozen=True)
-class BaseConfig(ABC):  # noqa: B024
-    pass
+
+class BaseConfig(ABC, BaseModel):
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+        extra="forbid",
+        frozen=True,
+        # UserWarning: conflict with protected namespace "model_"
+        protected_namespaces=(),
+    )
+
+    tools: Optional[List[Any]] = None
+    """A list of tools the model may
+    call. Currently, only functions are supported as a tool. Use this
+    to provide a list of functions the model may generate JSON inputs
+    for. A max of 128 functions are supported.
+    """
+
+    @field_validator("tools", mode="before")
+    @classmethod
+    def fields_type_checking(cls, tools):
+        if tools is not None:
+            from camel.toolkits import OpenAIFunction
+
+            for tool in tools:
+                if not isinstance(tool, OpenAIFunction):
+                    raise ValueError(
+                        f"The tool {tool} should "
+                        "be an instance of `OpenAIFunction`."
+                    )
+        return tools
+
+    def as_dict(self) -> dict[str, Any]:
+        config_dict = self.model_dump()
+
+        tools_schema = None
+        if self.tools:
+            from camel.toolkits import OpenAIFunction
+
+            tools_schema = []
+            for tool in self.tools:
+                if not isinstance(tool, OpenAIFunction):
+                    raise ValueError(
+                        f"The tool {tool} should "
+                        "be an instance of `OpenAIFunction`."
+                    )
+                tools_schema.append(tool.get_openai_tool_schema())
+        config_dict["tools"] = tools_schema
+        return config_dict

camel/configs/gemini_config.py

@@ -14,22 +14,13 @@
 
 
 from collections.abc import Iterable
-from dataclasses import asdict, dataclass
-from typing import TYPE_CHECKING, Optional
+from typing import Any, Optional
 
-from camel.configs.base_config import BaseConfig
+from pydantic import model_validator
 
-if TYPE_CHECKING:
-    from google.generativeai.protos import Schema
-    from google.generativeai.types.content_types import (
-        FunctionLibraryType,
-        ToolConfigType,
-    )
-    from google.generativeai.types.helper_types import RequestOptionsType
-    from google.generativeai.types.safety_types import SafetySettingOptions
+from camel.configs.base_config import BaseConfig
 
 
-@dataclass(frozen=True)
 class GeminiConfig(BaseConfig):
     r"""A simple dataclass used to configure the generation parameters of
     `GenerativeModel.generate_content`.
@@ -88,11 +79,71 @@ class GeminiConfig(BaseConfig):
     top_p: Optional[float] = None
     top_k: Optional[int] = None
     response_mime_type: Optional[str] = None
-    response_schema: Optional['Schema'] = None
-    safety_settings: Optional['SafetySettingOptions'] = None
-    tools: Optional['FunctionLibraryType'] = None
-    tool_config: Optional['ToolConfigType'] = None
-    request_options: Optional['RequestOptionsType'] = None
+    response_schema: Optional[Any] = None
+    safety_settings: Optional[Any] = None
+    tools: Optional[Any] = None
+    tool_config: Optional[Any] = None
+    request_options: Optional[Any] = None
+
+    @model_validator(mode="before")
+    @classmethod
+    def fields_type_checking(cls, data: Any):
+        if isinstance(data, dict):
+            response_schema = data.get("response_schema")
+            safety_settings = data.get("safety_settings")
+            tools = data.get("tools")
+            tool_config = data.get("tool_config")
+            request_options = data.get("request_options")
+
+            if response_schema:
+                from google.generativeai.protos import Schema
+                from google.generativeai.types.content_types import (
+                    FunctionLibraryType,
+                    ToolConfigType,
+                )
+                from google.generativeai.types.helper_types import (
+                    RequestOptionsType,
+                )
+                from google.generativeai.types.safety_types import (
+                    SafetySettingOptions,
+                )
+        else:
+            return data
+
+        if response_schema and not isinstance(response_schema, Schema):
+            raise ValueError(
+                "The response_schema should be "
+                "an instance of `google.generativeai.protos.Schema`."
+            )
+
+        if safety_settings and not isinstance(
+            safety_settings, SafetySettingOptions
+        ):
+            raise ValueError(
+                "The response_schema should be an instance of "
+                "`google.generativeai.types.safety_types.SafetySettingOptions`."
+            )
+
+        if tools is not None:
+            for tool in tools:
+                if not isinstance(tool, FunctionLibraryType):
+                    raise ValueError(
+                        "The tool should be an instance of "
+                        "`google.generativeai.types.content_types.FunctionLibraryType`."
+                    )
+        if tool_config and not isinstance(tool_config, ToolConfigType):
+            raise ValueError(
+                "The response_schema should be an instance of "
+                "`google.generativeai.types.content_types.ToolConfigType`."
+            )
+        if request_options and not isinstance(
+            request_options, RequestOptionsType
+        ):
+            raise ValueError(
+                "The response_schema should be an instance of "
+                "`google.generativeai.types.helper_types.RequestOptionsType`."
+            )
+        return data
 
 
-Gemini_API_PARAMS = {param for param in asdict(GeminiConfig()).keys()}
+Gemini_API_PARAMS = {param for param in GeminiConfig().model_fields.keys()}

camel/configs/groq_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.toolkits import OpenAIFunction
 
-
-@dataclass(frozen=True)
 class GroqConfig(BaseConfig):
     r"""Defines the parameters for generating chat completions using OpenAI
     compatibility.
@@ -98,22 +93,13 @@ class GroqConfig(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
     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"
 
 
-GROQ_API_PARAMS = {param for param in asdict(GroqConfig()).keys()}
+GROQ_API_PARAMS = {param for param in GroqConfig.model_fields.keys()}

camel/configs/litellm_config.py

@@ -13,16 +13,11 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from __future__ import annotations
 
-from dataclasses import asdict, dataclass
-from typing import TYPE_CHECKING, List, Optional, Union
+from typing import List, Optional, Union
 
 from camel.configs.base_config import BaseConfig
 
-if TYPE_CHECKING:
-    from camel.toolkits import OpenAIFunction
 
-
-@dataclass(frozen=True)
 class LiteLLMConfig(BaseConfig):
     r"""Defines the parameters for generating chat completions using the
     LiteLLM API.
@@ -88,7 +83,6 @@ class LiteLLMConfig(BaseConfig):
     user: Optional[str] = None
     response_format: Optional[dict] = None
     seed: Optional[int] = None
-    tools: Optional[list[OpenAIFunction]] = None
     tool_choice: Optional[Union[str, dict]] = None
     logprobs: Optional[bool] = None
     top_logprobs: Optional[int] = None
@@ -100,4 +94,4 @@ class LiteLLMConfig(BaseConfig):
     max_retries: Optional[int] = None
 
 
-LITELLM_API_PARAMS = {param for param in asdict(LiteLLMConfig()).keys()}
+LITELLM_API_PARAMS = {param for param in LiteLLMConfig.model_fields.keys()}

camel/configs/mistral_config.py

@@ -13,20 +13,13 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from __future__ import annotations
 
-from dataclasses import asdict, dataclass
-from typing import TYPE_CHECKING, Dict, Optional, Union
+from typing import Any, Dict, Optional, Union
 
-from camel.configs.base_config import BaseConfig
-
-if TYPE_CHECKING:
-    from mistralai.models.chat_completion import (
-        ResponseFormat,
-    )
+from pydantic import field_validator
 
-    from camel.toolkits import OpenAIFunction
+from camel.configs.base_config import BaseConfig
 
 
-@dataclass(frozen=True)
 class MistralConfig(BaseConfig):
     r"""Defines the parameters for generating chat completions using the
     Mistral API.
@@ -65,17 +58,21 @@ class MistralConfig(BaseConfig):
     random_seed: Optional[int] = None
     safe_mode: bool = False
     safe_prompt: bool = False
-    response_format: Optional[Union[Dict[str, str], ResponseFormat]] = None
-    tools: Optional[list[OpenAIFunction]] = None
+    response_format: Optional[Union[Dict[str, str], Any]] = None
     tool_choice: Optional[str] = "auto"
 
-    def __post_init__(self):
-        if self.tools is not None:
-            object.__setattr__(
-                self,
-                'tools',
-                [tool.get_openai_tool_schema() for tool in self.tools],
-            )
+    @field_validator("response_format", mode="before")
+    @classmethod
+    def fields_type_checking(cls, response_format):
+        if response_format and not isinstance(response_format, dict):
+            from mistralai.models.chat_completion import ResponseFormat
+
+            if not isinstance(response_format, ResponseFormat):
+                raise ValueError(
+                    f"The tool {response_format} should be an instance "
+                    "of `mistralai.models.chat_completion.ResponseFormat`."
+                )
+        return response_format
 
 
-MISTRAL_API_PARAMS = {param for param in asdict(MistralConfig()).keys()}
+MISTRAL_API_PARAMS = {param for param in MistralConfig().model_fields.keys()}

camel/configs/ollama_config.py

@@ -13,18 +13,16 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from __future__ import annotations
 
-from dataclasses import asdict, dataclass
-from typing import Sequence
+from typing import Sequence, Union
 
 from openai._types import NOT_GIVEN, NotGiven
 
 from camel.configs.base_config import BaseConfig
 
 
-@dataclass(frozen=True)
 class OllamaConfig(BaseConfig):
     r"""Defines the parameters for generating chat completions using OpenAI
-    compatibility.
+    compatibility
 
     Reference: https://github.com/ollama/ollama/blob/main/docs/openai.md
 
@@ -75,11 +73,11 @@ class OllamaConfig(BaseConfig):
     temperature: float = 0.2
     top_p: float = 1.0
     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
 
 
-OLLAMA_API_PARAMS = {param for param in asdict(OllamaConfig()).keys()}
+OLLAMA_API_PARAMS = {param for param in OllamaConfig.model_fields.keys()}

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.toolkits 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

@@ -13,16 +13,15 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from __future__ import annotations
 
-from dataclasses import asdict, dataclass, field
-from typing import Sequence
+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
-@dataclass(frozen=True)
 class VLLMConfig(BaseConfig):
     r"""Defines the parameters for generating chat completions using the
     OpenAI API.
@@ -91,13 +90,13 @@ class VLLMConfig(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 = ""
 
 
-VLLM_API_PARAMS = {param for param in asdict(VLLMConfig()).keys()}
+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.toolkits 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/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/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',
 ]