camel-ai 0.1.5.1__py3-none-any.whl → 0.1.5.3__py3-none-any.whl

camel/types/enums.py

@@ -29,6 +29,9 @@ class ModelType(Enum):
     GPT_4_32K = "gpt-4-32k"
     GPT_4_TURBO = "gpt-4-turbo"
     GPT_4O = "gpt-4o"
+    GLM_4 = "glm-4"
+    GLM_4V = 'glm-4v'
+    GLM_3_TURBO = "glm-3-turbo"
 
     STUB = "stub"
 
@@ -42,14 +45,21 @@ class ModelType(Enum):
     CLAUDE_2_0 = "claude-2.0"
     CLAUDE_INSTANT_1_2 = "claude-instant-1.2"
 
-    #  3 models
+    # Claude3 models
     CLAUDE_3_OPUS = "claude-3-opus-20240229"
     CLAUDE_3_SONNET = "claude-3-sonnet-20240229"
     CLAUDE_3_HAIKU = "claude-3-haiku-20240307"
 
+    # Nvidia models
+    NEMOTRON_4_REWARD = "nvidia/nemotron-4-340b-reward"
+
     @property
     def value_for_tiktoken(self) -> str:
-        return self.value if self is not ModelType.STUB else "gpt-3.5-turbo"
+        return (
+            self.value
+            if self is not ModelType.STUB and not isinstance(self, str)
+            else "gpt-3.5-turbo"
+        )
 
     @property
     def is_openai(self) -> bool:
@@ -62,6 +72,15 @@ class ModelType(Enum):
             ModelType.GPT_4O,
         }
 
+    @property
+    def is_zhipuai(self) -> bool:
+        r"""Returns whether this type of models is an ZhipuAI model."""
+        return self in {
+            ModelType.GLM_3_TURBO,
+            ModelType.GLM_4,
+            ModelType.GLM_4V,
+        }
+
     @property
     def is_open_source(self) -> bool:
         r"""Returns whether this type of models is open-source."""
@@ -87,6 +106,17 @@ class ModelType(Enum):
             ModelType.CLAUDE_3_HAIKU,
         }
 
+    @property
+    def is_nvidia(self) -> bool:
+        r"""Returns whether this type of models is Nvidia-released model.
+
+        Returns:
+            bool: Whether this type of models is nvidia.
+        """
+        return self in {
+            ModelType.NEMOTRON_4_REWARD,
+        }
+
     @property
     def token_limit(self) -> int:
         r"""Returns the maximum token limit for a given model.
@@ -103,6 +133,12 @@ class ModelType(Enum):
             return 128000
         elif self is ModelType.GPT_4O:
             return 128000
+        elif self == ModelType.GLM_4:
+            return 8192
+        elif self == ModelType.GLM_3_TURBO:
+            return 8192
+        elif self == ModelType.GLM_4V:
+            return 1024
         elif self is ModelType.STUB:
             return 4096
         elif self is ModelType.LLAMA_2:
@@ -112,7 +148,7 @@ class ModelType(Enum):
             return 2048
         elif self is ModelType.VICUNA_16K:
             return 16384
-        if self in {ModelType.CLAUDE_2_0, ModelType.CLAUDE_INSTANT_1_2}:
+        elif self in {ModelType.CLAUDE_2_0, ModelType.CLAUDE_INSTANT_1_2}:
             return 100_000
         elif self in {
             ModelType.CLAUDE_2_1,
@@ -121,6 +157,8 @@ class ModelType(Enum):
             ModelType.CLAUDE_3_HAIKU,
         }:
             return 200_000
+        elif self is ModelType.NEMOTRON_4_REWARD:
+            return 4096
         else:
             raise ValueError("Unknown model type")
 
@@ -189,8 +227,10 @@ class TaskType(Enum):
     EVALUATION = "evaluation"
     SOLUTION_EXTRACTION = "solution_extraction"
     ROLE_DESCRIPTION = "role_description"
+    GENERATE_TEXT_EMBEDDING_DATA = "generate_text_embedding_data"
     OBJECT_RECOGNITION = "object_recognition"
     DEFAULT = "default"
+    VIDEO_DESCRIPTION = "video_description"
 
 
 class VectorDistance(Enum):
@@ -238,7 +278,7 @@ class OpenAIImageType(Enum, metaclass=OpenAIImageTypeMeta):
     GIF = "gif"
 
 
-class OpenAIImageDetailType(Enum):
+class OpenAIVisionDetailType(Enum):
     AUTO = "auto"
     LOW = "low"
     HIGH = "high"
@@ -253,6 +293,57 @@ class OpenAPIName(Enum):
     COURSERA = "coursera"
     KLARNA = "klarna"
     SPEAK = "speak"
+    NASA_APOD = "nasa_apod"
+    BIZTOC = "biztoc"
+    CREATE_QR_CODE = "create_qr_code"
+    OUTSCHOOL = "outschool"
+    WEB_SCRAPER = "web_scraper"
+
+
+class ModelPlatformType(Enum):
+    OPENAI = "openai"
+    AZURE = "azure"
+    ANTHROPIC = "anthropic"
+    OPENSOURCE = "opensource"
+    OLLAMA = "ollama"
+    LITELLM = "litellm"
+    ZHIPU = "zhipuai"
+    DEFAULT = "default"
+
+    @property
+    def is_openai(self) -> bool:
+        r"""Returns whether this platform is openai."""
+        return self is ModelPlatformType.OPENAI
+
+    @property
+    def is_azure(self) -> bool:
+        r"""Returns whether this platform is azure."""
+        return self is ModelPlatformType.AZURE
+
+    @property
+    def is_anthropic(self) -> bool:
+        r"""Returns whether this platform is anthropic."""
+        return self is ModelPlatformType.ANTHROPIC
+
+    @property
+    def is_ollama(self) -> bool:
+        r"""Returns whether this platform is ollama."""
+        return self is ModelPlatformType.OLLAMA
+
+    @property
+    def is_litellm(self) -> bool:
+        r"""Returns whether this platform is litellm."""
+        return self is ModelPlatformType.LITELLM
+
+    @property
+    def is_zhipuai(self) -> bool:
+        r"""Returns whether this platform is zhipu."""
+        return self is ModelPlatformType.ZHIPU
+
+    @property
+    def is_open_source(self) -> bool:
+        r"""Returns whether this platform is opensource."""
+        return self is ModelPlatformType.OPENSOURCE
 
 
 class AudioModelType(Enum):

camel/utils/__init__.py

@@ -11,30 +11,35 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+
 from .commons import (
     PYDANTIC_V2,
-    api_key_required,
     api_keys_required,
     check_server_running,
+    create_chunks,
     dependencies_required,
     download_tasks,
     get_first_int,
     get_prompt_template_key_words,
     get_system_information,
     get_task_list,
+    model_api_key_required,
     print_text_animated,
+    text_extract_from_web,
     to_pascal,
 )
+from .constants import Constants
 from .token_counting import (
     AnthropicTokenCounter,
     BaseTokenCounter,
+    LiteLLMTokenCounter,
     OpenAITokenCounter,
     OpenSourceTokenCounter,
     get_model_encoding,
 )
 
 __all__ = [
-    'api_key_required',
+    'model_api_key_required',
     'print_text_animated',
     'get_prompt_template_key_words',
     'get_first_int',
@@ -49,6 +54,10 @@ __all__ = [
     'BaseTokenCounter',
     'OpenAITokenCounter',
     'OpenSourceTokenCounter',
+    'LiteLLMTokenCounter',
+    'Constants',
+    'text_extract_from_web',
+    'create_chunks',
     'dependencies_required',
     'api_keys_required',
 ]

camel/utils/commons.py

@@ -30,8 +30,9 @@ from camel.types import TaskType
 F = TypeVar('F', bound=Callable[..., Any])
 
 
-def api_key_required(func: F) -> F:
-    r"""Decorator that checks if the API key is available either as an environment variable or passed directly.
+def model_api_key_required(func: F) -> F:
+    r"""Decorator that checks if the API key is available either as an
+    environment variable or passed directly for a model.
 
     Args:
         func (callable): The function to be wrapped.
@@ -42,6 +43,9 @@ def api_key_required(func: F) -> F:
     Raises:
         ValueError: If the API key is not found, either as an environment
             variable or directly passed.
+
+    Note:
+        Supported model type: `OpenAI` and `Anthropic`.
     """
 
     @wraps(func)
@@ -50,10 +54,18 @@ def api_key_required(func: F) -> F:
             if not self._api_key and 'OPENAI_API_KEY' not in os.environ:
                 raise ValueError('OpenAI API key not found.')
             return func(self, *args, **kwargs)
+        elif self.model_type.is_zhipuai:
+            if 'ZHIPUAI_API_KEY' not in os.environ:
+                raise ValueError('ZhiPuAI API key not found.')
+            return func(self, *args, **kwargs)
         elif self.model_type.is_anthropic:
-            if 'ANTHROPIC_API_KEY' not in os.environ:
+            if not self._api_key and 'ANTHROPIC_API_KEY' not in os.environ:
                 raise ValueError('Anthropic API key not found.')
             return func(self, *args, **kwargs)
+        elif self.model_type.is_nvidia:
+            if not self._api_key and 'NVIDIA_API_KEY' not in os.environ:
+                raise ValueError('NVIDIA API key not found.')
+            return func(self, *args, **kwargs)
         else:
             raise ValueError('Unsupported model type.')
 
@@ -274,7 +286,9 @@ def api_keys_required(*required_keys: str) -> Callable[[F], F]:
         def wrapper(*args: Any, **kwargs: Any) -> Any:
             missing_keys = [k for k in required_keys if k not in os.environ]
             if missing_keys:
-                raise ValueError(f"Missing API keys: {', '.join(missing_keys)}")
+                raise ValueError(
+                    f"Missing API keys: {', '.join(missing_keys)}"
+                )
             return func(*args, **kwargs)
 
         return cast(F, wrapper)
@@ -326,3 +340,63 @@ def to_pascal(snake: str) -> str:
 
 
 PYDANTIC_V2 = pydantic.VERSION.startswith("2.")
+
+
+def text_extract_from_web(url: str) -> str:
+    r"""Get the text information from given url.
+
+    Args:
+        url (str): The website you want to search.
+
+    Returns:
+        str: All texts extract from the web.
+    """
+    try:
+        import requests
+        from newspaper import Article
+
+        # Request the target page
+        article = Article(url)
+        article.download()
+        article.parse()
+        text = article.text
+
+    except requests.RequestException as e:
+        text = f"Can't access {url}, error: {e}"
+
+    except Exception as e:
+        text = f"Can't extract text from {url}, error: {e}"
+
+    return text
+
+
+def create_chunks(text: str, n: int) -> List[str]:
+    r"""Returns successive n-sized chunks from provided text. Split a text
+    into smaller chunks of size n".
+
+    Args:
+        text (str): The text to be split.
+        n (int): The max length of a single chunk.
+
+    Returns:
+        List[str]: A list of split texts.
+    """
+
+    chunks = []
+    i = 0
+    while i < len(text):
+        # Find the nearest end of sentence within a range of 0.5 * n
+        # and 1.5 * n tokens
+        j = min(i + int(1.2 * n), len(text))
+        while j > i + int(0.8 * n):
+            # Decode the tokens and check for full stop or newline
+            chunk = text[i:j]
+            if chunk.endswith(".") or chunk.endswith("\n"):
+                break
+            j -= 1
+        # If no end of sentence found, use n tokens as the chunk size
+        if j == i + int(0.8 * n):
+            j = min(i + n, len(text))
+        chunks.append(text[i:j])
+        i = j
+    return chunks

camel/utils/constants.py

@@ -0,0 +1,26 @@
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+# Licensed under the Apache License, Version 2.0 (the “License”);
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an “AS IS” BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
+
+
+class Constants:
+    # This value defines the default size (both width and height) for images
+    # extracted from a video.
+    VIDEO_DEFAULT_IMAGE_SIZE = 768
+
+    # This value defines the interval (in number of frames) at which images
+    # are extracted from the video.
+    VIDEO_IMAGE_EXTRACTION_INTERVAL = 50
+
+    # default plug of imageio to read video
+    VIDEO_DEFAULT_PLUG_PYAV = "pyav"

camel/utils/token_counting.py

@@ -23,7 +23,7 @@ from typing import TYPE_CHECKING, List, Optional
 from anthropic import Anthropic
 from PIL import Image
 
-from camel.types import ModelType, OpenAIImageDetailType, OpenAIImageType
+from camel.types import ModelType, OpenAIImageType, OpenAIVisionDetailType
 
 if TYPE_CHECKING:
     from camel.messages import OpenAIMessage
@@ -245,6 +245,7 @@ class OpenAITokenCounter(BaseTokenCounter):
                         elif item["type"] == "image_url":
                             image_str: str = item["image_url"]["url"]
                             detail = item["image_url"]["detail"]
+
                             image_prefix_format = "data:image/{};base64,"
                             image_prefix: Optional[str] = None
                             for image_type in list(OpenAIImageType):
@@ -261,7 +262,7 @@ class OpenAITokenCounter(BaseTokenCounter):
                             )
                             image = Image.open(image_bytes)
                             num_tokens += count_tokens_from_image(
-                                image, OpenAIImageDetailType(detail)
+                                image, OpenAIVisionDetailType(detail)
                             )
                 if key == "name":
                     num_tokens += self.tokens_per_name
@@ -295,13 +296,67 @@ class AnthropicTokenCounter(BaseTokenCounter):
         Returns:
             int: Number of tokens in the messages.
         """
-        prompt = messages_to_prompt(messages, self.model_type)
+        num_tokens = 0
+        for message in messages:
+            content = str(message["content"])
+            num_tokens += self.client.count_tokens(content)
+        return num_tokens
+
+
+class LiteLLMTokenCounter:
+    def __init__(self, model_type: str):
+        r"""Constructor for the token counter for LiteLLM models.
+
+        Args:
+            model_type (str): Model type for which tokens will be counted.
+        """
+        self.model_type = model_type
+        self._token_counter = None
+        self._completion_cost = None
+
+    @property
+    def token_counter(self):
+        if self._token_counter is None:
+            from litellm import token_counter
+
+            self._token_counter = token_counter
+        return self._token_counter
+
+    @property
+    def completion_cost(self):
+        if self._completion_cost is None:
+            from litellm import completion_cost
+
+            self._completion_cost = completion_cost
+        return self._completion_cost
 
-        return self.client.count_tokens(prompt)
+    def count_tokens_from_messages(self, messages: List[OpenAIMessage]) -> int:
+        r"""Count number of tokens in the provided message list using
+        the tokenizer specific to this type of model.
+
+        Args:
+            messages (List[OpenAIMessage]): Message list with the chat history
+                in LiteLLM API format.
+
+        Returns:
+            int: Number of tokens in the messages.
+        """
+        return self.token_counter(model=self.model_type, messages=messages)
+
+    def calculate_cost_from_response(self, response: dict) -> float:
+        r"""Calculate the cost of the given completion response.
+
+        Args:
+            response (dict): The completion response from LiteLLM.
+
+        Returns:
+            float: The cost of the completion call in USD.
+        """
+        return self.completion_cost(completion_response=response)
 
 
 def count_tokens_from_image(
-    image: Image.Image, detail: OpenAIImageDetailType
+    image: Image.Image, detail: OpenAIVisionDetailType
 ) -> int:
     r"""Count image tokens for OpenAI vision model. An :obj:`"auto"`
     resolution model will be treated as :obj:`"high"`. All images with
@@ -315,13 +370,13 @@ def count_tokens_from_image(
 
     Args:
         image (PIL.Image.Image): Image to count number of tokens.
-        detail (OpenAIImageDetailType): Image detail type to count
+        detail (OpenAIVisionDetailType): Image detail type to count
             number of tokens.
 
     Returns:
         int: Number of tokens for the image given a detail type.
     """
-    if detail == OpenAIImageDetailType.LOW:
+    if detail == OpenAIVisionDetailType.LOW:
         return LOW_DETAIL_TOKENS
 
     width, height = image.size