camel-ai 0.1.5.4__py3-none-any.whl → 0.1.5.5__py3-none-any.whl

camel/__init__.py

@@ -12,7 +12,7 @@
 # limitations under the License.
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 
-__version__ = '0.1.5'
+__version__ = '0.1.5.5'
 
 __all__ = [
     '__version__',

camel/configs/__init__.py

@@ -14,11 +14,13 @@
 from .anthropic_config import ANTHROPIC_API_PARAMS, AnthropicConfig
 from .base_config import BaseConfig
 from .litellm_config import LITELLM_API_PARAMS, LiteLLMConfig
+from .ollama_config import OLLAMA_API_PARAMS, OllamaConfig
 from .openai_config import (
     OPENAI_API_PARAMS,
     ChatGPTConfig,
     OpenSourceConfig,
 )
+from .zhipuai_config import ZHIPUAI_API_PARAMS, ZhipuAIConfig
 
 __all__ = [
     'BaseConfig',
@@ -29,4 +31,8 @@ __all__ = [
     'OpenSourceConfig',
     'LiteLLMConfig',
     'LITELLM_API_PARAMS',
+    'OllamaConfig',
+    'OLLAMA_API_PARAMS',
+    'ZhipuAIConfig',
+    'ZHIPUAI_API_PARAMS',
 ]

camel/configs/litellm_config.py

@@ -13,11 +13,14 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from __future__ import annotations
 
-from dataclasses import asdict, dataclass, field
-from typing import List, Optional, Union
+from dataclasses import asdict, dataclass
+from typing import TYPE_CHECKING, List, Optional, Union
 
 from camel.configs.base_config import BaseConfig
 
+if TYPE_CHECKING:
+    from camel.functions import OpenAIFunction
+
 
 @dataclass(frozen=True)
 class LiteLLMConfig(BaseConfig):
@@ -25,9 +28,6 @@ class LiteLLMConfig(BaseConfig):
     LiteLLM API.
 
     Args:
-        model (str): The name of the language model to use for text completion.
-        messages (List): A list of message objects representing the
-            conversation context. (default: [])
         timeout (Optional[Union[float, str]], optional): Request timeout.
             (default: None)
         temperature (Optional[float], optional): Temperature parameter for
@@ -65,12 +65,7 @@ class LiteLLMConfig(BaseConfig):
         deployment_id (Optional[str], optional): Deployment ID. (default: None)
         extra_headers (Optional[dict], optional): Additional headers for the
             request. (default: None)
-        base_url (Optional[str], optional): Base URL for the API. (default:
-            None)
         api_version (Optional[str], optional): API version. (default: None)
-        api_key (Optional[str], optional): API key. (default: None)
-        model_list (Optional[list], optional): List of API base, version,
-            keys. (default: None)
         mock_response (Optional[str], optional): Mock completion response for
             testing or debugging. (default: None)
         custom_llm_provider (Optional[str], optional): Non-OpenAI LLM
@@ -79,8 +74,6 @@ class LiteLLMConfig(BaseConfig):
             (default: None)
     """
 
-    model: str = "gpt-3.5-turbo"
-    messages: List = field(default_factory=list)
     timeout: Optional[Union[float, str]] = None
     temperature: Optional[float] = None
     top_p: Optional[float] = None
@@ -91,20 +84,17 @@ class LiteLLMConfig(BaseConfig):
     max_tokens: Optional[int] = None
     presence_penalty: Optional[float] = None
     frequency_penalty: Optional[float] = None
-    logit_bias: Optional[dict] = field(default_factory=dict)
+    logit_bias: Optional[dict] = None
     user: Optional[str] = None
     response_format: Optional[dict] = None
     seed: Optional[int] = None
-    tools: Optional[List] = field(default_factory=list)
+    tools: Optional[list[OpenAIFunction]] = None
     tool_choice: Optional[Union[str, dict]] = None
     logprobs: Optional[bool] = None
     top_logprobs: Optional[int] = None
     deployment_id: Optional[str] = None
-    extra_headers: Optional[dict] = field(default_factory=dict)
-    base_url: Optional[str] = None
+    extra_headers: Optional[dict] = None
     api_version: Optional[str] = None
-    api_key: Optional[str] = None
-    model_list: Optional[list] = field(default_factory=list)
     mock_response: Optional[str] = None
     custom_llm_provider: Optional[str] = None
     max_retries: Optional[int] = None

camel/configs/ollama_config.py

@@ -0,0 +1,85 @@
+# =========== 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 __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from typing import Sequence
+
+from openai._types import NOT_GIVEN, NotGiven
+
+from camel.configs.base_config import BaseConfig
+
+
+@dataclass(frozen=True)
+class OllamaConfig(BaseConfig):
+    r"""Defines the parameters for generating chat completions using OpenAI
+    compatibility
+
+    Reference: https://github.com/ollama/ollama/blob/main/docs/openai.md
+
+    Args:
+        temperature (float, optional): Sampling temperature to use, between
+            :obj:`0` and :obj:`2`. Higher values make the output more random,
+            while lower values make it more focused and deterministic.
+            (default: :obj:`0.2`)
+        top_p (float, optional): An alternative to sampling with temperature,
+            called nucleus sampling, where the model considers the results of
+            the tokens with top_p probability mass. So :obj:`0.1` means only
+            the tokens comprising the top 10% probability mass are considered.
+            (default: :obj:`1.0`)
+        response_format (object, optional): An object specifying the format
+            that the model must output. Compatible with GPT-4 Turbo and all
+            GPT-3.5 Turbo models newer than gpt-3.5-turbo-1106. Setting to
+            {"type": "json_object"} enables JSON mode, which guarantees the
+            message the model generates is valid JSON. Important: when using
+            JSON mode, you must also instruct the model to produce JSON
+            yourself via a system or user message. Without this, the model
+            may generate an unending stream of whitespace until the generation
+            reaches the token limit, resulting in a long-running and seemingly
+            "stuck" request. Also note that the message content may be
+            partially cut off if finish_reason="length", which indicates the
+            generation exceeded max_tokens or the conversation exceeded the
+            max context length.
+        stream (bool, optional): If True, partial message deltas will be sent
+            as data-only server-sent events as they become available.
+            (default: :obj:`False`)
+        stop (str or list, optional): Up to :obj:`4` sequences where the API
+            will stop generating further tokens. (default: :obj:`None`)
+        max_tokens (int, optional): The maximum number of tokens to generate
+            in the chat completion. The total length of input tokens and
+            generated tokens is limited by the model's context length.
+            (default: :obj:`None`)
+        presence_penalty (float, optional): Number between :obj:`-2.0` and
+            :obj:`2.0`. Positive values penalize new tokens based on whether
+            they appear in the text so far, increasing the model's likelihood
+            to talk about new topics. See more information about frequency and
+            presence penalties. (default: :obj:`0.0`)
+        frequency_penalty (float, optional): Number between :obj:`-2.0` and
+            :obj:`2.0`. Positive values penalize new tokens based on their
+            existing frequency in the text so far, decreasing the model's
+            likelihood to repeat the same line verbatim. See more information
+            about frequency and presence penalties. (default: :obj:`0.0`)
+    """
+
+    temperature: float = 0.2
+    top_p: float = 1.0
+    stream: bool = False
+    stop: str | Sequence[str] | NotGiven = NOT_GIVEN
+    max_tokens: int | NotGiven = NOT_GIVEN
+    presence_penalty: float = 0.0
+    response_format: dict | NotGiven = NOT_GIVEN
+    frequency_penalty: float = 0.0
+
+
+OLLAMA_API_PARAMS = {param for param in asdict(OllamaConfig()).keys()}

camel/configs/zhipuai_config.py

@@ -0,0 +1,78 @@
+# =========== 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 __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from typing import TYPE_CHECKING, Optional, Sequence
+
+from openai._types import NOT_GIVEN, NotGiven
+
+from camel.configs.base_config import BaseConfig
+
+if TYPE_CHECKING:
+    from camel.functions import OpenAIFunction
+
+
+@dataclass(frozen=True)
+class ZhipuAIConfig(BaseConfig):
+    r"""Defines the parameters for generating chat completions using OpenAI
+    compatibility
+
+    Reference: https://open.bigmodel.cn/dev/api#glm-4v
+
+    Args:
+        temperature (float, optional): Sampling temperature to use, between
+            :obj:`0` and :obj:`2`. Higher values make the output more random,
+            while lower values make it more focused and deterministic.
+            (default: :obj:`0.2`)
+        top_p (float, optional): An alternative to sampling with temperature,
+            called nucleus sampling, where the model considers the results of
+            the tokens with top_p probability mass. So :obj:`0.1` means only
+            the tokens comprising the top 10% probability mass are considered.
+            (default: :obj:`0.6`)
+        stream (bool, optional): If True, partial message deltas will be sent
+            as data-only server-sent events as they become available.
+            (default: :obj:`False`)
+        stop (str or list, optional): Up to :obj:`4` sequences where the API
+            will stop generating further tokens. (default: :obj:`None`)
+        max_tokens (int, optional): The maximum number of tokens to generate
+            in the chat completion. The total length of input tokens and
+            generated tokens is limited by the model's context length.
+            (default: :obj:`None`)
+        tools (list[OpenAIFunction], optional): A list of tools the model may
+            call. Currently, only functions are supported as a tool. Use this
+            to provide a list of functions the model may generate JSON inputs
+            for. A max of 128 functions are supported.
+        tool_choice (Union[dict[str, str], str], optional): Controls which (if
+            any) tool is called by the model. :obj:`"none"` means the model
+            will not call any tool and instead generates a message.
+            :obj:`"auto"` means the model can pick between generating a
+            message or calling one or more tools.  :obj:`"required"` means the
+            model must call one or more tools. Specifying a particular tool
+            via {"type": "function", "function": {"name": "my_function"}}
+            forces the model to call that tool. :obj:`"none"` is the default
+            when no tools are present. :obj:`"auto"` is the default if tools
+            are present.
+    """
+
+    temperature: float = 0.2
+    top_p: float = 0.6
+    stream: bool = False
+    stop: str | Sequence[str] | NotGiven = NOT_GIVEN
+    max_tokens: int | NotGiven = NOT_GIVEN
+    tools: Optional[list[OpenAIFunction]] = None
+    tool_choice: Optional[dict[str, str] | str] = None
+
+
+ZHIPUAI_API_PARAMS = {param for param in asdict(ZhipuAIConfig()).keys()}

camel/embeddings/openai_embedding.py

@@ -20,7 +20,7 @@ from openai import NOT_GIVEN, NotGiven, OpenAI
 
 from camel.embeddings.base import BaseEmbedding
 from camel.types import EmbeddingModelType
-from camel.utils import model_api_key_required
+from camel.utils import api_keys_required
 
 
 class OpenAIEmbedding(BaseEmbedding[str]):
@@ -58,7 +58,7 @@ class OpenAIEmbedding(BaseEmbedding[str]):
         self._api_key = api_key or os.environ.get("OPENAI_API_KEY")
         self.client = OpenAI(timeout=60, max_retries=3, api_key=self._api_key)
 
-    @model_api_key_required
+    @api_keys_required("OPENAI_API_KEY")
     def embed_list(
         self,
         objs: list[str],

camel/functions/search_functions.py

@@ -15,8 +15,10 @@ import os
 from typing import Any, Dict, List
 
 from camel.functions.openai_function import OpenAIFunction
+from camel.utils import dependencies_required
 
 
+@dependencies_required('wikipedia')
 def search_wiki(entity: str) -> str:
     r"""Search the entity in WikiPedia and return the summary of the required
         page, containing factual information about the given entity.
@@ -28,13 +30,7 @@ def search_wiki(entity: str) -> str:
         str: The search result. If the page corresponding to the entity
             exists, return the summary of this entity in a string.
     """
-    try:
-        import wikipedia
-    except ImportError:
-        raise ImportError(
-            "Please install `wikipedia` first. You can install it by running "
-            "`pip install wikipedia`."
-        )
+    import wikipedia
 
     result: str
 
@@ -241,6 +237,7 @@ def search_google(
     return responses
 
 
+@dependencies_required('wolframalpha')
 def query_wolfram_alpha(query: str, is_detailed: bool) -> str:
     r"""Queries Wolfram|Alpha and returns the result. Wolfram|Alpha is an
     answer engine developed by Wolfram Research. It is offered as an online
@@ -255,13 +252,7 @@ def query_wolfram_alpha(query: str, is_detailed: bool) -> str:
     Returns:
         str: The result from Wolfram Alpha, formatted as a string.
     """
-    try:
-        import wolframalpha
-    except ImportError:
-        raise ImportError(
-            "Please install `wolframalpha` first. You can install it by"
-            " running `pip install wolframalpha`."
-        )
+    import wolframalpha
 
     WOLFRAMALPHA_APP_ID = os.environ.get('WOLFRAMALPHA_APP_ID')
     if not WOLFRAMALPHA_APP_ID:

camel/functions/slack_functions.py

@@ -19,6 +19,8 @@ import logging
 import os
 from typing import TYPE_CHECKING, List, Optional
 
+from camel.utils import dependencies_required
+
 if TYPE_CHECKING:
     from ssl import SSLContext
 
@@ -29,6 +31,7 @@ from camel.functions import OpenAIFunction
 logger = logging.getLogger(__name__)
 
 
+@dependencies_required('slack_sdk')
 def _login_slack(
     slack_token: Optional[str] = None,
     ssl: Optional[SSLContext] = None,
@@ -50,13 +53,8 @@ def _login_slack(
         KeyError: If SLACK_BOT_TOKEN or SLACK_USER_TOKEN environment variables
             are not set.
     """
-    try:
-        from slack_sdk import WebClient
-    except ImportError as e:
-        raise ImportError(
-            "Cannot import slack_sdk. Please install the package with \
-            `pip install slack_sdk`."
-        ) from e
+    from slack_sdk import WebClient
+
     if not slack_token:
         slack_token = os.environ.get("SLACK_BOT_TOKEN") or os.environ.get(
             "SLACK_USER_TOKEN"

camel/functions/twitter_function.py

@@ -20,6 +20,7 @@ from typing import List, Optional, Tuple, Union
 import requests
 
 from camel.functions import OpenAIFunction
+from camel.utils import dependencies_required
 
 TWEET_TEXT_LIMIT = 280
 
@@ -55,6 +56,7 @@ def get_twitter_api_key() -> Tuple[str, str]:
     return TWITTER_CONSUMER_KEY, TWITTER_CONSUMER_SECRET
 
 
+@dependencies_required('requests_oauthlib')
 def get_oauth_session() -> requests.Session:
     r'''Initiates an OAuth1Session with Twitter's API and returns it.
 
@@ -75,14 +77,7 @@ def get_oauth_session() -> requests.Session:
         https://github.com/twitterdev/Twitter-API-v2-sample-code/blob/main/Manage-Tweets/create_tweet.py
         https://github.com/twitterdev/Twitter-API-v2-sample-code/blob/main/User-Lookup/get_users_me_user_context.py
     '''
-    try:
-        from requests_oauthlib import OAuth1Session
-    except ImportError:
-        raise ImportError(
-            "Please install `requests_oauthlib` first. You can "
-            "install it by running `pip install "
-            "requests_oauthlib`."
-        )
+    from requests_oauthlib import OAuth1Session
 
     consumer_key, consumer_secret = get_twitter_api_key()
 

camel/functions/weather_functions.py

@@ -15,6 +15,7 @@ import os
 from typing import List, Literal
 
 from camel.functions.openai_function import OpenAIFunction
+from camel.utils import dependencies_required
 
 
 def get_openweathermap_api_key() -> str:
@@ -37,6 +38,7 @@ def get_openweathermap_api_key() -> str:
     return OPENWEATHERMAP_API_KEY
 
 
+@dependencies_required('pyowm')
 def get_weather_data(
     city: str,
     temp_units: Literal['kelvin', 'celsius', 'fahrenheit'] = 'kelvin',
@@ -85,14 +87,7 @@ def get_weather_data(
     """
     # NOTE: This tool may not work as expected since the input arguments like
     # `time_units` should be enum types which are not supported yet.
-
-    try:
-        import pyowm
-    except ImportError:
-        raise ImportError(
-            "Please install `pyowm` first. You can install it by running "
-            "`pip install pyowm`."
-        )
+    import pyowm
 
     OPENWEATHERMAP_API_KEY = get_openweathermap_api_key()
     owm = pyowm.OWM(OPENWEATHERMAP_API_KEY)

camel/interpreters/__init__.py

@@ -13,6 +13,7 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 
 from .base import BaseInterpreter
+from .docker_interpreter import DockerInterpreter
 from .internal_python_interpreter import InternalPythonInterpreter
 from .interpreter_error import InterpreterError
 from .subprocess_interpreter import SubprocessInterpreter
@@ -22,4 +23,5 @@ __all__ = [
     'InterpreterError',
     'InternalPythonInterpreter',
     'SubprocessInterpreter',
+    'DockerInterpreter',
 ]

camel/interpreters/docker_interpreter.py

@@ -0,0 +1,235 @@
+# =========== 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 io
+import shlex
+import tarfile
+import uuid
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional
+
+from colorama import Fore
+
+from camel.interpreters.base import BaseInterpreter
+from camel.interpreters.interpreter_error import InterpreterError
+from camel.utils import is_docker_running
+
+if TYPE_CHECKING:
+    from docker.models.containers import Container
+
+
+class DockerInterpreter(BaseInterpreter):
+    r"""A class for executing code files or code strings in a docker container.
+
+    This class handles the execution of code in different scripting languages
+    (currently Python and Bash) within a docker container, 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. Defaults to `True`.
+        print_stdout (bool, optional): If `True`, print the standard
+            output of the executed code. Defaults to `False`.
+        print_stderr (bool, optional): If `True`, print the standard error
+            of the executed code. Defaults to `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
+
+        # lazy initialization of container
+        self._container: Optional[Container] = None
+
+    def __del__(self) -> None:
+        if self._container is not None:
+            self._container.remove(force=True)
+
+    def _initialize_if_needed(self) -> None:
+        if self._container is not None:
+            return
+
+        if not is_docker_running():
+            raise InterpreterError(
+                "Docker daemon is not running. Please install/start docker "
+                "and try again."
+            )
+
+        import docker
+
+        client = docker.from_env()
+        self._container = client.containers.run(
+            "python:3.10",
+            detach=True,
+            name=f"camel-interpreter-{uuid.uuid4()}",
+            command="tail -f /dev/null",
+        )
+
+    def _create_file_in_container(self, content: str) -> Path:
+        # get a random name for the file
+        filename = str(uuid.uuid4())
+        # create a tar in memory
+        tar_stream = io.BytesIO()
+        with tarfile.open(fileobj=tar_stream, mode='w') as tar:
+            tarinfo = tarfile.TarInfo(name=filename)
+            tarinfo.size = len(content)
+            tar.addfile(tarinfo, io.BytesIO(content.encode('utf-8')))
+        tar_stream.seek(0)
+
+        # copy the tar into the container
+        if self._container is None:
+            raise InterpreterError(
+                "Container is not initialized. Try running the code again."
+            )
+        self._container.put_archive("/tmp", tar_stream)
+        return Path(f"/tmp/{filename}")
+
+    def _run_file_in_container(
+        self,
+        file: Path,
+        code_type: str,
+    ) -> str:
+        code_type = self._check_code_type(code_type)
+        commands = shlex.split(
+            self._CODE_EXECUTE_CMD_MAPPING[code_type].format(
+                file_name=str(file)
+            )
+        )
+        if self._container is None:
+            raise InterpreterError(
+                "Container is not initialized. Try running the code again."
+            )
+        stdout, stderr = self._container.exec_run(
+            commands,
+            demux=True,
+        ).output
+
+        if self.print_stdout and stdout:
+            print("======stdout======")
+            print(Fore.GREEN + stdout.decode() + Fore.RESET)
+            print("==================")
+        if self.print_stderr and stderr:
+            print("======stderr======")
+            print(Fore.RED + stderr.decode() + Fore.RESET)
+            print("==================")
+        exec_result = f"{stdout.decode()}" if stdout else ""
+        exec_result += f"(stderr: {stderr.decode()})" if stderr else ""
+        return exec_result
+
+    def run(
+        self,
+        code: str,
+        code_type: str,
+    ) -> str:
+        r"""Executes the given code in the conatiner attached to the
+        interpreter, and captures the stdout and stderr streams.
+
+        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 the
+                code type is unsupported, or there is an error in the docker
+                API/container
+        """
+        import docker.errors
+
+        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 in container:")
+            print(Fore.CYAN + code + Fore.RESET)
+            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."
+                )
+
+        self._initialize_if_needed()
+
+        try:
+            temp_file_path = self._create_file_in_container(code)
+            result = self._run_file_in_container(temp_file_path, code_type)
+        except docker.errors.APIError as e:
+            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:
+            raise InterpreterError(
+                f"Execution halted due to docker exceptoin: {e}. "
+                "This choice stops the current operation and any "
+                "further code execution."
+            ) from e
+        return result
+
+    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`."
+        )