localstack-core 4.7.1.dev49__py3-none-any.whl → 4.10.1.dev12__py3-none-any.whl

localstack/utils/container_utils/docker_cmd_client.py

@@ -6,7 +6,7 @@ import os
 import re
 import shlex
 import subprocess
-from typing import Callable, Optional, Union
+from collections.abc import Callable
 
 from localstack import config
 from localstack.utils.collections import ensure_list
@@ -96,7 +96,7 @@ class CmdDockerClient(ContainerClient):
     different response payloads or error messages returned by the `docker` vs `podman` commands.
     """
 
-    default_run_outfile: Optional[str] = None
+    default_run_outfile: str | None = None
 
     def _docker_cmd(self) -> list[str]:
         """
@@ -202,7 +202,7 @@ class CmdDockerClient(ContainerClient):
         except subprocess.CalledProcessError as e:
             self._check_and_raise_no_such_container_error(container_name, error=e)
             raise ContainerException(
-                "Docker process returned with errorcode %s" % e.returncode, e.stdout, e.stderr
+                f"Docker process returned with errorcode {e.returncode}", e.stdout, e.stderr
             ) from e
 
     def pause_container(self, container_name: str) -> None:
@@ -214,7 +214,7 @@ class CmdDockerClient(ContainerClient):
         except subprocess.CalledProcessError as e:
             self._check_and_raise_no_such_container_error(container_name, error=e)
             raise ContainerException(
-                "Docker process returned with errorcode %s" % e.returncode, e.stdout, e.stderr
+                f"Docker process returned with errorcode {e.returncode}", e.stdout, e.stderr
             ) from e
 
     def unpause_container(self, container_name: str) -> None:
@@ -226,7 +226,7 @@ class CmdDockerClient(ContainerClient):
         except subprocess.CalledProcessError as e:
             self._check_and_raise_no_such_container_error(container_name, error=e)
             raise ContainerException(
-                "Docker process returned with errorcode %s" % e.returncode, e.stdout, e.stderr
+                f"Docker process returned with errorcode {e.returncode}", e.stdout, e.stderr
             ) from e
 
     def remove_image(self, image: str, force: bool = True) -> None:
@@ -243,7 +243,7 @@ class CmdDockerClient(ContainerClient):
             if any(msg in to_str(e.stdout) for msg in error_messages):
                 raise NoSuchImage(image, stdout=e.stdout, stderr=e.stderr)
             raise ContainerException(
-                "Docker process returned with errorcode %s" % e.returncode, e.stdout, e.stderr
+                f"Docker process returned with errorcode {e.returncode}", e.stdout, e.stderr
             ) from e
 
     def commit(
@@ -262,26 +262,34 @@ class CmdDockerClient(ContainerClient):
         except subprocess.CalledProcessError as e:
             self._check_and_raise_no_such_container_error(container_name_or_id, error=e)
             raise ContainerException(
-                "Docker process returned with errorcode %s" % e.returncode, e.stdout, e.stderr
+                f"Docker process returned with errorcode {e.returncode}", e.stdout, e.stderr
             ) from e
 
-    def remove_container(self, container_name: str, force=True, check_existence=False) -> None:
-        if check_existence and container_name not in self.get_running_container_names():
+    def remove_container(
+        self, container_name: str, force=True, check_existence=False, volumes=False
+    ) -> None:
+        if check_existence and container_name not in self.get_all_container_names():
             return
         cmd = self._docker_cmd() + ["rm"]
         if force:
             cmd.append("-f")
+        if volumes:
+            cmd.append("--volumes")
         cmd.append(container_name)
         LOG.debug("Removing container with cmd %s", cmd)
         try:
-            run(cmd)
+            output = run(cmd)
+            # When the container does not exist, the output could have the error message without any exception
+            if isinstance(output, str) and not force:
+                self._check_output_and_raise_no_such_container_error(container_name, output=output)
         except subprocess.CalledProcessError as e:
-            self._check_and_raise_no_such_container_error(container_name, error=e)
+            if not force:
+                self._check_and_raise_no_such_container_error(container_name, error=e)
             raise ContainerException(
-                "Docker process returned with errorcode %s" % e.returncode, e.stdout, e.stderr
+                f"Docker process returned with errorcode {e.returncode}", e.stdout, e.stderr
             ) from e
 
-    def list_containers(self, filter: Union[list[str], str, None] = None, all=True) -> list[dict]:
+    def list_containers(self, filter: list[str] | str | None = None, all=True) -> list[dict]:
         filter = [filter] if isinstance(filter, str) else filter
         cmd = self._docker_cmd()
         cmd.append("ps")
@@ -297,7 +305,7 @@ class CmdDockerClient(ContainerClient):
             cmd_result = run(cmd).strip()
         except subprocess.CalledProcessError as e:
             raise ContainerException(
-                "Docker process returned with errorcode %s" % e.returncode, e.stdout, e.stderr
+                f"Docker process returned with errorcode {e.returncode}", e.stdout, e.stderr
             ) from e
         container_list = []
         if cmd_result:
@@ -351,14 +359,14 @@ class CmdDockerClient(ContainerClient):
             if re.match(".*container .+ does not exist", to_str(e.stdout)):
                 raise NoSuchContainer(container_name, stdout=e.stdout, stderr=e.stderr)
             raise ContainerException(
-                "Docker process returned with errorcode %s" % e.returncode, e.stdout, e.stderr
+                f"Docker process returned with errorcode {e.returncode}", e.stdout, e.stderr
             ) from e
 
     def pull_image(
         self,
         docker_image: str,
-        platform: Optional[DockerPlatform] = None,
-        log_handler: Optional[Callable[[str], None]] = None,
+        platform: DockerPlatform | None = None,
+        log_handler: Callable[[str], None] | None = None,
     ) -> None:
         cmd = self._docker_cmd()
         docker_image = self.registry_resolver_strategy.resolve(docker_image)
@@ -380,7 +388,7 @@ class CmdDockerClient(ContainerClient):
             if "Trying to pull" in stdout_str and "access to the resource is denied" in stdout_str:
                 raise NoSuchImage(docker_image, stdout=e.stdout, stderr=e.stderr)
             raise ContainerException(
-                "Docker process returned with errorcode %s" % e.returncode, e.stdout, e.stderr
+                f"Docker process returned with errorcode {e.returncode}", e.stdout, e.stderr
             ) from e
 
     def push_image(self, docker_image: str) -> None:
@@ -412,7 +420,7 @@ class CmdDockerClient(ContainerClient):
         dockerfile_path: str,
         image_name: str,
         context_path: str = None,
-        platform: Optional[DockerPlatform] = None,
+        platform: DockerPlatform | None = None,
     ):
         cmd = self._docker_cmd()
         dockerfile_path = Util.resolve_dockerfile_path(dockerfile_path)
@@ -474,7 +482,7 @@ class CmdDockerClient(ContainerClient):
                 return ""
             self._check_and_raise_no_such_container_error(container_name_or_id, error=e)
             raise ContainerException(
-                "Docker process returned with errorcode %s" % e.returncode, e.stdout, e.stderr
+                f"Docker process returned with errorcode {e.returncode}", e.stdout, e.stderr
             ) from e
 
     def stream_container_logs(self, container_name_or_id: str) -> CancellableStream:
@@ -489,7 +497,7 @@ class CmdDockerClient(ContainerClient):
 
         return CancellableProcessStream(process)
 
-    def _inspect_object(self, object_name_or_id: str) -> dict[str, Union[dict, list, str]]:
+    def _inspect_object(self, object_name_or_id: str) -> dict[str, dict | list | str]:
         cmd = self._docker_cmd()
         cmd += ["inspect", "--format", "{{json .}}", object_name_or_id]
         try:
@@ -499,7 +507,7 @@ class CmdDockerClient(ContainerClient):
             if "no such object" in to_str(e.stdout).lower():
                 raise NoSuchObject(object_name_or_id, stdout=e.stdout, stderr=e.stderr)
             raise ContainerException(
-                "Docker process returned with errorcode %s" % e.returncode, e.stdout, e.stderr
+                f"Docker process returned with errorcode {e.returncode}", e.stdout, e.stderr
             ) from e
         object_data = json.loads(cmd_result.strip())
         if isinstance(object_data, list):
@@ -516,7 +524,7 @@ class CmdDockerClient(ContainerClient):
             )
         return object_data
 
-    def inspect_container(self, container_name_or_id: str) -> dict[str, Union[dict, str]]:
+    def inspect_container(self, container_name_or_id: str) -> dict[str, dict | str]:
         try:
             return self._inspect_object(container_name_or_id)
         except NoSuchObject as e:
@@ -527,7 +535,7 @@ class CmdDockerClient(ContainerClient):
         image_name: str,
         pull: bool = True,
         strip_wellknown_repo_prefixes: bool = True,
-    ) -> dict[str, Union[dict, list, str]]:
+    ) -> dict[str, dict | list | str]:
         image_name = self.registry_resolver_strategy.resolve(image_name)
         try:
             result = self._inspect_object(image_name)
@@ -552,7 +560,7 @@ class CmdDockerClient(ContainerClient):
             return run(cmd).strip()
         except subprocess.CalledProcessError as e:
             raise ContainerException(
-                "Docker process returned with errorcode %s" % e.returncode, e.stdout, e.stderr
+                f"Docker process returned with errorcode {e.returncode}", e.stdout, e.stderr
             ) from e
 
     def delete_network(self, network_name: str) -> None:
@@ -566,10 +574,10 @@ class CmdDockerClient(ContainerClient):
                 raise NoSuchNetwork(network_name=network_name)
             else:
                 raise ContainerException(
-                    "Docker process returned with errorcode %s" % e.returncode, e.stdout, e.stderr
+                    f"Docker process returned with errorcode {e.returncode}", e.stdout, e.stderr
                 ) from e
 
-    def inspect_network(self, network_name: str) -> dict[str, Union[dict, str]]:
+    def inspect_network(self, network_name: str) -> dict[str, dict | str]:
         try:
             return self._inspect_object(network_name)
         except NoSuchObject as e:
@@ -579,7 +587,7 @@ class CmdDockerClient(ContainerClient):
         self,
         network_name: str,
         container_name_or_id: str,
-        aliases: Optional[list] = None,
+        aliases: list | None = None,
         link_local_ips: list[str] = None,
     ) -> None:
         LOG.debug(
@@ -603,7 +611,7 @@ class CmdDockerClient(ContainerClient):
                 raise NoSuchNetwork(network_name=network_name)
             self._check_and_raise_no_such_container_error(container_name_or_id, error=e)
             raise ContainerException(
-                "Docker process returned with errorcode %s" % e.returncode, e.stdout, e.stderr
+                f"Docker process returned with errorcode {e.returncode}", e.stdout, e.stderr
             ) from e
 
     def disconnect_container_from_network(
@@ -621,7 +629,7 @@ class CmdDockerClient(ContainerClient):
                 raise NoSuchNetwork(network_name=network_name)
             self._check_and_raise_no_such_container_error(container_name_or_id, error=e)
             raise ContainerException(
-                "Docker process returned with errorcode %s" % e.returncode, e.stdout, e.stderr
+                f"Docker process returned with errorcode {e.returncode}", e.stdout, e.stderr
             ) from e
 
     def get_container_ip(self, container_name_or_id: str) -> str:
@@ -641,10 +649,10 @@ class CmdDockerClient(ContainerClient):
             if "no such object" in to_str(e.stdout).lower():
                 raise NoSuchContainer(container_name_or_id, stdout=e.stdout, stderr=e.stderr)
             raise ContainerException(
-                "Docker process returned with errorcode %s" % e.returncode, e.stdout, e.stderr
+                f"Docker process returned with errorcode {e.returncode}", e.stdout, e.stderr
             ) from e
 
-    def login(self, username: str, password: str, registry: Optional[str] = None) -> None:
+    def login(self, username: str, password: str, registry: str | None = None) -> None:
         cmd = self._docker_cmd()
         # TODO specify password via stdin
         cmd += ["login", "-u", username, "-p", password]
@@ -654,7 +662,7 @@ class CmdDockerClient(ContainerClient):
             run(cmd)
         except subprocess.CalledProcessError as e:
             raise ContainerException(
-                "Docker process returned with errorcode %s" % e.returncode, e.stdout, e.stderr
+                f"Docker process returned with errorcode {e.returncode}", e.stdout, e.stderr
             ) from e
 
     @functools.cache
@@ -680,7 +688,7 @@ class CmdDockerClient(ContainerClient):
             if any(msg in to_str(e.stdout) for msg in error_messages):
                 raise NoSuchImage(image_name, stdout=e.stdout, stderr=e.stderr)
             raise ContainerException(
-                "Docker process returned with errorcode %s" % e.returncode, e.stdout, e.stderr
+                f"Docker process returned with errorcode {e.returncode}", e.stdout, e.stderr
             ) from e
         finally:
             Util.rm_env_vars_file(env_file)
@@ -701,13 +709,13 @@ class CmdDockerClient(ContainerClient):
     def exec_in_container(
         self,
         container_name_or_id: str,
-        command: Union[list[str], str],
+        command: list[str] | str,
         interactive=False,
         detach=False,
-        env_vars: Optional[dict[str, Optional[str]]] = None,
-        stdin: Optional[bytes] = None,
-        user: Optional[str] = None,
-        workdir: Optional[str] = None,
+        env_vars: dict[str, str | None] | None = None,
+        stdin: bytes | None = None,
+        user: str | None = None,
+        workdir: str | None = None,
     ) -> tuple[bytes, bytes]:
         env_file = None
         cmd = self._docker_cmd()
@@ -737,7 +745,7 @@ class CmdDockerClient(ContainerClient):
         stdin=None,
         interactive: bool = False,
         attach: bool = False,
-        flags: Optional[str] = None,
+        flags: str | None = None,
     ) -> tuple[bytes, bytes]:
         cmd = self._docker_cmd() + ["start"]
         if flags:
@@ -787,7 +795,7 @@ class CmdDockerClient(ContainerClient):
             if any(msg.lower() in to_str(e.stderr).lower() for msg in error_messages):
                 raise NoSuchContainer(container_name, stdout=e.stdout, stderr=e.stderr)
             raise ContainerException(
-                "Docker process returned with errorcode %s" % e.returncode, e.stdout, e.stderr
+                f"Docker process returned with errorcode {e.returncode}", e.stdout, e.stderr
             ) from e
 
     def _build_run_create_cmd(
@@ -795,31 +803,31 @@ class CmdDockerClient(ContainerClient):
         action: str,
         image_name: str,
         *,
-        name: Optional[str] = None,
-        entrypoint: Optional[Union[list[str], str]] = None,
+        name: str | None = None,
+        entrypoint: list[str] | str | None = None,
         remove: bool = False,
         interactive: bool = False,
         tty: bool = False,
         detach: bool = False,
-        command: Optional[Union[list[str], str]] = None,
-        volumes: Optional[list[SimpleVolumeBind]] = None,
-        ports: Optional[PortMappings] = None,
-        exposed_ports: Optional[list[str]] = None,
-        env_vars: Optional[dict[str, str]] = None,
-        user: Optional[str] = None,
-        cap_add: Optional[list[str]] = None,
-        cap_drop: Optional[list[str]] = None,
-        security_opt: Optional[list[str]] = None,
-        network: Optional[str] = None,
-        dns: Optional[Union[str, list[str]]] = None,
-        additional_flags: Optional[str] = None,
-        workdir: Optional[str] = None,
-        privileged: Optional[bool] = None,
-        labels: Optional[dict[str, str]] = None,
-        platform: Optional[DockerPlatform] = None,
-        ulimits: Optional[list[Ulimit]] = None,
-        init: Optional[bool] = None,
-        log_config: Optional[LogConfig] = None,
+        command: list[str] | str | None = None,
+        volumes: list[SimpleVolumeBind] | None = None,
+        ports: PortMappings | None = None,
+        exposed_ports: list[str] | None = None,
+        env_vars: dict[str, str] | None = None,
+        user: str | None = None,
+        cap_add: list[str] | None = None,
+        cap_drop: list[str] | None = None,
+        security_opt: list[str] | None = None,
+        network: str | None = None,
+        dns: str | list[str] | None = None,
+        additional_flags: str | None = None,
+        workdir: str | None = None,
+        privileged: bool | None = None,
+        labels: dict[str, str] | None = None,
+        platform: DockerPlatform | None = None,
+        ulimits: list[Ulimit] | None = None,
+        init: bool | None = None,
+        log_config: LogConfig | None = None,
     ) -> tuple[list[str], str]:
         env_file = None
         cmd = self._docker_cmd() + [action]
@@ -892,7 +900,7 @@ class CmdDockerClient(ContainerClient):
         return cmd, env_file
 
     @staticmethod
-    def _map_to_volume_param(volume: Union[SimpleVolumeBind, BindMount, VolumeDirMount]) -> str:
+    def _map_to_volume_param(volume: SimpleVolumeBind | BindMount | VolumeDirMount) -> str:
         """
         Maps the mount volume, to a parameter for the -v docker cli argument.
 
@@ -915,14 +923,22 @@ class CmdDockerClient(ContainerClient):
         Check the given client invocation error and raise a `NoSuchContainer` exception if it
         represents a `no such container` exception from Docker or Podman.
         """
+        self._check_output_and_raise_no_such_container_error(
+            container_name_or_id, str(error.stdout), error=str(error.stderr)
+        )
 
-        # consider different error messages for Docker/Podman
-        error_messages = ("No such container", "no container with name or ID")
-        process_stdout_lower = to_str(error.stdout).lower()
-        if any(msg.lower() in process_stdout_lower for msg in error_messages):
-            raise NoSuchContainer(container_name_or_id, stdout=error.stdout, stderr=error.stderr)
+    def _check_output_and_raise_no_such_container_error(
+        self, container_name_or_id: str, output: str, error: str | None = None
+    ):
+        """
+        Check the given client invocation output and raise a `NoSuchContainer` exception if it
+        represents a `no such container` exception from Docker or Podman.
+        """
+        possible_not_found_messages = ("No such container", "no container with name or ID")
+        if any(msg.lower() in output.lower() for msg in possible_not_found_messages):
+            raise NoSuchContainer(container_name_or_id, stdout=output, stderr=error)
 
-    def _transform_container_labels(self, labels: Union[str, dict[str, str]]) -> dict[str, str]:
+    def _transform_container_labels(self, labels: str | dict[str, str]) -> dict[str, str]:
         """
         Transforms the container labels returned by the docker command from the key-value pair format to a dict
         :param labels: Input string, comma separated key value pairs. Example: key1=value1,key2=value2

localstack/utils/container_utils/docker_sdk_client.py

@@ -6,9 +6,10 @@ import queue
 import re
 import socket
 import threading
+from collections.abc import Callable
 from functools import cache
 from time import sleep
-from typing import Callable, Optional, Union, cast
+from typing import cast
 from urllib.parse import quote
 
 import docker
@@ -56,7 +57,7 @@ class SdkDockerClient(ContainerClient):
     is doing some of the heavy lifting for us to support both target platforms.
     """
 
-    docker_client: Optional[DockerClient]
+    docker_client: DockerClient | None
 
     def __init__(self):
         try:
@@ -264,21 +265,23 @@ class SdkDockerClient(ContainerClient):
         except APIError as e:
             raise ContainerException() from e
 
-    def remove_container(self, container_name: str, force=True, check_existence=False) -> None:
-        LOG.debug("Removing container: %s", container_name)
-        if check_existence and container_name not in self.get_running_container_names():
+    def remove_container(
+        self, container_name: str, force=True, check_existence=False, volumes=False
+    ) -> None:
+        LOG.debug("Removing container: %s, with volumes: %s", container_name, volumes)
+        if check_existence and container_name not in self.get_all_container_names():
             LOG.debug("Aborting removing due to check_existence check")
             return
         try:
             container = self.client().containers.get(container_name)
-            container.remove(force=force)
+            container.remove(force=force, v=volumes)
         except NotFound:
             if not force:
                 raise NoSuchContainer(container_name)
         except APIError as e:
             raise ContainerException() from e
 
-    def list_containers(self, filter: Union[list[str], str, None] = None, all=True) -> list[dict]:
+    def list_containers(self, filter: list[str] | str | None = None, all=True) -> list[dict]:
         if filter:
             filter = [filter] if isinstance(filter, str) else filter
             filter = dict([f.split("=", 1) for f in filter])
@@ -337,14 +340,14 @@ class SdkDockerClient(ContainerClient):
     def pull_image(
         self,
         docker_image: str,
-        platform: Optional[DockerPlatform] = None,
-        log_handler: Optional[Callable[[str], None]] = None,
+        platform: DockerPlatform | None = None,
+        log_handler: Callable[[str], None] | None = None,
     ) -> None:
         LOG.debug("Pulling Docker image: %s", docker_image)
         # some path in the docker image string indicates a custom repository
 
         docker_image = self.registry_resolver_strategy.resolve(docker_image)
-        kwargs: dict[str, Union[str, bool]] = {"platform": platform}
+        kwargs: dict[str, str | bool] = {"platform": platform}
         try:
             if log_handler:
                 # Use a lower-level API, as the 'stream' argument is not available in the higher-level `pull`-API
@@ -389,7 +392,7 @@ class SdkDockerClient(ContainerClient):
         dockerfile_path: str,
         image_name: str,
         context_path: str = None,
-        platform: Optional[DockerPlatform] = None,
+        platform: DockerPlatform | None = None,
     ):
         try:
             dockerfile_path = Util.resolve_dockerfile_path(dockerfile_path)
@@ -466,7 +469,7 @@ class SdkDockerClient(ContainerClient):
         except APIError as e:
             raise ContainerException() from e
 
-    def inspect_container(self, container_name_or_id: str) -> dict[str, Union[dict, str]]:
+    def inspect_container(self, container_name_or_id: str) -> dict[str, dict | str]:
         try:
             return self.client().containers.get(container_name_or_id).attrs
         except NotFound:
@@ -479,7 +482,7 @@ class SdkDockerClient(ContainerClient):
         image_name: str,
         pull: bool = True,
         strip_wellknown_repo_prefixes: bool = True,
-    ) -> dict[str, Union[dict, list, str]]:
+    ) -> dict[str, dict | list | str]:
         image_name = self.registry_resolver_strategy.resolve(image_name)
         try:
             result = self.client().images.get(image_name).attrs
@@ -513,7 +516,7 @@ class SdkDockerClient(ContainerClient):
         except APIError as e:
             raise ContainerException() from e
 
-    def inspect_network(self, network_name: str) -> dict[str, Union[dict, str]]:
+    def inspect_network(self, network_name: str) -> dict[str, dict | str]:
         try:
             return self.client().networks.get(network_name).attrs
         except NotFound:
@@ -525,7 +528,7 @@ class SdkDockerClient(ContainerClient):
         self,
         network_name: str,
         container_name_or_id: str,
-        aliases: Optional[list] = None,
+        aliases: list | None = None,
         link_local_ips: list[str] = None,
     ) -> None:
         LOG.debug(
@@ -619,7 +622,7 @@ class SdkDockerClient(ContainerClient):
         stdin=None,
         interactive: bool = False,
         attach: bool = False,
-        flags: Optional[str] = None,
+        flags: str | None = None,
     ) -> tuple[bytes, bytes]:
         LOG.debug("Starting container %s", container_name_or_id)
         try:
@@ -668,7 +671,7 @@ class SdkDockerClient(ContainerClient):
                         sock.sendall(to_bytes(stdin))
                         sock.shutdown(socket.SHUT_WR)
                     stdout, stderr = self._read_from_sock(sock, False)
-                except socket.timeout:
+                except TimeoutError:
                     LOG.debug(
                         "Socket timeout when talking to the I/O streams of Docker container '%s'",
                         container_name_or_id,
@@ -701,31 +704,31 @@ class SdkDockerClient(ContainerClient):
         self,
         image_name: str,
         *,
-        name: Optional[str] = None,
-        entrypoint: Optional[Union[list[str], str]] = None,
+        name: str | None = None,
+        entrypoint: list[str] | str | None = None,
         remove: bool = False,
         interactive: bool = False,
         tty: bool = False,
         detach: bool = False,
-        command: Optional[Union[list[str], str]] = None,
-        volumes: Optional[list[SimpleVolumeBind]] = None,
-        ports: Optional[PortMappings] = None,
-        exposed_ports: Optional[list[str]] = None,
-        env_vars: Optional[dict[str, str]] = None,
-        user: Optional[str] = None,
-        cap_add: Optional[list[str]] = None,
-        cap_drop: Optional[list[str]] = None,
-        security_opt: Optional[list[str]] = None,
-        network: Optional[str] = None,
-        dns: Optional[Union[str, list[str]]] = None,
-        additional_flags: Optional[str] = None,
-        workdir: Optional[str] = None,
-        privileged: Optional[bool] = None,
-        labels: Optional[dict[str, str]] = None,
-        platform: Optional[DockerPlatform] = None,
-        ulimits: Optional[list[Ulimit]] = None,
-        init: Optional[bool] = None,
-        log_config: Optional[LogConfig] = None,
+        command: list[str] | str | None = None,
+        volumes: list[SimpleVolumeBind] | None = None,
+        ports: PortMappings | None = None,
+        exposed_ports: list[str] | None = None,
+        env_vars: dict[str, str] | None = None,
+        user: str | None = None,
+        cap_add: list[str] | None = None,
+        cap_drop: list[str] | None = None,
+        security_opt: list[str] | None = None,
+        network: str | None = None,
+        dns: str | list[str] | None = None,
+        additional_flags: str | None = None,
+        workdir: str | None = None,
+        privileged: bool | None = None,
+        labels: dict[str, str] | None = None,
+        platform: DockerPlatform | None = None,
+        ulimits: list[Ulimit] | None = None,
+        init: bool | None = None,
+        log_config: LogConfig | None = None,
     ) -> str:
         LOG.debug("Creating container with attributes: %s", locals())
         extra_hosts = None
@@ -832,31 +835,31 @@ class SdkDockerClient(ContainerClient):
         image_name: str,
         stdin=None,
         *,
-        name: Optional[str] = None,
-        entrypoint: Optional[str] = None,
+        name: str | None = None,
+        entrypoint: str | None = None,
         remove: bool = False,
         interactive: bool = False,
         tty: bool = False,
         detach: bool = False,
-        command: Optional[Union[list[str], str]] = None,
-        volumes: Optional[list[SimpleVolumeBind]] = None,
-        ports: Optional[PortMappings] = None,
-        exposed_ports: Optional[list[str]] = None,
-        env_vars: Optional[dict[str, str]] = None,
-        user: Optional[str] = None,
-        cap_add: Optional[list[str]] = None,
-        cap_drop: Optional[list[str]] = None,
-        security_opt: Optional[list[str]] = None,
-        network: Optional[str] = None,
-        dns: Optional[str] = None,
-        additional_flags: Optional[str] = None,
-        workdir: Optional[str] = None,
-        labels: Optional[dict[str, str]] = None,
-        platform: Optional[DockerPlatform] = None,
-        privileged: Optional[bool] = None,
-        ulimits: Optional[list[Ulimit]] = None,
-        init: Optional[bool] = None,
-        log_config: Optional[LogConfig] = None,
+        command: list[str] | str | None = None,
+        volumes: list[SimpleVolumeBind] | None = None,
+        ports: PortMappings | None = None,
+        exposed_ports: list[str] | None = None,
+        env_vars: dict[str, str] | None = None,
+        user: str | None = None,
+        cap_add: list[str] | None = None,
+        cap_drop: list[str] | None = None,
+        security_opt: list[str] | None = None,
+        network: str | None = None,
+        dns: str | None = None,
+        additional_flags: str | None = None,
+        workdir: str | None = None,
+        labels: dict[str, str] | None = None,
+        platform: DockerPlatform | None = None,
+        privileged: bool | None = None,
+        ulimits: list[Ulimit] | None = None,
+        init: bool | None = None,
+        log_config: LogConfig | None = None,
     ) -> tuple[bytes, bytes]:
         LOG.debug("Running container with image: %s", image_name)
         container = None
@@ -903,13 +906,13 @@ class SdkDockerClient(ContainerClient):
     def exec_in_container(
         self,
         container_name_or_id: str,
-        command: Union[list[str], str],
+        command: list[str] | str,
         interactive=False,
         detach=False,
-        env_vars: Optional[dict[str, Optional[str]]] = None,
-        stdin: Optional[bytes] = None,
-        user: Optional[str] = None,
-        workdir: Optional[str] = None,
+        env_vars: dict[str, str | None] | None = None,
+        stdin: bytes | None = None,
+        user: str | None = None,
+        workdir: str | None = None,
     ) -> tuple[bytes, bytes]:
         LOG.debug("Executing command in container %s: %s", container_name_or_id, command)
         try:
@@ -936,7 +939,7 @@ class SdkDockerClient(ContainerClient):
                         sock.shutdown(socket.SHUT_WR)
                         stdout, stderr = self._read_from_sock(sock, tty)
                         return stdout, stderr
-                    except socket.timeout:
+                    except TimeoutError:
                         pass
             else:
                 if detach:
@@ -957,7 +960,7 @@ class SdkDockerClient(ContainerClient):
         except APIError as e:
             raise ContainerException() from e
 
-    def login(self, username: str, password: str, registry: Optional[str] = None) -> None:
+    def login(self, username: str, password: str, registry: str | None = None) -> None:
         LOG.debug("Docker login for %s", username)
         try:
             self.client().login(username, password=password, registry=registry, reauth=True)