camel-ai 0.1.5.9__py3-none-any.whl → 0.1.6.1__py3-none-any.whl

camel/toolkits/dalle_toolkit.py

@@ -0,0 +1,146 @@
+# =========== 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 base64
+import os
+import uuid
+from io import BytesIO
+from typing import List, Optional
+
+from openai import OpenAI
+from PIL import Image
+
+from camel.toolkits import OpenAIFunction
+from camel.toolkits.base import BaseToolkit
+
+
+class DalleToolkit(BaseToolkit):
+    r"""A class representing a toolkit for image generation using OpenAI's.
+
+    This class provides methods handle image generation using OpenAI's DALL-E.
+    """
+
+    def base64_to_image(self, base64_string: str) -> Optional[Image.Image]:
+        r"""Converts a base64 encoded string into a PIL Image object.
+
+        Args:
+            base64_string (str): The base64 encoded string of the image.
+
+        Returns:
+            Optional[Image.Image]: The PIL Image object or None if conversion
+                fails.
+        """
+        try:
+            # Decode the base64 string to get the image data
+            image_data = base64.b64decode(base64_string)
+            # Create a memory buffer for the image data
+            image_buffer = BytesIO(image_data)
+            # Open the image using the PIL library
+            image = Image.open(image_buffer)
+            return image
+        except Exception as e:
+            print(f"An error occurred while converting base64 to image: {e}")
+            return None
+
+    def image_path_to_base64(self, image_path: str) -> str:
+        r"""Converts the file path of an image to a Base64 encoded string.
+
+        Args:
+            image_path (str): The path to the image file.
+
+        Returns:
+            str: A Base64 encoded string representing the content of the image
+                file.
+        """
+        try:
+            with open(image_path, "rb") as image_file:
+                return base64.b64encode(image_file.read()).decode('utf-8')
+        except Exception as e:
+            print(
+                f"An error occurred while converting image path to base64: {e}"
+            )
+            return ""
+
+    def image_to_base64(self, image: Image.Image) -> str:
+        r"""Converts an image into a base64-encoded string.
+
+        This function takes an image object as input, encodes the image into a
+        PNG format base64 string, and returns it.
+        If the encoding process encounters an error, it prints the error
+        message and returns None.
+
+        Args:
+            image: The image object to be encoded, supports any image format
+                that can be saved in PNG format.
+
+        Returns:
+            str: A base64-encoded string of the image.
+        """
+        try:
+            with BytesIO() as buffered_image:
+                image.save(buffered_image, format="PNG")
+                buffered_image.seek(0)
+                image_bytes = buffered_image.read()
+                base64_str = base64.b64encode(image_bytes).decode('utf-8')
+                return base64_str
+        except Exception as e:
+            print(f"An error occurred: {e}")
+            return ""
+
+    def get_dalle_img(self, prompt: str, image_dir: str = "img") -> str:
+        r"""Generate an image using OpenAI's DALL-E model.
+            The generated image is saved to the specified directory.
+
+        Args:
+            prompt (str): The text prompt based on which the image is
+                generated.
+            image_dir (str): The directory to save the generated image.
+                Defaults to 'img'.
+
+        Returns:
+            str: The path to the saved image.
+        """
+
+        dalle_client = OpenAI()
+        response = dalle_client.images.generate(
+            model="dall-e-3",
+            prompt=prompt,
+            size="1024x1792",
+            quality="standard",
+            n=1,  # NOTE: now dall-e-3 only supports n=1
+            response_format="b64_json",
+        )
+        image_b64 = response.data[0].b64_json
+        image = self.base64_to_image(image_b64)  # type: ignore[arg-type]
+
+        if image is None:
+            raise ValueError("Failed to convert base64 string to image.")
+
+        os.makedirs(image_dir, exist_ok=True)
+        image_path = os.path.join(image_dir, f"{uuid.uuid4()}.png")
+        image.save(image_path)
+
+        return image_path
+
+    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.get_dalle_img)]
+
+
+DALLE_FUNCS: List[OpenAIFunction] = DalleToolkit().get_tools()

camel/toolkits/github_toolkit.py

@@ -13,18 +13,18 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 
 import os
-from dataclasses import dataclass
 from datetime import datetime, timedelta
 from typing import List, Optional
 
+from pydantic import BaseModel
+
 from camel.utils import dependencies_required
 
 from .base import BaseToolkit
 from .openai_function import OpenAIFunction
 
 
-@dataclass
-class GithubIssue:
+class GithubIssue(BaseModel):
     r"""Represents a GitHub issue.
 
     Attributes:
@@ -35,29 +35,11 @@ class GithubIssue:
         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
+    title: str
+    body: str
+    number: int
+    file_path: str
+    file_content: str
 
     def __str__(self) -> str:
         r"""Returns a string representation of the issue.
@@ -75,8 +57,7 @@ class GithubIssue:
         )
 
 
-@dataclass
-class GithubPullRequestDiff:
+class GithubPullRequestDiff(BaseModel):
     r"""Represents a single diff of a pull request on Github.
 
     Attributes:
@@ -92,8 +73,7 @@ class GithubPullRequestDiff:
         return f"Filename: {self.filename}\nPatch: {self.patch}"
 
 
-@dataclass
-class GithubPullRequest:
+class GithubPullRequest(BaseModel):
     r"""Represents a pull request on Github.
 
     Attributes:
@@ -251,13 +231,17 @@ class GithubToolkit(BaseToolkit):
                 and pr.merged_at is not None
                 and pr.merged_at.timestamp() > earliest_date.timestamp()
             ):
-                pr_details = GithubPullRequest(pr.title, pr.body, [])
+                pr_details = GithubPullRequest(
+                    title=pr.title, body=pr.body, diffs=[]
+                )
 
                 # Get files changed in the PR
                 files = pr.get_files()
 
                 for file in files:
-                    diff = GithubPullRequestDiff(file.filename, file.patch)
+                    diff = GithubPullRequestDiff(
+                        filename=file.filename, patch=file.patch
+                    )
                     pr_details.diffs.append(diff)
 
                 merged_prs.append(str(pr_details))

camel/toolkits/google_maps_toolkit.py

@@ -36,7 +36,8 @@ def handle_googlemaps_exceptions(
     @wraps(func)
     def wrapper(*args: Any, **kwargs: Any) -> Any:
         try:
-            from googlemaps.exceptions import (  # type: ignore[import-untyped]  # isort: skip
+            # ruff: noqa: E501
+            from googlemaps.exceptions import (  # type: ignore[import]
                 ApiError,
                 HTTPError,
                 Timeout,

camel/toolkits/open_api_toolkit.py

@@ -18,11 +18,10 @@ from typing import Any, Callable, Dict, List, Optional, Tuple
 import requests
 
 from camel.toolkits import OpenAIFunction, openapi_security_config
-from camel.toolkits.base import BaseToolkit
 from camel.types import OpenAPIName
 
 
-class OpenAPIToolkit(BaseToolkit):
+class OpenAPIToolkit:
     r"""A class representing a toolkit for interacting with OpenAPI APIs.
 
     This class provides methods for interacting with APIs based on OpenAPI

camel/toolkits/openai_function.py

@@ -20,7 +20,7 @@ from jsonschema.validators import Draft202012Validator as JSONValidator
 from pydantic import create_model
 from pydantic.fields import FieldInfo
 
-from camel.utils import PYDANTIC_V2, to_pascal
+from camel.utils import get_pydantic_object_schema, to_pascal
 
 
 def _remove_a_key(d: Dict, remove_key: Any) -> None:
@@ -110,12 +110,7 @@ def get_openai_tool_schema(func: Callable) -> Dict[str, Any]:
         return create_model(name, **field)
 
     model = _create_mol(to_pascal(func.__name__), fields)
-    # NOTE: Method `.schema()` is deprecated in pydantic v2.
-    # the result would be identical to `.model_json_schema()` in v2
-    if PYDANTIC_V2:
-        parameters_dict = model.model_json_schema()
-    else:
-        parameters_dict = model.schema()
+    parameters_dict = get_pydantic_object_schema(model)
     # The `"title"` is generated by `model.model_json_schema()`
     # but is useless for openai json schema
     _remove_a_key(parameters_dict, "title")

camel/types/enums.py

@@ -208,7 +208,6 @@ class ModelType(Enum):
             # reference: https://lmsys.org/blog/2023-03-30-vicuna/
             return 2048
         elif self in {
-            ModelType.GPT_3_5_TURBO,
             ModelType.LLAMA_2,
             ModelType.NEMOTRON_4_REWARD,
             ModelType.STUB,
@@ -226,7 +225,10 @@ class ModelType(Enum):
             ModelType.GLM_4_OPEN_SOURCE,
         }:
             return 8_192
-        elif self is ModelType.VICUNA_16K:
+        elif self in {
+            ModelType.GPT_3_5_TURBO,
+            ModelType.VICUNA_16K,
+        }:
             return 16_384
         elif self in {
             ModelType.GPT_4_32K,
@@ -359,6 +361,8 @@ class TaskType(Enum):
     ROLE_DESCRIPTION = "role_description"
     GENERATE_TEXT_EMBEDDING_DATA = "generate_text_embedding_data"
     OBJECT_RECOGNITION = "object_recognition"
+    IMAGE_CRAFT = "image_craft"
+    MULTI_CONDITION_IMAGE_CRAFT = "multi_condition_image_craft"
     DEFAULT = "default"
     VIDEO_DESCRIPTION = "video_description"
 

camel/utils/__init__.py

@@ -13,17 +13,22 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 
 from .commons import (
-    PYDANTIC_V2,
+    AgentOpsMeta,
+    agentops_decorator,
     api_keys_required,
     check_server_running,
     create_chunks,
     dependencies_required,
     download_tasks,
+    func_string_to_callable,
     get_first_int,
     get_prompt_template_key_words,
+    get_pydantic_major_version,
+    get_pydantic_object_schema,
     get_system_information,
     get_task_list,
     is_docker_running,
+    json_to_function_code,
     print_text_animated,
     text_extract_from_web,
     to_pascal,
@@ -50,7 +55,6 @@ __all__ = [
     'AnthropicTokenCounter',
     'get_system_information',
     'to_pascal',
-    'PYDANTIC_V2',
     'get_model_encoding',
     'BaseTokenCounter',
     'OpenAITokenCounter',
@@ -64,4 +68,10 @@ __all__ = [
     'is_docker_running',
     'GeminiTokenCounter',
     'MistralTokenCounter',
+    'get_pydantic_major_version',
+    'get_pydantic_object_schema',
+    'func_string_to_callable',
+    'json_to_function_code',
+    'agentops_decorator',
+    'AgentOpsMeta',
 ]

camel/utils/commons.py

@@ -20,14 +20,27 @@ import subprocess
 import time
 import zipfile
 from functools import wraps
-from typing import Any, Callable, List, Optional, Set, TypeVar, cast
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+    Mapping,
+    Optional,
+    Set,
+    TypeVar,
+    cast,
+)
 from urllib.parse import urlparse
 
 import pydantic
 import requests
+from pydantic import BaseModel
 
 from camel.types import TaskType
 
+from .constants import Constants
+
 F = TypeVar('F', bound=Callable[..., Any])
 
 
@@ -303,7 +316,97 @@ def to_pascal(snake: str) -> str:
     )
 
 
-PYDANTIC_V2 = pydantic.VERSION.startswith("2.")
+def get_pydantic_major_version() -> int:
+    r"""Get the major version of Pydantic.
+
+    Returns:
+        int: The major version number of Pydantic if installed, otherwise 0.
+    """
+    try:
+        return int(pydantic.__version__.split(".")[0])
+    except ImportError:
+        return 0
+
+
+def get_pydantic_object_schema(pydantic_params: BaseModel) -> Dict:
+    r"""Get the JSON schema of a Pydantic model.
+
+    Args:
+        pydantic_params (BaseModel): The Pydantic model to retrieve the schema
+            for.
+
+    Returns:
+        dict: The JSON schema of the Pydantic model.
+    """
+    return pydantic_params.model_json_schema()
+
+
+def func_string_to_callable(code: str):
+    r"""Convert a function code string to a callable function object.
+
+    Args:
+        code (str): The function code as a string.
+
+    Returns:
+        Callable[..., Any]: The callable function object extracted from the
+            code string.
+    """
+    local_vars: Mapping[str, object] = {}
+    exec(code, globals(), local_vars)
+    func = local_vars.get(Constants.FUNC_NAME_FOR_STRUCTURE_OUTPUT)
+    return func
+
+
+def json_to_function_code(json_obj: Dict) -> str:
+    r"""Generate a Python function code from a JSON schema.
+
+    Args:
+        json_obj (dict): The JSON schema object containing properties and
+            required fields, and json format is follow openai tools schema
+
+    Returns:
+        str: The generated Python function code as a string.
+    """
+    properties = json_obj.get('properties', {})
+    required = json_obj.get('required', [])
+
+    if not properties or not required:
+        raise ValueError(
+            "JSON schema must contain 'properties' and 'required' fields"
+        )
+
+    args = []
+    docstring_args = []
+    return_keys = []
+
+    for prop in required:
+        description = properties[prop]['description']
+        prop_type = properties[prop]['type']
+        python_type = 'str' if prop_type == 'string' else prop_type
+        args.append(f"{prop}: {python_type}")
+        docstring_args.append(
+            f"        {prop} ({python_type}): {description}."
+        )
+        return_keys.append(prop)
+
+    # extract entity of schema
+    args_str = ", ".join(args)
+    docstring_args_str = "\n".join(docstring_args)
+    return_keys_str = ", ".join(return_keys)
+
+    # function template
+    function_code = f'''
+def {Constants.FUNC_NAME_FOR_STRUCTURE_OUTPUT}({args_str}):
+    r"""Return response with a specified json format.
+    Args:
+{docstring_args_str}
+    Returns:
+        Dict: A dictionary containing {return_keys_str}.
+    """
+    return {{{", ".join([f'"{prop}": {prop}' for prop in required])}}}
+    '''
+
+    return function_code
 
 
 def text_extract_from_web(url: str) -> str:
@@ -382,3 +485,50 @@ def is_docker_running() -> bool:
         return result.returncode == 0
     except (subprocess.CalledProcessError, FileNotFoundError):
         return False
+
+
+try:
+    from agentops import ToolEvent, record
+except ImportError:
+    ToolEvent = None
+
+
+def agentops_decorator(func):
+    r"""Decorator that records the execution of a function if ToolEvent is
+    available.
+
+    Parameters:
+        func (callable): The function to be decorated.
+
+    Returns:
+        callable: The wrapped function which records its execution details.
+    """
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        if ToolEvent:
+            tool_event = ToolEvent(name=func.__name__, params=kwargs)
+            result = func(*args, **kwargs)
+            tool_event.returns = result
+            record(tool_event)
+            return result
+        return func(*args, **kwargs)
+
+    return wrapper
+
+
+class AgentOpsMeta(type):
+    r"""Metaclass that automatically decorates all callable attributes with
+    the agentops_decorator,
+    except for the 'get_tools' method.
+
+    Methods:
+    __new__(cls, name, bases, dct):
+        Creates a new class with decorated methods.
+    """
+
+    def __new__(cls, name, bases, dct):
+        for attr, value in dct.items():
+            if callable(value) and attr != 'get_tools':
+                dct[attr] = agentops_decorator(value)
+        return super(AgentOpsMeta, cls).__new__(cls, name, bases, dct)

camel/utils/constants.py

@@ -24,3 +24,6 @@ class Constants:
 
     # default plug of imageio to read video
     VIDEO_DEFAULT_PLUG_PYAV = "pyav"
+
+    # return response with json format
+    FUNC_NAME_FOR_STRUCTURE_OUTPUT = "return_json_response"

camel/workforce/__init__.py

@@ -0,0 +1,23 @@
+# =========== 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. ===========
+
+from .base import BaseNode
+from .manager_node import ManagerNode
+from .worker_node import WorkerNode
+
+__all__ = [
+    "BaseNode",
+    "WorkerNode",
+    "ManagerNode",
+]

camel/workforce/base.py

@@ -0,0 +1,50 @@
+# =========== 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. ===========
+from abc import ABC, abstractmethod
+from typing import Any
+
+from camel.workforce.task_channel import TaskChannel
+
+
+class BaseNode(ABC):
+    def __init__(self, description: str) -> None:
+        self.node_id = str(id(self))
+        self.description = description
+        # every node is initialized to use its own channel
+        self._channel: TaskChannel = TaskChannel()
+        self._running = False
+
+    def reset(self, *args: Any, **kwargs: Any) -> Any:
+        """Resets the node to its initial state."""
+        raise NotImplementedError()
+
+    @abstractmethod
+    def set_channel(self, channel: TaskChannel):
+        r"""Sets the channel for the node."""
+
+    @abstractmethod
+    async def _listen_to_channel(self):
+        r"""Listens to the channel and handle tasks. This method should be
+        the main loop for the node.
+        """
+
+    @abstractmethod
+    async def start(self):
+        r"""Start the node."""
+
+    @abstractmethod
+    def stop(self):
+        r"""
+        Stop the node.
+        """