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

camel/interpreters/e2b_interpreter.py

@@ -0,0 +1,136 @@
+# ========= 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, ClassVar, Dict, List, Optional
+
+from camel.interpreters.base import BaseInterpreter
+from camel.interpreters.interpreter_error import InterpreterError
+from camel.logger import get_logger
+from camel.utils import api_keys_required
+
+logger = get_logger(__name__)
+
+
+class E2BInterpreter(BaseInterpreter):
+    r"""E2B Code Interpreter implementation.
+
+    Args:
+        require_confirm (bool, optional): If True, prompt user before running
+            code strings for security. (default: :obj:`True`)
+    """
+
+    _CODE_TYPE_MAPPING: ClassVar[Dict[str, Optional[str]]] = {
+        "python": None,
+        "py3": None,
+        "python3": None,
+        "py": None,
+        "shell": "bash",
+        "bash": "bash",
+        "sh": "bash",
+        "java": "java",
+        "javascript": "js",
+        "r": "r",
+    }
+
+    @api_keys_required("E2B_API_KEY")
+    def __init__(
+        self,
+        require_confirm: bool = True,
+    ) -> None:
+        from e2b_code_interpreter import Sandbox
+
+        self.require_confirm = require_confirm
+        self._sandbox = Sandbox(api_key=os.environ.get("E2B_API_KEY"))
+
+    def __del__(self) -> None:
+        r"""Destructor for the E2BInterpreter class.
+
+        This method ensures that the e2b sandbox is killed when the
+        interpreter is deleted.
+        """
+        if (
+            hasattr(self, '_sandbox')
+            and self._sandbox is not None
+            and self._sandbox.is_running()
+        ):
+            self._sandbox.kill()
+
+    def run(
+        self,
+        code: str,
+        code_type: str,
+    ) -> str:
+        r"""Executes the given code in the e2b sandbox.
+
+        Args:
+            code (str): The code string to execute.
+            code_type (str): The type of code to execute (e.g., 'python',
+                'bash').
+
+        Returns:
+            str: The string representation of the output of the executed code.
+
+        Raises:
+            InterpreterError: If the `code_type` is not supported or if any
+                runtime error occurs during the execution of the code.
+        """
+        if code_type not in self._CODE_TYPE_MAPPING:
+            raise InterpreterError(
+                f"Unsupported code type {code_type}. "
+                f"`{self.__class__.__name__}` only supports "
+                f"{', '.join(list(self._CODE_TYPE_MAPPING.keys()))}."
+            )
+        # Print code for security checking
+        if self.require_confirm:
+            logger.info(
+                f"The following {code_type} code will run on your "
+                "e2b sandbox: {code}"
+            )
+            while True:
+                choice = input("Running code? [Y/n]:").lower()
+                if choice in ["y", "yes", "ye"]:
+                    break
+                elif choice not in ["no", "n"]:
+                    continue
+                raise InterpreterError(
+                    "Execution halted: User opted not to run the code. "
+                    "This choice stops the current operation and any "
+                    "further code execution."
+                )
+
+        if self._CODE_TYPE_MAPPING[code_type] is None:
+            execution = self._sandbox.run_code(code)
+        else:
+            execution = self._sandbox.run_code(
+                code=code, language=self._CODE_TYPE_MAPPING[code_type]
+            )
+
+        if execution.text and execution.text.lower() != "none":
+            return execution.text
+
+        if execution.logs:
+            if execution.logs.stdout:
+                return ",".join(execution.logs.stdout)
+            elif execution.logs.stderr:
+                return ",".join(execution.logs.stderr)
+
+        return str(execution.error)
+
+    def supported_code_types(self) -> List[str]:
+        r"""Provides supported code types by the interpreter."""
+        return list(self._CODE_TYPE_MAPPING.keys())
+
+    def update_action_space(self, action_space: Dict[str, Any]) -> None:
+        r"""Updates action space for *python* interpreter"""
+        raise RuntimeError("E2B doesn't support " "`action_space`.")

camel/interpreters/subprocess_interpreter.py

@@ -22,6 +22,9 @@ from colorama import Fore
 
 from camel.interpreters.base import BaseInterpreter
 from camel.interpreters.interpreter_error import InterpreterError
+from camel.logger import get_logger
+
+logger = get_logger(__name__)
 
 
 class SubprocessInterpreter(BaseInterpreter):
@@ -141,8 +144,10 @@ class SubprocessInterpreter(BaseInterpreter):
 
         # Print code for security checking
         if self.require_confirm:
-            print(f"The following {code_type} code will run on your computer:")
-            print(Fore.CYAN + code + Fore.RESET)
+            logger.info(
+                f"The following {code_type} code will run on your "
+                "computer: {code}"
+            )
             while True:
                 choice = input("Running code? [Y/n]:").lower()
                 if choice in ["y", "yes", "ye", ""]:

camel/loaders/__init__.py

@@ -13,7 +13,7 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 
 from .apify_reader import Apify
-from .base_io import File
+from .base_io import File, create_file, create_file_from_raw_bytes
 from .chunkr_reader import ChunkrReader
 from .firecrawl_reader import Firecrawl
 from .jina_url_reader import JinaURLReader
@@ -21,6 +21,8 @@ from .unstructured_io import UnstructuredIO
 
 __all__ = [
     'File',
+    'create_file',
+    'create_file_from_raw_bytes',
     'UnstructuredIO',
     'JinaURLReader',
     'Firecrawl',

camel/loaders/base_io.py

@@ -22,6 +22,47 @@ from typing import Any, Dict, List, Optional
 from camel.utils import dependencies_required
 
 
+def create_file(file: BytesIO, filename: str) -> "File":
+    r"""Reads an uploaded file and returns a File object.
+
+    Args:
+        file (BytesIO): A BytesIO object representing the contents of the
+            file.
+        filename (str): The name of the file.
+
+    Returns:
+        File: A File object.
+    """
+    ext_to_cls = {
+        "docx": DocxFile,
+        "pdf": PdfFile,
+        "txt": TxtFile,
+        "json": JsonFile,
+        "html": HtmlFile,
+    }
+
+    ext = filename.split(".")[-1].lower()
+    if ext not in ext_to_cls:
+        raise NotImplementedError(f"File type {ext} not supported")
+
+    out_file = ext_to_cls[ext].from_bytes(file, filename)
+    return out_file
+
+
+def create_file_from_raw_bytes(raw_bytes: bytes, filename: str) -> "File":
+    r"""Reads raw bytes and returns a File object.
+
+    Args:
+        raw_bytes (bytes): The raw bytes content of the file.
+        filename (str): The name of the file.
+
+    Returns:
+        File: A File object.
+    """
+    file = BytesIO(raw_bytes)
+    return create_file(file, filename)
+
+
 class File(ABC):
     r"""Represents an uploaded file comprised of Documents.
 
@@ -79,47 +120,6 @@ class File(ABC):
         file = BytesIO(raw_bytes)
         return cls.from_bytes(file, filename)
 
-    @staticmethod
-    def create_file(file: BytesIO, filename: str) -> "File":
-        r"""Reads an uploaded file and returns a File object.
-
-        Args:
-            file (BytesIO): A BytesIO object representing the contents of the
-                file.
-            filename (str): The name of the file.
-
-        Returns:
-            File: A File object.
-        """
-        ext_to_cls = {
-            "docx": DocxFile,
-            "pdf": PdfFile,
-            "txt": TxtFile,
-            "json": JsonFile,
-            "html": HtmlFile,
-        }
-
-        ext = filename.split(".")[-1].lower()
-        if ext not in ext_to_cls:
-            raise NotImplementedError(f"File type {ext} not supported")
-
-        out_file = ext_to_cls[ext].from_bytes(file, filename)
-        return out_file
-
-    @staticmethod
-    def create_file_from_raw_bytes(raw_bytes: bytes, filename: str) -> "File":
-        r"""Reads raw bytes and returns a File object.
-
-        Args:
-            raw_bytes (bytes): The raw bytes content of the file.
-            filename (str): The name of the file.
-
-        Returns:
-            File: A File object.
-        """
-        file = BytesIO(raw_bytes)
-        return File.create_file(file, filename)
-
     def __repr__(self) -> str:
         return (
             f"File(name={self.name}, id={self.file_id}, "

camel/loaders/firecrawl_reader.py

@@ -17,8 +17,6 @@ from typing import Any, Dict, Optional
 
 from pydantic import BaseModel
 
-from camel.utils import api_keys_required
-
 
 class Firecrawl:
     r"""Firecrawl allows you to turn entire websites into LLM-ready markdown.
@@ -32,7 +30,6 @@ class Firecrawl:
         https://docs.firecrawl.dev/introduction
     """
 
-    @api_keys_required("FIRECRAWL_API_KEY")
     def __init__(
         self,
         api_key: Optional[str] = None,

camel/logger.py

@@ -0,0 +1,112 @@
+# ========= 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 logging
+import os
+import sys
+
+# Create a private logger
+_logger = logging.getLogger('camel')
+
+
+def _configure_library_logging():
+    if os.environ.get('CAMEL_LOGGING_DISABLED', 'False').lower() == 'true':
+        return
+
+    if not logging.root.handlers and not _logger.handlers:
+        logging.basicConfig(
+            level=os.environ.get('LOGLEVEL', 'INFO').upper(),
+            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+            stream=sys.stdout,
+        )
+        logging.setLoggerClass(logging.Logger)
+        _logger.info("Camel library logging has been configured.")
+    else:
+        _logger.debug("Existing logger configuration found, using that.")
+
+
+def disable_logging():
+    r"""Disable all logging for the Camel library.
+
+    This function sets the log level to a value higher than CRITICAL,
+    effectively disabling all log messages, and adds a NullHandler to
+    suppress any potential warnings about no handlers being found.
+    """
+    os.environ['CAMEL_LOGGING_DISABLED'] = 'true'
+    _logger.setLevel(logging.CRITICAL + 1)
+    # Avoid adding multiple NullHandlers
+    if not any(
+        isinstance(handler, logging.NullHandler)
+        for handler in _logger.handlers
+    ):
+        _logger.addHandler(logging.NullHandler())
+    _logger.debug("Logging has been disabled.")
+
+
+def enable_logging():
+    r"""Enable logging for the Camel library.
+
+    This function re-enables logging if it was previously disabled,
+    and configures the library logging using the default settings.
+    If the logging is already configured,
+        this function does not change its configuration.
+    """
+    os.environ['CAMEL_LOGGING_DISABLED'] = 'false'
+    _configure_library_logging()
+
+
+def set_log_level(level):
+    r"""Set the logging level for the Camel library.
+
+    Args:
+        level (Union[str, int]): The logging level to set. This can be a string
+            (e.g., 'INFO') or a logging level constant (e.g., logging.INFO,
+            logging.DEBUG).
+            See https://docs.python.org/3/library/logging.html#levels
+
+    Raises:
+        ValueError: If the provided level is not a valid logging level.
+    """
+    valid_levels = ['NOTSET', 'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL']
+    if isinstance(level, str):
+        if level.upper() not in valid_levels:
+            raise ValueError(
+                f"Invalid logging level."
+                f" Choose from: {', '.join(valid_levels)}"
+            )
+        level = level.upper()
+    elif not isinstance(level, int):
+        raise ValueError(
+            "Logging level must be an option from the logging module."
+        )
+
+    _logger.setLevel(level)
+    _logger.debug(f"Logging level set to: {logging.getLevelName(level)}")
+
+
+def get_logger(name):
+    r"""Get a logger with the specified name, prefixed with 'camel.'.
+
+    Args:
+        name (str): The name to be appended to 'camel.' to create the logger.
+
+    Returns:
+        logging.Logger: A logger instance with the name 'camel.{name}'.
+    """
+    return logging.getLogger(f'camel.{name}')
+
+
+# Lazy configuration: Only configure logging if explicitly enabled.
+if os.environ.get('CAMEL_LOGGING_DISABLED', 'False').strip().lower() != 'true':
+    _configure_library_logging()

camel/messages/__init__.py

@@ -20,10 +20,11 @@ from camel.types import (
 )
 
 from .conversion import (
+    AlpacaItem,
     HermesFunctionFormatter,
     ShareGPTMessage,
 )
-from .conversion.models import (
+from .conversion.conversation_models import (
     ShareGPTConversation,
 )
 from .conversion.sharegpt.function_call_formatter import (
@@ -52,4 +53,5 @@ __all__ = [
     'ShareGPTMessage',
     'BaseMessage',
     'FunctionCallingMessage',
+    'AlpacaItem',
 ]

camel/messages/base.py

@@ -15,10 +15,11 @@ import base64
 import io
 import re
 from dataclasses import dataclass
-from typing import Any, Dict, List, Literal, Optional, Tuple, Union
+from typing import Any, Dict, List, Literal, Optional, Tuple, Type, Union
 
 import numpy as np
 from PIL import Image
+from pydantic import BaseModel
 
 from camel.messages import (
     FunctionCallFormatter,
@@ -51,24 +52,27 @@ class BaseMessage:
             for the message.
         content (str): The content of the message.
         video_bytes (Optional[bytes]): Optional bytes of a video associated
-            with the message. Default is None.
+            with the message. (default::obj:`None`)
         image_list (Optional[List[Image.Image]]): Optional list of PIL Image
-            objects associated with the message. Default is None.
+            objects associated with the message. (default::obj:`None`)
         image_detail (Literal["auto", "low", "high"]): Detail level of the
-            images associated with the message. Default is "auto".
+            images associated with the message. (default::obj:`auto`)
         video_detail (Literal["auto", "low", "high"]): Detail level of the
-            videos associated with the message. Default is "low".
+            videos associated with the message. (default::obj:`low`)
+        parsed: Optional[Union[Type[BaseModel], dict]]: Optional object which
+            is parsed from the content. (default::obj:`None`)
     """
 
     role_name: str
     role_type: RoleType
-    meta_dict: Optional[Dict[str, str]]
+    meta_dict: Optional[Dict[str, Any]]
     content: str
 
     video_bytes: Optional[bytes] = None
     image_list: Optional[List[Image.Image]] = None
     image_detail: Literal["auto", "low", "high"] = "auto"
     video_detail: Literal["auto", "low", "high"] = "low"
+    parsed: Optional[Union[Type[BaseModel], dict]] = None
 
     @classmethod
     def make_user_message(
@@ -419,7 +423,6 @@ class BaseMessage:
                 "text": self.content,
             }
         )
-
         if self.image_list and len(self.image_list) > 0:
             for image in self.image_list:
                 if image.format is None:

camel/messages/conversion/__init__.py

@@ -12,7 +12,8 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 
-from .models import (
+from .alpaca import AlpacaItem
+from .conversation_models import (
     ShareGPTConversation,
     ShareGPTMessage,
     ToolCall,
@@ -24,6 +25,7 @@ __all__ = [
     'ShareGPTMessage',
     'ShareGPTConversation',
     'HermesFunctionFormatter',
+    'AlpacaItem',
     'ToolCall',
     'ToolResponse',
 ]

camel/messages/conversion/alpaca.py

@@ -0,0 +1,122 @@
+# ========= 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 re
+
+from pydantic import BaseModel, Field, field_validator
+
+
+class AlpacaItem(BaseModel):
+    r"""Represents an instruction-response item in the Alpaca format.
+
+    Appropripate for both cases where input field is empty, or populated.
+    Provides parsing from string format using the class method from_string().
+
+    Args:
+        instruction (str): The instruction/question/prompt
+        input (str): Input context or examples (put empty string if none)
+        output (str): The response/answer to the instruction
+    """
+
+    instruction: str = Field(description="The instruction/question/prompt")
+    input: str = Field(
+        description="Optional context or input for the task."
+        " For example, when the instruction is \"Summarize the "
+        "following article\", the input is the article."
+    )
+    output: str = Field(description="The response/answer to the instruction")
+
+    @field_validator('instruction', 'output')
+    def no_section_markers(cls, value: str) -> str:
+        r"""Ensures fields don't contain section markers like '###
+        Response:'
+        """
+        if (
+            '### Response' in value
+            or '### Instruction' in value
+            or '### Input' in value
+        ):
+            raise ValueError("Field cannot contain section markers")
+        return value.strip()
+
+    @classmethod
+    def from_string(cls, text: str) -> "AlpacaItem":
+        r"""Creates an AlpacaItem from a formatted string.
+
+        Args:
+            text: String in either of these formats:
+                 With input:
+                 ### Instruction:
+                 {instruction}
+                 ### Input:
+                 {input}
+                 ### Response:
+                 {response}
+
+                 Without input:
+                 ### Instruction:
+                 {instruction}
+                 ### Response:
+                 {response}
+
+        Returns:
+            AlpacaItem: Parsed instance
+
+        Raises:
+            ValueError: text doesn't match expected format or sections missing
+        """
+        # Strip and standardize newlines
+        text = text.strip().replace('\r\n', '\n')
+
+        # Try to extract sections using regex
+        instruction_match = re.search(
+            r'###\s*Instruction:\s*\n(.+?)(?=\n###|\Z)', text, re.DOTALL
+        )
+        input_match = re.search(
+            r'###\s*Input:\s*\n(.+?)(?=\n###|\Z)', text, re.DOTALL
+        )
+        response_match = re.search(
+            r'###\s*Response:\s*\n(.+?)(?=\n###|\Z)', text, re.DOTALL
+        )
+
+        if not instruction_match or not response_match:
+            raise ValueError(
+                "Text must contain '### Instruction:'"
+                " and '### Response:' sections"
+            )
+
+        return cls(
+            instruction=instruction_match.group(1).strip(),
+            input=input_match.group(1).strip() if input_match else "",
+            output=response_match.group(1).strip(),
+        )
+
+    def to_string(self) -> str:
+        r"""Converts the AlpacaItem to its string representation.
+
+        Returns:
+            str: Formatted string representation with sections markers
+        """
+        return "\n".join(
+            [
+                "### Instruction:",
+                self.instruction,
+                "",
+                "### Input:",
+                self.input,
+                "",
+                "### Response:",
+                self.output,
+            ]
+        )

camel/models/__init__.py

@@ -21,7 +21,9 @@ from .groq_model import GroqModel
 from .litellm_model import LiteLLMModel
 from .mistral_model import MistralModel
 from .model_factory import ModelFactory
+from .model_manager import ModelManager, ModelProcessingError
 from .nemotron_model import NemotronModel
+from .nvidia_model import NvidiaModel
 from .ollama_model import OllamaModel
 from .openai_audio_models import OpenAIAudioModels
 from .openai_compatible_model import OpenAICompatibleModel
@@ -29,6 +31,7 @@ from .openai_model import OpenAIModel
 from .qwen_model import QwenModel
 from .reka_model import RekaModel
 from .samba_model import SambaModel
+from .sglang_model import SGLangModel
 from .stub_model import StubModel
 from .togetherai_model import TogetherAIModel
 from .vllm_model import VLLMModel
@@ -46,11 +49,14 @@ __all__ = [
     'ZhipuAIModel',
     'CohereModel',
     'ModelFactory',
+    'ModelManager',
     'LiteLLMModel',
     'OpenAIAudioModels',
     'NemotronModel',
+    'NvidiaModel',
     'OllamaModel',
     'VLLMModel',
+    'SGLangModel',
     'GeminiModel',
     'OpenAICompatibleModel',
     'RekaModel',
@@ -58,5 +64,6 @@ __all__ = [
     'TogetherAIModel',
     'YiModel',
     'QwenModel',
+    'ModelProcessingError',
     'DeepSeekModel',
 ]