camel-ai 0.2.25__py3-none-any.whl → 0.2.27__py3-none-any.whl

camel/extractors/python_strategies.py

@@ -0,0 +1,226 @@
+# ========= Copyright 2023-2024 @ 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-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+
+import ast
+from typing import Optional
+
+from camel.extractors.base import BaseExtractorStrategy
+from camel.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+class BoxedStrategy(BaseExtractorStrategy):
+    r"""Extracts content from \\boxed{} environments."""
+
+    async def extract(self, text: str) -> Optional[str]:
+        r"""Extract content from \\boxed{} environments.
+
+        Args:
+            text (str): The input text to process.
+
+        Returns:
+            Optional[str]: Content inside \\boxed{} if found, else None.
+        """
+        # Find the start of the boxed content
+        boxed_pattern = "\\boxed{"
+        if boxed_pattern not in text:
+            logger.debug("No \\boxed{} content found in the response")
+            return None
+
+        start_idx = text.find(boxed_pattern) + len(boxed_pattern)
+        if start_idx >= len(text):
+            logger.debug("Malformed \\boxed{} (no content after opening)")
+            return None
+
+        # Use stack-based approach to handle nested braces
+        stack = 1  # Start with one opening brace
+        end_idx = start_idx
+        escape_mode = False
+
+        for i in range(start_idx, len(text)):
+            char = text[i]
+
+            # Handle escape sequences
+            if escape_mode:
+                escape_mode = False
+                continue
+
+            if char == '\\':
+                escape_mode = True
+                continue
+
+            if char == '{':
+                stack += 1
+            elif char == '}':
+                stack -= 1
+
+            if stack == 0:  # Found the matching closing brace
+                end_idx = i
+                break
+
+        # Check if we found a complete boxed expression
+        if stack != 0:
+            logger.debug("Unbalanced braces in \\boxed{} content")
+            return None
+
+        # Extract the content
+        content = text[start_idx:end_idx].strip()
+        logger.debug(f"Extracted boxed content: {content}")
+        return content
+
+
+class PythonListStrategy(BaseExtractorStrategy):
+    r"""Extracts and normalizes Python lists."""
+
+    async def extract(self, text: str) -> Optional[str]:
+        r"""Extract and normalize a Python list.
+
+        Args:
+            text (str): The input text to process.
+
+        Returns:
+            Optional[str]: Normalized list as a string if found, else None.
+        """
+
+        text = text.strip()
+        if not (text.startswith('[') and text.endswith(']')):
+            logger.debug("Content is not a list format (missing brackets)")
+            return None
+
+        try:
+            # Fix any escaped quotes before parsing
+            fixed_content = text.replace('\\"', '"')
+            parsed = ast.literal_eval(fixed_content)
+            if isinstance(parsed, list):
+                # Sort the list for normalization
+                sorted_list = sorted(parsed, key=lambda x: str(x))
+                return repr(sorted_list)
+            else:
+                logger.debug(f"Content is not a list, got {type(parsed)}")
+                return None
+        except (SyntaxError, ValueError) as e:
+            logger.debug(f"Failed to parse as Python list: {e}")
+            return None
+
+
+class PythonDictStrategy(BaseExtractorStrategy):
+    r"""Extracts and normalizes Python dictionaries."""
+
+    async def extract(self, text: str) -> Optional[str]:
+        r"""Extract and normalize a Python dictionary.
+
+        Args:
+            text (str): The input text to process.
+
+        Returns:
+            Optional[str]: Normalized dictionary as a string, else None.
+        """
+
+        text = text.strip()
+        if not (text.startswith('{') and text.endswith('}')):
+            logger.debug("Content is not a dictionary format (missing braces)")
+            return None
+
+        try:
+            # Fix any escaped quotes before parsing
+            fixed_content = text.replace('\\"', '"')
+            parsed = ast.literal_eval(fixed_content)
+            if isinstance(parsed, dict):
+                # Sort the dictionary items for normalization
+                sorted_dict = dict(
+                    sorted(parsed.items(), key=lambda x: str(x[0]))
+                )
+                return repr(sorted_dict)
+            else:
+                logger.debug(
+                    f"Content is not a dictionary, got {type(parsed)}"
+                )
+                return None
+        except (SyntaxError, ValueError) as e:
+            logger.debug(f"Failed to parse as Python dictionary: {e}")
+            return None
+
+
+class PythonSetStrategy(BaseExtractorStrategy):
+    r"""Extracts and normalizes Python sets."""
+
+    async def extract(self, text: str) -> Optional[str]:
+        r"""Extract and normalize a Python set.
+
+        Args:
+            text (str): The input text to process.
+
+        Returns:
+            Optional[str]: Normalized set as a string if found, else None.
+        """
+
+        text = text.strip()
+        # Check for set syntax: {1, 2, 3} or set([1, 2, 3])
+        if not (
+            (text.startswith('{') and text.endswith('}'))
+            or (text.startswith('set(') and text.endswith(')'))
+        ):
+            logger.debug("Content is not a set format")
+            return None
+
+        try:
+            # Fix any escaped quotes before parsing
+            fixed_content = text.replace('\\"', '"')
+            parsed = ast.literal_eval(fixed_content)
+            if isinstance(parsed, set):
+                # Sort the set elements for normalization
+                sorted_set = sorted(parsed, key=lambda x: str(x))
+                return repr(set(sorted_set))
+            else:
+                logger.debug(f"Content is not a set, got {type(parsed)}")
+                return None
+        except (SyntaxError, ValueError) as e:
+            logger.debug(f"Failed to parse as Python set: {e}")
+            return None
+
+
+class PythonTupleStrategy(BaseExtractorStrategy):
+    r"""Extracts and normalizes Python tuples."""
+
+    async def extract(self, text: str) -> Optional[str]:
+        r"""Extract and normalize a Python tuple.
+
+        Args:
+            text (str): The input text to process.
+
+        Returns:
+            Optional[str]: Normalized tuple as a string if found, else None.
+        """
+
+        text = text.strip()
+        # Check for tuple syntax: (1, 2, 3) or (1,)
+        if not (text.startswith('(') and text.endswith(')')):
+            logger.debug("Content is not a tuple format (missing parentheses)")
+            return None
+
+        try:
+            # Fix any escaped quotes before parsing
+            fixed_content = text.replace('\\"', '"')
+            parsed = ast.literal_eval(fixed_content)
+            if isinstance(parsed, tuple):
+                # Sort the tuple elements for normalization
+                sorted_tuple = tuple(sorted(parsed, key=lambda x: str(x)))
+                return repr(sorted_tuple)
+            else:
+                logger.debug(f"Content is not a tuple, got {type(parsed)}")
+                return None
+        except (SyntaxError, ValueError) as e:
+            logger.debug(f"Failed to parse as Python tuple: {e}")
+            return None

camel/models/__init__.py

@@ -37,9 +37,11 @@ from .qwen_model import QwenModel
 from .reka_model import RekaModel
 from .samba_model import SambaModel
 from .sglang_model import SGLangModel
+from .siliconflow_model import SiliconFlowModel
 from .stub_model import StubModel
 from .togetherai_model import TogetherAIModel
 from .vllm_model import VLLMModel
+from .volcano_model import VolcanoModel
 from .yi_model import YiModel
 from .zhipuai_model import ZhipuAIModel
 
@@ -76,4 +78,6 @@ __all__ = [
     'MoonshotModel',
     'AIMLModel',
     'BaseAudioModel',
+    'SiliconFlowModel',
+    'VolcanoModel',
 ]

camel/models/anthropic_model.py

@@ -35,13 +35,13 @@ class AnthropicModel(BaseModelBackend):
         model_type (Union[ModelType, str]): Model for which a backend is
             created, one of CLAUDE_* series.
         model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
-            that will be fed into Anthropic.messages.create().  If
+            that will be fed into `openai.ChatCompletion.create()`.  If
             :obj:`None`, :obj:`AnthropicConfig().as_dict()` will be used.
             (default: :obj:`None`)
         api_key (Optional[str], optional): The API key for authenticating with
             the Anthropic service. (default: :obj:`None`)
         url (Optional[str], optional): The url to the Anthropic service.
-            (default: :obj:`None`)
+            (default: :obj:`https://api.anthropic.com/v1/`)
         token_counter (Optional[BaseTokenCounter], optional): Token counter to
             use for the model. If not provided, :obj:`AnthropicTokenCounter`
             will be used. (default: :obj:`None`)
@@ -61,43 +61,24 @@ class AnthropicModel(BaseModelBackend):
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
     ) -> None:
-        from anthropic import Anthropic, AsyncAnthropic
+        from openai import AsyncOpenAI, OpenAI
 
         if model_config_dict is None:
             model_config_dict = AnthropicConfig().as_dict()
         api_key = api_key or os.environ.get("ANTHROPIC_API_KEY")
-        url = url or os.environ.get("ANTHROPIC_API_BASE_URL")
+        url = (
+            url
+            or os.environ.get("ANTHROPIC_API_BASE_URL")
+            or "https://api.anthropic.com/v1/"
+        )
         super().__init__(
             model_type, model_config_dict, api_key, url, token_counter
         )
-        self.client = Anthropic(api_key=self._api_key, base_url=self._url)
-        self.async_client = AsyncAnthropic(
-            api_key=self._api_key, base_url=self._url
-        )
+        self.client = OpenAI(base_url=self._url, api_key=self._api_key)
 
-    def _convert_response_from_anthropic_to_openai(self, response):
-        # openai ^1.0.0 format, reference openai/types/chat/chat_completion.py
-        obj = ChatCompletion.construct(
-            id=None,
-            choices=[
-                dict(
-                    index=0,
-                    message={
-                        "role": "assistant",
-                        "content": next(
-                            content.text
-                            for content in response.content
-                            if content.type == "text"
-                        ),
-                    },
-                    finish_reason=response.stop_reason,
-                )
-            ],
-            created=None,
-            model=response.model,
-            object="chat.completion",
+        self.async_client = AsyncOpenAI(
+            api_key=self._api_key, base_url=self._url
         )
-        return obj
 
     @property
     def token_counter(self) -> BaseTokenCounter:
@@ -126,22 +107,13 @@ class AnthropicModel(BaseModelBackend):
         Returns:
             ChatCompletion: Response in the OpenAI API format.
         """
-        from anthropic import NOT_GIVEN
-
-        if messages[0]["role"] == "system":
-            sys_msg = str(messages.pop(0)["content"])
-        else:
-            sys_msg = NOT_GIVEN  # type: ignore[assignment]
-        response = self.client.messages.create(
+        response = self.client.chat.completions.create(
             model=self.model_type,
-            system=sys_msg,
-            messages=messages,  # type: ignore[arg-type]
+            messages=messages,
             **self.model_config_dict,
+            tools=tools,  # type: ignore[arg-type]
         )
 
-        # format response to openai format
-        response = self._convert_response_from_anthropic_to_openai(response)
-
         return response
 
     async def _arun(
@@ -159,21 +131,14 @@ class AnthropicModel(BaseModelBackend):
         Returns:
             ChatCompletion: Response in the OpenAI API format.
         """
-        from anthropic import NOT_GIVEN
-
-        if messages[0]["role"] == "system":
-            sys_msg = str(messages.pop(0)["content"])
-        else:
-            sys_msg = NOT_GIVEN  # type: ignore[assignment]
-        response = await self.async_client.messages.create(
+        response = await self.async_client.chat.completions.create(
             model=self.model_type,
-            system=sys_msg,
-            messages=messages,  # type: ignore[arg-type]
+            messages=messages,
             **self.model_config_dict,
+            tools=tools,  # type: ignore[arg-type]
         )
 
-        # format response to openai format
-        return self._convert_response_from_anthropic_to_openai(response)
+        return response
 
     def check_model_config(self):
         r"""Check whether the model configuration is valid for anthropic
@@ -181,8 +146,7 @@ class AnthropicModel(BaseModelBackend):
 
         Raises:
             ValueError: If the model configuration dictionary contains any
-                unexpected arguments to OpenAI API, or it does not contain
-                :obj:`model_path` or :obj:`server_url`.
+                unexpected arguments to Anthropic API.
         """
         for param in self.model_config_dict:
             if param not in ANTHROPIC_API_PARAMS:

camel/models/azure_openai_model.py

@@ -128,18 +128,23 @@ class AzureOpenAIModel(BaseModelBackend):
         Args:
             messages (List[OpenAIMessage]): Message list with the chat history
                 in OpenAI API format.
+            response_format (Optional[Type[BaseModel]]): The format of the
+                response.
+            tools (Optional[List[Dict[str, Any]]]): The schema of the tools to
+                use for the request.
 
         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.azure_deployment_name,  # type:ignore[arg-type]
-            **self.model_config_dict,
+        response_format = response_format or self.model_config_dict.get(
+            "response_format", None
         )
-        return response
+        if response_format:
+            return self._request_parse(messages, response_format, tools)
+        else:
+            return self._request_chat_completion(messages, tools)
 
     async def _arun(
         self,
@@ -152,18 +157,93 @@ class AzureOpenAIModel(BaseModelBackend):
         Args:
             messages (List[OpenAIMessage]): Message list with the chat history
                 in OpenAI API format.
+            response_format (Optional[Type[BaseModel]]): The format of the
+                response.
+            tools (Optional[List[Dict[str, Any]]]): The schema of the tools to
+                use for the request.
 
         Returns:
             Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
                 `ChatCompletion` in the non-stream mode, or
                 `AsyncStream[ChatCompletionChunk]` in the stream mode.
         """
-        response = await self._async_client.chat.completions.create(
+        response_format = response_format or self.model_config_dict.get(
+            "response_format", None
+        )
+        if response_format:
+            return await self._arequest_parse(messages, response_format, tools)
+        else:
+            return await self._arequest_chat_completion(messages, tools)
+
+    def _request_chat_completion(
+        self,
+        messages: List[OpenAIMessage],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        request_config = self.model_config_dict.copy()
+
+        if tools:
+            request_config["tools"] = tools
+
+        return self._client.chat.completions.create(
+            messages=messages,
+            model=self.azure_deployment_name,  # type:ignore[arg-type]
+            **request_config,
+        )
+
+    async def _arequest_chat_completion(
+        self,
+        messages: List[OpenAIMessage],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+        request_config = self.model_config_dict.copy()
+
+        if tools:
+            request_config["tools"] = tools
+
+        return await self._async_client.chat.completions.create(
+            messages=messages,
+            model=self.azure_deployment_name,  # type:ignore[arg-type]
+            **request_config,
+        )
+
+    def _request_parse(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Type[BaseModel],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> ChatCompletion:
+        request_config = self.model_config_dict.copy()
+
+        request_config["response_format"] = response_format
+        request_config.pop("stream", None)
+        if tools is not None:
+            request_config["tools"] = tools
+
+        return self._client.beta.chat.completions.parse(
+            messages=messages,
+            model=self.azure_deployment_name,  # type:ignore[arg-type]
+            **request_config,
+        )
+
+    async def _arequest_parse(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Type[BaseModel],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> ChatCompletion:
+        request_config = self.model_config_dict.copy()
+
+        request_config["response_format"] = response_format
+        request_config.pop("stream", None)
+        if tools is not None:
+            request_config["tools"] = tools
+
+        return await self._async_client.beta.chat.completions.parse(
             messages=messages,
             model=self.azure_deployment_name,  # type:ignore[arg-type]
-            **self.model_config_dict,
+            **request_config,
         )
-        return response
 
     def check_model_config(self):
         r"""Check whether the model configuration contains any

camel/models/model_factory.py

@@ -37,6 +37,7 @@ from camel.models.siliconflow_model import SiliconFlowModel
 from camel.models.stub_model import StubModel
 from camel.models.togetherai_model import TogetherAIModel
 from camel.models.vllm_model import VLLMModel
+from camel.models.volcano_model import VolcanoModel
 from camel.models.yi_model import YiModel
 from camel.models.zhipuai_model import ZhipuAIModel
 from camel.types import ModelPlatformType, ModelType, UnifiedModelType
@@ -107,6 +108,8 @@ class ModelFactory:
             model_class = SiliconFlowModel
         elif model_platform.is_aiml:
             model_class = AIMLModel
+        elif model_platform.is_volcano:
+            model_class = VolcanoModel
 
         elif model_platform.is_openai and model_type.is_openai:
             model_class = OpenAIModel

camel/models/openai_compatible_model.py

@@ -86,18 +86,23 @@ class OpenAICompatibleModel(BaseModelBackend):
         Args:
             messages (List[OpenAIMessage]): Message list with the chat history
                 in OpenAI API format.
+            response_format (Optional[Type[BaseModel]]): The format of the
+                response.
+            tools (Optional[List[Dict[str, Any]]]): The schema of the tools to
+                use for the request.
 
         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,
+        response_format = response_format or self.model_config_dict.get(
+            "response_format", None
         )
-        return response
+        if response_format:
+            return self._request_parse(messages, response_format, tools)
+        else:
+            return self._request_chat_completion(messages, tools)
 
     async def _arun(
         self,
@@ -110,18 +115,93 @@ class OpenAICompatibleModel(BaseModelBackend):
         Args:
             messages (List[OpenAIMessage]): Message list with the chat history
                 in OpenAI API format.
+            response_format (Optional[Type[BaseModel]]): The format of the
+                response.
+            tools (Optional[List[Dict[str, Any]]]): The schema of the tools to
+                use for the request.
 
         Returns:
             Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
                 `ChatCompletion` in the non-stream mode, or
                 `AsyncStream[ChatCompletionChunk]` in the stream mode.
         """
-        response = await self._async_client.chat.completions.create(
+        response_format = response_format or self.model_config_dict.get(
+            "response_format", None
+        )
+        if response_format:
+            return await self._arequest_parse(messages, response_format, tools)
+        else:
+            return await self._arequest_chat_completion(messages, tools)
+
+    def _request_chat_completion(
+        self,
+        messages: List[OpenAIMessage],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        request_config = self.model_config_dict.copy()
+
+        if tools:
+            request_config["tools"] = tools
+
+        return self._client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+            **request_config,
+        )
+
+    async def _arequest_chat_completion(
+        self,
+        messages: List[OpenAIMessage],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+        request_config = self.model_config_dict.copy()
+
+        if tools:
+            request_config["tools"] = tools
+
+        return await self._async_client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+            **request_config,
+        )
+
+    def _request_parse(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Type[BaseModel],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> ChatCompletion:
+        request_config = self.model_config_dict.copy()
+
+        request_config["response_format"] = response_format
+        request_config.pop("stream", None)
+        if tools is not None:
+            request_config["tools"] = tools
+
+        return self._client.beta.chat.completions.parse(
+            messages=messages,
+            model=self.model_type,
+            **request_config,
+        )
+
+    async def _arequest_parse(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Type[BaseModel],
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> ChatCompletion:
+        request_config = self.model_config_dict.copy()
+
+        request_config["response_format"] = response_format
+        request_config.pop("stream", None)
+        if tools is not None:
+            request_config["tools"] = tools
+
+        return await self._async_client.beta.chat.completions.parse(
             messages=messages,
             model=self.model_type,
-            **self.model_config_dict,
+            **request_config,
         )
-        return response
 
     @property
     def token_counter(self) -> BaseTokenCounter: