foamlib 0.6.10__tar.gz → 0.6.12__tar.gz

{foamlib-0.6.10 → foamlib-0.6.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.6.10
+Version: 0.6.12
 Summary: A Python interface for interacting with OpenFOAM
 Author-email: "Gabriel S. Gerlero" <ggerlero@cimec.unl.edu.ar>
 Project-URL: Homepage, https://github.com/gerlero/foamlib

{foamlib-0.6.10 → foamlib-0.6.12}/foamlib/__init__.py

@@ -1,6 +1,6 @@
 """A Python interface for interacting with OpenFOAM."""
 
-__version__ = "0.6.10"
+__version__ = "0.6.12"
 
 from ._cases import (
     AsyncFoamCase,

{foamlib-0.6.10 → foamlib-0.6.12}/foamlib/_cases/_async.py

@@ -1,8 +1,10 @@
+from __future__ import annotations
+
 import asyncio
 import multiprocessing
 import sys
 from contextlib import asynccontextmanager
-from typing import TYPE_CHECKING, Any, Callable, Optional, TypeVar, Union, overload
+from typing import TYPE_CHECKING, Any, Callable, TypeVar, overload
 
 if sys.version_info >= (3, 9):
     from collections.abc import (
@@ -22,7 +24,6 @@ else:
 
 import aioshutil
 
-from .._files import FoamFieldFile
 from ._base import FoamCaseBase
 from ._run import FoamCaseRunBase
 from ._subprocess import run_async
@@ -31,6 +32,8 @@ from ._util import ValuedGenerator, awaitableasynccontextmanager
 if TYPE_CHECKING:
     import os
 
+    from .._files import FoamFieldFile
+
 X = TypeVar("X")
 Y = TypeVar("Y")
 
@@ -48,7 +51,7 @@ class AsyncFoamCase(FoamCaseRunBase):
 
     class TimeDirectory(FoamCaseRunBase.TimeDirectory):
         @property
-        def _case(self) -> "AsyncFoamCase":
+        def _case(self) -> AsyncFoamCase:
             return AsyncFoamCase(self.path.parent)
 
         async def cell_centers(self) -> FoamFieldFile:
@@ -62,8 +65,8 @@ class AsyncFoamCase(FoamCaseRunBase):
 
     max_cpus = multiprocessing.cpu_count()
     """
-    Maximum number of CPUs to use for running instances of `AsyncFoamCase` concurrently. 
-    
+    Maximum number of CPUs to use for running instances of `AsyncFoamCase` concurrently.
+
     Defaults to the number of CPUs on the system.
     """
 
@@ -91,7 +94,7 @@ class AsyncFoamCase(FoamCaseRunBase):
 
     @staticmethod
     async def _run(
-        cmd: Union[Sequence[Union[str, "os.PathLike[str]"]], str],
+        cmd: Sequence[str | os.PathLike[str]] | str,
         *,
         cpus: int,
         **kwargs: Any,
@@ -101,19 +104,18 @@ class AsyncFoamCase(FoamCaseRunBase):
 
     @staticmethod
     async def _rmtree(
-        path: Union["os.PathLike[str]", str], ignore_errors: bool = False
+        path: os.PathLike[str] | str, *, ignore_errors: bool = False
     ) -> None:
         await aioshutil.rmtree(path, ignore_errors=ignore_errors)
 
     @staticmethod
     async def _copytree(
-        src: Union["os.PathLike[str]", str],
-        dest: Union["os.PathLike[str]", str],
+        src: os.PathLike[str] | str,
+        dest: os.PathLike[str] | str,
         *,
         symlinks: bool = False,
-        ignore: Optional[
-            Callable[[Union["os.PathLike[str]", str], Collection[str]], Collection[str]]
-        ] = None,
+        ignore: Callable[[os.PathLike[str] | str, Collection[str]], Collection[str]]
+        | None = None,
     ) -> None:
         await aioshutil.copytree(src, dest, symlinks=symlinks, ignore=ignore)
 
@@ -127,16 +129,14 @@ class AsyncFoamCase(FoamCaseRunBase):
             await coro
 
     @overload
-    def __getitem__(
-        self, index: Union[int, float, str]
-    ) -> "AsyncFoamCase.TimeDirectory": ...
+    def __getitem__(self, index: int | float | str) -> AsyncFoamCase.TimeDirectory: ...
 
     @overload
-    def __getitem__(self, index: slice) -> Sequence["AsyncFoamCase.TimeDirectory"]: ...
+    def __getitem__(self, index: slice) -> Sequence[AsyncFoamCase.TimeDirectory]: ...
 
     def __getitem__(
-        self, index: Union[int, slice, float, str]
-    ) -> Union["AsyncFoamCase.TimeDirectory", Sequence["AsyncFoamCase.TimeDirectory"]]:
+        self, index: int | slice | float | str
+    ) -> AsyncFoamCase.TimeDirectory | Sequence[AsyncFoamCase.TimeDirectory]:
         ret = super().__getitem__(index)
         if isinstance(ret, FoamCaseBase.TimeDirectory):
             return AsyncFoamCase.TimeDirectory(ret)
@@ -148,10 +148,10 @@ class AsyncFoamCase(FoamCaseRunBase):
 
     async def run(
         self,
-        cmd: Optional[Union[Sequence[Union[str, "os.PathLike[str]"]], str]] = None,
+        cmd: Sequence[str | os.PathLike[str]] | str | None = None,
         *,
-        parallel: Optional[bool] = None,
-        cpus: Optional[int] = None,
+        parallel: bool | None = None,
+        cpus: int | None = None,
         check: bool = True,
         log: bool = True,
     ) -> None:
@@ -192,7 +192,7 @@ class AsyncFoamCase(FoamCaseRunBase):
     @awaitableasynccontextmanager
     @asynccontextmanager
     async def copy(
-        self, dst: Optional[Union["os.PathLike[str]", str]] = None
+        self, dst: os.PathLike[str] | str | None = None
     ) -> AsyncGenerator[Self, None]:
         """
         Make a copy of this case.
@@ -213,7 +213,7 @@ class AsyncFoamCase(FoamCaseRunBase):
     @awaitableasynccontextmanager
     @asynccontextmanager
     async def clone(
-        self, dst: Optional[Union["os.PathLike[str]", str]] = None
+        self, dst: os.PathLike[str] | str | None = None
     ) -> AsyncGenerator[Self, None]:
         """
         Clone this case (make a clean copy).

{foamlib-0.6.10 → foamlib-0.6.12}/foamlib/_cases/_base.py

@@ -1,22 +1,19 @@
+from __future__ import annotations
+
 import shutil
 import sys
 from pathlib import Path
-from typing import (
-    TYPE_CHECKING,
-    Optional,
-    Union,
-    overload,
-)
+from typing import TYPE_CHECKING, overload
 
 if sys.version_info >= (3, 9):
     from collections.abc import (
         Iterator,
         Sequence,
-        Set,
     )
+    from collections.abc import Set as AbstractSet
 else:
-    from typing import AbstractSet as Set
     from typing import (
+        AbstractSet,
         Iterator,
         Sequence,
     )
@@ -28,10 +25,10 @@ if TYPE_CHECKING:
 
 
 class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
-    def __init__(self, path: Union["os.PathLike[str]", str] = Path()):
+    def __init__(self, path: os.PathLike[str] | str = Path()) -> None:
         self.path = Path(path).absolute()
 
-    class TimeDirectory(Set[FoamFieldFile]):
+    class TimeDirectory(AbstractSet[FoamFieldFile]):
         """
         An OpenFOAM time directory in a case.
 
@@ -40,11 +37,11 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
         :param path: The path to the time directory.
         """
 
-        def __init__(self, path: Union["os.PathLike[str]", str]):
+        def __init__(self, path: os.PathLike[str] | str) -> None:
             self.path = Path(path).absolute()
 
         @property
-        def _case(self) -> "FoamCaseBase":
+        def _case(self) -> FoamCaseBase:
             return FoamCaseBase(self.path.parent)
 
         @property
@@ -97,7 +94,7 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
             return str(self.path)
 
     @property
-    def _times(self) -> Sequence["FoamCaseBase.TimeDirectory"]:
+    def _times(self) -> Sequence[FoamCaseBase.TimeDirectory]:
         times = []
         for p in self.path.iterdir():
             if p.is_dir():
@@ -113,29 +110,28 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
         return times
 
     @overload
-    def __getitem__(
-        self, index: Union[int, float, str]
-    ) -> "FoamCaseBase.TimeDirectory": ...
+    def __getitem__(self, index: int | float | str) -> FoamCaseBase.TimeDirectory: ...
 
     @overload
-    def __getitem__(self, index: slice) -> Sequence["FoamCaseBase.TimeDirectory"]: ...
+    def __getitem__(self, index: slice) -> Sequence[FoamCaseBase.TimeDirectory]: ...
 
     def __getitem__(
-        self, index: Union[int, slice, float, str]
-    ) -> Union["FoamCaseBase.TimeDirectory", Sequence["FoamCaseBase.TimeDirectory"]]:
+        self, index: int | slice | float | str
+    ) -> FoamCaseBase.TimeDirectory | Sequence[FoamCaseBase.TimeDirectory]:
         if isinstance(index, str):
             return FoamCaseBase.TimeDirectory(self.path / index)
         if isinstance(index, float):
             for time in self._times:
                 if time.time == index:
                     return time
-            raise IndexError(f"Time {index} not found")
+            msg = f"Time {index} not found"
+            raise IndexError(msg)
         return self._times[index]
 
     def __len__(self) -> int:
         return len(self._times)
 
-    def __delitem__(self, key: Union[int, float, str]) -> None:
+    def __delitem__(self, key: int | float | str) -> None:
         shutil.rmtree(self[key].path)
 
     @property
@@ -143,22 +139,24 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
         """The name of the case."""
         return self.path.name
 
-    def file(self, path: Union["os.PathLike[str]", str]) -> FoamFile:
+    def file(self, path: os.PathLike[str] | str) -> FoamFile:
         """Return a FoamFile object for the given path in the case."""
         return FoamFile(self.path / path)
 
     @property
-    def _nsubdomains(self) -> Optional[int]:
+    def _nsubdomains(self) -> int | None:
         """Return the number of subdomains as set in the decomposeParDict, or None if no decomposeParDict is found."""
         try:
             nsubdomains = self.decompose_par_dict["numberOfSubdomains"]
             if not isinstance(nsubdomains, int):
-                raise TypeError(
+                msg = (
                     f"numberOfSubdomains in {self.decompose_par_dict} is not an integer"
                 )
-            return nsubdomains
+                raise TypeError(msg)
         except FileNotFoundError:
             return None
+        else:
+            return nsubdomains
 
     @property
     def _nprocessors(self) -> int:
@@ -170,7 +168,8 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
         """The application name as set in the controlDict."""
         application = self.control_dict["application"]
         if not isinstance(application, str):
-            raise TypeError(f"application in {self.control_dict} is not a string")
+            msg = f"application in {self.control_dict} is not a string"
+            raise TypeError(msg)
         return application
 
     @property

{foamlib-0.6.10 → foamlib-0.6.12}/foamlib/_cases/_run.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import os
 import shlex
 import shutil
@@ -6,13 +8,7 @@ import tempfile
 from abc import abstractmethod
 from contextlib import contextmanager
 from pathlib import Path
-from typing import (
-    IO,
-    Any,
-    Optional,
-    Tuple,
-    Union,
-)
+from typing import IO, TYPE_CHECKING, Any
 
 if sys.version_info >= (3, 9):
     from collections.abc import (
@@ -22,11 +18,11 @@ if sys.version_info >= (3, 9):
         Generator,
         Mapping,
         Sequence,
-        Set,
     )
+    from collections.abc import Set as AbstractSet
 else:
-    from typing import AbstractSet as Set
     from typing import (
+        AbstractSet,
         Callable,
         Collection,
         Coroutine,
@@ -40,22 +36,24 @@ if sys.version_info >= (3, 11):
 else:
     from typing_extensions import Self
 
-from .._files import FoamFieldFile
 from ._base import FoamCaseBase
 from ._subprocess import DEVNULL, STDOUT
 
+if TYPE_CHECKING:
+    from .._files import FoamFieldFile
+
 
 class FoamCaseRunBase(FoamCaseBase):
     class TimeDirectory(FoamCaseBase.TimeDirectory):
         @abstractmethod
         def cell_centers(
             self,
-        ) -> Union[FoamFieldFile, Coroutine[None, None, FoamFieldFile]]:
+        ) -> FoamFieldFile | Coroutine[None, None, FoamFieldFile]:
             raise NotImplementedError
 
         @property
         @abstractmethod
-        def _case(self) -> "FoamCaseRunBase":
+        def _case(self) -> FoamCaseRunBase:
             raise NotImplementedError
 
         def _cell_centers_calls(self) -> Generator[Any, None, FoamFieldFile]:
@@ -70,92 +68,91 @@ class FoamCaseRunBase(FoamCaseBase):
 
             return ret
 
-    def __delitem__(self, key: Union[int, float, str]) -> None:
+    def __delitem__(self, key: int | float | str) -> None:
         shutil.rmtree(self[key].path)
 
     @staticmethod
     @abstractmethod
     def _run(
-        cmd: Union[Sequence[Union[str, "os.PathLike[str]"]], str],
+        cmd: Sequence[str | os.PathLike[str]] | str,
         *,
         cpus: int,
         **kwargs: Any,
-    ) -> Union[None, Coroutine[None, None, None]]:
+    ) -> None | Coroutine[None, None, None]:
         raise NotImplementedError
 
     @staticmethod
     @abstractmethod
     def _rmtree(
-        path: Union["os.PathLike[str]", str], *, ignore_errors: bool = False
-    ) -> Union[None, Coroutine[None, None, None]]:
+        path: os.PathLike[str] | str, *, ignore_errors: bool = False
+    ) -> None | Coroutine[None, None, None]:
         raise NotImplementedError
 
     @staticmethod
     @abstractmethod
     def _copytree(
-        src: Union["os.PathLike[str]", str],
-        dest: Union["os.PathLike[str]", str],
+        src: os.PathLike[str] | str,
+        dest: os.PathLike[str] | str,
         *,
         symlinks: bool = False,
-        ignore: Optional[
-            Callable[[Union["os.PathLike[str]", str], Collection[str]], Collection[str]]
-        ] = None,
-    ) -> Union[None, Coroutine[None, None, None]]:
+        ignore: Callable[[os.PathLike[str] | str, Collection[str]], Collection[str]]
+        | None = None,
+    ) -> None | Coroutine[None, None, None]:
         raise NotImplementedError
 
     @abstractmethod
-    def clean(self, *, check: bool = False) -> Union[None, Coroutine[None, None, None]]:
+    def clean(self, *, check: bool = False) -> None | Coroutine[None, None, None]:
         raise NotImplementedError
 
     @abstractmethod
-    def copy(self, dst: Optional[Union["os.PathLike[str]", str]] = None) -> Any:
+    def copy(self, dst: os.PathLike[str] | str | None = None) -> Any:
         raise NotImplementedError
 
     @abstractmethod
-    def clone(self, dst: Optional[Union["os.PathLike[str]", str]] = None) -> Any:
+    def clone(self, dst: os.PathLike[str] | str | None = None) -> Any:
         raise NotImplementedError
 
     @abstractmethod
     def _prepare(
         self, *, check: bool = True, log: bool = True
-    ) -> Union[None, Coroutine[None, None, None]]:
+    ) -> None | Coroutine[None, None, None]:
         raise NotImplementedError
 
     @abstractmethod
     def run(
         self,
-        cmd: Optional[Union[Sequence[Union[str, "os.PathLike[str]"]], str]] = None,
+        cmd: Sequence[str | os.PathLike[str]] | str | None = None,
         *,
-        parallel: Optional[bool] = None,
-        cpus: Optional[int] = None,
+        parallel: bool | None = None,
+        cpus: int | None = None,
         check: bool = True,
         log: bool = True,
-    ) -> Union[None, Coroutine[None, None, None]]:
+    ) -> None | Coroutine[None, None, None]:
         raise NotImplementedError
 
     @abstractmethod
     def block_mesh(
         self, *, check: bool = True, log: bool = True
-    ) -> Union[None, Coroutine[None, None, None]]:
+    ) -> None | Coroutine[None, None, None]:
         raise NotImplementedError
 
     @abstractmethod
     def decompose_par(
         self, *, check: bool = True, log: bool = True
-    ) -> Union[None, Coroutine[None, None, None]]:
+    ) -> None | Coroutine[None, None, None]:
         raise NotImplementedError
 
     @abstractmethod
     def reconstruct_par(
         self, *, check: bool = True, log: bool = True
-    ) -> Union[None, Coroutine[None, None, None]]:
+    ) -> None | Coroutine[None, None, None]:
         raise NotImplementedError
 
     @abstractmethod
-    def restore_0_dir(self) -> Union[None, Coroutine[None, None, None]]:
+    def restore_0_dir(self) -> None | Coroutine[None, None, None]:
         raise NotImplementedError
 
-    def __clean_paths(self) -> Set[Path]:
+    def __clean_paths(self) -> AbstractSet[Path]:
         has_decompose_par_dict = (self.path / "system" / "decomposeParDict").is_file()
         has_block_mesh_dict = (self.path / "system" / "blockMeshDict").is_file()
 
@@ -186,18 +183,18 @@ class FoamCaseRunBase(FoamCaseBase):
 
     def __clone_ignore(
         self,
-    ) -> Callable[[Union["os.PathLike[str]", str], Collection[str]], Collection[str]]:
+    ) -> Callable[[os.PathLike[str] | str, Collection[str]], Collection[str]]:
         clean_paths = self.__clean_paths()
 
         def ignore(
-            path: Union["os.PathLike[str]", str], names: Collection[str]
+            path: os.PathLike[str] | str, names: Collection[str]
         ) -> Collection[str]:
             paths = {Path(path) / name for name in names}
             return {p.name for p in paths.intersection(clean_paths)}
 
         return ignore
 
-    def __clean_script(self) -> Optional[Path]:
+    def __clean_script(self) -> Path | None:
         """Return the path to the (All)clean script, or None if no clean script is found."""
         clean = self.path / "clean"
         all_clean = self.path / "Allclean"
@@ -214,7 +211,7 @@ class FoamCaseRunBase(FoamCaseBase):
 
         return script
 
-    def __prepare_script(self) -> Optional[Path]:
+    def __prepare_script(self) -> Path | None:
         """Return the path to the Allrun.pre script, or None if no prepare script is found."""
         script = self.path / "Allrun.pre"
 
@@ -226,7 +223,7 @@ class FoamCaseRunBase(FoamCaseBase):
 
         return script
 
-    def __run_script(self, *, parallel: Optional[bool]) -> Optional[Path]:
+    def __run_script(self, *, parallel: bool | None) -> Path | None:
         """Return the path to the (All)run script, or None if no run script is found."""
         run = self.path / "run"
         run_parallel = self.path / "run-parallel"
@@ -242,9 +239,8 @@ class FoamCaseRunBase(FoamCaseBase):
                 elif parallel is False:
                     script = run if run.is_file() else all_run
                 else:
-                    raise ValueError(
-                        "Both (All)run and (All)run-parallel scripts are present. Please specify parallel argument."
-                    )
+                    msg = "Both (All)run and (All)run-parallel scripts are present. Please specify parallel argument."
+                    raise ValueError(msg)
             else:
                 script = run if run.is_file() else all_run
         elif parallel is not False and (
@@ -259,7 +255,7 @@ class FoamCaseRunBase(FoamCaseBase):
 
         return script
 
-    def __env(self, *, shell: bool) -> Optional[Mapping[str, str]]:
+    def __env(self, *, shell: bool) -> Mapping[str, str] | None:
         sip_workaround = os.environ.get(
             "FOAM_LD_LIBRARY_PATH", ""
         ) and not os.environ.get("DYLD_LIBRARY_PATH", "")
@@ -278,8 +274,8 @@ class FoamCaseRunBase(FoamCaseBase):
 
     @contextmanager
     def __output(
-        self, cmd: Union[Sequence[Union[str, "os.PathLike[str]"]], str], *, log: bool
-    ) -> Generator[Tuple[Union[int, IO[bytes]], Union[int, IO[bytes]]], None, None]:
+        self, cmd: Sequence[str | os.PathLike[str]] | str, *, log: bool
+    ) -> Generator[tuple[int | IO[bytes], int | IO[bytes]], None, None]:
         if log:
             if isinstance(cmd, str):
                 name = shlex.split(cmd)[0]
@@ -299,7 +295,7 @@ class FoamCaseRunBase(FoamCaseBase):
         return ret
 
     def _copy_calls(
-        self, dst: Optional[Union["os.PathLike[str]", str]]
+        self, dst: os.PathLike[str] | str | None
     ) -> Generator[Any, None, Self]:
         if dst is None:
             dst = self.__mkrundir()
@@ -321,7 +317,7 @@ class FoamCaseRunBase(FoamCaseBase):
                     p.unlink()
 
     def _clone_calls(
-        self, dst: Optional[Union["os.PathLike[str]", str]]
+        self, dst: os.PathLike[str] | str | None
     ) -> Generator[Any, None, Self]:
         if dst is None:
             dst = self.__mkrundir()
@@ -366,10 +362,10 @@ class FoamCaseRunBase(FoamCaseBase):
 
     def _run_calls(
         self,
-        cmd: Optional[Union[Sequence[Union[str, "os.PathLike[str]"]], str]] = None,
+        cmd: Sequence[str | os.PathLike[str]] | str | None = None,
         *,
-        parallel: Optional[bool],
-        cpus: Optional[int],
+        parallel: bool | None,
+        cpus: int | None,
         check: bool,
         log: bool,
         **kwargs: Any,
@@ -420,9 +416,8 @@ class FoamCaseRunBase(FoamCaseBase):
                             cpus = self._nsubdomains
                         else:
                             cpus = 1
-                else:
-                    if cpus is None:
-                        cpus = 1
+                elif cpus is None:
+                    cpus = 1
 
                 yield self.run(
                     [script_path], parallel=False, cpus=cpus, check=check, **kwargs
@@ -450,9 +445,8 @@ class FoamCaseRunBase(FoamCaseBase):
 
                     if cpus is None:
                         cpus = max(self._nprocessors, 1)
-                else:
-                    if cpus is None:
-                        cpus = 1
+                elif cpus is None:
+                    cpus = 1
 
                 yield self.run(
                     [self.application],

{foamlib-0.6.10 → foamlib-0.6.12}/foamlib/_cases/_slurm.py

@@ -1,6 +1,8 @@
+from __future__ import annotations
+
 import shutil
 import sys
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any
 
 if sys.version_info >= (3, 9):
     from collections.abc import Sequence
@@ -19,7 +21,7 @@ class AsyncSlurmFoamCase(AsyncFoamCase):
 
     @staticmethod
     async def _run(
-        cmd: Union[Sequence[Union[str, "os.PathLike[str]"]], str],
+        cmd: Sequence[str | os.PathLike[str]] | str,
         *,
         cpus: int,
         fallback: bool = False,
@@ -42,10 +44,10 @@ class AsyncSlurmFoamCase(AsyncFoamCase):
 
     async def run(
         self,
-        cmd: Optional[Union[Sequence[Union[str, "os.PathLike[str]"]], str]] = None,
+        cmd: Sequence[str | os.PathLike[str]] | str | None = None,
         *,
-        parallel: Optional[bool] = None,
-        cpus: Optional[int] = None,
+        parallel: bool | None = None,
+        cpus: int | None = None,
         check: bool = True,
         log: bool = True,
         fallback: bool = False,

{foamlib-0.6.10 → foamlib-0.6.12}/foamlib/_cases/_subprocess.py

@@ -1,8 +1,10 @@
+from __future__ import annotations
+
 import asyncio
 import subprocess
 import sys
 from io import BytesIO
-from typing import IO, TYPE_CHECKING, Optional, Union
+from typing import IO, TYPE_CHECKING
 
 if TYPE_CHECKING:
     import os
@@ -31,14 +33,14 @@ STDOUT = subprocess.STDOUT
 
 
 def run_sync(
-    cmd: Union[Sequence[Union[str, "os.PathLike[str]"]], str],
+    cmd: Sequence[str | os.PathLike[str]] | str,
     *,
     check: bool = True,
-    cwd: Optional["os.PathLike[str]"] = None,
-    env: Optional[Mapping[str, str]] = None,
-    stdout: Optional[Union[int, IO[bytes]]] = None,
-    stderr: Optional[Union[int, IO[bytes]]] = None,
-) -> "CompletedProcess[bytes]":
+    cwd: os.PathLike[str] | None = None,
+    env: Mapping[str, str] | None = None,
+    stdout: int | IO[bytes] | None = None,
+    stderr: int | IO[bytes] | None = None,
+) -> CompletedProcess[bytes]:
     if not isinstance(cmd, str) and sys.version_info < (3, 8):
         cmd = [str(arg) for arg in cmd]
 
@@ -87,14 +89,14 @@ def run_sync(
 
 
 async def run_async(
-    cmd: Union[Sequence[Union[str, "os.PathLike[str]"]], str],
+    cmd: Sequence[str | os.PathLike[str]] | str,
     *,
     check: bool = True,
-    cwd: Optional["os.PathLike[str]"] = None,
-    env: Optional[Mapping[str, str]] = None,
-    stdout: Optional[Union[int, IO[bytes]]] = None,
-    stderr: Optional[Union[int, IO[bytes]]] = None,
-) -> "CompletedProcess[bytes]":
+    cwd: os.PathLike[str] | None = None,
+    env: Mapping[str, str] | None = None,
+    stdout: int | IO[bytes] | None = None,
+    stderr: int | IO[bytes] | None = None,
+) -> CompletedProcess[bytes]:
     if isinstance(cmd, str):
         proc = await asyncio.create_subprocess_shell(
             cmd,