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

camel/interpreters/subprocess_interpreter.py

@@ -0,0 +1,190 @@
+# =========== 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 shlex
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Any, ClassVar, Dict, List
+
+from colorama import Fore
+
+from camel.interpreters.base import BaseInterpreter
+from camel.interpreters.interpreter_error import InterpreterError
+
+
+class SubprocessInterpreter(BaseInterpreter):
+    r"""SubprocessInterpreter is a class for executing code files or code
+    strings in a subprocess.
+
+    This class handles the execution of code in different scripting languages
+    (currently Python and Bash) within a subprocess, capturing their
+    stdout and stderr streams, and allowing user checking before executing code
+    strings.
+
+    Args:
+        require_confirm (bool, optional): If True, prompt user before running
+            code strings for security. (default: :obj:`True`)
+        print_stdout (bool, optional): If True, print the standard output of
+            the executed code. (default: :obj:`False`)
+        print_stderr (bool, optional): If True, print the standard error of the
+            executed code. (default: :obj:`True`)
+    """
+
+    _CODE_EXECUTE_CMD_MAPPING: ClassVar[Dict[str, str]] = {
+        "python": "python {file_name}",
+        "bash": "bash {file_name}",
+    }
+
+    _CODE_EXTENSION_MAPPING: ClassVar[Dict[str, str]] = {
+        "python": "py",
+        "bash": "sh",
+    }
+
+    _CODE_TYPE_MAPPING: ClassVar[Dict[str, str]] = {
+        "python": "python",
+        "py3": "python",
+        "python3": "python",
+        "py": "python",
+        "shell": "bash",
+        "bash": "bash",
+        "sh": "bash",
+    }
+
+    def __init__(
+        self,
+        require_confirm: bool = True,
+        print_stdout: bool = False,
+        print_stderr: bool = True,
+    ) -> None:
+        self.require_confirm = require_confirm
+        self.print_stdout = print_stdout
+        self.print_stderr = print_stderr
+
+    def run_file(
+        self,
+        file: Path,
+        code_type: str,
+    ) -> 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').
+
+        Returns:
+            str: A string containing the captured stdout and stderr of the
+                executed code.
+
+        Raises:
+            RuntimeError: If the provided file path does not point to a file.
+            InterpreterError: If the code type provided is not supported.
+        """
+        if not file.is_file():
+            raise RuntimeError(f"{file} is not a file.")
+        code_type = self._check_code_type(code_type)
+        cmd = shlex.split(
+            self._CODE_EXECUTE_CMD_MAPPING[code_type].format(
+                file_name=str(file)
+            )
+        )
+        proc = subprocess.Popen(
+            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
+        )
+        stdout, stderr = proc.communicate()
+        if self.print_stdout and stdout:
+            print("======stdout======")
+            print(Fore.GREEN + stdout + Fore.RESET)
+            print("==================")
+        if self.print_stderr and stderr:
+            print("======stderr======")
+            print(Fore.RED + stderr + Fore.RESET)
+            print("==================")
+        exec_result = f"{stdout}"
+        exec_result += f"(stderr: {stderr})" if stderr else ""
+        return exec_result
+
+    def run(
+        self,
+        code: str,
+        code_type: str,
+    ) -> str:
+        r"""Generates a temporary file with the given code, executes it, and
+            deletes the file afterward.
+
+        Args:
+            code (str): The code string to execute.
+            code_type (str): The type of code to execute (e.g., 'python',
+                'bash').
+
+        Returns:
+            str: A string containing the captured stdout and stderr of the
+                executed code.
+
+        Raises:
+            InterpreterError: If the user declines to run the code or if the
+                code type is unsupported.
+        """
+        code_type = self._check_code_type(code_type)
+
+        # 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)
+            while True:
+                choice = input("Running code? [Y/n]:").lower()
+                if choice in ["y", "yes", "ye", ""]:
+                    break
+                elif choice in ["no", "n"]:
+                    raise InterpreterError(
+                        "Execution halted: User opted not to run the code. "
+                        "This choice stops the current operation and any "
+                        "further code execution."
+                    )
+        temp_file_path = self._create_temp_file(
+            code=code, extension=self._CODE_EXTENSION_MAPPING[code_type]
+        )
+
+        result = self.run_file(temp_file_path, code_type)
+
+        temp_file_path.unlink()
+        return result
+
+    def _create_temp_file(self, code: str, extension: str) -> Path:
+        with tempfile.NamedTemporaryFile(
+            mode="w", delete=False, suffix=f".{extension}"
+        ) as f:
+            f.write(code)
+            name = f.name
+        return Path(name)
+
+    def _check_code_type(self, code_type: str) -> str:
+        if code_type not in self._CODE_TYPE_MAPPING:
+            raise InterpreterError(
+                f"Unsupported code type {code_type}. Currently "
+                f"`{self.__class__.__name__}` only supports "
+                f"{', '.join(self._CODE_EXTENSION_MAPPING.keys())}."
+            )
+        return self._CODE_TYPE_MAPPING[code_type]
+
+    def supported_code_types(self) -> List[str]:
+        r"""Provides supported code types by the interpreter."""
+        return list(self._CODE_EXTENSION_MAPPING.keys())
+
+    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`."
+        )

camel/loaders/__init__.py

@@ -0,0 +1,22 @@
+# =========== 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_io import File, read_file
+from .unstructured_io import UnstructuredIO
+
+__all__ = [
+    'File',
+    'read_file',
+    'UnstructuredIO',
+]

camel/{functions/base_io_functions.py → loaders/base_io.py}

@@ -35,10 +35,10 @@ class File(ABC):
         Args:
             name (str): The name of the file.
             id (str): The unique identifier of the file.
-            metadata (Dict[str, Any], optional):
-            Additional metadata associated with the file. Defaults to None.
-            docs (List[Dict[str, Any]], optional):
-            A list of documents contained within the file. Defaults to None.
+            metadata (Dict[str, Any], optional): Additional metadata
+                associated with the file. Defaults to None.
+            docs (List[Dict[str, Any]], optional): A list of documents
+                contained within the file. Defaults to None.
         """
         self.name = name
         self.id = id
@@ -51,20 +51,21 @@ class File(ABC):
         r"""Creates a File object from a BytesIO object.
 
         Args:
-            file (BytesIO):
-            A BytesIO object representing the contents of the file.
+            file (BytesIO): A BytesIO object representing the contents of the
+                file.
 
         Returns:
             File: A File object.
         """
 
     def __repr__(self) -> str:
-        return (f"File(name={self.name}, id={self.id}, "
-                f"metadata={self.metadata}, docs={self.docs})")
+        return (
+            f"File(name={self.name}, id={self.id}, "
+            f"metadata={self.metadata}, docs={self.docs})"
+        )
 
     def __str__(self) -> str:
-        return (
-            f"File(name={self.name}, id={self.id}, metadata={self.metadata})")
+        return f"File(name={self.name}, id={self.id}, metadata={self.metadata})"
 
     def copy(self) -> "File":
         r"""Create a deep copy of this File"""
@@ -90,14 +91,13 @@ def strip_consecutive_newlines(text: str) -> str:
 
 
 class DocxFile(File):
-
     @classmethod
     def from_bytes(cls, file: BytesIO) -> "DocxFile":
         r"""Creates a DocxFile object from a BytesIO object.
 
         Args:
-            file (BytesIO):
-            A BytesIO object representing the contents of the docx file.
+            file (BytesIO): A BytesIO object representing the contents of the
+                docx file.
 
         Returns:
             DocxFile: A DocxFile object.
@@ -106,9 +106,11 @@ class DocxFile(File):
         try:
             import docx2txt
         except ImportError:
-            raise ImportError("Please install `docx2txt` first. "
-                              "You can install it by running "
-                              "`pip install docx2txt`.")
+            raise ImportError(
+                "Please install `docx2txt` first. "
+                "You can install it by running "
+                "`pip install docx2txt`."
+            )
         text = docx2txt.process(file)
         text = strip_consecutive_newlines(text)
         # Create a dictionary with the extracted text
@@ -121,14 +123,13 @@ class DocxFile(File):
 
 
 class PdfFile(File):
-
     @classmethod
     def from_bytes(cls, file: BytesIO) -> "PdfFile":
         r"""Creates a PdfFile object from a BytesIO object.
 
         Args:
-            file (BytesIO):
-            A BytesIO object representing the contents of the pdf file.
+            file (BytesIO): A BytesIO object representing the contents of the
+                pdf file.
 
         Returns:
             PdfFile: A PdfFile object.
@@ -137,9 +138,11 @@ class PdfFile(File):
         try:
             import fitz
         except ImportError:
-            raise ImportError("Please install `PyMuPDF` first. "
-                              "You can install it by running "
-                              "`pip install PyMuPDF`.")
+            raise ImportError(
+                "Please install `PyMuPDF` first. "
+                "You can install it by running "
+                "`pip install PyMuPDF`."
+            )
         pdf = fitz.open(stream=file.read(), filetype="pdf")
         docs = []
         for i, page in enumerate(pdf):
@@ -156,14 +159,13 @@ class PdfFile(File):
 
 
 class TxtFile(File):
-
     @classmethod
     def from_bytes(cls, file: BytesIO) -> "TxtFile":
         r"""Creates a TxtFile object from a BytesIO object.
 
         Args:
-            file (BytesIO):
-            A BytesIO object representing the contents of the txt file.
+            file (BytesIO): A BytesIO object representing the contents of the
+                txt file.
 
         Returns:
             TxtFile: A TxtFile object.
@@ -181,14 +183,13 @@ class TxtFile(File):
 
 
 class JsonFile(File):
-
     @classmethod
     def from_bytes(cls, file: BytesIO) -> "JsonFile":
         r"""Creates a JsonFile object from a BytesIO object.
 
         Args:
-            file (BytesIO):
-            A BytesIO object representing the contents of the json file.
+            file (BytesIO): A BytesIO object representing the contents of the
+                json file.
 
         Returns:
             JsonFile: A JsonFile object.
@@ -205,14 +206,13 @@ class JsonFile(File):
 
 
 class HtmlFile(File):
-
     @classmethod
     def from_bytes(cls, file: BytesIO) -> "HtmlFile":
         r"""Creates a HtmlFile object from a BytesIO object.
 
         Args:
-            file (BytesIO):
-            A BytesIO object representing the contents of the html file.
+            file (BytesIO): A BytesIO object representing the contents of the
+                html file.
 
         Returns:
             HtmlFile: A HtmlFile object.
@@ -221,9 +221,11 @@ class HtmlFile(File):
         try:
             from bs4 import BeautifulSoup
         except ImportError:
-            raise ImportError("Please install `beautifulsoup4` first. "
-                              "You can install it by running "
-                              "`pip install beautifulsoup4`.")
+            raise ImportError(
+                "Please install `beautifulsoup4` first. "
+                "You can install it by running "
+                "`pip install beautifulsoup4`."
+            )
         soup = BeautifulSoup(file, "html.parser")
         text = soup.get_text()
         text = strip_consecutive_newlines(text)
@@ -258,4 +260,5 @@ def read_file(file: BytesIO) -> File:
         return HtmlFile.from_bytes(file)
     else:
         raise NotImplementedError(
-            f"File type {file.name.split('.')[-1]} not supported")
+            f"File type {file.name.split('.')[-1]} not supported"
+        )