camel-ai 0.2.62__py3-none-any.whl → 0.2.65__py3-none-any.whl

camel/datasets/static_dataset.py

@@ -13,6 +13,7 @@
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 import json
 import random
+from collections.abc import Sequence
 from pathlib import Path
 from typing import (
     Any,
@@ -288,6 +289,11 @@ class StaticDataset(Dataset):
             )
         raw_data = []
 
+        if not isinstance(data, Sequence):
+            raise TypeError(
+                f"{type(data).__name__} does not support indexing."
+            )
+
         for i in range(len(data)):
             item = data[i]
             if not isinstance(item, dict):

camel/interpreters/base.py

@@ -12,7 +12,7 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Tuple, Union
 
 
 class BaseInterpreter(ABC):
@@ -47,3 +47,16 @@ class BaseInterpreter(ABC):
     def update_action_space(self, action_space: Dict[str, Any]) -> None:
         r"""Updates action space for *python* interpreter"""
         pass
+
+    @abstractmethod
+    def execute_command(self, command: str) -> Union[str, Tuple[str, str]]:
+        r"""Executes a command in the interpreter.
+
+        Args:
+            command (str): The command to execute.
+
+        Returns:
+            Tuple[str, str]: A tuple containing the stdout and stderr of the
+                command execution.
+        """
+        pass

camel/interpreters/docker/Dockerfile

@@ -1,12 +1,68 @@
-FROM python:3.9-slim
+# syntax=docker/dockerfile:1
 
-# Install R and required dependencies
+FROM ubuntu:22.04
+
+# Set environment variable to avoid interactive prompts
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Update and install base utilities
 RUN apt-get update && apt-get install -y \
-    r-base \
-    && rm -rf /var/lib/apt/lists/*
+    build-essential \
+    software-properties-common \
+    curl \
+    wget \
+    git \
+    git-lfs \
+    netcat \
+    sudo \
+    tzdata \
+    && rm -rf /var/lib/apt/lists/* \
+    && apt-get clean \
+    && apt-get autoremove -y
+
+# Install Python 3.10 and its dependencies
+RUN add-apt-repository ppa:deadsnakes/ppa && \
+    apt-get update && \
+    apt-get install -y \
+        python3.10 \
+        python3.10-venv \
+        python3.10-dev \
+        python3.10-distutils \
+        python3-pip \
+    && ln -s /usr/bin/python3.10 /usr/bin/python \
+    && rm -rf /var/lib/apt/lists/* \
+    && apt-get clean \
+    && apt-get autoremove -y
+
+# Install R
+RUN apt-get update && \
+    apt-get install -y r-base && \
+    rm -rf /var/lib/apt/lists/* && \
+    apt-get clean && \
+    apt-get autoremove -y
+
+# Install NodeJS 22.x
+RUN curl -fsSL https://deb.nodesource.com/setup_22.x | bash - && \
+    apt-get install -y nodejs && \
+    rm -rf /var/lib/apt/lists/* && \
+    apt-get clean && \
+    apt-get autoremove -y
+
+# Install Poetry
+RUN curl -fsSL https://install.python-poetry.org | python3.10 - && \
+    ln -s ~/.local/bin/poetry /usr/local/bin/poetry
+
+# Upgrade pip and install base Python packages
+RUN python3.10 -m pip install --upgrade pip setuptools wheel
+
+# Install uv
+RUN curl -LsSf https://astral.sh/uv/install.sh | sh && \
+    mv /root/.local/bin/uv /usr/local/bin/uv && \
+    mv /root/.local/bin/uvx /usr/local/bin/uvx && \
+    chmod +x /usr/local/bin/uv /usr/local/bin/uvx
 
-# Set working directory
+# Setup working directory
 WORKDIR /workspace
 
-# Keep container running
-CMD ["tail", "-f", "/dev/null"]
+# Set default shell
+CMD ["/bin/bash"]

camel/interpreters/docker_interpreter.py

@@ -53,12 +53,14 @@ class DockerInterpreter(BaseInterpreter):
         "python": "python {file_name}",
         "bash": "bash {file_name}",
         "r": "Rscript {file_name}",
+        "node": "node {file_name}",
     }
 
     _CODE_EXTENSION_MAPPING: ClassVar[Dict[str, str]] = {
         "python": "py",
         "bash": "sh",
         "r": "R",
+        "node": "js",
     }
 
     _CODE_TYPE_MAPPING: ClassVar[Dict[str, str]] = {
@@ -71,6 +73,11 @@ class DockerInterpreter(BaseInterpreter):
         "sh": "bash",
         "r": "r",
         "R": "r",
+        "node": "node",
+        "js": "node",
+        "javascript": "node",
+        "typescript": "node",
+        "ts": "node",
     }
 
     def __init__(
@@ -92,8 +99,11 @@ class DockerInterpreter(BaseInterpreter):
         This method ensures that the Docker container is removed when the
         interpreter is deleted.
         """
-        if self._container is not None:
-            self._container.remove(force=True)
+        try:
+            if self._container is not None:
+                self.cleanup()
+        except ImportError as e:
+            logger.warning(f"Error during container cleanup: {e}")
 
     def _initialize_if_needed(self) -> None:
         if self._container is not None:
@@ -180,10 +190,24 @@ class DockerInterpreter(BaseInterpreter):
         exec_result += f"(stderr: {stderr.decode()})" if stderr else ""
         return exec_result
 
+    def cleanup(self) -> None:
+        r"""Explicitly stops and removes the Docker container.
+
+        This method should be called when you're done with the interpreter
+        to ensure proper cleanup of Docker resources.
+        """
+        try:
+            if self._container is not None:
+                self._container.stop()
+                self._container.remove(force=True)
+                self._container = None
+        except Exception as e:
+            logger.error(f"Error during container cleanup: {e}")
+
     def run(
         self,
         code: str,
-        code_type: str,
+        code_type: str = "python",
     ) -> str:
         r"""Executes the given code in the container attached to the
         interpreter, and captures the stdout and stderr streams.
@@ -191,7 +215,7 @@ class DockerInterpreter(BaseInterpreter):
         Args:
             code (str): The code string to execute.
             code_type (str): The type of code to execute (e.g., 'python',
-                'bash').
+                'bash'). (default: obj:`python`)
 
         Returns:
             str: A string containing the captured stdout and stderr of the
@@ -229,13 +253,16 @@ class DockerInterpreter(BaseInterpreter):
         try:
             temp_file_path = self._create_file_in_container(code)
             result = self._run_file_in_container(temp_file_path, code_type)
+            # Clean up after execution
         except docker.errors.APIError as e:
+            self.cleanup()
             raise InterpreterError(
                 f"Execution halted due to docker API error: {e.explanation}. "
                 "This choice stops the current operation and any "
                 "further code execution."
             ) from e
         except docker.errors.DockerException as e:
+            self.cleanup()  # Clean up even if there's an error
             raise InterpreterError(
                 f"Execution halted due to docker exceptoin: {e}. "
                 "This choice stops the current operation and any "
@@ -258,6 +285,37 @@ class DockerInterpreter(BaseInterpreter):
 
     def update_action_space(self, action_space: Dict[str, Any]) -> None:
         r"""Updates action space for *python* interpreter"""
-        raise RuntimeError(
-            "SubprocessInterpreter doesn't support " "`action_space`."
-        )
+        raise RuntimeError("DockerInterpreter doesn't support `action_space`.")
+
+    def execute_command(self, command: str) -> str:
+        r"""Executes a command in the Docker container and returns its output.
+
+        Args:
+            command (str): The command to execute in the container.
+
+        Returns:
+            str: A string containing the captured stdout and stderr of the
+                executed command.
+
+        Raises:
+            InterpreterError: If the container is not initialized or there is
+                an error executing the command.
+        """
+        self._initialize_if_needed()
+
+        if self._container is None:
+            raise InterpreterError(
+                "Container is not initialized. Try running the command again."
+            )
+
+        try:
+            stdout, stderr = self._container.exec_run(
+                command,
+                demux=True,
+            ).output
+            exec_result = f"{stdout.decode()}" if stdout else ""
+            exec_result += f"(stderr: {stderr.decode()})" if stderr else ""
+            return exec_result
+
+        except Exception as e:
+            raise InterpreterError(f"Failed to execute command: {e!s}") from e

camel/interpreters/e2b_interpreter.py

@@ -63,24 +63,27 @@ class E2BInterpreter(BaseInterpreter):
         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()
+        try:
+            if (
+                hasattr(self, '_sandbox')
+                and self._sandbox is not None
+                and self._sandbox.is_running()
+            ):
+                self._sandbox.kill()
+        except ImportError as e:
+            logger.warning(f"Error during sandbox cleanup: {e}")
 
     def run(
         self,
         code: str,
-        code_type: str,
+        code_type: str = "python",
     ) -> 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').
+                'bash'). (default: obj:`python`)
 
         Returns:
             str: The string representation of the output of the executed code.
@@ -138,3 +141,15 @@ class E2BInterpreter(BaseInterpreter):
     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`.")
+
+    def execute_command(self, command: str) -> str:
+        r"""Execute a command can be used to resolve the dependency of the
+        code.
+
+        Args:
+            command (str): The command to execute.
+
+        Returns:
+            str: The output of the command.
+        """
+        return self._sandbox.commands.run(command)

camel/interpreters/internal_python_interpreter.py

@@ -14,6 +14,8 @@
 import ast
 import difflib
 import importlib
+import os
+import subprocess
 import typing
 from typing import Any, ClassVar, Dict, List, Optional
 
@@ -89,13 +91,15 @@ class InternalPythonInterpreter(BaseInterpreter):
         raise_error: bool = False,
     ) -> None:
         self.action_space = action_space or dict()
+        # Add print to action space
+        self.action_space['print'] = print
         self.state = self.action_space.copy()
         self.fuzz_state: Dict[str, Any] = dict()
         self.import_white_list = import_white_list or list()
         self.raise_error = raise_error
         self.unsafe_mode = unsafe_mode
 
-    def run(self, code: str, code_type: str) -> str:
+    def run(self, code: str, code_type: str = "python") -> str:
         r"""Executes the given code with specified code type in the
         interpreter.
 
@@ -111,7 +115,7 @@ class InternalPythonInterpreter(BaseInterpreter):
             code (str): The python code to be executed.
             code_type (str): The type of the code, which should be one of the
             supported code types (`python`, `py`, `python3`, `python2`).
-
+                (default: obj:`python`)
 
         Returns:
             str: The string representation of the output of the executed code.
@@ -531,3 +535,27 @@ class InternalPythonInterpreter(BaseInterpreter):
                 return self.fuzz_state[close_matches[0]]
             else:
                 raise InterpreterError(f"The variable `{key}` is not defined.")
+
+    def execute_command(self, command: str) -> tuple[str, str]:
+        r"""Execute a command in the internal python interpreter.
+
+        Args:
+            command (str): The command to execute.
+
+        Returns:
+            tuple: A tuple containing the stdout and stderr of the command.
+        """
+        try:
+            proc = subprocess.Popen(
+                command,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                env=os.environ,
+                shell=True,
+            )
+            stdout, stderr = proc.communicate()
+
+            return stdout, stderr
+        except Exception as e:
+            raise InterpreterError(f"Error executing command: {e}")

camel/interpreters/ipython_interpreter.py

@@ -118,13 +118,13 @@ class JupyterKernelInterpreter(BaseInterpreter):
         exec_result = "\n".join(outputs)
         return self._clean_ipython_output(exec_result)
 
-    def run(self, code: str, code_type: str) -> str:
+    def run(self, code: str, code_type: str = "python") -> str:
         r"""Executes the given code in the Jupyter kernel.
 
         Args:
             code (str): The code string to execute.
             code_type (str): The type of code to execute (e.g., 'python',
-                'bash').
+                'bash'). (default: obj:`python`)
 
         Returns:
             str: A string containing the captured result of the
@@ -144,6 +144,24 @@ class JupyterKernelInterpreter(BaseInterpreter):
 
         return result
 
+    def execute_command(self, command: str) -> str:
+        r"""Executes a shell command in the Jupyter kernel.
+
+        Args:
+            command (str): The shell command to execute.
+
+        Returns:
+            str: A string containing the captured result of the
+                executed command.
+
+        """
+        try:
+            self._initialize_if_needed()
+            system_command = f"!{command}"
+            return self._execute(system_command, TIMEOUT)
+        except Exception as e:
+            raise InterpreterError(f"Error executing command: {e}")
+
     def supported_code_types(self) -> List[str]:
         r"""Provides supported code types by the interpreter.
 
@@ -164,5 +182,5 @@ class JupyterKernelInterpreter(BaseInterpreter):
                 does not support updating the action space.
         """
         raise RuntimeError(
-            "SubprocessInterpreter doesn't support " "`action_space`."
+            "JupyterKernelInterpreter doesn't support " "`action_space`."
         )

camel/interpreters/subprocess_interpreter.py

@@ -87,14 +87,14 @@ class SubprocessInterpreter(BaseInterpreter):
     def run_file(
         self,
         file: Path,
-        code_type: str,
+        code_type: str = "python",
     ) -> str:
         r"""Executes a code file in a subprocess and captures its output.
 
         Args:
             file (Path): The path object of the file to run.
             code_type (str): The type of code to execute (e.g., 'python',
-                'bash').
+                'bash'). (default: obj:`python`)
 
         Returns:
             str: A string containing the captured stdout and stderr of the
@@ -425,3 +425,35 @@ class SubprocessInterpreter(BaseInterpreter):
                 return True
             except subprocess.CalledProcessError:
                 return False
+
+    def execute_command(self, command: str) -> tuple[str, str]:
+        r"""Executes a shell command in a subprocess and captures its output.
+
+        Args:
+            command (str): The shell command to execute.
+
+        Returns:
+            tuple: A tuple containing the captured stdout and stderr of the
+                executed command.
+
+        Raises:
+            InterpreterError: If the command execution fails.
+        """
+        try:
+            # Get current Python executable's environment
+            env = os.environ.copy()
+
+            proc = subprocess.Popen(
+                command,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+                env=env,
+                shell=True,  # Use shell=True for command execution
+            )
+            # Add timeout to prevent hanging processes
+            stdout, stderr = proc.communicate(timeout=self.execution_timeout)
+
+            return stdout, stderr
+        except Exception as e:
+            raise InterpreterError(f"Error executing command: {e}")

camel/memories/records.py

@@ -15,8 +15,8 @@
 # Enables postponed evaluation of annotations (for string-based type hints)
 from __future__ import annotations
 
+import time
 from dataclasses import asdict
-from datetime import datetime, timezone
 from typing import Any, ClassVar, Dict
 from uuid import UUID, uuid4
 
@@ -53,7 +53,8 @@ class MemoryRecord(BaseModel):
     uuid: UUID = Field(default_factory=uuid4)
     extra_info: Dict[str, str] = Field(default_factory=dict)
     timestamp: float = Field(
-        default_factory=lambda: datetime.now(timezone.utc).timestamp()
+        default_factory=lambda: time.time_ns()
+        / 1_000_000_000  # Nanosecond precision
     )
     agent_id: str = Field(default="")
 
@@ -109,5 +110,6 @@ class ContextRecord(BaseModel):
     memory_record: MemoryRecord
     score: float
     timestamp: float = Field(
-        default_factory=lambda: datetime.now(timezone.utc).timestamp()
+        default_factory=lambda: time.time_ns()
+        / 1_000_000_000  # Nanosecond precision
     )

camel/models/__init__.py

@@ -18,6 +18,7 @@ from .azure_openai_model import AzureOpenAIModel
 from .base_audio_model import BaseAudioModel
 from .base_model import BaseModelBackend
 from .cohere_model import CohereModel
+from .crynux_model import CrynuxModel
 from .deepseek_model import DeepSeekModel
 from .fish_audio_model import FishAudioModel
 from .gemini_model import GeminiModel
@@ -96,4 +97,5 @@ __all__ = [
     'VolcanoModel',
     'LMStudioModel',
     'WatsonXModel',
+    'CrynuxModel',
 ]