localstack-core 4.6.1.dev60__py3-none-any.whl → 4.10.1.dev12__py3-none-any.whl

localstack/utils/container_utils/container_client.py

@@ -5,24 +5,17 @@ import logging
 import os
 import re
 import shlex
-import sys
 import tarfile
 import tempfile
 from abc import ABCMeta, abstractmethod
+from collections.abc import Callable
 from enum import Enum, unique
 from pathlib import Path
 from typing import (
-    Callable,
-    Dict,
-    List,
     Literal,
     NamedTuple,
-    Optional,
     Protocol,
-    Tuple,
     TypedDict,
-    Union,
-    get_args,
 )
 
 import dotenv
@@ -60,7 +53,7 @@ class DockerContainerStats(TypedDict):
     MemUsage: tuple[int, int]
     NetIO: tuple[int, int]
     PIDs: int
-    SDKStats: Optional[dict]
+    SDKStats: dict | None
 
 
 class ContainerException(Exception):
@@ -146,7 +139,7 @@ class Ulimit:
 
     name: str
     soft_limit: int
-    hard_limit: Optional[int] = None
+    hard_limit: int | None = None
 
     def __repr__(self):
         """Format: <type>=<soft limit>[:<hard limit>]"""
@@ -157,26 +150,18 @@ class Ulimit:
 
 
 # defines the type for port mappings (source->target port range)
-PortRange = Union[List, HashableList]
+PortRange = list | HashableList
 # defines the protocol for a port range ("tcp" or "udp")
 PortProtocol = str
 
 
-def isinstance_union(obj, class_or_tuple):
-    # that's some dirty hack
-    if sys.version_info < (3, 10):
-        return isinstance(obj, get_args(PortRange))
-    else:
-        return isinstance(obj, class_or_tuple)
-
-
 class PortMappings:
     """Maps source to target port ranges for Docker port mappings."""
 
     # bind host to be used for defining port mappings
     bind_host: str
     # maps `from` port range to `to` port range for port mappings
-    mappings: Dict[Tuple[PortRange, PortProtocol], List]
+    mappings: dict[tuple[PortRange, PortProtocol], list]
 
     def __init__(self, bind_host: str = None):
         self.bind_host = bind_host if bind_host else ""
@@ -184,14 +169,14 @@ class PortMappings:
 
     def add(
         self,
-        port: Union[int, PortRange],
-        mapped: Union[int, PortRange] = None,
+        port: int | PortRange,
+        mapped: int | PortRange = None,
         protocol: PortProtocol = "tcp",
     ):
         mapped = mapped or port
-        if isinstance_union(port, PortRange):
+        if isinstance(port, PortRange):
             for i in range(port[1] - port[0] + 1):
-                if isinstance_union(mapped, PortRange):
+                if isinstance(mapped, PortRange):
                     self.add(port[0] + i, mapped[0] + i, protocol)
                 else:
                     self.add(port[0] + i, mapped, protocol)
@@ -253,7 +238,7 @@ class PortMappings:
 
         return " ".join([entry(k, v) for k, v in self.mappings.items()])
 
-    def to_list(self) -> List[str]:  # TODO test
+    def to_list(self) -> list[str]:  # TODO test
         bind_address = f"{self.bind_host}:" if self.bind_host else ""
 
         def entry(k, v):
@@ -269,7 +254,7 @@ class PortMappings:
 
         return [item for k, v in self.mappings.items() for item in entry(k, v)]
 
-    def to_dict(self) -> Dict[str, Union[Tuple[str, Union[int, List[int]]], int]]:
+    def to_dict(self) -> dict[str, tuple[str, int | list[int]] | int]:
         bind_address = self.bind_host or ""
 
         def bind_port(bind_address, host_port):
@@ -367,7 +352,7 @@ class PortMappings:
         return f"<PortMappings: {self.to_dict()}>"
 
 
-SimpleVolumeBind = Tuple[str, str]
+SimpleVolumeBind = tuple[str, str]
 """Type alias for a simple version of VolumeBind"""
 
 
@@ -455,27 +440,23 @@ class VolumeDirMount:
 
 
 class VolumeMappings:
-    mappings: List[Union[SimpleVolumeBind, BindMount]]
+    mappings: list[SimpleVolumeBind | BindMount]
 
-    def __init__(self, mappings: List[Union[SimpleVolumeBind, BindMount, VolumeDirMount]] = None):
+    def __init__(self, mappings: list[SimpleVolumeBind | BindMount | VolumeDirMount] = None):
         self.mappings = mappings if mappings is not None else []
 
-    def add(self, mapping: Union[SimpleVolumeBind, BindMount, VolumeDirMount]):
+    def add(self, mapping: SimpleVolumeBind | BindMount | VolumeDirMount):
         self.append(mapping)
 
     def append(
         self,
-        mapping: Union[
-            SimpleVolumeBind,
-            BindMount,
-            VolumeDirMount,
-        ],
+        mapping: SimpleVolumeBind | BindMount | VolumeDirMount,
     ):
         self.mappings.append(mapping)
 
     def find_target_mapping(
         self, container_dir: str
-    ) -> Optional[Union[SimpleVolumeBind, BindMount, VolumeDirMount]]:
+    ) -> SimpleVolumeBind | BindMount | VolumeDirMount | None:
         """
         Looks through the volumes and returns the one where the container dir matches ``container_dir``.
         Returns None if there is no volume mapping to the given container directory.
@@ -514,27 +495,27 @@ class VolumeInfo(NamedTuple):
     mode: str
     rw: bool
     propagation: str
-    name: Optional[str] = None
-    driver: Optional[str] = None
+    name: str | None = None
+    driver: str | None = None
 
 
 @dataclasses.dataclass
 class LogConfig:
     type: Literal["json-file", "syslog", "journald", "gelf", "fluentd", "none", "awslogs", "splunk"]
-    config: Dict[str, str] = dataclasses.field(default_factory=dict)
+    config: dict[str, str] = dataclasses.field(default_factory=dict)
 
 
 @dataclasses.dataclass
 class ContainerConfiguration:
     image_name: str
-    name: Optional[str] = None
+    name: str | None = None
     volumes: VolumeMappings = dataclasses.field(default_factory=VolumeMappings)
     ports: PortMappings = dataclasses.field(default_factory=PortMappings)
-    exposed_ports: List[str] = dataclasses.field(default_factory=list)
-    entrypoint: Optional[Union[List[str], str]] = None
-    additional_flags: Optional[str] = None
-    command: Optional[List[str]] = None
-    env_vars: Dict[str, str] = dataclasses.field(default_factory=dict)
+    exposed_ports: list[str] = dataclasses.field(default_factory=list)
+    entrypoint: list[str] | str | None = None
+    additional_flags: str | None = None
+    command: list[str] | None = None
+    env_vars: dict[str, str] = dataclasses.field(default_factory=dict)
 
     privileged: bool = False
     remove: bool = False
@@ -542,19 +523,19 @@ class ContainerConfiguration:
     tty: bool = False
     detach: bool = False
 
-    stdin: Optional[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
-    workdir: Optional[str] = None
-    platform: Optional[str] = None
-    ulimits: Optional[List[Ulimit]] = None
-    labels: Optional[Dict[str, str]] = None
-    init: Optional[bool] = None
-    log_config: Optional[LogConfig] = None
+    stdin: 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
+    workdir: str | None = None
+    platform: str | None = None
+    ulimits: list[Ulimit] | None = None
+    labels: dict[str, str] | None = None
+    init: bool | None = None
+    log_config: LogConfig | None = None
 
 
 class ContainerConfigurator(Protocol):
@@ -577,17 +558,17 @@ class DockerRunFlags:
     create: https://docs.docker.com/engine/reference/commandline/create/
     """
 
-    env_vars: Optional[Dict[str, str]]
-    extra_hosts: Optional[Dict[str, str]]
-    labels: Optional[Dict[str, str]]
-    volumes: Optional[List[SimpleVolumeBind]]
-    network: Optional[str]
-    platform: Optional[DockerPlatform]
-    privileged: Optional[bool]
-    ports: Optional[PortMappings]
-    ulimits: Optional[List[Ulimit]]
-    user: Optional[str]
-    dns: Optional[List[str]]
+    env_vars: dict[str, str] | None
+    extra_hosts: dict[str, str] | None
+    labels: dict[str, str] | None
+    volumes: list[SimpleVolumeBind] | None
+    network: str | None
+    platform: DockerPlatform | None
+    privileged: bool | None
+    ports: PortMappings | None
+    ulimits: list[Ulimit] | None
+    user: str | None
+    dns: list[str] | None
 
 
 class RegistryResolverStrategy(Protocol):
@@ -621,7 +602,7 @@ class ContainerClient(metaclass=ABCMeta):
         """Returns the usage statistics of the container with the given name"""
         pass
 
-    def get_networks(self, container_name: str) -> List[str]:
+    def get_networks(self, container_name: str) -> list[str]:
         LOG.debug("Getting networks for container: %s", container_name)
         container_attrs = self.inspect_container(container_name_or_id=container_name)
         return list(container_attrs["NetworkSettings"].get("Networks", {}).keys())
@@ -689,8 +670,16 @@ class ContainerClient(metaclass=ABCMeta):
         """Unpauses a container with the given name."""
 
     @abstractmethod
-    def remove_container(self, container_name: str, force=True, check_existence=False) -> None:
-        """Removes container with given name"""
+    def remove_container(
+        self, container_name: str, force=True, check_existence=False, volumes=False
+    ) -> None:
+        """Removes container
+
+        :param container_name: Name of the container
+        :param force: Force the removal of a running container (uses SIGKILL)
+        :param check_existence: Return if container doesn't exist
+        :param volumes: Remove anonymous volumes associated with the container
+        """
 
     @abstractmethod
     def remove_image(self, image: str, force: bool = True) -> None:
@@ -701,17 +690,19 @@ class ContainerClient(metaclass=ABCMeta):
         """
 
     @abstractmethod
-    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]:
         """List all containers matching the given filters
 
         :return: A list of dicts with keys id, image, name, labels, status
         """
 
-    def get_running_container_names(self) -> List[str]:
+    def get_running_container_names(self) -> list[str]:
         """Returns a list of the names of all running containers"""
-        result = self.list_containers(all=False)
-        result = [container["name"] for container in result]
-        return result
+        return self.__get_container_names(return_all=False)
+
+    def get_all_container_names(self) -> list[str]:
+        """Returns a list of the names of all containers including stopped ones"""
+        return self.__get_container_names(return_all=True)
 
     def is_container_running(self, container_name: str) -> bool:
         """Checks whether a container with a given name is currently running"""
@@ -722,7 +713,7 @@ class ContainerClient(metaclass=ABCMeta):
         container_name,
         file_contents: bytes,
         container_path: str,
-        chmod_mode: Optional[int] = None,
+        chmod_mode: int | None = None,
     ) -> None:
         """
         Create a file in container with the provided content. Provide the 'chmod_mode' argument if you want the file to have specific permissions.
@@ -754,8 +745,8 @@ class ContainerClient(metaclass=ABCMeta):
     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:
         """
         Pulls an image with a given name from a Docker registry
@@ -773,7 +764,7 @@ class ContainerClient(metaclass=ABCMeta):
         dockerfile_path: str,
         image_name: str,
         context_path: str = None,
-        platform: Optional[DockerPlatform] = None,
+        platform: DockerPlatform | None = None,
     ) -> str:
         """Builds an image from the given Dockerfile
 
@@ -798,7 +789,7 @@ class ContainerClient(metaclass=ABCMeta):
         strip_latest: bool = True,
         include_tags: bool = True,
         strip_wellknown_repo_prefixes: bool = True,
-    ) -> List[str]:
+    ) -> list[str]:
         """
         Get all names of docker images available to the container engine
         :param strip_latest: return images both with and without :latest tag
@@ -817,13 +808,13 @@ class ContainerClient(metaclass=ABCMeta):
         """Returns a blocking generator you can iterate over to retrieve log output as it happens."""
 
     @abstractmethod
-    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]:
         """Get detailed attributes of a container.
 
         :return: Dict containing docker attributes as returned by the daemon
         """
 
-    def inspect_container_volumes(self, container_name_or_id) -> List[VolumeInfo]:
+    def inspect_container_volumes(self, container_name_or_id) -> list[VolumeInfo]:
         """Return information about the volumes mounted into the given container.
 
         :param container_name_or_id: the container name or id
@@ -838,7 +829,7 @@ class ContainerClient(metaclass=ABCMeta):
     @abstractmethod
     def inspect_image(
         self, image_name: str, pull: bool = True, strip_wellknown_repo_prefixes: bool = True
-    ) -> Dict[str, Union[dict, list, str]]:
+    ) -> dict[str, dict | list | str]:
         """Get detailed attributes of an image.
 
         :param image_name: Image name to inspect
@@ -864,7 +855,7 @@ class ContainerClient(metaclass=ABCMeta):
         """
 
     @abstractmethod
-    def inspect_network(self, network_name: str) -> Dict[str, Union[Dict, str]]:
+    def inspect_network(self, network_name: str) -> dict[str, dict | str]:
         """Get detailed attributes of an network.
 
         :return: Dict containing docker attributes as returned by the daemon
@@ -875,8 +866,8 @@ class ContainerClient(metaclass=ABCMeta):
         self,
         network_name: str,
         container_name_or_id: str,
-        aliases: Optional[List] = None,
-        link_local_ips: List[str] = None,
+        aliases: list | None = None,
+        link_local_ips: list[str] = None,
     ) -> None:
         """
         Connects a container to a given network
@@ -911,7 +902,7 @@ class ContainerClient(metaclass=ABCMeta):
         If container has multiple networks, it will return the IP of the first
         """
 
-    def get_image_cmd(self, docker_image: str, pull: bool = True) -> List[str]:
+    def get_image_cmd(self, docker_image: str, pull: bool = True) -> list[str]:
         """Get the command for the given image
         :param docker_image: Docker image to inspect
         :param pull: Whether to pull if image is not present
@@ -987,31 +978,31 @@ class ContainerClient(metaclass=ABCMeta):
         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[Union[VolumeMappings, 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: VolumeMappings | 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:
         """Creates a container with the given image
 
@@ -1024,32 +1015,32 @@ class ContainerClient(metaclass=ABCMeta):
         image_name: str,
         stdin: bytes = 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[Union[VolumeMappings, 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,
-    ) -> Tuple[bytes, bytes]:
+        command: list[str] | str | None = None,
+        volumes: VolumeMappings | 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]:
         """Creates and runs a given docker container
 
         :return: A tuple (stdout, stderr)
@@ -1057,7 +1048,7 @@ class ContainerClient(metaclass=ABCMeta):
 
     def run_container_from_config(
         self, container_config: ContainerConfiguration
-    ) -> Tuple[bytes, bytes]:
+    ) -> tuple[bytes, bytes]:
         """Like ``run_container`` but uses the parameters from the configuration."""
 
         return self.run_container(
@@ -1093,14 +1084,14 @@ class ContainerClient(metaclass=ABCMeta):
     def exec_in_container(
         self,
         container_name_or_id: str,
-        command: Union[List[str], str],
+        command: list[str] | str,
         interactive: bool = False,
         detach: bool = False,
-        env_vars: Optional[Dict[str, Optional[str]]] = None,
-        stdin: Optional[bytes] = None,
-        user: Optional[str] = None,
-        workdir: Optional[str] = None,
-    ) -> Tuple[bytes, bytes]:
+        env_vars: dict[str, str | None] | None = None,
+        stdin: bytes | None = None,
+        user: str | None = None,
+        workdir: str | None = None,
+    ) -> tuple[bytes, bytes]:
         """Execute a given command in a container
 
         :return: A tuple (stdout, stderr)
@@ -1113,8 +1104,8 @@ class ContainerClient(metaclass=ABCMeta):
         stdin: bytes = None,
         interactive: bool = False,
         attach: bool = False,
-        flags: Optional[str] = None,
-    ) -> Tuple[bytes, bytes]:
+        flags: str | None = None,
+    ) -> tuple[bytes, bytes]:
         """Start a given, already created container
 
         :return: A tuple (stdout, stderr) if attach or interactive is set, otherwise a tuple (b"container_name_or_id", b"")
@@ -1127,7 +1118,7 @@ class ContainerClient(metaclass=ABCMeta):
         """
 
     @abstractmethod
-    def login(self, username: str, password: str, registry: Optional[str] = None) -> None:
+    def login(self, username: str, password: str, registry: str | None = None) -> None:
         """
         Login into an OCI registry
 
@@ -1136,18 +1127,23 @@ class ContainerClient(metaclass=ABCMeta):
         :param registry: Registry url
         """
 
+    def __get_container_names(self, return_all: bool) -> list[str]:
+        result = self.list_containers(all=return_all)
+        result = [container["name"] for container in result]
+        return result
+
 
 class Util:
     MAX_ENV_ARGS_LENGTH = 20000
 
     @staticmethod
-    def format_env_vars(key: str, value: Optional[str]):
+    def format_env_vars(key: str, value: str | None):
         if value is None:
             return key
         return f"{key}={value}"
 
     @classmethod
-    def create_env_vars_file_flag(cls, env_vars: Dict) -> Tuple[List[str], Optional[str]]:
+    def create_env_vars_file_flag(cls, env_vars: dict) -> tuple[list[str], str | None]:
         if not env_vars:
             return [], None
         result = []
@@ -1185,14 +1181,14 @@ class Util:
         return f
 
     @staticmethod
-    def append_without_latest(image_names: List[str]):
+    def append_without_latest(image_names: list[str]):
         suffix = ":latest"
         for image in list(image_names):
             if image.endswith(suffix):
                 image_names.append(image[: -len(suffix)])
 
     @staticmethod
-    def strip_wellknown_repo_prefixes(image_names: List[str]) -> List[str]:
+    def strip_wellknown_repo_prefixes(image_names: list[str]) -> list[str]:
         """
         Remove well-known repo prefixes like `localhost/` or `docker.io/library/` from the list of given
         image names. This is mostly to ensure compatibility of our Docker client with Podman API responses.
@@ -1238,7 +1234,7 @@ class Util:
                     LOG.debug("File to copy empty, ignoring...")
 
     @staticmethod
-    def _read_docker_cli_env_file(env_file: str) -> Dict[str, str]:
+    def _read_docker_cli_env_file(env_file: str) -> dict[str, str]:
         """
         Read an environment file in docker CLI format, specified here:
         https://docs.docker.com/reference/cli/docker/container/run/#env
@@ -1247,7 +1243,7 @@ class Util:
         """
         env_vars = {}
         try:
-            with open(env_file, mode="rt") as f:
+            with open(env_file) as f:
                 env_file_lines = f.readlines()
         except FileNotFoundError as e:
             LOG.error(
@@ -1280,16 +1276,16 @@ class Util:
     @staticmethod
     def parse_additional_flags(
         additional_flags: str,
-        env_vars: Optional[Dict[str, str]] = None,
-        labels: Optional[Dict[str, str]] = None,
-        volumes: Optional[List[SimpleVolumeBind]] = None,
-        network: Optional[str] = None,
-        platform: Optional[DockerPlatform] = None,
-        ports: Optional[PortMappings] = None,
-        privileged: Optional[bool] = None,
-        user: Optional[str] = None,
-        ulimits: Optional[List[Ulimit]] = None,
-        dns: Optional[Union[str, List[str]]] = None,
+        env_vars: dict[str, str] | None = None,
+        labels: dict[str, str] | None = None,
+        volumes: list[SimpleVolumeBind] | None = None,
+        network: str | None = None,
+        platform: DockerPlatform | None = None,
+        ports: PortMappings | None = None,
+        privileged: bool | None = None,
+        user: str | None = None,
+        ulimits: list[Ulimit] | None = None,
+        dns: str | list[str] | None = None,
     ) -> DockerRunFlags:
         """Parses additional CLI-formatted Docker flags, which could overwrite provided defaults.
         :param additional_flags: String which contains the flag definitions inspired by the Docker CLI reference:
@@ -1510,8 +1506,8 @@ class Util:
 
     @staticmethod
     def convert_mount_list_to_dict(
-        volumes: Union[List[SimpleVolumeBind], VolumeMappings],
-    ) -> Dict[str, Dict[str, str]]:
+        volumes: list[SimpleVolumeBind] | VolumeMappings,
+    ) -> dict[str, dict[str, str]]:
         """Converts a List of (host_path, container_path) tuples to a Dict suitable as volume argument for docker sdk"""
 
         def _map_to_dict(paths: SimpleVolumeBind | BindMount | VolumeDirMount):