camel-ai 0.2.10__py3-none-any.whl → 0.2.11__py3-none-any.whl

camel/toolkits/code_execution.py

@@ -11,9 +11,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
-from typing import List, Literal, Optional
+from typing import List, Literal, Optional, Union
 
-from camel.interpreters import InternalPythonInterpreter
+from camel.interpreters import (
+    DockerInterpreter,
+    InternalPythonInterpreter,
+    JupyterKernelInterpreter,
+    SubprocessInterpreter,
+)
 from camel.toolkits import FunctionTool
 from camel.toolkits.base import BaseToolkit
 
@@ -29,26 +34,55 @@ class CodeExecutionToolkit(BaseToolkit):
             by `eval()` without any security check. (default: :obj:`False`)
         import_white_list ( Optional[List[str]]): A list of allowed imports.
             (default: :obj:`None`)
+        require_confirm (bool): Whether to require confirmation before executing code.
+            (default: :obj:`False`)
     """
 
     def __init__(
         self,
         sandbox: Literal[
-            "internal_python", "jupyter", "docker"
+            "internal_python", "jupyter", "docker", "subprocess"
         ] = "internal_python",
         verbose: bool = False,
         unsafe_mode: bool = False,
         import_white_list: Optional[List[str]] = None,
+        require_confirm: bool = False,
     ) -> None:
-        # TODO: Add support for docker and jupyter.
         self.verbose = verbose
         self.unsafe_mode = unsafe_mode
         self.import_white_list = import_white_list or list()
+
+        # Type annotation for interpreter to allow all possible types
+        self.interpreter: Union[
+            InternalPythonInterpreter,
+            JupyterKernelInterpreter,
+            DockerInterpreter,
+            SubprocessInterpreter,
+        ]
+
         if sandbox == "internal_python":
             self.interpreter = InternalPythonInterpreter(
                 unsafe_mode=self.unsafe_mode,
                 import_white_list=self.import_white_list,
             )
+        elif sandbox == "jupyter":
+            self.interpreter = JupyterKernelInterpreter(
+                require_confirm=require_confirm,
+                print_stdout=self.verbose,
+                print_stderr=self.verbose,
+            )
+        elif sandbox == "docker":
+            self.interpreter = DockerInterpreter(
+                require_confirm=require_confirm,
+                print_stdout=self.verbose,
+                print_stderr=self.verbose,
+            )
+        elif sandbox == "subprocess":
+            self.interpreter = SubprocessInterpreter(
+                require_confirm=require_confirm,
+                print_stdout=self.verbose,
+                print_stderr=self.verbose,
+            )
         else:
             raise RuntimeError(
                 f"The sandbox type `{sandbox}` is not supported."

camel/toolkits/human_toolkit.py

@@ -36,6 +36,7 @@ class HumanToolkit(BaseToolkit):
         Returns:
             str: The answer from the human.
         """
+        print(f"Question: {question}")
         logger.info(f"Question: {question}")
         reply = input("Your reply: ")
         logger.info(f"User reply: {reply}")

camel/toolkits/meshy_toolkit.py

@@ -0,0 +1,185 @@
+# ========= 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
+
+import requests
+
+from camel.toolkits.base import BaseToolkit
+from camel.utils import api_keys_required
+
+
+class MeshyToolkit(BaseToolkit):
+    r"""A class representing a toolkit for 3D model generation using Meshy.
+
+    This class provides methods that handle text/image to 3D model
+    generation using Meshy.
+
+    Call the generate_3d_model_complete method to generate a refined 3D model.
+
+    Ref:
+    https://docs.meshy.ai/api-text-to-3d-beta#create-a-text-to-3d-preview-task
+    """
+
+    @api_keys_required("MESHY_API_KEY")
+    def __init__(self):
+        r"""Initializes the MeshyToolkit with the API key from the
+        environment.
+        """
+        self.api_key = os.getenv('MESHY_API_KEY')
+
+    def generate_3d_preview(
+        self, prompt: str, art_style: str, negative_prompt: str
+    ) -> Dict[str, Any]:
+        r"""Generates a 3D preview using the Meshy API.
+
+        Args:
+            prompt (str): Description of the object.
+            art_style (str): Art style for the 3D model.
+            negative_prompt (str): What the model should not look like.
+
+        Returns:
+            Dict[str, Any]: The result property of the response contains the
+                task id of the newly created Text to 3D task.
+        """
+        payload = {
+            "mode": "preview",
+            "prompt": prompt,
+            "art_style": art_style,
+            "negative_prompt": negative_prompt,
+        }
+        headers = {"Authorization": f"Bearer {self.api_key}"}
+
+        response = requests.post(
+            "https://api.meshy.ai/v2/text-to-3d",
+            headers=headers,
+            json=payload,
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def refine_3d_model(self, preview_task_id: str) -> Dict[str, Any]:
+        r"""Refines a 3D model using the Meshy API.
+
+        Args:
+            preview_task_id (str): The task ID of the preview to refine.
+
+        Returns:
+            Dict[str, Any]: The response from the Meshy API.
+        """
+        payload = {"mode": "refine", "preview_task_id": preview_task_id}
+        headers = {"Authorization": f"Bearer {self.api_key}"}
+
+        response = requests.post(
+            "https://api.meshy.ai/v2/text-to-3d",
+            headers=headers,
+            json=payload,
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def get_task_status(self, task_id: str) -> Dict[str, Any]:
+        r"""Retrieves the status or result of a specific 3D model generation
+        task using the Meshy API.
+
+        Args:
+            task_id (str): The ID of the task to retrieve.
+
+        Returns:
+            Dict[str, Any]: The response from the Meshy API.
+        """
+        headers = {"Authorization": f"Bearer {self.api_key}"}
+
+        response = requests.get(
+            f"https://api.meshy.ai/v2/text-to-3d/{task_id}",
+            headers=headers,
+        )
+        response.raise_for_status()
+        return response.json()
+
+    def wait_for_task_completion(
+        self, task_id: str, polling_interval: int = 10, timeout: int = 3600
+    ) -> Dict[str, Any]:
+        r"""Waits for a task to complete by polling its status.
+
+        Args:
+            task_id (str): The ID of the task to monitor.
+            polling_interval (int): Seconds to wait between status checks.
+                (default::obj:`10`)
+            timeout (int): Maximum seconds to wait before timing out.
+                (default::obj:`3600`)
+
+        Returns:
+            Dict[str, Any]: Final response from the API when task completes.
+
+        Raises:
+            TimeoutError: If task doesn't complete within timeout period.
+            RuntimeError: If task fails or is canceled.
+        """
+        import time
+
+        start_time = time.time()
+
+        while True:
+            if time.time() - start_time > timeout:
+                raise TimeoutError(
+                    f"Task {task_id} timed out after {timeout} seconds"
+                )
+
+            response = self.get_task_status(task_id)
+            status = response.get("status")  # Direct access to status field
+            elapsed = int(time.time() - start_time)
+
+            print(f"Status after {elapsed}s: {status}")
+
+            if status == "SUCCEEDED":
+                return response
+            elif status in [
+                "FAILED",
+                "CANCELED",
+            ]:  # Also updating these status values
+                raise RuntimeError(f"Task {task_id} {status}")
+
+            time.sleep(polling_interval)
+
+    def generate_3d_model_complete(
+        self, prompt: str, art_style: str, negative_prompt: str
+    ) -> Dict[str, Any]:
+        r"""Generates a complete 3D model by handling preview and refinement
+        stages
+
+        Args:
+            prompt (str): Description of the object.
+            art_style (str): Art style for the 3D model.
+            negative_prompt (str): What the model should not look like.
+
+        Returns:
+            Dict[str, Any]: The final refined 3D model response.
+        """
+        # Generate preview
+        preview_response = self.generate_3d_preview(
+            prompt, art_style, negative_prompt
+        )
+        preview_task_id = str(preview_response.get("result"))
+
+        # Wait for preview completion
+        self.wait_for_task_completion(preview_task_id)
+
+        # Start refinement
+        refine_response = self.refine_3d_model(preview_task_id)
+        refine_task_id = str(refine_response.get("result"))
+
+        # Wait for refinement completion and return final result
+        return self.wait_for_task_completion(refine_task_id)

camel/toolkits/twitter_toolkit.py

@@ -20,12 +20,15 @@ from typing import Any, Dict, List, Optional, Union
 import requests
 from requests_oauthlib import OAuth1
 
+from camel.logger import get_logger
 from camel.toolkits import FunctionTool
 from camel.toolkits.base import BaseToolkit
 from camel.utils import api_keys_required
 
 TWEET_TEXT_LIMIT = 280
 
+logger = get_logger(__name__)
+
 
 @api_keys_required(
     "TWITTER_CONSUMER_KEY",

camel/types/enums.py

@@ -65,7 +65,17 @@ class ModelType(UnifiedModelType, Enum):
     CLAUDE_3_5_SONNET = "claude-3-5-sonnet-20240620"
 
     # Nvidia models
-    NEMOTRON_4_REWARD = "nvidia/nemotron-4-340b-reward"
+    NVIDIA_NEMOTRON_340B_INSTRUCT = "nvidia/nemotron-4-340b-instruct"
+    NVIDIA_NEMOTRON_340B_REWARD = "nvidia/nemotron-4-340b-reward"
+    NVIDIA_YI_LARGE = "01-ai/yi-large"
+    NVIDIA_MISTRAL_LARGE = "mistralai/mistral-large"
+    NVIDIA_MIXTRAL_8X7B = "mistralai/mixtral-8x7b-instruct"
+    NVIDIA_LLAMA3_70B = "meta/llama3-70b"
+    NVIDIA_LLAMA3_1_8B_INSTRUCT = "meta/llama-3.1-8b-instruct"
+    NVIDIA_LLAMA3_1_70B_INSTRUCT = "meta/llama-3.1-70b-instruct"
+    NVIDIA_LLAMA3_1_405B_INSTRUCT = "meta/llama-3.1-405b-instruct"
+    NVIDIA_LLAMA3_2_1B_INSTRUCT = "meta/llama-3.2-1b-instruct"
+    NVIDIA_LLAMA3_2_3B_INSTRUCT = "meta/llama-3.2-3b-instruct"
 
     # Gemini models
     GEMINI_1_5_FLASH = "gemini-1.5-flash"
@@ -165,6 +175,7 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.GPT_4,
             ModelType.GPT_4_TURBO,
             ModelType.GPT_4O,
+            ModelType.GPT_4O_MINI,
         }
 
     @property
@@ -225,13 +236,19 @@ class ModelType(UnifiedModelType, Enum):
 
     @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.
-        """
+        r"""Returns whether this type of models is a NVIDIA model."""
         return self in {
-            ModelType.NEMOTRON_4_REWARD,
+            ModelType.NVIDIA_NEMOTRON_340B_INSTRUCT,
+            ModelType.NVIDIA_NEMOTRON_340B_REWARD,
+            ModelType.NVIDIA_YI_LARGE,
+            ModelType.NVIDIA_MISTRAL_LARGE,
+            ModelType.NVIDIA_LLAMA3_70B,
+            ModelType.NVIDIA_MIXTRAL_8X7B,
+            ModelType.NVIDIA_LLAMA3_1_8B_INSTRUCT,
+            ModelType.NVIDIA_LLAMA3_1_70B_INSTRUCT,
+            ModelType.NVIDIA_LLAMA3_1_405B_INSTRUCT,
+            ModelType.NVIDIA_LLAMA3_2_1B_INSTRUCT,
+            ModelType.NVIDIA_LLAMA3_2_3B_INSTRUCT,
         }
 
     @property
@@ -329,7 +346,6 @@ class ModelType(UnifiedModelType, Enum):
         if self is ModelType.GLM_4V:
             return 1024
         elif self in {
-            ModelType.NEMOTRON_4_REWARD,
             ModelType.STUB,
             ModelType.REKA_CORE,
             ModelType.REKA_EDGE,
@@ -338,6 +354,8 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.QWEN_MATH_TURBO,
             ModelType.COHERE_COMMAND,
             ModelType.COHERE_COMMAND_LIGHT,
+            ModelType.NVIDIA_NEMOTRON_340B_INSTRUCT,
+            ModelType.NVIDIA_NEMOTRON_340B_REWARD,
         }:
             return 4_096
         elif self in {
@@ -349,6 +367,7 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.GLM_3_TURBO,
             ModelType.GLM_4,
             ModelType.QWEN_VL_PLUS,
+            ModelType.NVIDIA_LLAMA3_70B,
         }:
             return 8_192
         elif self in {
@@ -370,6 +389,9 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.YI_LARGE_FC,
             ModelType.QWEN_MAX,
             ModelType.QWEN_VL_MAX,
+            ModelType.NVIDIA_YI_LARGE,
+            ModelType.NVIDIA_MISTRAL_LARGE,
+            ModelType.NVIDIA_MIXTRAL_8X7B,
             ModelType.QWEN_QWQ_32B,
         }:
             return 32_768
@@ -401,6 +423,11 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.COHERE_COMMAND_R,
             ModelType.COHERE_COMMAND_R_PLUS,
             ModelType.COHERE_COMMAND_NIGHTLY,
+            ModelType.NVIDIA_LLAMA3_1_8B_INSTRUCT,
+            ModelType.NVIDIA_LLAMA3_1_70B_INSTRUCT,
+            ModelType.NVIDIA_LLAMA3_1_405B_INSTRUCT,
+            ModelType.NVIDIA_LLAMA3_2_1B_INSTRUCT,
+            ModelType.NVIDIA_LLAMA3_2_3B_INSTRUCT,
         }:
             return 128_000
         elif self in {
@@ -582,6 +609,7 @@ class ModelPlatformType(Enum):
     COHERE = "cohere"
     YI = "lingyiwanwu"
     QWEN = "tongyi-qianwen"
+    NVIDIA = "nvidia"
     DEEPSEEK = "deepseek"
 
     @property
@@ -670,6 +698,11 @@ class ModelPlatformType(Enum):
         r"""Returns whether this platform is Qwen."""
         return self is ModelPlatformType.QWEN
 
+    @property
+    def is_nvidia(self) -> bool:
+        r"""Returns whether this platform is Nvidia."""
+        return self is ModelPlatformType.NVIDIA
+
     @property
     def is_deepseek(self) -> bool:
         r"""Returns whether this platform is DeepSeek."""

camel/utils/commons.py

@@ -12,6 +12,7 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import importlib
+import logging
 import os
 import platform
 import re
@@ -39,14 +40,19 @@ import pydantic
 import requests
 from pydantic import BaseModel
 
+from camel.logger import get_logger
 from camel.types import TaskType
 
 from .constants import Constants
 
 F = TypeVar('F', bound=Callable[..., Any])
 
+logger = get_logger(__name__)
 
-def print_text_animated(text, delay: float = 0.02, end: str = ""):
+
+def print_text_animated(
+    text, delay: float = 0.02, end: str = "", log_level: int = logging.INFO
+):
     r"""Prints the given text with an animated effect.
 
     Args:
@@ -55,11 +61,22 @@ def print_text_animated(text, delay: float = 0.02, end: str = ""):
             (default: :obj:`0.02`)
         end (str, optional): The end character to print after each
             character of text. (default: :obj:`""`)
+        log_level (int, optional): The log level to use.
+            See https://docs.python.org/3/library/logging.html#levels
+            (default: :obj:`logging.INFO`)
     """
-    for char in text:
-        print(char, end=end, flush=True)
-        time.sleep(delay)
-    print('\n')
+    if logger.isEnabledFor(log_level):
+        # timestamp and other prefixes
+        logger.log(log_level, '')
+
+        for char in text:
+            print(char, end=end, flush=True)
+            time.sleep(delay)
+        # Close the log entry
+        logger.log(log_level, '')
+    else:
+        # This may be relevant for logging frameworks
+        logger.log(log_level, text)
 
 
 def get_prompt_template_key_words(template: str) -> Set[str]:

camel/utils/token_counting.py

@@ -22,6 +22,7 @@ from typing import TYPE_CHECKING, List, Optional
 
 from PIL import Image
 
+from camel.logger import get_logger
 from camel.types import (
     ModelType,
     OpenAIImageType,
@@ -44,6 +45,8 @@ SQUARE_PIXELS = 512
 SQUARE_TOKENS = 170
 EXTRA_TOKENS = 85
 
+logger = get_logger(__name__)
+
 
 def get_model_encoding(value_for_tiktoken: str):
     r"""Get model encoding from tiktoken.
@@ -65,7 +68,7 @@ def get_model_encoding(value_for_tiktoken: str):
         ]:
             encoding = tiktoken.get_encoding("o200k_base")
         else:
-            print("Model not found. Using cl100k_base encoding.")
+            logger.info("Model not found. Using cl100k_base encoding.")
             encoding = tiktoken.get_encoding("cl100k_base")
     return encoding
 

{camel_ai-0.2.10.dist-info → camel_ai-0.2.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: camel-ai
-Version: 0.2.10
+Version: 0.2.11
 Summary: Communicative Agents for AI Society Study
 Home-page: https://www.camel-ai.org/
 License: Apache-2.0
@@ -257,7 +257,7 @@ conda create --name camel python=3.10
 conda activate camel
 
 # Clone github repo
-git clone -b v0.2.10 https://github.com/camel-ai/camel.git
+git clone -b v0.2.11 https://github.com/camel-ai/camel.git
 
 # Change directory into project directory
 cd camel