camel-ai 0.2.37__py3-none-any.whl → 0.2.39__py3-none-any.whl

camel/models/model_factory.py

@@ -11,8 +11,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
+import json
 from typing import Dict, Optional, Type, Union
 
+import yaml
+
 from camel.models.aiml_model import AIMLModel
 from camel.models.anthropic_model import AnthropicModel
 from camel.models.azure_openai_model import AzureOpenAIModel
@@ -24,6 +27,7 @@ from camel.models.groq_model import GroqModel
 from camel.models.internlm_model import InternLMModel
 from camel.models.litellm_model import LiteLLMModel
 from camel.models.mistral_model import MistralModel
+from camel.models.modelscope_model import ModelScopeModel
 from camel.models.moonshot_model import MoonshotModel
 from camel.models.nvidia_model import NvidiaModel
 from camel.models.ollama_model import OllamaModel
@@ -60,6 +64,7 @@ class ModelFactory:
         token_counter: Optional[BaseTokenCounter] = None,
         api_key: Optional[str] = None,
         url: Optional[str] = None,
+        timeout: Optional[int] = None,
     ) -> BaseModelBackend:
         r"""Creates an instance of `BaseModelBackend` of the specified type.
 
@@ -79,6 +84,8 @@ class ModelFactory:
                 with the model service. (default: :obj:`None`)
             url (Optional[str], optional): The url to the model service.
                 (default: :obj:`None`)
+            timeout (Optional[float], optional): The timeout value in seconds
+                for API calls. (default: :obj:`None`)
 
         Returns:
             BaseModelBackend: The initialized backend.
@@ -142,6 +149,8 @@ class ModelFactory:
             model_class = InternLMModel
         elif model_platform.is_moonshot and model_type.is_moonshot:
             model_class = MoonshotModel
+        elif model_platform.is_modelscope:
+            model_class = ModelScopeModel
         elif model_type == ModelType.STUB:
             model_class = StubModel
 
@@ -157,4 +166,118 @@ class ModelFactory:
             api_key=api_key,
             url=url,
             token_counter=token_counter,
+            timeout=timeout,
         )
+
+    @classmethod
+    def __parse_model_platform(
+        cls, model_platform_str: str
+    ) -> ModelPlatformType:
+        r"""Parses a string and returns the corresponding ModelPlatformType
+        enum.
+
+        Args:
+            model_platform_str (str): The platform name as a string. Can be in
+                the form "ModelPlatformType.<NAME>" or simply "<NAME>".
+
+        Returns:
+            ModelPlatformType: The matching enum value.
+
+        Raises:
+            ValueError: If the platform name is not a valid member of
+                ModelPlatformType.
+        """
+
+        try:
+            if model_platform_str.startswith("ModelPlatformType."):
+                platform_name = model_platform_str.split('.')[-1]
+            else:
+                platform_name = model_platform_str.upper()
+
+            if platform_name not in ModelPlatformType.__members__:
+                raise ValueError(
+                    f"Invalid model platform: {platform_name}. "
+                    f"Valid options: "
+                    f"{', '.join(ModelPlatformType.__members__.keys())}"
+                )
+
+            return ModelPlatformType[platform_name]
+
+        except KeyError:
+            raise KeyError(f"Invalid model platform: {model_platform_str}")
+
+    @classmethod
+    def __load_yaml(cls, filepath: str) -> Dict:
+        r"""Loads and parses a YAML file into a dictionary.
+
+        Args:
+            filepath (str): Path to the YAML configuration file.
+
+        Returns:
+            Dict: The parsed YAML content as a dictionary.
+        """
+        with open(filepath, 'r') as file:
+            config = yaml.safe_load(file)
+
+        return config
+
+    @classmethod
+    def __load_json(cls, filepath: str) -> Dict:
+        r"""Loads and parses a JSON file into a dictionary.
+
+        Args:
+            filepath (str): Path to the JSON configuration file.
+
+        Returns:
+            Dict: The parsed JSON content as a dictionary.
+        """
+        with open(filepath, 'r') as file:
+            config = json.load(file)
+
+        return config
+
+    @classmethod
+    def create_from_yaml(cls, filepath: str) -> BaseModelBackend:
+        r"""Creates and returns a model base backend instance
+        from a YAML configuration file.
+
+        Args:
+            filepath (str): Path to the YAML file containing model
+                configuration.
+
+        Returns:
+            BaseModelBackend: An instance of the model backend based on the
+                configuration.
+        """
+
+        config = cls.__load_yaml(filepath)
+        config["model_platform"] = cls.__parse_model_platform(
+            config["model_platform"]
+        )
+
+        model = ModelFactory.create(**config)
+
+        return model
+
+    @classmethod
+    def create_from_json(cls, filepath: str) -> BaseModelBackend:
+        r"""Creates and returns a base model backend instance
+        from a JSON configuration file.
+
+        Args:
+            filepath (str): Path to the JSON file containing model
+                configuration.
+
+        Returns:
+            BaseModelBackend: An instance of the model backend based on the
+                configuration.
+        """
+
+        config = cls.__load_json(filepath)
+        config["model_platform"] = cls.__parse_model_platform(
+            config["model_platform"]
+        )
+
+        model = ModelFactory.create(**config)
+
+        return model

camel/models/modelscope_model.py

@@ -0,0 +1,208 @@
+# ========= 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, Dict, List, Optional, Type, Union
+
+from openai import AsyncOpenAI, AsyncStream, OpenAI, Stream
+from pydantic import BaseModel
+
+from camel.configs import MODELSCOPE_API_PARAMS, ModelScopeConfig
+from camel.messages import OpenAIMessage
+from camel.models import BaseModelBackend
+from camel.models._utils import try_modify_message_with_format
+from camel.types import (
+    ChatCompletion,
+    ChatCompletionChunk,
+    ModelType,
+)
+from camel.utils import (
+    BaseTokenCounter,
+    OpenAITokenCounter,
+    api_keys_required,
+)
+
+
+class ModelScopeModel(BaseModelBackend):
+    r"""ModelScope API in a unified BaseModelBackend interface.
+
+    Args:
+        model_type (Union[ModelType, str]): Model for which a backend is
+            created, one of ModelScope series.
+        model_config_dict (Optional[Dict[str, Any]], optional): A dictionary
+            that will be fed into:obj:`openai.ChatCompletion.create()`. If
+            :obj:`None`, :obj:`ModelScopeConfig().as_dict()` will be used.
+            (default: :obj:`None`)
+        api_key (Optional[str], optional): The MODELSCOPE_SDK_TOKEN for
+            authenticating with the ModelScope service. (default: :obj:`None`)
+            refer to the following link for more details:
+            https://modelscope.cn/my/myaccesstoken
+        url (Optional[str], optional): The url to the ModelScope service.
+            (default: :obj:`https://api-inference.modelscope.cn/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`)
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
+    """
+
+    @api_keys_required(
+        [
+            ("api_key", 'MODELSCOPE_SDK_TOKEN'),
+        ]
+    )
+    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,
+        timeout: Optional[float] = None,
+    ) -> None:
+        if model_config_dict is None:
+            model_config_dict = ModelScopeConfig().as_dict()
+        api_key = api_key or os.environ.get("MODELSCOPE_SDK_TOKEN")
+        url = url or os.environ.get(
+            "MODELSCOPE_API_BASE_URL",
+            "https://api-inference.modelscope.cn/v1/",
+        )
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
+        super().__init__(
+            model_type, model_config_dict, api_key, url, token_counter, timeout
+        )
+        self._client = OpenAI(
+            timeout=self._timeout,
+            max_retries=3,
+            api_key=self._api_key,
+            base_url=self._url,
+        )
+        self._async_client = AsyncOpenAI(
+            timeout=self._timeout,
+            max_retries=3,
+            api_key=self._api_key,
+            base_url=self._url,
+        )
+
+    async def _arun(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+        r"""Runs inference of ModelScope chat completion.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in OpenAI API format.
+
+        Returns:
+            Union[ChatCompletion, AsyncStream[ChatCompletionChunk]]:
+                `ChatCompletion` in the non-stream mode, or
+                `AsyncStream[ChatCompletionChunk]` in the stream mode.
+        """
+        request_config = self._prepare_request(
+            messages, response_format, tools
+        )
+
+        response = await self._async_client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+            **request_config,
+        )
+        return response
+
+    def _run(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Union[ChatCompletion, Stream[ChatCompletionChunk]]:
+        r"""Runs inference of ModelScope 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.
+        """
+        request_config = self._prepare_request(
+            messages, response_format, tools
+        )
+
+        response = self._client.chat.completions.create(
+            messages=messages,
+            model=self.model_type,
+            **request_config,
+        )
+        return response
+
+    def _prepare_request(
+        self,
+        messages: List[OpenAIMessage],
+        response_format: Optional[Type[BaseModel]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> Dict[str, Any]:
+        request_config = self.model_config_dict.copy()
+        if tools:
+            request_config["tools"] = tools
+        elif response_format:
+            try_modify_message_with_format(messages[-1], response_format)
+            request_config["response_format"] = {"type": "json_object"}
+
+        return request_config
+
+    @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 ModelScope API.
+
+        Raises:
+            ValueError: If the model configuration dictionary contains any
+                unexpected arguments to ModelScope API.
+        """
+        for param in self.model_config_dict:
+            if param not in MODELSCOPE_API_PARAMS:
+                raise ValueError(
+                    f"Unexpected argument `{param}` is "
+                    "input into ModelScope 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/moonshot_model.py

@@ -52,6 +52,10 @@ class MoonshotModel(BaseModelBackend):
             use for the model. If not provided, :obj:`OpenAITokenCounter(
             ModelType.GPT_4)` will be used.
             (default: :obj:`None`)
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
     """
 
     @api_keys_required([("api_key", "MOONSHOT_API_KEY")])
@@ -62,6 +66,7 @@ class MoonshotModel(BaseModelBackend):
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = MoonshotConfig().as_dict()
@@ -70,12 +75,13 @@ class MoonshotModel(BaseModelBackend):
             "MOONSHOT_API_BASE_URL",
             "https://api.moonshot.cn/v1",
         )
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter
+            model_type, model_config_dict, api_key, url, token_counter, timeout
         )
         self._client = OpenAI(
             api_key=self._api_key,
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             base_url=self._url,
         )

camel/models/nemotron_model.py

@@ -36,6 +36,10 @@ class NemotronModel(BaseModelBackend):
             the Nvidia service. (default: :obj:`None`)
         url (Optional[str], optional): The url to the Nvidia service.
             (default: :obj:`https://integrate.api.nvidia.com/v1`)
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
 
     Notes:
         Nemotron model doesn't support additional model config like OpenAI.
@@ -51,20 +55,22 @@ class NemotronModel(BaseModelBackend):
         model_type: Union[ModelType, str],
         api_key: Optional[str] = None,
         url: Optional[str] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         url = url or os.environ.get(
             "NVIDIA_API_BASE_URL", "https://integrate.api.nvidia.com/v1"
         )
         api_key = api_key or os.environ.get("NVIDIA_API_KEY")
-        super().__init__(model_type, {}, api_key, url)
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
+        super().__init__(model_type, {}, api_key, url, None, timeout)
         self._client = OpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             base_url=self._url,
             api_key=self._api_key,
         )
         self._async_client = AsyncOpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             base_url=self._url,
             api_key=self._api_key,

camel/models/nvidia_model.py

@@ -47,6 +47,10 @@ class NvidiaModel(BaseModelBackend):
             use for the model. If not provided, :obj:`OpenAITokenCounter(
             ModelType.GPT_4)` will be used.
             (default: :obj:`None`)
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
     """
 
     @api_keys_required(
@@ -61,6 +65,7 @@ class NvidiaModel(BaseModelBackend):
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = NvidiaConfig().as_dict()
@@ -68,17 +73,18 @@ class NvidiaModel(BaseModelBackend):
         url = url or os.environ.get(
             "NVIDIA_API_BASE_URL", "https://integrate.api.nvidia.com/v1"
         )
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter
+            model_type, model_config_dict, api_key, url, token_counter, timeout
         )
         self._client = OpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,
         )
         self._async_client = AsyncOpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,

camel/models/ollama_model.py

@@ -49,6 +49,10 @@ class OllamaModel(BaseModelBackend):
             use for the model. If not provided, :obj:`OpenAITokenCounter(
             ModelType.GPT_4O_MINI)` will be used.
             (default: :obj:`None`)
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
 
     References:
         https://github.com/ollama/ollama/blob/main/docs/openai.md
@@ -61,24 +65,26 @@ class OllamaModel(BaseModelBackend):
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         if model_config_dict is None:
             model_config_dict = OllamaConfig().as_dict()
         url = url or os.environ.get("OLLAMA_BASE_URL")
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter
+            model_type, model_config_dict, api_key, url, token_counter, timeout
         )
         if not self._url:
             self._start_server()
         # Use OpenAI client as interface call Ollama
         self._client = OpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             api_key="Set-but-ignored",  # required but ignored
             base_url=self._url,
         )
         self._async_client = AsyncOpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             api_key="Set-but-ignored",  # required but ignored
             base_url=self._url,

camel/models/openai_audio_models.py

@@ -29,19 +29,21 @@ class OpenAIAudioModels(BaseAudioModel):
         self,
         api_key: Optional[str] = None,
         url: Optional[str] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         r"""Initialize an instance of OpenAI."""
-        super().__init__(api_key, url)
+        super().__init__(api_key, url, timeout)
         self._url = url or os.environ.get("OPENAI_API_BASE_URL")
         self._api_key = api_key or os.environ.get("OPENAI_API_KEY")
+        self._timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         self._client = OpenAI(
-            timeout=120,
+            timeout=self._timeout,
             max_retries=3,
             base_url=self._url,
             api_key=self._api_key,
         )
         self._async_client = AsyncOpenAI(
-            timeout=120,
+            timeout=self._timeout,
             max_retries=3,
             base_url=self._url,
             api_key=self._api_key,
@@ -76,8 +78,8 @@ class OpenAIAudioModels(BaseAudioModel):
         Returns:
             Union[List[_legacy_response.HttpxBinaryResponseContent],
                 _legacy_response.HttpxBinaryResponseContent]: List of response
-                content object from OpenAI if input charaters more than 4096,
-                single response content if input charaters less than 4096.
+                content object from OpenAI if input characters more than 4096,
+                single response content if input characters less than 4096.
 
         Raises:
             Exception: If there's an error during the TTS API call.

camel/models/openai_compatible_model.py

@@ -46,6 +46,10 @@ class OpenAICompatibleModel(BaseModelBackend):
             use for the model. If not provided, :obj:`OpenAITokenCounter(
             ModelType.GPT_4O_MINI)` will be used.
             (default: :obj:`None`)
+        timeout (Optional[float], optional): The timeout value in seconds for
+            API calls. If not provided, will fall back to the MODEL_TIMEOUT
+            environment variable or default to 180 seconds.
+            (default: :obj:`None`)
     """
 
     def __init__(
@@ -55,21 +59,23 @@ class OpenAICompatibleModel(BaseModelBackend):
         api_key: Optional[str] = None,
         url: Optional[str] = None,
         token_counter: Optional[BaseTokenCounter] = None,
+        timeout: Optional[float] = None,
     ) -> None:
         api_key = api_key or os.environ.get("OPENAI_COMPATIBILITY_API_KEY")
         url = url or os.environ.get("OPENAI_COMPATIBILITY_API_BASE_URL")
+        timeout = timeout or float(os.environ.get("MODEL_TIMEOUT", 180))
         super().__init__(
-            model_type, model_config_dict, api_key, url, token_counter
+            model_type, model_config_dict, api_key, url, token_counter, timeout
         )
         self._client = OpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,
         )
 
         self._async_client = AsyncOpenAI(
-            timeout=180,
+            timeout=self._timeout,
             max_retries=3,
             api_key=self._api_key,
             base_url=self._url,