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

camel/toolkits/github_toolkit.py

@@ -0,0 +1,245 @@
+# =========== 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. ===========
+
+import os
+from dataclasses import dataclass
+from typing import List, Optional
+
+from camel.functions import OpenAIFunction
+
+from .base import BaseToolkit
+
+
+@dataclass
+class GithubIssue:
+    r"""Represents a GitHub issue.
+
+    Attributes:
+        title (str): The title of the issue.
+        body (str): The body/content of the issue.
+        number (int): The issue number.
+        file_path (str): The path of the file associated with the issue.
+        file_content (str): The content of the file associated with the issue.
+    """
+
+    def __init__(
+        self,
+        title: str,
+        body: str,
+        number: int,
+        file_path: str,
+        file_content: str,
+    ) -> None:
+        r"""Initialize a GithubIssue object.
+
+        Args:
+            title (str): The title of the GitHub issue.
+            body (str): The body/content of the GitHub issue.
+            number (int): The issue number.
+            file_path (str): The path of the file associated with the issue.
+            file_content (str): The content of the file associated with the issue.
+        """
+        self.title = title
+        self.body = body
+        self.number = number
+        self.file_path = file_path
+        self.file_content = file_content
+
+    def summary(self) -> str:
+        r"""Returns a summary of the issue.
+
+        Returns:
+            str: A string containing the title, body, number, file path, and file content of the issue.
+        """
+        return (
+            f"Title: {self.title}\n"
+            f"Body: {self.body}\n"
+            f"Number: {self.number}\n"
+            f"File Path: {self.file_path}\n"
+            f"File Content: {self.file_content}"
+        )
+
+
+class GithubToolkit(BaseToolkit):
+    r"""A class representing a toolkit for interacting with GitHub repositories.
+
+    This class provides methods for retrieving open issues, retrieving specific issues,
+    and creating pull requests in a GitHub repository.
+
+    Args:
+        repo_name (str): The name of the GitHub repository.
+        access_token (str, optional): The access token to authenticate with GitHub.
+            If not provided, it will be obtained using the `get_github_access_token` method.
+    """
+
+    def __init__(
+        self, repo_name: str, access_token: Optional[str] = None
+    ) -> None:
+        r"""Initializes a new instance of the GitHubToolkit class.
+
+        Args:
+            repo_name (str): The name of the GitHub repository.
+            access_token (str, optional): The access token to authenticate with GitHub.
+                If not provided, it will be obtained using the `get_github_access_token` method.
+        """
+        if access_token is None:
+            access_token = self.get_github_access_token()
+
+        try:
+            from github import Auth, Github
+        except ImportError:
+            raise ImportError(
+                "Please install `github` first. You can install it by running "
+                "`pip install wikipedia`."
+            )
+        self.github = Github(auth=Auth.Token(access_token))
+        self.repo = self.github.get_repo(repo_name)
+
+    def get_tools(self) -> List[OpenAIFunction]:
+        r"""Returns a list of OpenAIFunction objects representing the functions in the toolkit.
+
+        Returns:
+            List[OpenAIFunction]: A list of OpenAIFunction objects representing the functions in the toolkit.
+        """
+        return [
+            OpenAIFunction(self.retrieve_issue_list),
+            OpenAIFunction(self.retrieve_issue),
+            OpenAIFunction(self.create_pull_request),
+        ]
+
+    def get_github_access_token(self) -> str:
+        r"""Retrieve the GitHub access token from environment variables.
+
+        Returns:
+            str: A string containing the GitHub access token.
+
+        Raises:
+            ValueError: If the API key or secret is not found in the environment variables.
+        """
+        # Get `GITHUB_ACCESS_TOKEN` here: https://github.com/settings/tokens
+        GITHUB_ACCESS_TOKEN = os.environ.get("GITHUB_ACCESS_TOKEN")
+
+        if not GITHUB_ACCESS_TOKEN:
+            raise ValueError(
+                "`GITHUB_ACCESS_TOKEN` not found in environment variables. Get it "
+                "here: `https://github.com/settings/tokens`."
+            )
+        return GITHUB_ACCESS_TOKEN
+
+    def retrieve_issue_list(self) -> List[GithubIssue]:
+        r"""Retrieve a list of open issues from the repository.
+
+        Returns:
+            A list of GithubIssue objects representing the open issues.
+        """
+        issues = self.repo.get_issues(state='open')
+        return [
+            GithubIssue(
+                title=issue.title,
+                body=issue.body,
+                number=issue.number,
+                file_path=issue.labels[
+                    0
+                ].name,  # for now we require file path to be the first label in the PR
+                file_content=self.retrieve_file_content(issue.labels[0].name),
+            )
+            for issue in issues
+            if not issue.pull_request
+        ]
+
+    def retrieve_issue(self, issue_number: int) -> Optional[str]:
+        r"""Retrieves an issue from a GitHub repository.
+
+        This function retrieves an issue from a specified repository using the
+        issue number.
+
+        Args:
+            issue_number (int): The number of the issue to retrieve.
+
+        Returns:
+            str: A formatted report of the retrieved issue.
+        """
+        issues = self.retrieve_issue_list()
+        for issue in issues:
+            if issue.number == issue_number:
+                return issue.summary()
+        return None
+
+    def create_pull_request(
+        self,
+        file_path: str,
+        new_content: str,
+        pr_title: str,
+        body: str,
+        branch_name: str,
+    ) -> str:
+        r"""Creates a pull request.
+
+        This function creates a pull request in specified repository, which updates a
+        file in the specific path with new content. The pull request description
+        contains information about the issue title and number.
+
+        Args:
+            file_path (str): The path of the file to be updated in the repository.
+            new_content (str): The specified new content of the specified file.
+            pr_title (str): The title of the issue that is solved by this pull request.
+            body (str): The commit message for the pull request.
+            branch_name (str): The name of the branch to create and submit the pull request from.
+
+        Returns:
+            str: A formatted report of whether the pull request was created successfully or not.
+        """
+        sb = self.repo.get_branch(self.repo.default_branch)
+        self.repo.create_git_ref(
+            ref=f"refs/heads/{branch_name}", sha=sb.commit.sha
+        )
+
+        file = self.repo.get_contents(file_path)
+        from github.ContentFile import ContentFile
+
+        if isinstance(file, ContentFile):
+            self.repo.update_file(
+                file.path, body, new_content, file.sha, branch=branch_name
+            )
+            pr = self.repo.create_pull(
+                title=pr_title,
+                body=body,
+                head=branch_name,
+                base=self.repo.default_branch,
+            )
+
+            if pr is not None:
+                return f"Title: {pr.title}\n" f"Body: {pr.body}\n"
+            else:
+                return "Failed to create pull request."
+        else:
+            raise ValueError("PRs with multiple files aren't supported yet.")
+
+    def retrieve_file_content(self, file_path: str) -> str:
+        r"""Retrieves the content of a file from the GitHub repository.
+
+        Args:
+            file_path (str): The path of the file to retrieve.
+
+        Returns:
+            str: The decoded content of the file.
+        """
+        file_content = self.repo.get_contents(file_path)
+
+        from github.ContentFile import ContentFile
+
+        if isinstance(file_content, ContentFile):
+            return file_content.decoded_content.decode()
+        else:
+            raise ValueError("PRs with multiple files aren't supported yet.")

camel/types/__init__.py

@@ -12,24 +12,30 @@
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from .enums import (
-    RoleType,
+    AudioModelType,
+    EmbeddingModelType,
     ModelType,
+    OpenAIBackendRole,
+    OpenAIImageDetailType,
+    OpenAIImageType,
+    OpenAPIName,
+    RoleType,
+    StorageType,
     TaskType,
     TerminationMode,
-    OpenAIBackendRole,
-    EmbeddingModelType,
     VectorDistance,
+    VoiceType,
 )
 from .openai_types import (
-    Choice,
     ChatCompletion,
+    ChatCompletionAssistantMessageParam,
     ChatCompletionChunk,
+    ChatCompletionFunctionMessageParam,
     ChatCompletionMessage,
     ChatCompletionMessageParam,
     ChatCompletionSystemMessageParam,
     ChatCompletionUserMessageParam,
-    ChatCompletionAssistantMessageParam,
-    ChatCompletionFunctionMessageParam,
+    Choice,
     CompletionUsage,
 )
 
@@ -41,6 +47,7 @@ __all__ = [
     'OpenAIBackendRole',
     'EmbeddingModelType',
     'VectorDistance',
+    'StorageType',
     'Choice',
     'ChatCompletion',
     'ChatCompletionChunk',
@@ -51,4 +58,9 @@ __all__ = [
     'ChatCompletionAssistantMessageParam',
     'ChatCompletionFunctionMessageParam',
     'CompletionUsage',
+    'OpenAIImageType',
+    'OpenAIImageDetailType',
+    'OpenAPIName',
+    'AudioModelType',
+    'VoiceType',
 ]

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_4O = "gpt-4o"
 
     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,11 +56,10 @@ 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,
-            ModelType.GPT_4_TURBO_VISION,
+            ModelType.GPT_4O,
         }
 
     @property
@@ -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,15 +95,13 @@ 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:
             return 32768
         elif self is ModelType.GPT_4_TURBO:
             return 128000
-        elif self is ModelType.GPT_4_TURBO_VISION:
+        elif self is ModelType.GPT_4O:
             return 128000
         elif self is ModelType.STUB:
             return 4096
@@ -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,75 @@ 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"
+
+
+class OpenAPIName(Enum):
+    COURSERA = "coursera"
+    KLARNA = "klarna"
+    SPEAK = "speak"
+
+
+class AudioModelType(Enum):
+    TTS_1 = "tts-1"
+    TTS_1_HD = "tts-1-hd"
+
+    @property
+    def is_openai(self) -> bool:
+        r"""Returns whether this type of audio models is an OpenAI-released
+        model."""
+        return self in {
+            AudioModelType.TTS_1,
+            AudioModelType.TTS_1_HD,
+        }
+
+
+class VoiceType(Enum):
+    ALLOY = "alloy"
+    ECHO = "echo"
+    FABLE = "fable"
+    ONYX = "onyx"
+    NOVA = "nova"
+    SHIMMER = "shimmer"
+
+    @property
+    def is_openai(self) -> bool:
+        r"""Returns whether this type of voice is an OpenAI-released voice."""
+        return self in {
+            VoiceType.ALLOY,
+            VoiceType.ECHO,
+            VoiceType.FABLE,
+            VoiceType.ONYX,
+            VoiceType.NOVA,
+            VoiceType.SHIMMER,
+        }

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,44 @@
 # 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,
+    api_keys_required,
+    check_server_running,
+    dependencies_required,
     download_tasks,
-    parse_doc,
+    get_first_int,
+    get_prompt_template_key_words,
+    get_system_information,
     get_task_list,
-    check_server_running,
+    print_text_animated,
+    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',
+    'dependencies_required',
+    'api_keys_required',
 ]