camel-ai 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

camel/types/enums.py

@@ -12,7 +12,7 @@
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 import re
-from enum import Enum
+from enum import Enum, EnumMeta
 
 
 class RoleType(Enum):
@@ -24,12 +24,11 @@ class RoleType(Enum):
 
 
 class ModelType(Enum):
-    GPT_3_5_TURBO = "gpt-3.5-turbo-1106"
-    GPT_3_5_TURBO_16K = "gpt-3.5-turbo-1106"
+    GPT_3_5_TURBO = "gpt-3.5-turbo"
     GPT_4 = "gpt-4"
     GPT_4_32K = "gpt-4-32k"
-    GPT_4_TURBO = "gpt-4-1106-preview"
-    GPT_4_TURBO_VISION = "gpt-4-vision-preview"
+    GPT_4_TURBO = "gpt-4-turbo"
+    GPT_4_TURBO_VISION = "gpt-4-turbo"
 
     STUB = "stub"
 
@@ -37,6 +36,17 @@ class ModelType(Enum):
     VICUNA = "vicuna"
     VICUNA_16K = "vicuna-16k"
 
+    # Legacy anthropic models
+    # NOTE: anthropic lagecy models only Claude 2.1 has system prompt support
+    CLAUDE_2_1 = "claude-2.1"
+    CLAUDE_2_0 = "claude-2.0"
+    CLAUDE_INSTANT_1_2 = "claude-instant-1.2"
+
+    #  3 models
+    CLAUDE_3_OPUS = "claude-3-opus-20240229"
+    CLAUDE_3_SONNET = "claude-3-sonnet-20240229"
+    CLAUDE_3_HAIKU = "claude-3-haiku-20240307"
+
     @property
     def value_for_tiktoken(self) -> str:
         return self.value if self is not ModelType.STUB else "gpt-3.5-turbo"
@@ -46,7 +56,6 @@ class ModelType(Enum):
         r"""Returns whether this type of models is an OpenAI-released model."""
         return self in {
             ModelType.GPT_3_5_TURBO,
-            ModelType.GPT_3_5_TURBO_16K,
             ModelType.GPT_4,
             ModelType.GPT_4_32K,
             ModelType.GPT_4_TURBO,
@@ -62,6 +71,22 @@ class ModelType(Enum):
             ModelType.VICUNA_16K,
         }
 
+    @property
+    def is_anthropic(self) -> bool:
+        r"""Returns whether this type of models is Anthropic-released model.
+
+        Returns:
+            bool: Whether this type of models is anthropic.
+        """
+        return self in {
+            ModelType.CLAUDE_INSTANT_1_2,
+            ModelType.CLAUDE_2_0,
+            ModelType.CLAUDE_2_1,
+            ModelType.CLAUDE_3_OPUS,
+            ModelType.CLAUDE_3_SONNET,
+            ModelType.CLAUDE_3_HAIKU,
+        }
+
     @property
     def token_limit(self) -> int:
         r"""Returns the maximum token limit for a given model.
@@ -70,8 +95,6 @@ class ModelType(Enum):
         """
         if self is ModelType.GPT_3_5_TURBO:
             return 16385
-        elif self is ModelType.GPT_3_5_TURBO_16K:
-            return 16385
         elif self is ModelType.GPT_4:
             return 8192
         elif self is ModelType.GPT_4_32K:
@@ -89,6 +112,15 @@ 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}:
+            return 100_000
+        elif self in {
+            ModelType.CLAUDE_2_1,
+            ModelType.CLAUDE_3_OPUS,
+            ModelType.CLAUDE_3_SONNET,
+            ModelType.CLAUDE_3_HAIKU,
+        }:
+            return 200_000
         else:
             raise ValueError("Unknown model type")
 
@@ -107,8 +139,10 @@ class ModelType(Enum):
             pattern = r'^vicuna-\d+b-v\d+\.\d+-16k$'
             return bool(re.match(pattern, model_name))
         elif self is ModelType.LLAMA_2:
-            return (self.value in model_name.lower()
-                    or "llama2" in model_name.lower())
+            return (
+                self.value in model_name.lower()
+                or "llama2" in model_name.lower()
+            )
         else:
             return self.value in model_name.lower()
 
@@ -155,13 +189,21 @@ class TaskType(Enum):
     EVALUATION = "evaluation"
     SOLUTION_EXTRACTION = "solution_extraction"
     ROLE_DESCRIPTION = "role_description"
+    OBJECT_RECOGNITION = "object_recognition"
     DEFAULT = "default"
 
 
 class VectorDistance(Enum):
-    DOT = 1
-    COSINE = 2
-    EUCLIDEAN = 3
+    r"""Distance metrics used in a vector database."""
+
+    DOT = "dot"
+    r"""Dot product. https://en.wikipedia.org/wiki/Dot_product"""
+
+    COSINE = "cosine"
+    r"""Cosine similarity. https://en.wikipedia.org/wiki/Cosine_similarity"""
+
+    EUCLIDEAN = "euclidean"
+    r"""Euclidean distance. https://en.wikipedia.org/wiki/Euclidean_distance"""
 
 
 class OpenAIBackendRole(Enum):
@@ -174,3 +216,34 @@ class OpenAIBackendRole(Enum):
 class TerminationMode(Enum):
     ANY = "any"
     ALL = "all"
+
+
+class OpenAIImageTypeMeta(EnumMeta):
+    def __contains__(cls, image_type: object) -> bool:
+        try:
+            cls(image_type)
+        except ValueError:
+            return False
+        return True
+
+
+class OpenAIImageType(Enum, metaclass=OpenAIImageTypeMeta):
+    r"""Image types supported by OpenAI vision model."""
+
+    # https://platform.openai.com/docs/guides/vision
+    PNG = "png"
+    JPEG = "jpeg"
+    JPG = "jpg"
+    WEBP = "webp"
+    GIF = "gif"
+
+
+class OpenAIImageDetailType(Enum):
+    AUTO = "auto"
+    LOW = "low"
+    HIGH = "high"
+
+
+class StorageType(Enum):
+    MILVUS = "milvus"
+    QDRANT = "qdrant"

camel/types/openai_types.py

@@ -14,17 +14,22 @@
 # isort: skip_file
 from openai.types.chat.chat_completion import ChatCompletion, Choice
 from openai.types.chat.chat_completion_assistant_message_param import (
-    ChatCompletionAssistantMessageParam, )
+    ChatCompletionAssistantMessageParam,
+)
 from openai.types.chat.chat_completion_chunk import ChatCompletionChunk
 from openai.types.chat.chat_completion_function_message_param import (
-    ChatCompletionFunctionMessageParam, )
+    ChatCompletionFunctionMessageParam,
+)
 from openai.types.chat.chat_completion_message import ChatCompletionMessage
 from openai.types.chat.chat_completion_message_param import (
-    ChatCompletionMessageParam, )
+    ChatCompletionMessageParam,
+)
 from openai.types.chat.chat_completion_system_message_param import (
-    ChatCompletionSystemMessageParam, )
+    ChatCompletionSystemMessageParam,
+)
 from openai.types.chat.chat_completion_user_message_param import (
-    ChatCompletionUserMessageParam, )
+    ChatCompletionUserMessageParam,
+)
 from openai.types.completion_usage import CompletionUsage
 
 Choice = Choice

camel/utils/__init__.py

@@ -11,37 +11,42 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
-from .python_interpreter import PythonInterpreter
 from .commons import (
-    openai_api_key_required,
-    print_text_animated,
-    get_prompt_template_key_words,
-    get_first_int,
+    PYDANTIC_V2,
+    api_key_required,
+    check_server_running,
     download_tasks,
-    parse_doc,
+    get_first_int,
+    get_prompt_template_key_words,
+    get_system_information,
     get_task_list,
-    check_server_running,
+    print_text_animated,
+    role_playing_with_function,
+    to_pascal,
 )
 from .token_counting import (
-    get_model_encoding,
+    AnthropicTokenCounter,
     BaseTokenCounter,
     OpenAITokenCounter,
     OpenSourceTokenCounter,
+    get_model_encoding,
 )
 
 __all__ = [
-    'count_tokens_openai_chat_models',
-    'openai_api_key_required',
+    'api_key_required',
     'print_text_animated',
     'get_prompt_template_key_words',
     'get_first_int',
     'download_tasks',
-    'PythonInterpreter',
-    'parse_doc',
     'get_task_list',
-    'get_model_encoding',
     'check_server_running',
+    'AnthropicTokenCounter',
+    'get_system_information',
+    'to_pascal',
+    'PYDANTIC_V2',
+    'get_model_encoding',
     'BaseTokenCounter',
     'OpenAITokenCounter',
     'OpenSourceTokenCounter',
+    'role_playing_with_function',
 ]

camel/utils/commons.py

@@ -11,26 +11,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
-import inspect
 import os
+import platform
 import re
 import socket
 import time
 import zipfile
 from functools import wraps
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    List,
-    Optional,
-    Set,
-    Tuple,
-    TypeVar,
-    cast,
-)
+from typing import Any, Callable, List, Optional, Set, TypeVar, cast
 from urllib.parse import urlparse
 
+import pydantic
 import requests
 
 from camel.types import TaskType
@@ -38,7 +29,33 @@ from camel.types import TaskType
 F = TypeVar('F', bound=Callable[..., Any])
 
 
-def openai_api_key_required(func: F) -> F:
+# Set lazy import
+def get_lazy_imported_functions_module():
+    from camel.functions import (
+        MAP_FUNCS,
+        MATH_FUNCS,
+        SEARCH_FUNCS,
+        TWITTER_FUNCS,
+        WEATHER_FUNCS,
+    )
+
+    return [
+        *MATH_FUNCS,
+        *SEARCH_FUNCS,
+        *WEATHER_FUNCS,
+        *MAP_FUNCS,
+        *TWITTER_FUNCS,
+    ]
+
+
+# Set lazy import
+def get_lazy_imported_types_module():
+    from camel.types import ModelType
+
+    return ModelType.GPT_4_TURBO
+
+
+def api_key_required(func: F) -> F:
     r"""Decorator that checks if the OpenAI API key is available in the
     environment variables.
 
@@ -55,10 +72,16 @@ def openai_api_key_required(func: F) -> F:
 
     @wraps(func)
     def wrapper(self, *args, **kwargs):
-        if 'OPENAI_API_KEY' in os.environ:
+        if self.model_type.is_openai:
+            if 'OPENAI_API_KEY' not in os.environ:
+                raise ValueError('OpenAI API key not found.')
+            return func(self, *args, **kwargs)
+        elif self.model_type.is_anthropic:
+            if 'ANTHROPIC_API_KEY' not in os.environ:
+                raise ValueError('Anthropic API key not found.')
             return func(self, *args, **kwargs)
         else:
-            raise ValueError('OpenAI API key not found.')
+            raise ValueError('Unsupported model type.')
 
     return cast(F, wrapper)
 
@@ -116,12 +139,26 @@ def get_first_int(string: str) -> Optional[int]:
 
 
 def download_tasks(task: TaskType, folder_path: str) -> None:
+    r"""Downloads task-related files from a specified URL and extracts them.
+
+    This function downloads a zip file containing tasks based on the specified
+    `task` type from a predefined URL, saves it to `folder_path`, and then
+    extracts the contents of the zip file into the same folder. After
+    extraction, the zip file is deleted.
+
+    Args:
+        task (TaskType): An enum representing the type of task to download.
+        folder_path (str): The path of the folder where the zip file will be
+                           downloaded and extracted.
+    """
     # Define the path to save the zip file
     zip_file_path = os.path.join(folder_path, "tasks.zip")
 
     # Download the zip file from the Google Drive link
-    response = requests.get("https://huggingface.co/datasets/camel-ai/"
-                            f"metadata/resolve/main/{task.value}_tasks.zip")
+    response = requests.get(
+        "https://huggingface.co/datasets/camel-ai/"
+        f"metadata/resolve/main/{task.value}_tasks.zip"
+    )
 
     # Save the zip file
     with open(zip_file_path, "wb") as f:
@@ -134,70 +171,6 @@ def download_tasks(task: TaskType, folder_path: str) -> None:
     os.remove(zip_file_path)
 
 
-def parse_doc(func: Callable) -> Dict[str, Any]:
-    r"""Parse the docstrings of a function to extract the function name,
-    description and parameters.
-
-    Args:
-        func (Callable): The function to be parsed.
-    Returns:
-        Dict[str, Any]: A dictionary with the function's name,
-            description, and parameters.
-    """
-
-    doc = inspect.getdoc(func)
-    if not doc:
-        raise ValueError(
-            f"Invalid function {func.__name__}: no docstring provided.")
-
-    properties = {}
-    required = []
-
-    parts = re.split(r'\n\s*\n', doc)
-    func_desc = parts[0].strip()
-
-    args_section = next((p for p in parts if 'Args:' in p), None)
-    if args_section:
-        args_descs: List[Tuple[str, str, str, ]] = re.findall(
-            r'(\w+)\s*\((\w+)\):\s*(.*)', args_section)
-        properties = {
-            name.strip(): {
-                'type': type,
-                'description': desc
-            }
-            for name, type, desc in args_descs
-        }
-        for name in properties:
-            required.append(name)
-
-    # Parameters from the function signature
-    sign_params = list(inspect.signature(func).parameters.keys())
-    if len(sign_params) != len(required):
-        raise ValueError(
-            f"Number of parameters in function signature ({len(sign_params)})"
-            f" does not match that in docstring ({len(required)}).")
-
-    for param in sign_params:
-        if param not in required:
-            raise ValueError(f"Parameter '{param}' in function signature"
-                             " is missing in the docstring.")
-
-    parameters = {
-        "type": "object",
-        "properties": properties,
-        "required": required,
-    }
-
-    # Construct the function dictionary
-    function_dict = {
-        "name": func.__name__,
-        "description": func_desc,
-        "parameters": parameters,
-    }
-
-    return function_dict
-
-
 def get_task_list(task_response: str) -> List[str]:
     r"""Parse the response of the Agent and return task list.
 
@@ -241,3 +214,191 @@ def check_server_running(server_url: str) -> bool:
 
     # if the port is open, the result should be 0.
     return result == 0
+
+
+def get_system_information():
+    r"""Gathers information about the operating system.
+
+    Returns:
+        dict: A dictionary containing various pieces of OS information.
+    """
+    sys_info = {
+        "OS Name": os.name,
+        "System": platform.system(),
+        "Release": platform.release(),
+        "Version": platform.version(),
+        "Machine": platform.machine(),
+        "Processor": platform.processor(),
+        "Platform": platform.platform(),
+    }
+
+    return sys_info
+
+
+def to_pascal(snake: str) -> str:
+    """Convert a snake_case string to PascalCase.
+
+    Args:
+        snake (str): The snake_case string to be converted.
+
+    Returns:
+        str: The converted PascalCase string.
+    """
+    # Check if the string is already in PascalCase
+    if re.match(r'^[A-Z][a-zA-Z0-9]*([A-Z][a-zA-Z0-9]*)*$', snake):
+        return snake
+    # Remove leading and trailing underscores
+    snake = snake.strip('_')
+    # Replace multiple underscores with a single one
+    snake = re.sub('_+', '_', snake)
+    # Convert to PascalCase
+    return re.sub(
+        '_([0-9A-Za-z])',
+        lambda m: m.group(1).upper(),
+        snake.title(),
+    )
+
+
+PYDANTIC_V2 = pydantic.VERSION.startswith("2.")
+
+
+def role_playing_with_function(
+    task_prompt: str = (
+        "Assume now is 2024 in the Gregorian calendar, "
+        "estimate the current age of University of Oxford "
+        "and then add 10 more years to this age, "
+        "and get the current weather of the city where "
+        "the University is located. And tell me what time "
+        "zone University of Oxford is in. And use my twitter "
+        "account infomation to create a tweet. "
+    ),
+    function_list: Optional[List] = None,
+    model_type=None,
+    chat_turn_limit=10,
+    assistant_role_name: str = "Searcher",
+    user_role_name: str = "Professor",
+) -> None:
+    r"""Initializes and conducts a `RolePlaying` with `FunctionCallingConfig`
+    session. The function creates an interactive and dynamic role-play session
+    where the AI Assistant and User engage based on the given task, roles, and
+    available functions. It demonstrates the versatility of AI in handling
+    diverse tasks and user interactions within a structured `RolePlaying`
+    framework.
+
+    Args:
+        task_prompt (str): The initial task or scenario description to start
+            the `RolePlaying` session. Defaults to a prompt involving the
+            estimation of KAUST's age and weather information.
+        function_list (list): A list of functions that the agent can utilize
+            during the session. Defaults to a combination of math, search, and
+            weather functions.
+        model_type (ModelType): The type of chatbot model used for both the
+            assistant and the user. Defaults to `GPT-4 Turbo`.
+        chat_turn_limit (int): The maximum number of turns (exchanges) in the
+            chat session. Defaults to 10.
+        assistant_role_name (str): The role name assigned to the AI Assistant.
+            Defaults to 'Searcher'.
+        user_role_name (str): The role name assigned to the User. Defaults to
+            'Professor'.
+
+    Returns:
+        None: This function does not return any value but prints out the
+            session's dialogues and outputs.
+    """
+
+    # Run lazy import
+    if function_list is None:
+        function_list = get_lazy_imported_functions_module()
+    if model_type is None:
+        model_type = get_lazy_imported_types_module()
+
+    from colorama import Fore
+
+    from camel.agents.chat_agent import FunctionCallingRecord
+    from camel.configs import ChatGPTConfig, FunctionCallingConfig
+    from camel.societies import RolePlaying
+
+    task_prompt = task_prompt
+    user_model_config = ChatGPTConfig(temperature=0.0)
+
+    function_list = function_list
+    assistant_model_config = FunctionCallingConfig.from_openai_function_list(
+        function_list=function_list,
+        kwargs=dict(temperature=0.0),
+    )
+
+    role_play_session = RolePlaying(
+        assistant_role_name=assistant_role_name,
+        user_role_name=user_role_name,
+        assistant_agent_kwargs=dict(
+            model_type=model_type,
+            model_config=assistant_model_config,
+            function_list=function_list,
+        ),
+        user_agent_kwargs=dict(
+            model_type=model_type,
+            model_config=user_model_config,
+        ),
+        task_prompt=task_prompt,
+        with_task_specify=False,
+    )
+
+    print(
+        Fore.GREEN
+        + f"AI Assistant sys message:\n{role_play_session.assistant_sys_msg}\n"
+    )
+    print(
+        Fore.BLUE + f"AI User sys message:\n{role_play_session.user_sys_msg}\n"
+    )
+
+    print(Fore.YELLOW + f"Original task prompt:\n{task_prompt}\n")
+    print(
+        Fore.CYAN
+        + f"Specified task prompt:\n{role_play_session.specified_task_prompt}\n"
+    )
+    print(Fore.RED + f"Final task prompt:\n{role_play_session.task_prompt}\n")
+
+    n = 0
+    input_msg = role_play_session.init_chat()
+    while n < chat_turn_limit:
+        n += 1
+        assistant_response, user_response = role_play_session.step(input_msg)
+
+        if assistant_response.terminated:
+            print(
+                Fore.GREEN
+                + (
+                    "AI Assistant terminated. Reason: "
+                    f"{assistant_response.info['termination_reasons']}."
+                )
+            )
+            break
+        if user_response.terminated:
+            print(
+                Fore.GREEN
+                + (
+                    "AI User terminated. "
+                    f"Reason: {user_response.info['termination_reasons']}."
+                )
+            )
+            break
+
+        # Print output from the user
+        print_text_animated(
+            Fore.BLUE + f"AI User:\n\n{user_response.msg.content}\n"
+        )
+
+        # Print output from the assistant, including any function
+        # execution information
+        print_text_animated(Fore.GREEN + "AI Assistant:")
+        called_functions: List[FunctionCallingRecord] = assistant_response.info[
+            'called_functions'
+        ]
+        for func_record in called_functions:
+            print_text_animated(f"{func_record}")
+        print_text_animated(f"{assistant_response.msg.content}\n")
+
+        if "CAMEL_TASK_DONE" in user_response.msg.content:
+            break
+
+        input_msg = assistant_response.msg