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

camel/generators.py

@@ -43,24 +43,27 @@ class SystemMessageGenerator:
             self.sys_prompts = sys_prompts
             self.sys_msg_meta_dict_keys = sys_msg_meta_dict_keys or set()
         else:
-            assistant_prompt_template = PromptTemplateGenerator(
-            ).get_system_prompt(
-                task_type,
-                RoleType.ASSISTANT,
+            assistant_prompt_template = (
+                PromptTemplateGenerator().get_system_prompt(
+                    task_type,
+                    RoleType.ASSISTANT,
+                )
             )
             user_prompt_template = PromptTemplateGenerator().get_system_prompt(
                 task_type,
                 RoleType.USER,
             )
-            critic_prompt_template = PromptTemplateGenerator(
-            ).get_system_prompt(
-                task_type,
-                RoleType.CRITIC,
+            critic_prompt_template = (
+                PromptTemplateGenerator().get_system_prompt(
+                    task_type,
+                    RoleType.CRITIC,
+                )
             )
-            embodiment_prompt_template = PromptTemplateGenerator(
-            ).get_system_prompt(
-                task_type,
-                RoleType.EMBODIMENT,
+            embodiment_prompt_template = (
+                PromptTemplateGenerator().get_system_prompt(
+                    task_type,
+                    RoleType.EMBODIMENT,
+                )
             )
 
             self.sys_prompts = dict()
@@ -73,7 +76,8 @@ class SystemMessageGenerator:
                 assistant_prompt_template.key_words
                 | user_prompt_template.key_words
                 | critic_prompt_template.key_words
-                | embodiment_prompt_template.key_words)
+                | embodiment_prompt_template.key_words
+            )
 
         if RoleType.DEFAULT not in self.sys_prompts:
             self.sys_prompts[RoleType.DEFAULT] = "You are a helpful assistant."
@@ -85,9 +89,11 @@ class SystemMessageGenerator:
             meta_dict (Dict[str, str]): The dictionary to validate.
         """
         if not set(meta_dict.keys()).issubset(self.sys_msg_meta_dict_keys):
-            raise ValueError("The keys of the meta_dict should be in "
-                             f"{self.sys_msg_meta_dict_keys}. "
-                             f"Got {set(meta_dict.keys())} instead.")
+            raise ValueError(
+                "The keys of the meta_dict should be in "
+                f"{self.sys_msg_meta_dict_keys}. "
+                f"Got {set(meta_dict.keys())} instead."
+            )
 
     def from_dict(
         self,
@@ -109,8 +115,12 @@ class SystemMessageGenerator:
         role_name, role_type = role_tuple
         sys_prompt = self.sys_prompts[role_type]
         sys_prompt = sys_prompt.format(**meta_dict)
-        return BaseMessage(role_name=role_name, role_type=role_type,
-                           meta_dict=meta_dict, content=sys_prompt)
+        return BaseMessage(
+            role_name=role_name,
+            role_type=role_type,
+            meta_dict=meta_dict,
+            content=sys_prompt,
+        )
 
     def from_dicts(
         self,
@@ -134,7 +144,8 @@ class SystemMessageGenerator:
         """
         if len(meta_dicts) != len(role_tuples):
             raise ValueError(
-                "The number of meta_dicts and role_types should be the same.")
+                "The number of meta_dicts and role_types should be the same."
+            )
 
         return [
             self.from_dict(meta_dict, role_tuple)
@@ -143,13 +154,13 @@ class SystemMessageGenerator:
 
 
 class RoleNameGenerator:
-
-    def __init__(self, assistant_role_names_path:
-                 str = "data/ai_society/assistant_roles.txt",
-                 user_role_names_path: str = "data/ai_society/user_roles.txt",
-                 assistant_role_names: Optional[List[str]] = None,
-                 user_role_names: Optional[List[str]] = None) -> None:
-
+    def __init__(
+        self,
+        assistant_role_names_path: str = "data/ai_society/assistant_roles.txt",
+        user_role_names_path: str = "data/ai_society/user_roles.txt",
+        assistant_role_names: Optional[List[str]] = None,
+        user_role_names: Optional[List[str]] = None,
+    ) -> None:
         if assistant_role_names is None:
             with open(assistant_role_names_path, "r") as f:
                 assistant_role_names_: List[str] = f.read().splitlines()
@@ -176,13 +187,15 @@ class RoleNameGenerator:
 
 
 class AISocietyTaskPromptGenerator:
-
     def __init__(
         self,
         num_tasks: int = 10,
     ) -> None:
-        self.generate_tasks_prompt = PromptTemplateGenerator(
-        ).get_generate_tasks_prompt(TaskType.AI_SOCIETY)
+        self.generate_tasks_prompt = (
+            PromptTemplateGenerator().get_generate_tasks_prompt(
+                TaskType.AI_SOCIETY
+            )
+        )
 
         self.num_tasks = num_tasks
 
@@ -190,14 +203,17 @@ class AISocietyTaskPromptGenerator:
     def from_role_files(
         self,
         assistant_role_names_path: str = "data/ai_society/assistant_roles.txt",
-        user_role_names_path: str = "data/ai_society/user_roles.txt"
+        user_role_names_path: str = "data/ai_society/user_roles.txt",
     ) -> Generator[Tuple[str, Tuple[str, str]], None, None]:
         roles_generator = RoleNameGenerator(
-            assistant_role_names_path, user_role_names_path).from_role_files()
+            assistant_role_names_path, user_role_names_path
+        ).from_role_files()
         for role_1, role_2 in roles_generator:
             generate_tasks_prompt = self.generate_tasks_prompt.format(
-                assistant_role=role_1, user_role=role_2,
-                num_tasks=self.num_tasks)
+                assistant_role=role_1,
+                user_role=role_2,
+                num_tasks=self.num_tasks,
+            )
 
             yield (generate_tasks_prompt, (role_1, role_2))
 
@@ -206,19 +222,19 @@ class AISocietyTaskPromptGenerator:
     ) -> Generator[Tuple[str, Tuple[str, str]], None, None]:
         for role_1, role_2 in role_generator:
             generate_tasks_prompt = self.generate_tasks_prompt.format(
-                assistant_role=role_1, user_role=role_2,
-                num_tasks=self.num_tasks)
+                assistant_role=role_1,
+                user_role=role_2,
+                num_tasks=self.num_tasks,
+            )
 
             yield (generate_tasks_prompt, (role_1, role_2))
 
 
 class SingleTxtGenerator:
-
     def __init__(
         self,
         text_file_path: str,
     ) -> None:
-
         with open(text_file_path, "r") as f:
             data_list: List[str] = f.read().splitlines()
             self.data_list = [
@@ -231,30 +247,33 @@ class SingleTxtGenerator:
 
 
 class CodeTaskPromptGenerator:
-
     def __init__(
         self,
         num_tasks: int = 50,
     ) -> None:
-
-        self.generate_tasks_prompt = PromptTemplateGenerator(
-        ).get_generate_tasks_prompt(TaskType.CODE)
+        self.generate_tasks_prompt = (
+            PromptTemplateGenerator().get_generate_tasks_prompt(TaskType.CODE)
+        )
 
         self.num_tasks = num_tasks
 
     def from_role_files(
-        self, languages_path: str = "data/code/languages.txt",
-        domains_path: str = "data/code/domains.txt"
+        self,
+        languages_path: str = "data/code/languages.txt",
+        domains_path: str = "data/code/domains.txt",
     ) -> Generator[Tuple[TextPrompt, str, str], None, None]:
         language_generator = SingleTxtGenerator(
-            languages_path).from_role_files()
+            languages_path
+        ).from_role_files()
 
         for language in language_generator:
             domains_generator = SingleTxtGenerator(
-                domains_path).from_role_files()
+                domains_path
+            ).from_role_files()
             for domain in domains_generator:
                 generated_tasks_prompt = self.generate_tasks_prompt.format(
-                    language=language, domain=domain, num_tasks=self.num_tasks)
+                    language=language, domain=domain, num_tasks=self.num_tasks
+                )
                 yield generated_tasks_prompt, language, domain
 
     def from_role_generator(

camel/human.py

@@ -39,8 +39,11 @@ class Human:
             displayed to the user.
     """
 
-    def __init__(self, name: str = "Kill Switch Engineer",
-                 logger_color: Any = Fore.MAGENTA) -> None:
+    def __init__(
+        self,
+        name: str = "Kill Switch Engineer",
+        logger_color: Any = Fore.MAGENTA,
+    ) -> None:
         self.name = name
         self.logger_color = logger_color
         self.input_button = f"Input by {self.name}."
@@ -62,11 +65,13 @@ class Human:
         print_text_animated(
             self.logger_color + "\n> Proposals from "
             f"{messages[0].role_name} ({messages[0].role_type}). "
-            "Please choose an option:\n")
+            "Please choose an option:\n"
+        )
         for index, option in enumerate(options):
             print_text_animated(
-                self.logger_color +
-                f"\x1b[3mOption {index + 1}:\n{option}\x1b[0m\n")
+                self.logger_color
+                + f"\x1b[3mOption {index + 1}:\n{option}\x1b[0m\n"
+            )
             self.options_dict[str(index + 1)] = option
 
     def get_input(self) -> str:
@@ -77,13 +82,15 @@ class Human:
         """
         while True:
             human_input = input(
-                self.logger_color +
-                f"Please enter your choice ([1-{len(self.options_dict)}]): ")
+                self.logger_color
+                + f"Please enter your choice ([1-{len(self.options_dict)}]): "
+            )
             print("\n")
             if human_input in self.options_dict:
                 break
-            print_text_animated(self.logger_color +
-                                "\n> Invalid choice. Please try again.\n")
+            print_text_animated(
+                self.logger_color + "\n> Invalid choice. Please try again.\n"
+            )
 
         return human_input
 
@@ -105,8 +112,7 @@ class Human:
 
         return content
 
-    def reduce_step(self,
-                    messages: Sequence[BaseMessage]) -> ChatAgentResponse:
+    def reduce_step(self, messages: Sequence[BaseMessage]) -> ChatAgentResponse:
         r"""Performs one step of the conversation by displaying options to the
         user, getting their input, and parsing their choice.
 

camel/interpreters/__init__.py

@@ -0,0 +1,25 @@
+# =========== 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 BaseInterpreter
+from .internal_python_interpreter import InternalPythonInterpreter
+from .interpreter_error import InterpreterError
+from .subprocess_interpreter import SubprocessInterpreter
+
+__all__ = [
+    'BaseInterpreter',
+    'InterpreterError',
+    'InternalPythonInterpreter',
+    'SubprocessInterpreter',
+]

camel/interpreters/base.py

@@ -0,0 +1,49 @@
+# =========== 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, Dict, List
+
+
+class BaseInterpreter(ABC):
+    r"""An abstract base class for code interpreters."""
+
+    @abstractmethod
+    def run(self, code: str, code_type: str) -> str:
+        r"""Executes the given code based on its type.
+
+        Args:
+            code (str): The code to be executed.
+            code_type (str): The type of the code, which must be one of the
+                types returned by `supported_code_types()`.
+
+        Returns:
+            str: The result of the code execution. If the execution fails, this
+                should include sufficient information to diagnose and correct
+                the issue.
+
+        Raises:
+            InterpreterError: If the code execution encounters errors that
+                could be resolved by modifying or regenerating the code.
+        """
+        pass
+
+    @abstractmethod
+    def supported_code_types(self) -> List[str]:
+        r"""Provides supported code types by the interpreter."""
+        pass
+
+    @abstractmethod
+    def update_action_space(self, action_space: Dict[str, Any]) -> None:
+        r"""Updates action space for *python* interpreter"""
+        pass

camel/{utils/python_interpreter.py → interpreters/internal_python_interpreter.py}

@@ -15,22 +15,17 @@ import ast
 import difflib
 import importlib
 import typing
-from typing import Any, Dict, List, Optional
+from typing import Any, ClassVar, Dict, List, Optional
 
+from camel.interpreters.base import BaseInterpreter
+from camel.interpreters.interpreter_error import InterpreterError
 
-class InterpreterError(ValueError):
-    r"""An error raised when the interpreter cannot evaluate a Python
-    expression, due to syntax error or unsupported operations.
-    """
-
-    pass
 
-
-class PythonInterpreter():
+class InternalPythonInterpreter(BaseInterpreter):
     r"""A customized python interpreter to control the execution of
     LLM-generated codes. The interpreter makes sure the code can only execute
     functions given in action space and import white list. It also supports
-    fuzzy variable matching to reveive uncertain input variable name.
+    fuzzy variable matching to retrieve uncertain input variable name.
 
     .. highlight:: none
 
@@ -64,40 +59,101 @@ class PythonInterpreter():
     Modifications copyright (C) 2023 CAMEL-AI.org
 
     Args:
-        action_space (Dict[str, Any]): A dictionary that maps action names to
-            their corresponding functions or objects. The interpreter can only
-            execute functions that are either directly listed in this
+        action_space (Dict[str, Any], optional): A dictionary that maps action
+            names to their corresponding functions or objects. The interpreter
+            can only execute functions that are either directly listed in this
             dictionary or are member functions of objects listed in this
             dictionary. The concept of :obj:`action_space` is derived from
             EmbodiedAgent, representing the actions that an agent is capable of
-            performing.
-        import_white_list (Optional[List[str]], optional): A list that stores
+            performing. If `None`, set to empty dict. (default: :obj:`None`)
+        import_white_list (List[str], optional): A list that stores
             the Python modules or functions that can be imported in the code.
             All submodules and functions of the modules listed in this list are
             importable. Any other import statements will be rejected. The
             module and its submodule or function name are separated by a period
             (:obj:`.`). (default: :obj:`None`)
+        unsafe_mode (bool, optional): If `True`, the interpreter runs the code
+            by `eval()` without any security check. (default: :obj:`False`)
+        raise_error (bool, optional): Raise error if the interpreter fails.
+            (default: :obj:`False`)
     """
 
-    def __init__(self, action_space: Dict[str, Any],
-                 import_white_list: Optional[List[str]] = None) -> None:
-        self.action_space = action_space
+    _CODE_TYPES: ClassVar[List[str]] = ["python", "py", "python3", "python2"]
+
+    def __init__(
+        self,
+        action_space: Optional[Dict[str, Any]] = None,
+        import_white_list: Optional[List[str]] = None,
+        unsafe_mode: bool = False,
+        raise_error: bool = False,
+    ) -> None:
+        self.action_space = action_space or dict()
         self.state = self.action_space.copy()
-        self.fuzz_state: Dict[str, Any] = {}
-        self.import_white_list = import_white_list or []
+        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:
+        r"""Executes the given code with specified code type in the
+        interpreter.
+
+        This method takes a string of code and its type, checks if the code
+        type is supported, and then executes the code. If `unsafe_mode` is
+        set to `False`, the code is executed in a controlled environment using
+        the `execute` method. If `unsafe_mode` is `True`, the code is executed
+        using `eval()` with the action space as the global context. An
+        `InterpreterError` is raised if the code type is unsupported or if any
+        runtime error occurs during execution.
+
+        Args:
+            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`).
+
+
+        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_TYPES:
+            raise InterpreterError(
+                f"Unsupported code type {code_type}. "
+                f"`{self.__class__.__name__}` only supports "
+                f"{', '.join(self._CODE_TYPES)}."
+            )
+        if not self.unsafe_mode:
+            return str(self.execute(code))
+        else:
+            return str(eval(code, self.action_space))
+
+    def update_action_space(self, action_space: Dict[str, Any]) -> None:
+        r"""Updates action space for *python* interpreter."""
+        self.action_space.update(action_space)
+
+    def supported_code_types(self) -> List[str]:
+        r"""Provides supported code types by the interpreter."""
+        return self._CODE_TYPES
 
-    def execute(self, code: str, state: Optional[Dict[str, Any]] = None,
-                fuzz_state: Optional[Dict[str, Any]] = None,
-                keep_state: bool = True) -> Any:
-        r""" Execute the input python codes in a security environment.
+    def execute(
+        self,
+        code: str,
+        state: Optional[Dict[str, Any]] = None,
+        fuzz_state: Optional[Dict[str, Any]] = None,
+        keep_state: bool = True,
+    ) -> Any:
+        r"""Execute the input python codes in a security environment.
 
         Args:
             code (str): Generated python code to be executed.
             state (Optional[Dict[str, Any]], optional): External variables that
                 may be used in the generated code. (default: :obj:`None`)
-            fuzz_state (Optional[Dict[str, Any]], optional): External varibles
-                that do not have certain varible names. The interpreter will
-                use fuzzy matching to access these varibales. For example, if
+            fuzz_state (Optional[Dict[str, Any]], optional): External variables
+                that do not have certain variable names. The interpreter will
+                use fuzzy matching to access these variables. For example, if
                 :obj:`fuzz_state` has a variable :obj:`image`, the generated
                 code can use :obj:`input_image` to access it. (default:
                 :obj:`None`)
@@ -120,7 +176,12 @@ class PythonInterpreter():
         try:
             expression = ast.parse(code)
         except SyntaxError as e:
-            raise InterpreterError(f"Syntax error in code: {e}")
+            if self.raise_error:
+                raise InterpreterError(f"Syntax error in code: {e}")
+            else:
+                import traceback
+
+                return traceback.format_exc()
 
         result = None
         for idx, node in enumerate(expression.body):
@@ -129,11 +190,18 @@ class PythonInterpreter():
             except InterpreterError as e:
                 if not keep_state:
                     self.clear_state()
-                msg = (f"Evaluation of the code stopped at node {idx}. "
-                       f"See:\n{e}")
+                msg = (
+                    f"Evaluation of the code stopped at node {idx}. "
+                    f"See:\n{e}"
+                )
                 # More information can be provided by `ast.unparse()`,
                 # which is new in python 3.9.
-                raise InterpreterError(msg)
+                if self.raise_error:
+                    raise InterpreterError(msg)
+                else:
+                    import traceback
+
+                    return traceback.format_exc()
             if line_result is not None:
                 result = line_result
 
@@ -143,7 +211,7 @@ class PythonInterpreter():
         return result
 
     def clear_state(self) -> None:
-        r"""Initialize :obj:`state` and :obj:`fuzz_state`"""
+        r"""Initialize :obj:`state` and :obj:`fuzz_state`."""
         self.state = self.action_space.copy()
         self.fuzz_state = {}
 
@@ -204,7 +272,8 @@ class PythonInterpreter():
             return self._execute_ast(expression.value)
         elif isinstance(expression, ast.JoinedStr):
             return "".join(
-                [str(self._execute_ast(v)) for v in expression.values])
+                [str(self._execute_ast(v)) for v in expression.values]
+            )
         elif isinstance(expression, ast.List):
             # List -> evaluate all elements
             return [self._execute_ast(elt) for elt in expression.elts]
@@ -223,7 +292,8 @@ class PythonInterpreter():
             # For now we refuse anything else. Let's add things as we need
             # them.
             raise InterpreterError(
-                f"{expression.__class__.__name__} is not supported.")
+                f"{expression.__class__.__name__} is not supported."
+            )
 
     def _execute_assign(self, assign: ast.Assign) -> Any:
         targets = assign.targets
@@ -238,18 +308,23 @@ class PythonInterpreter():
             self.state[target.id] = value
         elif isinstance(target, ast.Tuple):
             if not isinstance(value, tuple):
-                raise InterpreterError(f"Expected type tuple, but got"
-                                       f"{value.__class__.__name__} instead.")
+                raise InterpreterError(
+                    f"Expected type tuple, but got"
+                    f"{value.__class__.__name__} instead."
+                )
             if len(target.elts) != len(value):
                 raise InterpreterError(
                     f"Expected {len(target.elts)} values but got"
-                    f" {len(value)}.")
+                    f" {len(value)}."
+                )
             for t, v in zip(target.elts, value):
                 self.state[self._execute_ast(t)] = v
         else:
-            raise InterpreterError(f"Unsupported variable type. Expected "
-                                   f"ast.Name or ast.Tuple, got "
-                                   f"{target.__class__.__name__} instead.")
+            raise InterpreterError(
+                f"Unsupported variable type. Expected "
+                f"ast.Name or ast.Tuple, got "
+                f"{target.__class__.__name__} instead."
+            )
 
     def _execute_call(self, call: ast.Call) -> Any:
         callable_func = self._execute_ast(call.func)
@@ -268,7 +343,8 @@ class PythonInterpreter():
         if not isinstance(subscript.ctx, ast.Load):
             raise InterpreterError(
                 f"{subscript.ctx.__class__.__name__} is not supported for "
-                "subscript.")
+                "subscript."
+            )
         if isinstance(value, (list, tuple)):
             return value[int(index)]
         if index in value:
@@ -294,7 +370,8 @@ class PythonInterpreter():
     def _execute_condition(self, condition: ast.Compare):
         if len(condition.ops) > 1:
             raise InterpreterError(
-                "Cannot evaluate conditions with multiple operators")
+                "Cannot evaluate conditions with multiple operators"
+            )
 
         left = self._execute_ast(condition.left)
         comparator = condition.ops[0]
@@ -328,7 +405,8 @@ class PythonInterpreter():
         if not isinstance(if_statement.test, ast.Compare):
             raise InterpreterError(
                 "Only Campare expr supported in if statement, get"
-                f" {if_statement.test.__class__.__name__}")
+                f" {if_statement.test.__class__.__name__}"
+            )
         if self._execute_condition(if_statement.test):
             for line in if_statement.body:
                 line_result = self._execute_ast(line)
@@ -378,9 +456,11 @@ class PythonInterpreter():
                 return
 
         if not found_name:
-            raise InterpreterError(f"It is not permitted to import modules "
-                                   f"than module white list (try to import "
-                                   f"{full_name}).")
+            raise InterpreterError(
+                f"It is not permitted to import modules "
+                f"than module white list (try to import "
+                f"{full_name})."
+            )
 
     def _execute_binop(self, binop: ast.BinOp):
         left = self._execute_ast(binop.left)
@@ -427,8 +507,9 @@ class PythonInterpreter():
         if key in self.state:
             return self.state[key]
         else:
-            close_matches = (difflib.get_close_matches(
-                key, list(self.fuzz_state.keys()), n=1))
+            close_matches = difflib.get_close_matches(
+                key, list(self.fuzz_state.keys()), n=1
+            )
             if close_matches:
                 return self.fuzz_state[close_matches[0]]
             else:

camel/interpreters/interpreter_error.py

@@ -0,0 +1,19 @@
+# =========== 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. ===========
+
+# TODO: Do we need a file to store this error class?
+class InterpreterError(Exception):
+    r"""Exception raised for errors that can be solved by regenerating code"""
+
+    pass