ag2 0.9.7__py3-none-any.whl → 0.9.9__py3-none-any.whl

autogen/cache/redis_cache.py

@@ -7,7 +7,7 @@
 import pickle
 import sys
 from types import TracebackType
-from typing import Any, Optional, Union
+from typing import Any
 
 if sys.version_info >= (3, 11):
     from typing import Self
@@ -42,7 +42,7 @@ class RedisCache(AbstractCache):
         __exit__(self, exc_type, exc_value, traceback): Context management exit.
     """
 
-    def __init__(self, seed: Union[str, int], redis_url: str):
+    def __init__(self, seed: str | int, redis_url: str):
         """Initialize the RedisCache instance.
 
         Args:
@@ -64,7 +64,7 @@ class RedisCache(AbstractCache):
         """
         return f"autogen:{self.seed}:{key}"
 
-    def get(self, key: str, default: Optional[Any] = None) -> Optional[Any]:
+    def get(self, key: str, default: Any | None = None) -> Any | None:
         """Retrieve an item from the Redis cache.
 
         Args:
@@ -109,7 +109,7 @@ class RedisCache(AbstractCache):
         return self
 
     def __exit__(
-        self, exc_type: Optional[type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
     ) -> None:
         """Exit the runtime context related to the object.
 

autogen/code_utils.py

@@ -13,18 +13,18 @@ import subprocess
 import sys
 import time
 import venv
+from collections.abc import Callable
 from concurrent.futures import ThreadPoolExecutor, TimeoutError
 from hashlib import md5
 from types import SimpleNamespace
-from typing import Callable, Optional, Union
 
 import docker
 
 from .types import UserMessageImageContentPart, UserMessageTextContentPart
 
 SENTINEL = object()
-DEFAULT_MODEL = "gpt-4"
-FAST_MODEL = "gpt-3.5-turbo"
+DEFAULT_MODEL = "gpt-5"
+FAST_MODEL = "gpt-5-nano"
 # Regular expression for finding a code block
 # ```[ \t]*(\w+)?[ \t]*\r?\n(.*?)[ \t]*\r?\n``` Matches multi-line code blocks.
 #   The [ \t]* matches the potential spaces before language name.
@@ -46,7 +46,7 @@ PYTHON_VARIANTS = ["python", "Python", "py"]
 logger = logging.getLogger(__name__)
 
 
-def content_str(content: Union[str, list[Union[UserMessageTextContentPart, UserMessageImageContentPart]], None]) -> str:
+def content_str(content: str | list[UserMessageTextContentPart | UserMessageImageContentPart] | None) -> str:
     """Converts the `content` field of an OpenAI message into a string format.
 
     This function processes content that may be a string, a list of mixed text and image URLs, or None,
@@ -107,7 +107,7 @@ def infer_lang(code: str) -> str:
 # TODO: In the future move, to better support https://spec.commonmark.org/0.30/#fenced-code-blocks
 #       perhaps by using a full Markdown parser.
 def extract_code(
-    text: Union[str, list], pattern: str = CODE_BLOCK_PATTERN, detect_single_line_code: bool = False
+    text: str | list, pattern: str = CODE_BLOCK_PATTERN, detect_single_line_code: bool = False
 ) -> list[tuple[str, str]]:
     """Extract code from a text.
 
@@ -216,7 +216,7 @@ def in_docker_container() -> bool:
     return os.path.exists("/.dockerenv")
 
 
-def decide_use_docker(use_docker: Optional[bool]) -> Optional[bool]:
+def decide_use_docker(use_docker: bool | None) -> bool | None:
     if use_docker is None:
         env_var_use_docker = os.environ.get("AUTOGEN_USE_DOCKER", "True")
 
@@ -279,13 +279,13 @@ def _sanitize_filename_for_docker_tag(filename: str) -> str:
 
 
 def execute_code(
-    code: Optional[str] = None,
-    timeout: Optional[int] = None,
-    filename: Optional[str] = None,
-    work_dir: Optional[str] = None,
-    use_docker: Union[list[str], str, bool] = SENTINEL,
-    lang: Optional[str] = "python",
-) -> tuple[int, str, Optional[str]]:
+    code: str | None = None,
+    timeout: int | None = None,
+    filename: str | None = None,
+    work_dir: str | None = None,
+    use_docker: list[str] | str | bool = SENTINEL,
+    lang: str | None = "python",
+) -> tuple[int, str, str | None]:
     """Execute code in a docker container.
     This function is not tested on MacOS.
 
@@ -491,11 +491,11 @@ def _remove_check(response):
 def eval_function_completions(
     responses: list[str],
     definition: str,
-    test: Optional[str] = None,
-    entry_point: Optional[str] = None,
-    assertions: Optional[Union[str, Callable[[str], tuple[str, float]]]] = None,
-    timeout: Optional[float] = 3,
-    use_docker: Optional[bool] = True,
+    test: str | None = None,
+    entry_point: str | None = None,
+    assertions: str | Callable[[str], tuple[str, float]] | None = None,
+    timeout: float | None = 3,
+    use_docker: bool | None = True,
 ) -> dict:
     """`(openai<1)` Select a response from a list of responses for the function completion task (using generated assertions), and/or evaluate if the task is successful using a gold test.
 

autogen/coding/base.py

@@ -7,7 +7,7 @@
 from __future__ import annotations
 
 from collections.abc import Mapping
-from typing import Any, Literal, Optional, Protocol, TypedDict, Union, runtime_checkable
+from typing import Any, Literal, Protocol, TypedDict, runtime_checkable
 
 from pydantic import BaseModel, Field
 
@@ -40,7 +40,7 @@ class CodeExtractor(Protocol):
     """(Experimental) A code extractor class that extracts code blocks from a message."""
 
     def extract_code_blocks(
-        self, message: Optional[Union[str, list[Union[UserMessageTextContentPart, UserMessageImageContentPart]]]]
+        self, message: str | list[UserMessageTextContentPart | UserMessageImageContentPart] | None
     ) -> list[CodeBlock]:
         """(Experimental) Extract code blocks from a message.
 
@@ -98,10 +98,10 @@ class IPythonCodeResult(CodeResult):
 CodeExecutionConfig = TypedDict(
     "CodeExecutionConfig",
     {
-        "executor": Union[Literal["ipython-embedded", "commandline-local"], CodeExecutor],
-        "last_n_messages": Union[int, Literal["auto"]],
+        "executor": Literal["ipython-embedded", "commandline-local"] | CodeExecutor,
+        "last_n_messages": int | Literal["auto"],
         "timeout": int,
-        "use_docker": Union[bool, str, list[str]],
+        "use_docker": bool | str | list[str],
         "work_dir": str,
         "ipython-embedded": Mapping[str, Any],
         "commandline-local": Mapping[str, Any],
@@ -113,7 +113,7 @@ CodeExecutionConfig = TypedDict(
 class CommandLineCodeResult(CodeResult):
     """(Experimental) A code result class for command line code executor."""
 
-    code_file: Optional[str] = Field(
+    code_file: str | None = Field(
         default=None,
         description="The file that the executed code block was saved to.",
     )

autogen/coding/docker_commandline_code_executor.py

@@ -14,7 +14,7 @@ from hashlib import md5
 from pathlib import Path
 from time import sleep
 from types import TracebackType
-from typing import Any, ClassVar, Optional, Union
+from typing import Any, ClassVar
 
 import docker
 from docker.errors import ImageNotFound
@@ -64,15 +64,15 @@ class DockerCommandLineCodeExecutor(CodeExecutor):
     def __init__(
         self,
         image: str = "python:3-slim",
-        container_name: Optional[str] = None,
+        container_name: str | None = None,
         timeout: int = 60,
-        work_dir: Optional[Union[Path, str]] = None,
-        bind_dir: Optional[Union[Path, str]] = None,
+        work_dir: Path | str | None = None,
+        bind_dir: Path | str | None = None,
         auto_remove: bool = True,
         stop_container: bool = True,
-        execution_policies: Optional[dict[str, bool]] = None,
+        execution_policies: dict[str, bool] | None = None,
         *,
-        container_create_kwargs: Optional[dict[str, Any]] = None,
+        container_create_kwargs: dict[str, Any] | None = None,
     ):
         """(Experimental) A code executor class that executes code through
         a command line environment in a Docker container.
@@ -281,8 +281,8 @@ class DockerCommandLineCodeExecutor(CodeExecutor):
 
     def __exit__(
         self,
-        exc_type: Optional[type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> None:
         self.stop()

autogen/coding/func_with_reqs.py

@@ -8,10 +8,11 @@
 import functools
 import importlib
 import inspect
+from collections.abc import Callable
 from dataclasses import dataclass, field
 from importlib.abc import SourceLoader
 from textwrap import dedent, indent
-from typing import Any, Callable, Generic, TypeVar, Union
+from typing import Any, Generic, TypeVar, Union
 
 from typing_extensions import ParamSpec
 
@@ -39,10 +40,10 @@ class Alias:
 @dataclass
 class ImportFromModule:
     module: str
-    imports: list[Union[str, Alias]]
+    imports: list[str | Alias]
 
 
-Import = Union[str, ImportFromModule, Alias]
+Import = str | ImportFromModule | Alias
 
 
 def _import_to_str(im: Import) -> str:
@@ -52,7 +53,7 @@ def _import_to_str(im: Import) -> str:
         return f"import {im.name} as {im.alias}"
     else:
 
-        def to_str(i: Union[str, Alias]) -> str:
+        def to_str(i: str | Alias) -> str:
             if isinstance(i, str):
                 return i
             else:
@@ -161,7 +162,7 @@ def with_requirements(
 
 
 def _build_python_functions_file(
-    funcs: list[Union[FunctionWithRequirements[Any, P], Callable[..., Any], FunctionWithRequirementsStr]],
+    funcs: list[FunctionWithRequirements[Any, P] | Callable[..., Any] | FunctionWithRequirementsStr],
 ) -> str:
     # First collect all global imports
     global_imports: set[str] = set()
@@ -177,7 +178,7 @@ def _build_python_functions_file(
     return content
 
 
-def to_stub(func: Union[Callable[..., Any], FunctionWithRequirementsStr]) -> str:
+def to_stub(func: Callable[..., Any] | FunctionWithRequirementsStr) -> str:
     """Generate a stub for a function as a string
 
     Args:

autogen/coding/jupyter/base.py

@@ -5,7 +5,7 @@
 # Portions derived from https://github.com/microsoft/autogen are under the MIT License.
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Optional, Protocol, runtime_checkable
+from typing import Protocol, runtime_checkable
 
 from ...doc_utils import export_module
 
@@ -19,9 +19,9 @@ class JupyterConnectionInfo:
     """`str` - Host of the Jupyter gateway server"""
     use_https: bool
     """`bool` - Whether to use HTTPS"""
-    port: Optional[int] = None
+    port: int | None = None
     """`Optional[int]` - Port of the Jupyter gateway server. If None, the default port is used"""
-    token: Optional[str] = None
+    token: str | None = None
     """`Optional[str]` - Token for authentication. If None, no token is used"""
 
 

autogen/coding/jupyter/docker_jupyter_server.py

@@ -14,7 +14,6 @@ import sys
 import uuid
 from pathlib import Path
 from types import TracebackType
-from typing import Optional
 
 import docker
 
@@ -62,8 +61,8 @@ WORKDIR "${HOME}"
     def __init__(
         self,
         *,
-        custom_image_name: Optional[str] = None,
-        container_name: Optional[str] = None,
+        custom_image_name: str | None = None,
+        container_name: str | None = None,
         auto_remove: bool = True,
         stop_container: bool = True,
         docker_env: dict[str, str] = {},
@@ -162,6 +161,6 @@ WORKDIR "${HOME}"
         return self
 
     def __exit__(
-        self, exc_type: Optional[type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
     ) -> None:
         self.stop()

autogen/coding/jupyter/import_utils.py

@@ -3,9 +3,10 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import subprocess
+from collections.abc import Callable
 from functools import lru_cache
 from logging import getLogger
-from typing import Callable, TypeVar
+from typing import TypeVar
 
 from ...import_utils import patch_object
 
@@ -20,8 +21,7 @@ def is_jupyter_kernel_gateway_installed() -> bool:
     try:
         subprocess.run(
             ["jupyter", "kernelgateway", "--version"],
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
+            capture_output=True,
             check=True,
         )
         return True

autogen/coding/jupyter/jupyter_client.py

@@ -12,7 +12,7 @@ import sys
 import uuid
 from dataclasses import dataclass
 from types import TracebackType
-from typing import Any, Optional, cast
+from typing import Any, cast
 
 from ...doc_utils import export_module
 
@@ -126,7 +126,7 @@ class JupyterKernelClient:
         return self
 
     def __exit__(
-        self, exc_type: Optional[type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
     ) -> None:
         self.stop()
 
@@ -154,7 +154,7 @@ class JupyterKernelClient:
         self._websocket.send_text(json.dumps(message))
         return message_id
 
-    def _receive_message(self, timeout_seconds: Optional[float]) -> Optional[dict[str, Any]]:
+    def _receive_message(self, timeout_seconds: float | None) -> dict[str, Any] | None:
         self._websocket.settimeout(timeout_seconds)
         try:
             data = self._websocket.recv()
@@ -164,7 +164,7 @@ class JupyterKernelClient:
         except websocket.WebSocketTimeoutException:
             return None
 
-    def wait_for_ready(self, timeout_seconds: Optional[float] = None) -> bool:
+    def wait_for_ready(self, timeout_seconds: float | None = None) -> bool:
         message_id = self._send_message(content={}, channel="shell", message_type="kernel_info_request")
         while True:
             message = self._receive_message(timeout_seconds)
@@ -177,7 +177,7 @@ class JupyterKernelClient:
             ):
                 return True
 
-    def execute(self, code: str, timeout_seconds: Optional[float] = None) -> ExecutionResult:
+    def execute(self, code: str, timeout_seconds: float | None = None) -> ExecutionResult:
         message_id = self._send_message(
             content={
                 "code": code,

autogen/coding/jupyter/jupyter_code_executor.py

@@ -11,7 +11,6 @@ import sys
 import uuid
 from pathlib import Path
 from types import TracebackType
-from typing import Optional, Union
 
 from ...doc_utils import export_module
 
@@ -31,10 +30,10 @@ from .jupyter_client import JupyterClient
 class JupyterCodeExecutor(CodeExecutor):
     def __init__(
         self,
-        jupyter_server: Union[JupyterConnectable, JupyterConnectionInfo],
+        jupyter_server: JupyterConnectable | JupyterConnectionInfo,
         kernel_name: str = "python3",
         timeout: int = 60,
-        output_dir: Union[Path, str] = Path(),
+        output_dir: Path | str = Path(),
     ):
         """(Experimental) A code executor class that executes code statefully using
         a Jupyter server supplied to this class.
@@ -155,6 +154,6 @@ class JupyterCodeExecutor(CodeExecutor):
         return self
 
     def __exit__(
-        self, exc_type: Optional[type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
     ) -> None:
         self.stop()

autogen/coding/jupyter/local_jupyter_server.py

@@ -13,7 +13,6 @@ import signal
 import subprocess
 import sys
 from types import TracebackType
-from typing import Optional
 
 from ...doc_utils import export_module
 
@@ -36,7 +35,7 @@ class LocalJupyterServer(JupyterConnectable):
     def __init__(
         self,
         ip: str = "127.0.0.1",
-        port: Optional[int] = None,
+        port: int | None = None,
         token: str | GenerateToken = GenerateToken(),
         log_file: str = "jupyter_gateway.log",
         log_level: str = "INFO",
@@ -54,9 +53,6 @@ class LocalJupyterServer(JupyterConnectable):
             log_max_bytes (int, optional): Max logfile size. Defaults to 1048576.
             log_backup_count (int, optional): Number of backups for rotating log. Defaults to 3.
         """
-        # Remove as soon as https://github.com/jupyter-server/kernel_gateway/issues/398 is fixed
-        if sys.platform == "win32":
-            raise ValueError("LocalJupyterServer is not supported on Windows due to kernelgateway bug.")
 
         # Check Jupyter gateway server is installed
         try:
@@ -167,6 +163,6 @@ class LocalJupyterServer(JupyterConnectable):
         return self
 
     def __exit__(
-        self, exc_type: Optional[type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
+        self, exc_type: type[BaseException] | None, exc_val: BaseException | None, exc_tb: TracebackType | None
     ) -> None:
         self.stop()

autogen/coding/local_commandline_code_executor.py

@@ -10,11 +10,12 @@ import re
 import subprocess
 import sys
 import warnings
+from collections.abc import Callable
 from hashlib import md5
 from pathlib import Path
 from string import Template
 from types import SimpleNamespace
-from typing import Any, Callable, ClassVar, Optional, Union
+from typing import Any, ClassVar
 
 from typing_extensions import ParamSpec
 
@@ -73,11 +74,11 @@ $functions"""
     def __init__(
         self,
         timeout: int = 60,
-        virtual_env_context: Optional[SimpleNamespace] = None,
-        work_dir: Union[Path, str] = Path(),
-        functions: list[Union[FunctionWithRequirements[Any, A], Callable[..., Any], FunctionWithRequirementsStr]] = [],
+        virtual_env_context: SimpleNamespace | None = None,
+        work_dir: Path | str = Path(),
+        functions: list[FunctionWithRequirements[Any, A] | Callable[..., Any] | FunctionWithRequirementsStr] = [],
         functions_module: str = "functions",
-        execution_policies: Optional[dict[str, bool]] = None,
+        execution_policies: dict[str, bool] | None = None,
     ):
         """(Experimental) A code executor class that executes or saves LLM generated code a local command line
         environment.
@@ -128,7 +129,7 @@ $functions"""
 
         self._timeout = timeout
         self._work_dir: Path = work_dir
-        self._virtual_env_context: Optional[SimpleNamespace] = virtual_env_context
+        self._virtual_env_context: SimpleNamespace | None = virtual_env_context
 
         self._functions = functions
         # Setup could take some time so we intentionally wait for the first code block to do it.
@@ -168,7 +169,7 @@ $functions"""
     @property
     def functions(
         self,
-    ) -> list[Union[FunctionWithRequirements[Any, A], Callable[..., Any], FunctionWithRequirementsStr]]:
+    ) -> list[FunctionWithRequirements[Any, A] | Callable[..., Any] | FunctionWithRequirementsStr]:
         """(Experimental) The functions that are available to the code executor."""
         return self._functions
 

autogen/coding/markdown_code_extractor.py

@@ -5,7 +5,6 @@
 # Portions derived from https://github.com/microsoft/autogen are under the MIT License.
 # SPDX-License-Identifier: MIT
 import re
-from typing import Union
 
 from ..code_utils import CODE_BLOCK_PATTERN, UNKNOWN, content_str, infer_lang
 from ..doc_utils import export_module
@@ -20,7 +19,7 @@ class MarkdownCodeExtractor(CodeExtractor):
     """(Experimental) A class that extracts code blocks from a message using Markdown syntax."""
 
     def extract_code_blocks(
-        self, message: Union[str, list[Union[UserMessageTextContentPart, UserMessageImageContentPart]], None]
+        self, message: str | list[UserMessageTextContentPart | UserMessageImageContentPart] | None
     ) -> list[CodeBlock]:
         """(Experimental) Extract code blocks from a message. If no code blocks are found,
         return an empty list.

autogen/coding/utils.py

@@ -7,7 +7,6 @@
 # Will return the filename relative to the workspace path
 import re
 from pathlib import Path
-from typing import Optional
 
 filename_patterns = [
     re.compile(r"^<!-- (filename:)?(.+?) -->", re.DOTALL),
@@ -18,7 +17,7 @@ filename_patterns = [
 
 
 # Raises ValueError if the file is not in the workspace
-def _get_file_name_from_content(code: str, workspace_path: Path) -> Optional[str]:
+def _get_file_name_from_content(code: str, workspace_path: Path) -> str | None:
     first_line = code.split("\n")[0].strip()
     # TODO - support other languages
     for pattern in filename_patterns:

autogen/doc_utils.py

@@ -4,7 +4,8 @@
 
 __all__ = ["export_module"]
 
-from typing import Callable, Optional, TypeVar
+from collections.abc import Callable
+from typing import TypeVar
 
 T = TypeVar("T")
 
@@ -25,7 +26,7 @@ def export_module(module: str) -> Callable[[T], T]:
     return decorator
 
 
-def get_target_module(obj: object) -> Optional[str]:
+def get_target_module(obj: object) -> str | None:
     """Get the target module where an object should be documented."""
     if not hasattr(obj, "__module__"):
         return None

autogen/environments/docker_python_environment.py

@@ -8,7 +8,7 @@ import shutil
 import subprocess
 import tempfile
 import uuid
-from typing import Any, Optional, Tuple
+from typing import Any
 
 from asyncer import asyncify
 
@@ -24,19 +24,18 @@ class DockerPythonEnvironment(PythonEnvironment):
         self,
         image: str = "python:3.11-slim",
         container_name_prefix: str = "ag2_docker_env_",
-        volumes: Optional[dict[str, str]] = None,
-        environment: Optional[dict[str, str]] = None,
-        network: Optional[str] = None,
-        pip_packages: Optional[list[str]] = None,
-        requirements_file: Optional[str] = None,
-        dockerfile: Optional[str] = None,
-        build_args: Optional[dict[str, str]] = None,
+        volumes: dict[str, str] | None = None,
+        environment: dict[str, str] | None = None,
+        network: str | None = None,
+        pip_packages: list[str] | None = None,
+        requirements_file: str | None = None,
+        dockerfile: str | None = None,
+        build_args: dict[str, str] | None = None,
         cleanup_container: bool = True,
         keep_container_running: bool = False,
         container_startup_timeout: int = 30,
     ):
-        """
-        Initialize a Docker Python environment.
+        """Initialize a Docker Python environment.
 
         Args:
             image: Docker image to use (ignored if dockerfile is provided)
@@ -99,8 +98,7 @@ class DockerPythonEnvironment(PythonEnvironment):
                 subprocess.run(
                     ["docker", "pull", self.image],
                     check=True,
-                    stdout=subprocess.PIPE,
-                    stderr=subprocess.PIPE,
+                    capture_output=True,
                     text=True,
                 )
                 logging.info(f"Pulled Docker image: {self.image}")
@@ -133,8 +131,7 @@ class DockerPythonEnvironment(PythonEnvironment):
             _ = subprocess.run(
                 build_cmd,
                 check=True,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
+                capture_output=True,
                 text=True,
             )
             logging.info(f"Built custom Docker image: {self._custom_image_name}")
@@ -185,8 +182,7 @@ class DockerPythonEnvironment(PythonEnvironment):
             result = subprocess.run(
                 run_cmd,
                 check=True,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE,
+                capture_output=True,
                 text=True,
             )
 
@@ -211,8 +207,7 @@ class DockerPythonEnvironment(PythonEnvironment):
                 _ = subprocess.run(
                     ["docker", "exec", self._container_name, "pip", "install", "--no-cache-dir"] + self.pip_packages,
                     check=True,
-                    stdout=subprocess.PIPE,
-                    stderr=subprocess.PIPE,
+                    capture_output=True,
                     text=True,
                 )
                 logging.info("Successfully installed pip packages")
@@ -241,8 +236,7 @@ class DockerPythonEnvironment(PythonEnvironment):
                             f"/workspace/{req_filename}",
                         ],
                         check=True,
-                        stdout=subprocess.PIPE,
-                        stderr=subprocess.PIPE,
+                        capture_output=True,
                         text=True,
                     )
                     logging.info("Successfully installed requirements")
@@ -261,8 +255,7 @@ class DockerPythonEnvironment(PythonEnvironment):
                     subprocess.run(
                         ["docker", "stop", self._container_name],
                         check=True,
-                        stdout=subprocess.PIPE,
-                        stderr=subprocess.PIPE,
+                        capture_output=True,
                         text=True,
                     )
                 except subprocess.CalledProcessError:
@@ -275,8 +268,7 @@ class DockerPythonEnvironment(PythonEnvironment):
                     subprocess.run(
                         ["docker", "rm", "-f", self._container_name],
                         check=True,
-                        stdout=subprocess.PIPE,
-                        stderr=subprocess.PIPE,
+                        capture_output=True,
                         text=True,
                     )
                 except subprocess.CalledProcessError:
@@ -289,8 +281,7 @@ class DockerPythonEnvironment(PythonEnvironment):
                     subprocess.run(
                         ["docker", "rmi", self._custom_image_name],
                         check=True,
-                        stdout=subprocess.PIPE,
-                        stderr=subprocess.PIPE,
+                        capture_output=True,
                         text=True,
                     )
                 except subprocess.CalledProcessError:
@@ -350,9 +341,8 @@ class DockerPythonEnvironment(PythonEnvironment):
         except Exception as e:
             return {"success": False, "error": f"Execution error: {str(e)}"}
 
-    def _run_subprocess_with_timeout(self, cmd: list[str], timeout: int) -> Tuple[bool, str, str, int]:
-        """
-        Run a subprocess with timeout and return status, stdout, stderr, and return code.
+    def _run_subprocess_with_timeout(self, cmd: list[str], timeout: int) -> tuple[bool, str, str, int]:
+        """Run a subprocess with timeout and return status, stdout, stderr, and return code.
 
         Args:
             cmd: Command to run as a list of strings