camel-ai 0.2.11__py3-none-any.whl → 0.2.13__py3-none-any.whl

camel/loaders/base_io.py

@@ -22,6 +22,47 @@ from typing import Any, Dict, List, Optional
 from camel.utils import dependencies_required
 
 
+def create_file(file: BytesIO, filename: str) -> "File":
+    r"""Reads an uploaded file and returns a File object.
+
+    Args:
+        file (BytesIO): A BytesIO object representing the contents of the
+            file.
+        filename (str): The name of the file.
+
+    Returns:
+        File: A File object.
+    """
+    ext_to_cls = {
+        "docx": DocxFile,
+        "pdf": PdfFile,
+        "txt": TxtFile,
+        "json": JsonFile,
+        "html": HtmlFile,
+    }
+
+    ext = filename.split(".")[-1].lower()
+    if ext not in ext_to_cls:
+        raise NotImplementedError(f"File type {ext} not supported")
+
+    out_file = ext_to_cls[ext].from_bytes(file, filename)
+    return out_file
+
+
+def create_file_from_raw_bytes(raw_bytes: bytes, filename: str) -> "File":
+    r"""Reads raw bytes and returns a File object.
+
+    Args:
+        raw_bytes (bytes): The raw bytes content of the file.
+        filename (str): The name of the file.
+
+    Returns:
+        File: A File object.
+    """
+    file = BytesIO(raw_bytes)
+    return create_file(file, filename)
+
+
 class File(ABC):
     r"""Represents an uploaded file comprised of Documents.
 
@@ -79,47 +120,6 @@ class File(ABC):
         file = BytesIO(raw_bytes)
         return cls.from_bytes(file, filename)
 
-    @staticmethod
-    def create_file(file: BytesIO, filename: str) -> "File":
-        r"""Reads an uploaded file and returns a File object.
-
-        Args:
-            file (BytesIO): A BytesIO object representing the contents of the
-                file.
-            filename (str): The name of the file.
-
-        Returns:
-            File: A File object.
-        """
-        ext_to_cls = {
-            "docx": DocxFile,
-            "pdf": PdfFile,
-            "txt": TxtFile,
-            "json": JsonFile,
-            "html": HtmlFile,
-        }
-
-        ext = filename.split(".")[-1].lower()
-        if ext not in ext_to_cls:
-            raise NotImplementedError(f"File type {ext} not supported")
-
-        out_file = ext_to_cls[ext].from_bytes(file, filename)
-        return out_file
-
-    @staticmethod
-    def create_file_from_raw_bytes(raw_bytes: bytes, filename: str) -> "File":
-        r"""Reads raw bytes and returns a File object.
-
-        Args:
-            raw_bytes (bytes): The raw bytes content of the file.
-            filename (str): The name of the file.
-
-        Returns:
-            File: A File object.
-        """
-        file = BytesIO(raw_bytes)
-        return File.create_file(file, filename)
-
     def __repr__(self) -> str:
         return (
             f"File(name={self.name}, id={self.file_id}, "

camel/messages/__init__.py

@@ -20,6 +20,7 @@ from camel.types import (
 )
 
 from .conversion import (
+    AlpacaItem,
     HermesFunctionFormatter,
     ShareGPTMessage,
 )
@@ -52,4 +53,5 @@ __all__ = [
     'ShareGPTMessage',
     'BaseMessage',
     'FunctionCallingMessage',
+    'AlpacaItem',
 ]

camel/messages/base.py

@@ -52,15 +52,15 @@ class BaseMessage:
             for the message.
         content (str): The content of the message.
         video_bytes (Optional[bytes]): Optional bytes of a video associated
-            with the message. (default::obj:`None`)
+            with the message. (default: :obj:`None`)
         image_list (Optional[List[Image.Image]]): Optional list of PIL Image
-            objects associated with the message. (default::obj:`None`)
+            objects associated with the message. (default: :obj:`None`)
         image_detail (Literal["auto", "low", "high"]): Detail level of the
-            images associated with the message. (default::obj:`auto`)
+            images associated with the message. (default: :obj:`auto`)
         video_detail (Literal["auto", "low", "high"]): Detail level of the
-            videos associated with the message. (default::obj:`low`)
+            videos associated with the message. (default: :obj:`low`)
         parsed: Optional[Union[Type[BaseModel], dict]]: Optional object which
-            is parsed from the content. (default::obj:`None`)
+            is parsed from the content. (default: :obj:`None`)
     """
 
     role_name: str

camel/models/__init__.py

@@ -16,6 +16,7 @@ from .azure_openai_model import AzureOpenAIModel
 from .base_model import BaseModelBackend
 from .cohere_model import CohereModel
 from .deepseek_model import DeepSeekModel
+from .fish_audio_model import FishAudioModel
 from .gemini_model import GeminiModel
 from .groq_model import GroqModel
 from .litellm_model import LiteLLMModel
@@ -31,6 +32,7 @@ from .openai_model import OpenAIModel
 from .qwen_model import QwenModel
 from .reka_model import RekaModel
 from .samba_model import SambaModel
+from .sglang_model import SGLangModel
 from .stub_model import StubModel
 from .togetherai_model import TogetherAIModel
 from .vllm_model import VLLMModel
@@ -55,6 +57,7 @@ __all__ = [
     'NvidiaModel',
     'OllamaModel',
     'VLLMModel',
+    'SGLangModel',
     'GeminiModel',
     'OpenAICompatibleModel',
     'RekaModel',
@@ -64,4 +67,5 @@ __all__ = [
     'QwenModel',
     'ModelProcessingError',
     'DeepSeekModel',
+    'FishAudioModel',
 ]

camel/models/anthropic_model.py

@@ -12,7 +12,7 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import os
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Literal, Optional, Union
 
 from camel.configs import ANTHROPIC_API_PARAMS, AnthropicConfig
 from camel.messages import OpenAIMessage
@@ -35,7 +35,7 @@ class AnthropicModel(BaseModelBackend):
         model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
             that will be fed into Anthropic.messages.create().  If
             :obj:`None`, :obj:`AnthropicConfig().as_dict()` will be used.
-            (default::obj:`None`)
+            (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.
@@ -94,19 +94,29 @@ class AnthropicModel(BaseModelBackend):
                 tokenization style.
         """
         if not self._token_counter:
-            self._token_counter = AnthropicTokenCounter()
+            self._token_counter = AnthropicTokenCounter(self.model_type)
         return self._token_counter
 
-    def count_tokens_from_prompt(self, prompt: str) -> int:
+    @dependencies_required('anthropic')
+    def count_tokens_from_prompt(
+        self, prompt: str, role: Literal["user", "assistant"]
+    ) -> int:
         r"""Count the number of tokens from a prompt.
 
         Args:
             prompt (str): The prompt string.
+            role (Literal["user", "assistant"]): The role of the message
+                sender, either "user" or "assistant".
 
         Returns:
             int: The number of tokens in the prompt.
         """
-        return self.client.count_tokens(prompt)
+        from anthropic.types.beta import BetaMessageParam
+
+        return self.client.beta.messages.count_tokens(
+            messages=[BetaMessageParam(content=prompt, role=role)],
+            model=self.model_type,
+        ).input_tokens
 
     @api_keys_required("ANTHROPIC_API_KEY")
     def run(

camel/models/azure_openai_model.py

@@ -91,7 +91,7 @@ class AzureOpenAIModel(BaseModelBackend):
             azure_deployment=self.azure_deployment_name,
             api_version=self.api_version,
             api_key=self._api_key,
-            timeout=60,
+            timeout=180,
             max_retries=3,
         )
 

camel/models/base_model.py

@@ -21,6 +21,7 @@ from camel.types import (
     ChatCompletion,
     ChatCompletionChunk,
     ModelType,
+    ParsedChatCompletion,
     UnifiedModelType,
 )
 from camel.utils import BaseTokenCounter
@@ -114,6 +115,33 @@ class BaseModelBackend(ABC):
         """
         return self.token_counter.count_tokens_from_messages(messages)
 
+    def _to_chat_completion(
+        self, response: ParsedChatCompletion
+    ) -> ChatCompletion:
+        if len(response.choices) > 1:
+            print("Warning: Multiple response choices detected")
+
+        choice = dict(
+            index=response.choices[0].index,
+            message={
+                "role": response.choices[0].message.role,
+                "content": response.choices[0].message.content,
+                "tool_calls": response.choices[0].message.tool_calls,
+                "parsed": response.choices[0].message.parsed,
+            },
+            finish_reason=response.choices[0].finish_reason,
+        )
+
+        obj = ChatCompletion.construct(
+            id=response.id,
+            choices=[choice],
+            created=response.created,
+            model=response.model,
+            object="chat.completion",
+            usage=response.usage,
+        )
+        return obj
+
     @property
     def token_limit(self) -> int:
         r"""Returns the maximum token limit for a given model.

camel/models/deepseek_model.py

@@ -70,7 +70,7 @@ class DeepSeekModel(BaseModelBackend):
         )
 
         self._client = OpenAI(
-            timeout=60,
+            timeout=180,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,

camel/models/fish_audio_model.py

@@ -0,0 +1,146 @@
+# ========= 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 os
+from typing import Any, Optional
+
+
+class FishAudioModel:
+    r"""Provides access to FishAudio's Text-to-Speech (TTS) and Speech_to_Text
+    (STT) models.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        url: Optional[str] = None,
+    ) -> None:
+        r"""Initialize an instance of FishAudioModel.
+
+        Args:
+            api_key (Optional[str]): API key for FishAudio service. If not
+                provided, the environment variable `FISHAUDIO_API_KEY` will be
+                used.
+            url (Optional[str]): Base URL for FishAudio API. If not provided,
+                the environment variable `FISHAUDIO_API_BASE_URL` will be used.
+        """
+        from fish_audio_sdk import Session
+
+        self._api_key = api_key or os.environ.get("FISHAUDIO_API_KEY")
+        self._url = url or os.environ.get(
+            "FISHAUDIO_API_BASE_URL", "https://api.fish.audio"
+        )
+        self.session = Session(apikey=self._api_key, base_url=self._url)
+
+    def text_to_speech(
+        self,
+        input: str,
+        storage_path: str,
+        reference_id: Optional[str] = None,
+        reference_audio: Optional[str] = None,
+        reference_audio_text: Optional[str] = None,
+        **kwargs: Any,
+    ) -> Any:
+        r"""Convert text to speech and save the output to a file.
+
+        Args:
+            input_text (str): The text to convert to speech.
+            storage_path (str): The file path where the resulting speech will
+                be saved.
+            reference_id (Optional[str]): An optional reference ID to
+                associate with the request. (default: :obj:`None`)
+            reference_audio (Optional[str]): Path to an audio file for
+                reference speech. (default: :obj:`None`)
+            reference_audio_text (Optional[str]): Text for the reference audio.
+                (default: :obj:`None`)
+            **kwargs (Any): Additional parameters to pass to the TTS request.
+
+        Raises:
+            FileNotFoundError: If the reference audio file cannot be found.
+        """
+        from fish_audio_sdk import ReferenceAudio, TTSRequest
+
+        directory = os.path.dirname(storage_path)
+        if directory and not os.path.exists(directory):
+            os.makedirs(directory)
+
+        if not reference_audio:
+            with open(f"{storage_path}", "wb") as f:
+                for chunk in self.session.tts(
+                    TTSRequest(reference_id=reference_id, text=input, **kwargs)
+                ):
+                    f.write(chunk)
+        else:
+            if not os.path.exists(reference_audio):
+                raise FileNotFoundError(
+                    f"Reference audio file not found: {reference_audio}"
+                )
+            if not reference_audio_text:
+                raise ValueError("reference_audio_text should be provided")
+            with open(f"{reference_audio}", "rb") as audio_file:
+                with open(f"{storage_path}", "wb") as f:
+                    for chunk in self.session.tts(
+                        TTSRequest(
+                            text=input,
+                            references=[
+                                ReferenceAudio(
+                                    audio=audio_file.read(),
+                                    text=reference_audio_text,
+                                )
+                            ],
+                            **kwargs,
+                        )
+                    ):
+                        f.write(chunk)
+
+    def speech_to_text(
+        self,
+        audio_file_path: str,
+        language: Optional[str] = None,
+        ignore_timestamps: Optional[bool] = None,
+        **kwargs: Any,
+    ) -> str:
+        r"""Convert speech to text from an audio file.
+
+        Args:
+            audio_file_path (str): The path to the audio file to transcribe.
+            language (Optional[str]): The language of the audio. (default:
+                :obj:`None`)
+            ignore_timestamps (Optional[bool]): Whether to ignore timestamps.
+                (default: :obj:`None`)
+            **kwargs (Any): Additional parameters to pass to the STT request.
+
+        Returns:
+            str: The transcribed text from the audio.
+
+        Raises:
+            FileNotFoundError: If the audio file cannot be found.
+        """
+        from fish_audio_sdk import ASRRequest
+
+        if not os.path.exists(audio_file_path):
+            raise FileNotFoundError(f"Audio file not found: {audio_file_path}")
+
+        with open(f"{audio_file_path}", "rb") as audio_file:
+            audio_data = audio_file.read()
+
+        response = self.session.asr(
+            ASRRequest(
+                audio=audio_data,
+                language=language,
+                ignore_timestamps=ignore_timestamps,
+                **kwargs,
+            )
+        )
+        return response.text

camel/models/gemini_model.py

@@ -71,7 +71,7 @@ class GeminiModel(BaseModelBackend):
             model_type, model_config_dict, api_key, url, token_counter
         )
         self._client = OpenAI(
-            timeout=60,
+            timeout=180,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,

camel/models/groq_model.py

@@ -63,13 +63,13 @@ class GroqModel(BaseModelBackend):
             model_config_dict = GroqConfig().as_dict()
         api_key = api_key or os.environ.get("GROQ_API_KEY")
         url = url or os.environ.get(
-            "GROQ_API_BASE_URL" or "https://api.groq.com/openai/v1"
+            "GROQ_API_BASE_URL", "https://api.groq.com/openai/v1"
         )
         super().__init__(
             model_type, model_config_dict, api_key, url, token_counter
         )
         self._client = OpenAI(
-            timeout=60,
+            timeout=180,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,

camel/models/model_factory.py

@@ -29,6 +29,7 @@ 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.sglang_model import SGLangModel
 from camel.models.stub_model import StubModel
 from camel.models.togetherai_model import TogetherAIModel
 from camel.models.vllm_model import VLLMModel
@@ -86,6 +87,8 @@ class ModelFactory:
             model_class = OllamaModel
         elif model_platform.is_vllm:
             model_class = VLLMModel
+        elif model_platform.is_sglang:
+            model_class = SGLangModel
         elif model_platform.is_openai_compatible_model:
             model_class = OpenAICompatibleModel
         elif model_platform.is_samba:

camel/models/nemotron_model.py

@@ -52,7 +52,7 @@ class NemotronModel(BaseModelBackend):
         api_key = api_key or os.environ.get("NVIDIA_API_KEY")
         super().__init__(model_type, {}, api_key, url)
         self._client = OpenAI(
-            timeout=60,
+            timeout=180,
             max_retries=3,
             base_url=self._url,
             api_key=self._api_key,

camel/models/nvidia_model.py

@@ -66,7 +66,7 @@ class NvidiaModel(BaseModelBackend):
             model_type, model_config_dict, api_key, url, token_counter
         )
         self._client = OpenAI(
-            timeout=60,
+            timeout=180,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,

camel/models/ollama_model.py

@@ -70,7 +70,7 @@ class OllamaModel(BaseModelBackend):
             self._start_server()
         # Use OpenAI client as interface call Ollama
         self._client = OpenAI(
-            timeout=60,
+            timeout=180,
             max_retries=3,
             api_key="Set-but-ignored",  # required but ignored
             base_url=self._url,
@@ -134,6 +134,18 @@ class OllamaModel(BaseModelBackend):
                 `ChatCompletion` in the non-stream mode, or
                 `Stream[ChatCompletionChunk]` in the stream mode.
         """
+        if self.model_config_dict.get("response_format"):
+            # stream is not supported in beta.chat.completions.parse
+            if "stream" in self.model_config_dict:
+                del self.model_config_dict["stream"]
+
+            response = self._client.beta.chat.completions.parse(
+                messages=messages,
+                model=self.model_type,
+                **self.model_config_dict,
+            )
+
+            return self._to_chat_completion(response)
 
         response = self._client.chat.completions.create(
             messages=messages,

camel/models/openai_compatible_model.py

@@ -61,7 +61,7 @@ class OpenAICompatibleModel(BaseModelBackend):
             model_type, model_config_dict, api_key, url, token_counter
         )
         self._client = OpenAI(
-            timeout=60,
+            timeout=180,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,

camel/models/openai_model.py

@@ -24,7 +24,6 @@ from camel.types import (
     ChatCompletion,
     ChatCompletionChunk,
     ModelType,
-    ParsedChatCompletion,
 )
 from camel.utils import (
     BaseTokenCounter,
@@ -68,7 +67,7 @@ class OpenAIModel(BaseModelBackend):
             model_type, model_config_dict, api_key, url, token_counter
         )
         self._client = OpenAI(
-            timeout=60,
+            timeout=180,
             max_retries=3,
             base_url=self._url,
             api_key=self._api_key,
@@ -148,31 +147,6 @@ class OpenAIModel(BaseModelBackend):
         )
         return response
 
-    def _to_chat_completion(
-        self, response: "ParsedChatCompletion"
-    ) -> ChatCompletion:
-        # TODO: Handle n > 1 or warn consumers it's not supported
-        choice = dict(
-            index=response.choices[0].index,
-            message={
-                "role": response.choices[0].message.role,
-                "content": response.choices[0].message.content,
-                "tool_calls": response.choices[0].message.tool_calls,
-                "parsed": response.choices[0].message.parsed,
-            },
-            finish_reason=response.choices[0].finish_reason,
-        )
-
-        obj = ChatCompletion.construct(
-            id=response.id,
-            choices=[choice],
-            created=response.created,
-            model=response.model,
-            object="chat.completion",
-            usage=response.usage,
-        )
-        return obj
-
     def check_model_config(self):
         r"""Check whether the model configuration contains any
         unexpected arguments to OpenAI API.

camel/models/qwen_model.py

@@ -71,7 +71,7 @@ class QwenModel(BaseModelBackend):
             model_type, model_config_dict, api_key, url, token_counter
         )
         self._client = OpenAI(
-            timeout=60,
+            timeout=180,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,

camel/models/reward/__init__.py

@@ -0,0 +1,22 @@
+# ========= 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. =========
+from .base_reward_model import BaseRewardModel
+from .evaluator import Evaluator
+from .nemotron_model import NemotronRewardModel
+
+__all__ = [
+    'BaseRewardModel',
+    'NemotronRewardModel',
+    'Evaluator',
+]

camel/models/reward/base_reward_model.py

@@ -0,0 +1,58 @@
+# ========= 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. =========
+from abc import ABC, abstractmethod
+from typing import Dict, List, Optional, Union
+
+from camel.types import ModelType
+
+
+class BaseRewardModel(ABC):
+    r"""Abstract base class for reward models. Reward models are used to
+    evaluate messages and return scores based on different criteria.
+
+    Subclasses should implement the 'evaluate' and 'get_scores_types' methods.
+    """
+
+    def __init__(
+        self,
+        model_type: Union[ModelType, str],
+        api_key: Optional[str] = None,
+        url: Optional[str] = None,
+    ) -> None:
+        self.model_type = model_type
+        self.api_key = api_key
+        self.url = url
+
+    @abstractmethod
+    def evaluate(self, messages: List[Dict[str, str]]) -> Dict[str, float]:
+        r"""Evaluate the messages and return scores based on different
+        criteria.
+
+        Args:
+            messages (List[Dict[str, str]]): A list of messages where each
+                message is a dictionary with 'role' and 'content'.
+
+        Returns:
+            Dict[str, float]: A dictionary mapping score types to their values.
+        """
+        pass
+
+    @abstractmethod
+    def get_scores_types(self) -> List[str]:
+        r"""Get the list of score types that the reward model can return.
+
+        Returns:
+            List[str]: A list of score types that the reward model can return.
+        """
+        pass