devservices 1.0.4__tar.gz → 1.0.6__tar.gz

{devservices-1.0.4 → devservices-1.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: devservices
-Version: 1.0.4
+Version: 1.0.6
 Requires-Python: >=3.10
 License-File: LICENSE.md
 Requires-Dist: pyyaml

{devservices-1.0.4 → devservices-1.0.6}/README.md

@@ -11,7 +11,7 @@ A standalone cli tool used to manage dependencies for services. It simplifies th
 The recommended way to install devservices is through a virtualenv in the requirements.txt.
 
 ```
-devservices==1.0.4
+devservices==1.0.6
 ```
 
 

{devservices-1.0.4 → devservices-1.0.6}/devservices/commands/down.py

@@ -56,10 +56,13 @@ def down(args: Namespace) -> None:
     service_name = args.service_name
     try:
         service = find_matching_service(service_name)
-    except (ConfigError, ServiceNotFoundError) as e:
+    except ConfigError as e:
         capture_exception(e)
         console.failure(str(e))
         exit(1)
+    except ServiceNotFoundError as e:
+        console.failure(str(e))
+        exit(1)
 
     modes = service.config.modes
 
@@ -69,24 +72,34 @@ def down(args: Namespace) -> None:
         console.warning(f"{service.name} is not running")
         exit(0)
 
-    mode = state.get_mode_for_service(service.name) or "default"
-    mode_dependencies = modes[mode]
+    active_modes = state.get_active_modes_for_service(service.name)
+    mode_dependencies = set()
+    for active_mode in active_modes:
+        active_mode_dependencies = modes.get(active_mode, [])
+        mode_dependencies.update(active_mode_dependencies)
 
     with Status(
         lambda: console.warning(f"Stopping {service.name}"),
         lambda: console.success(f"{service.name} stopped"),
     ) as status:
         try:
-            remote_dependencies = install_and_verify_dependencies(service, mode=mode)
+            remote_dependencies = install_and_verify_dependencies(
+                service, modes=active_modes
+            )
+        except DependencyError as de:
+            capture_exception(de)
+            status.failure(str(de))
+            exit(1)
+        try:
+            remote_dependencies = get_non_shared_remote_dependencies(
+                service, remote_dependencies
+            )
         except DependencyError as de:
             capture_exception(de)
             status.failure(str(de))
             exit(1)
-        remote_dependencies = get_non_shared_remote_dependencies(
-            service, remote_dependencies
-        )
         try:
-            _down(service, remote_dependencies, mode_dependencies, status)
+            _down(service, remote_dependencies, list(mode_dependencies), status)
         except DockerComposeError as dce:
             capture_exception(dce)
             status.failure(f"Failed to stop {service.name}: {dce.stderr}")

{devservices-1.0.4 → devservices-1.0.6}/devservices/commands/list_dependencies.py

@@ -32,10 +32,13 @@ def list_dependencies(args: Namespace) -> None:
 
     try:
         service = find_matching_service(service_name)
-    except (ConfigError, ServiceNotFoundError) as e:
+    except ConfigError as e:
         capture_exception(e)
         console.failure(str(e))
         exit(1)
+    except ServiceNotFoundError as e:
+        console.failure(str(e))
+        exit(1)
 
     dependencies = service.config.dependencies
 
@@ -45,4 +48,4 @@ def list_dependencies(args: Namespace) -> None:
 
     console.info(f"Dependencies of {service.name}:")
     for dependency_key, dependency_info in dependencies.items():
-        console.info("-" + dependency_key + ":" + dependency_info.description)
+        console.info("- " + dependency_key + ": " + dependency_info.description)

{devservices-1.0.4 → devservices-1.0.6}/devservices/commands/list_services.py

@@ -47,7 +47,9 @@ def list_services(args: Namespace) -> None:
 
     for service in services_to_show:
         status = "running" if service.name in running_services else "stopped"
+        active_modes = state.get_active_modes_for_service(service.name)
         console.info(f"- {service.name}")
+        console.info(f"  modes: {active_modes}")
         console.info(f"  status: {status}")
         console.info(f"  location: {service.repo_path}")
 

{devservices-1.0.4 → devservices-1.0.6}/devservices/commands/logs.py

@@ -46,10 +46,13 @@ def logs(args: Namespace) -> None:
     service_name = args.service_name
     try:
         service = find_matching_service(service_name)
-    except (ConfigError, ServiceNotFoundError) as e:
+    except ConfigError as e:
         capture_exception(e)
         console.failure(str(e))
         exit(1)
+    except ServiceNotFoundError as e:
+        console.failure(str(e))
+        exit(1)
 
     modes = service.config.modes
     # TODO: allow custom modes to be used

{devservices-1.0.4 → devservices-1.0.6}/devservices/commands/purge.py

@@ -8,11 +8,13 @@ from argparse import ArgumentParser
 from argparse import Namespace
 
 from devservices.constants import DEVSERVICES_CACHE_DIR
+from devservices.constants import DEVSERVICES_ORCHESTRATOR_LABEL
 from devservices.constants import DOCKER_NETWORK_NAME
 from devservices.exceptions import DockerDaemonNotRunningError
+from devservices.exceptions import DockerError
 from devservices.utils.console import Console
 from devservices.utils.console import Status
-from devservices.utils.docker import stop_all_running_containers
+from devservices.utils.docker import stop_matching_containers
 from devservices.utils.state import State
 
 
@@ -25,14 +27,6 @@ def purge(_args: Namespace) -> None:
     """Purge the local devservices cache."""
     console = Console()
 
-    # Prompt the user to stop all running containers
-    should_stop_containers = console.confirm(
-        "Warning: Purging stops all running containers and clears devservices state. Would you like to continue?"
-    )
-    if not should_stop_containers:
-        console.warning("Purge canceled")
-        return
-
     if os.path.exists(DEVSERVICES_CACHE_DIR):
         try:
             shutil.rmtree(DEVSERVICES_CACHE_DIR)
@@ -42,13 +36,16 @@ def purge(_args: Namespace) -> None:
     state = State()
     state.clear_state()
     with Status(
-        lambda: console.warning("Stopping all running containers"),
-        lambda: console.success("All running containers have been stopped"),
+        lambda: console.warning("Stopping all running devservices containers"),
+        lambda: console.success("All running devservices containers have been stopped"),
     ):
         try:
-            stop_all_running_containers()
+            stop_matching_containers(DEVSERVICES_ORCHESTRATOR_LABEL, should_remove=True)
         except DockerDaemonNotRunningError:
-            console.warning("The docker daemon not running, no containers to stop")
+            console.warning("The docker daemon is not running, no containers to stop")
+        except DockerError as e:
+            console.failure(f"Failed to stop running devservices containers {e.stderr}")
+            exit(1)
 
     console.warning("Removing any devservices networks")
     devservices_networks = (

{devservices-1.0.4 → devservices-1.0.6}/devservices/commands/status.py

@@ -81,10 +81,13 @@ def status(args: Namespace) -> None:
     service_name = args.service_name
     try:
         service = find_matching_service(service_name)
-    except (ConfigError, ServiceNotFoundError) as e:
+    except ConfigError as e:
         capture_exception(e)
         console.failure(str(e))
         exit(1)
+    except ServiceNotFoundError as e:
+        console.failure(str(e))
+        exit(1)
 
     modes = service.config.modes
     # TODO: allow custom modes to be used

{devservices-1.0.4 → devservices-1.0.6}/devservices/commands/up.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import concurrent.futures
 import os
 import subprocess
 from argparse import _SubParsersAction
@@ -23,7 +22,6 @@ from devservices.exceptions import ServiceNotFoundError
 from devservices.utils.console import Console
 from devservices.utils.console import Status
 from devservices.utils.dependencies import construct_dependency_graph
-from devservices.utils.dependencies import get_non_shared_remote_dependencies
 from devservices.utils.dependencies import install_and_verify_dependencies
 from devservices.utils.dependencies import InstalledRemoteDependency
 from devservices.utils.docker_compose import get_docker_compose_commands_to_run
@@ -58,64 +56,17 @@ def up(args: Namespace) -> None:
     service_name = args.service_name
     try:
         service = find_matching_service(service_name)
-    except (ConfigError, ServiceNotFoundError) as e:
+    except ConfigError as e:
         capture_exception(e)
         console.failure(str(e))
         exit(1)
+    except ServiceNotFoundError as e:
+        console.failure(str(e))
+        exit(1)
 
     modes = service.config.modes
     mode = args.mode
 
-    state = State()
-    started_services = state.get_started_services()
-    running_mode = state.get_mode_for_service(service.name) or "default"
-
-    # TODO: Remove this once we properly handle mode switching
-    if service.name in started_services and running_mode != mode:
-        console.warning(
-            f"Service '{service.name}' is already running in mode: '{running_mode}', restarting in mode: '{mode}'"
-        )
-        with Status() as status:
-            try:
-                remote_dependencies = install_and_verify_dependencies(
-                    service, mode=running_mode
-                )
-            except DependencyError as de:
-                capture_exception(de)
-                status.failure(str(de))
-                exit(1)
-            except ModeDoesNotExistError as mde:
-                capture_exception(mde)
-                status.failure(str(mde))
-                exit(1)
-            service_config_file_path = os.path.join(
-                service.repo_path, DEVSERVICES_DIR_NAME, CONFIG_FILE_NAME
-            )
-            current_env = os.environ.copy()
-            running_mode_dependencies = modes[running_mode]
-            remote_dependencies_to_bring_down = get_non_shared_remote_dependencies(
-                service, remote_dependencies
-            )
-            down_docker_compose_commands = get_docker_compose_commands_to_run(
-                service=service,
-                remote_dependencies=list(remote_dependencies_to_bring_down),
-                current_env=current_env,
-                command="down",
-                options=[],
-                service_config_file_path=service_config_file_path,
-                mode_dependencies=running_mode_dependencies,
-            )
-
-            with concurrent.futures.ThreadPoolExecutor() as executor:
-                futures = [
-                    executor.submit(run_cmd, cmd, current_env)
-                    for cmd in down_docker_compose_commands
-                ]
-                for future in concurrent.futures.as_completed(futures):
-                    future.result()
-
-            state.remove_started_service(service.name)
-
     with Status(
         lambda: console.warning(f"Starting '{service.name}' in mode: '{mode}'"),
         lambda: console.success(f"{service.name} started"),
@@ -123,7 +74,7 @@ def up(args: Namespace) -> None:
         try:
             status.info("Retrieving dependencies")
             remote_dependencies = install_and_verify_dependencies(
-                service, force_update_dependencies=True, mode=mode
+                service, force_update_dependencies=True, modes=[mode]
             )
         except DependencyError as de:
             capture_exception(de)
@@ -139,14 +90,14 @@ def up(args: Namespace) -> None:
             pass
         try:
             mode_dependencies = modes[mode]
-            _up(service, remote_dependencies, mode_dependencies, status)
+            _up(service, [mode], remote_dependencies, mode_dependencies, status)
         except DockerComposeError as dce:
             capture_exception(dce)
             status.failure(f"Failed to start {service.name}: {dce.stderr}")
             exit(1)
     # TODO: We should factor in healthchecks here before marking service as running
     state = State()
-    state.add_started_service(service.name, mode)
+    state.update_started_service(service.name, mode)
 
 
 def _bring_up_dependency(
@@ -160,6 +111,7 @@ def _bring_up_dependency(
 
 def _up(
     service: Service,
+    modes: list[str],
     remote_dependencies: set[InstalledRemoteDependency],
     mode_dependencies: list[str],
     status: Status,
@@ -177,7 +129,7 @@ def _up(
         DEVSERVICES_DEPENDENCIES_CACHE_DIR_KEY
     ] = relative_local_dependency_directory
     options = ["-d"]
-    dependency_graph = construct_dependency_graph(service)
+    dependency_graph = construct_dependency_graph(service, modes=modes)
     starting_order = dependency_graph.get_starting_order()
     sorted_remote_dependencies = sorted(
         remote_dependencies, key=lambda dep: starting_order.index(dep.service_name)

{devservices-1.0.4 → devservices-1.0.6}/devservices/commands/update.py

@@ -7,10 +7,10 @@ from argparse import ArgumentParser
 from argparse import Namespace
 from importlib import metadata
 
-from devservices.commands.check_for_update import check_for_update
 from devservices.constants import DEVSERVICES_DOWNLOAD_URL
 from devservices.exceptions import BinaryInstallError
 from devservices.exceptions import DevservicesUpdateError
+from devservices.utils.check_for_update import check_for_update
 from devservices.utils.console import Console
 from devservices.utils.install_binary import install_binary
 

{devservices-1.0.4 → devservices-1.0.6}/devservices/constants.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import os
+from datetime import timedelta
 
 MINIMUM_DOCKER_COMPOSE_VERSION = "2.29.7"
 DEVSERVICES_DIR_NAME = "devservices"
@@ -12,6 +13,7 @@ DEVSERVICES_LOCAL_DIR = os.path.expanduser("~/.local/share/sentry-devservices")
 DEVSERVICES_DEPENDENCIES_CACHE_DIR = os.path.join(DEVSERVICES_CACHE_DIR, "dependencies")
 DEVSERVICES_DEPENDENCIES_CACHE_DIR_KEY = "DEVSERVICES_DEPENDENCIES_CACHE_DIR"
 STATE_DB_FILE = os.path.join(DEVSERVICES_LOCAL_DIR, "state")
+DEVSERVICES_ORCHESTRATOR_LABEL = "orchestrator=devservices"
 DOCKER_COMPOSE_COMMAND_LENGTH = 7
 
 DEPENDENCY_CONFIG_VERSION = "v1"
@@ -21,9 +23,18 @@ DEPENDENCY_GIT_PARTIAL_CLONE_CONFIG_OPTIONS = {
     "core.sparseCheckout": "true",
 }
 
+DEVSERVICES_RELEASES_URL = (
+    "https://api.github.com/repos/getsentry/devservices/releases/latest"
+)
 DOCKER_COMPOSE_DOWNLOAD_URL = "https://github.com/docker/compose/releases/download"
 DEVSERVICES_DOWNLOAD_URL = "https://github.com/getsentry/devservices/releases/download"
 BINARY_PERMISSIONS = 0o755
 MAX_LOG_LINES = "100"
 LOGGER_NAME = "devservices"
 DOCKER_NETWORK_NAME = "devservices"
+
+# Latest Version Cache
+DEVSERVICES_LATEST_VERSION_CACHE_FILE = os.path.join(
+    DEVSERVICES_CACHE_DIR, "latest_version.txt"
+)
+DEVSERVICES_LATEST_VERSION_CACHE_TTL = timedelta(minutes=15)

{devservices-1.0.4 → devservices-1.0.6}/devservices/exceptions.py

@@ -57,8 +57,8 @@ class DockerComposeInstallationError(BinaryInstallError):
     pass
 
 
-class DockerComposeError(Exception):
-    """Base class for Docker Compose related errors."""
+class DockerError(Exception):
+    """Base class for Docker related errors."""
 
     def __init__(self, command: str, returncode: int, stdout: str, stderr: str):
         self.command = command
@@ -67,6 +67,12 @@ class DockerComposeError(Exception):
         self.stderr = stderr
 
 
+class DockerComposeError(DockerError):
+    """Base class for Docker Compose related errors."""
+
+    pass
+
+
 class ModeDoesNotExistError(Exception):
     """Raised when a mode does not exist."""
 

{devservices-1.0.4 → devservices-1.0.6}/devservices/main.py

@@ -23,10 +23,10 @@ from devservices.commands import purge
 from devservices.commands import status
 from devservices.commands import up
 from devservices.commands import update
-from devservices.commands.check_for_update import check_for_update
 from devservices.constants import LOGGER_NAME
 from devservices.exceptions import DockerComposeInstallationError
 from devservices.exceptions import DockerDaemonNotRunningError
+from devservices.utils.check_for_update import check_for_update
 from devservices.utils.console import Console
 from devservices.utils.docker_compose import check_docker_compose_version
 
@@ -102,7 +102,7 @@ def main() -> None:
     else:
         parser.print_help()
 
-    if args.command != "update":
+    if args.command != "update" and os.environ.get("CI") != "true":
         newest_version = check_for_update()
         if newest_version != current_version:
             console.warning(

devservices-1.0.6/devservices/utils/check_for_update.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import json
+import os
+from datetime import datetime
+from datetime import timedelta
+from urllib.request import urlopen
+
+from devservices.constants import DEVSERVICES_CACHE_DIR
+from devservices.constants import DEVSERVICES_LATEST_VERSION_CACHE_FILE
+from devservices.constants import DEVSERVICES_LATEST_VERSION_CACHE_TTL
+from devservices.constants import DEVSERVICES_RELEASES_URL
+
+
+def _delete_cached_version() -> None:
+    if os.path.exists(DEVSERVICES_LATEST_VERSION_CACHE_FILE):
+        os.remove(DEVSERVICES_LATEST_VERSION_CACHE_FILE)
+
+
+def _get_cache_age() -> timedelta:
+    if os.path.exists(DEVSERVICES_LATEST_VERSION_CACHE_FILE):
+        file_modification_time = datetime.fromtimestamp(
+            os.path.getmtime(DEVSERVICES_LATEST_VERSION_CACHE_FILE)
+        )
+        return datetime.now() - file_modification_time
+    return timedelta.max
+
+
+def _get_cached_version() -> str | None:
+    cache_age = _get_cache_age()
+    if cache_age < DEVSERVICES_LATEST_VERSION_CACHE_TTL:
+        with open(DEVSERVICES_LATEST_VERSION_CACHE_FILE, "r", encoding="utf-8") as f:
+            return f.read()
+    else:
+        _delete_cached_version()
+        return None
+
+
+def _set_cached_version(latest_version: str) -> None:
+    with open(DEVSERVICES_LATEST_VERSION_CACHE_FILE, "w", encoding="utf-8") as f:
+        f.write(latest_version)
+
+
+def check_for_update() -> str | None:
+    os.makedirs(DEVSERVICES_CACHE_DIR, exist_ok=True)
+
+    cached_version = _get_cached_version()
+    if cached_version is not None:
+        return cached_version
+
+    with urlopen(DEVSERVICES_RELEASES_URL) as response:
+        if response.status == 200:
+            data = json.loads(response.read())
+            latest_version = str(data["tag_name"])
+
+            _set_cached_version(latest_version)
+
+            return latest_version
+    return None

{devservices-1.0.4 → devservices-1.0.6}/devservices/utils/dependencies.py

@@ -160,11 +160,20 @@ class GitConfigManager:
 
 
 def install_and_verify_dependencies(
-    service: Service, force_update_dependencies: bool = False, mode: str = "default"
+    service: Service,
+    force_update_dependencies: bool = False,
+    modes: list[str] | None = None,
 ) -> set[InstalledRemoteDependency]:
-    if mode not in service.config.modes:
-        raise ModeDoesNotExistError(service_name=service.name, mode=mode)
-    mode_dependencies = set(service.config.modes[mode])
+    """
+    Install and verify dependencies for a service
+    """
+    if modes is None:
+        modes = ["default"]
+    mode_dependencies = set()
+    for mode in modes:
+        if mode not in service.config.modes:
+            raise ModeDoesNotExistError(service_name=service.name, mode=mode)
+        mode_dependencies.update(service.config.modes[mode])
     matching_dependencies = [
         dependency
         for dependency_key, dependency in list(service.config.dependencies.items())
@@ -346,8 +355,18 @@ def install_dependency(dependency: RemoteConfig) -> set[InstalledRemoteDependenc
                 branch=dependency.branch,
             ) from e
 
-    nested_dependencies = list(installed_config.dependencies.values())
-    nested_remote_configs = _get_remote_configs(nested_dependencies)
+    if dependency.mode not in installed_config.modes:
+        raise ModeDoesNotExistError(
+            service_name=installed_config.service_name,
+            mode=dependency.mode,
+        )
+
+    active_nested_dependencies = [
+        nested_dependency
+        for nested_dependency_name, nested_dependency in installed_config.dependencies.items()
+        if nested_dependency_name in installed_config.modes[dependency.mode]
+    ]
+    nested_remote_configs = _get_remote_configs(active_nested_dependencies)
 
     installed_dependencies: set[InstalledRemoteDependency] = set(
         [
@@ -526,15 +545,23 @@ def get_remote_dependency_config(remote_config: RemoteConfig) -> ServiceConfig:
     return load_service_config_from_file(dependency_repo_dir)
 
 
-def construct_dependency_graph(service: Service) -> DependencyGraph:
+def construct_dependency_graph(service: Service, modes: list[str]) -> DependencyGraph:
     dependency_graph = DependencyGraph()
 
-    def _construct_dependency_graph(service_config: ServiceConfig) -> None:
+    def _construct_dependency_graph(
+        service_config: ServiceConfig, modes: list[str]
+    ) -> None:
+        service_mode_dependencies = set()
+        for mode in modes:
+            service_mode_dependencies.update(service_config.modes.get(mode, []))
         for dependency_name, dependency in service_config.dependencies.items():
+            # Skip the dependency if it's not in the modes (since it may not be installed and we don't care about it)
+            if dependency_name not in service_mode_dependencies:
+                continue
             dependency_graph.add_edge(service_config.service_name, dependency_name)
             if _has_remote_config(dependency.remote):
                 dependency_config = get_remote_dependency_config(dependency.remote)
-                _construct_dependency_graph(dependency_config)
+                _construct_dependency_graph(dependency_config, [dependency.remote.mode])
 
-    _construct_dependency_graph(service.config)
+    _construct_dependency_graph(service.config, modes)
     return dependency_graph

{devservices-1.0.4 → devservices-1.0.6}/devservices/utils/devenv.py

@@ -13,7 +13,7 @@ def get_coderoot() -> str:
     config_path = os.path.join(home, ".config", "sentry-devenv", "config.ini")
     try:
         devenv_config: ConfigParser = read_config(config_path)
-        return devenv_config.get("devenv", "coderoot", fallback="")
+        return os.path.expanduser(devenv_config.get("devenv", "coderoot", fallback=""))
     except (FileNotFoundError, NoSectionError, NoOptionError):
         # TODO: Handle the case where there is no config file or the coderoot is not set
         raise Exception("Failed to read code root from config")

devservices-1.0.6/devservices/utils/docker.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import subprocess
+
+from devservices.exceptions import DockerDaemonNotRunningError
+from devservices.exceptions import DockerError
+
+
+def check_docker_daemon_running() -> None:
+    """Checks if the Docker daemon is running. Raises DockerDaemonNotRunningError if not."""
+    try:
+        subprocess.run(
+            ["docker", "info"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+    except subprocess.CalledProcessError as e:
+        raise DockerDaemonNotRunningError from e
+
+
+def get_matching_containers(label: str) -> list[str]:
+    """
+    Returns a list of container IDs with the given label
+    """
+    check_docker_daemon_running()
+    try:
+        return (
+            subprocess.check_output(
+                [
+                    "docker",
+                    "ps",
+                    "-q",
+                    "--filter",
+                    f"label={label}",
+                ],
+                stderr=subprocess.DEVNULL,
+            )
+            .decode()
+            .strip()
+            .splitlines()
+        )
+    except subprocess.CalledProcessError as e:
+        raise DockerError(
+            command=f"docker ps -q --filter label={label}",
+            returncode=e.returncode,
+            stdout=e.stdout,
+            stderr=e.stderr,
+        ) from e
+
+
+def stop_matching_containers(label: str, should_remove: bool = False) -> None:
+    """
+    Stops all containers with the given label.
+    If should_remove is True, the containers will be removed.
+    """
+    matching_containers = get_matching_containers(label)
+    if len(matching_containers) == 0:
+        return
+    try:
+        subprocess.run(
+            ["docker", "stop"] + matching_containers,
+            check=True,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+    except subprocess.CalledProcessError as e:
+        raise DockerError(
+            command=f"docker stop {' '.join(matching_containers)}",
+            returncode=e.returncode,
+            stdout=e.stdout,
+            stderr=e.stderr,
+        ) from e
+    if should_remove:
+        try:
+            subprocess.run(
+                ["docker", "rm"] + matching_containers,
+                check=True,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            )
+        except subprocess.CalledProcessError as e:
+            raise DockerError(
+                command=f"docker rm {' '.join(matching_containers)}",
+                returncode=e.returncode,
+                stdout=e.stdout,
+                stderr=e.stderr,
+            ) from e