foamlib 0.8.5__tar.gz → 0.8.7__tar.gz

{foamlib-0.8.5 → foamlib-0.8.7}/.github/workflows/ci.yml

@@ -49,11 +49,11 @@ jobs:
         options: --health-cmd="mysqladmin ping" --health-interval=10s --health-timeout=5s --health-retries=3
     strategy:
       matrix:
-        openfoam-version: [2406, 2006, 12, 9]
+        openfoam-version: [2412, 2006, 12, 9]
         python-version: ['3.7', '3.8', '3.9', '3.10', '3.11', '3.12', '3.13']
         slurm: [false]
         include:
-          - openfoam-version: 2406
+          - openfoam-version: 2412
             python-version: '3.13'
             slurm: true
           - openfoam-version: 12

{foamlib-0.8.5 → foamlib-0.8.7}/.github/workflows/docker.yml

@@ -80,7 +80,7 @@ jobs:
       packages: write
     strategy:
       matrix:
-        openfoam-version: [2406, 2312, 12, 11]
+        openfoam-version: [2412, 2406, 12, 11]
       fail-fast: false
     steps:
       - name: Set up QEMU

{foamlib-0.8.5 → foamlib-0.8.7}/Dockerfile

@@ -1,7 +1,7 @@
 
 ARG BASE=python:3.12-slim
 
-ARG OPENFOAM_VERSION=2406
+ARG OPENFOAM_VERSION=2412
 FROM microfluidica/openfoam:${OPENFOAM_VERSION} AS openfoam
 
 ARG VIRTUAL_ENV=/opt/venv

{foamlib-0.8.5 → foamlib-0.8.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: foamlib
-Version: 0.8.5
+Version: 0.8.7
 Summary: A Python interface for interacting with OpenFOAM
 Project-URL: Homepage, https://github.com/gerlero/foamlib
 Project-URL: Repository, https://github.com/gerlero/foamlib
@@ -29,6 +29,7 @@ Requires-Dist: aioshutil<2,>=1
 Requires-Dist: numpy<3,>=1
 Requires-Dist: numpy<3,>=1.25.0; python_version >= '3.10'
 Requires-Dist: pyparsing<4,>=3.1.2
+Requires-Dist: rich<14,>=13
 Requires-Dist: typing-extensions<5,>=4; python_version < '3.11'
 Provides-Extra: dev
 Requires-Dist: mypy<2,>=1; extra == 'dev'

{foamlib-0.8.5 → foamlib-0.8.7}/foamlib/__init__.py

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

{foamlib-0.8.5 → foamlib-0.8.7}/foamlib/_cases/_async.py

@@ -99,6 +99,9 @@ class AsyncFoamCase(FoamCaseRunBase):
         cpus: int,
         **kwargs: Any,
     ) -> None:
+        if isinstance(cmd, str):
+            cmd = [*AsyncFoamCase._SHELL, cmd]
+
         async with AsyncFoamCase._cpus(cpus):
             await run_async(cmd, **kwargs)
 

{foamlib-0.8.5 → foamlib-0.8.7}/foamlib/_cases/_run.py

@@ -10,13 +10,16 @@ from contextlib import contextmanager
 from pathlib import Path
 from typing import IO, TYPE_CHECKING, Any
 
+from rich.progress import Progress
+
+from ._util import SingletonContextManager
+
 if sys.version_info >= (3, 9):
     from collections.abc import (
         Callable,
         Collection,
         Coroutine,
         Generator,
-        Mapping,
         Sequence,
     )
     from collections.abc import Set as AbstractSet
@@ -27,7 +30,6 @@ else:
         Collection,
         Coroutine,
         Generator,
-        Mapping,
         Sequence,
     )
 
@@ -68,6 +70,10 @@ class FoamCaseRunBase(FoamCaseBase):
 
             return ret
 
+    _SHELL = ("bash", "-c")
+
+    __progress = SingletonContextManager(Progress)
+
     def __delitem__(self, key: int | float | str) -> None:
         shutil.rmtree(self[key].path)
 
@@ -255,38 +261,60 @@ class FoamCaseRunBase(FoamCaseBase):
 
         return script
 
-    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", "")
-
-        if not shell or sip_workaround:
-            env = os.environ.copy()
-
-            if not shell:
-                env["PWD"] = str(self.path)
-
-            if sip_workaround:
-                env["DYLD_LIBRARY_PATH"] = env["FOAM_LD_LIBRARY_PATH"]
-
-            return env
-        return None
-
     @contextmanager
     def __output(
         self, cmd: Sequence[str | os.PathLike[str]] | str, *, log: bool
-    ) -> Generator[tuple[int | IO[bytes], int | IO[bytes]], None, None]:
+    ) -> Generator[tuple[int | IO[str], int | IO[str]], None, None]:
         if log:
             if isinstance(cmd, str):
                 name = shlex.split(cmd)[0]
             else:
                 name = Path(cmd[0]).name if isinstance(cmd[0], os.PathLike) else cmd[0]
 
-            with (self.path / f"log.{name}").open("ab") as stdout:
+            with (self.path / f"log.{name}").open("a") as stdout:
                 yield stdout, STDOUT
         else:
             yield DEVNULL, DEVNULL
 
+    @contextmanager
+    def __process_stdout(
+        self, cmd: Sequence[str | os.PathLike[str]] | str
+    ) -> Generator[Callable[[str], None], None, None]:
+        if isinstance(cmd, str):
+            name = shlex.split(cmd)[0]
+        else:
+            name = Path(cmd[0]).name if isinstance(cmd[0], os.PathLike) else cmd[0]
+
+        try:
+            with self.control_dict as control_dict:
+                if control_dict["stopAt"] == "endTime":
+                    control_dict_end_time = control_dict["endTime"]
+                    if isinstance(control_dict_end_time, (int, float)):
+                        end_time = control_dict_end_time
+                    else:
+                        end_time = None
+                else:
+                    end_time = None
+        except (KeyError, FileNotFoundError):
+            end_time = None
+
+        with self.__progress as progress:
+            task = progress.add_task(f"({self.name}) Running {name}...", total=None)
+
+            def process_stdout(line: str) -> None:
+                if line.startswith("Time = "):
+                    try:
+                        time = float(line.split()[2])
+                    except ValueError:
+                        progress.update(task)
+                    else:
+                        progress.update(task, completed=time, total=end_time)
+                else:
+                    progress.update(task)
+
+            yield process_stdout
+            progress.update(task, completed=1, total=1)
+
     def __mkrundir(self) -> Path:
         d = Path(os.environ["FOAM_RUN"], "foamlib")
         d.mkdir(parents=True, exist_ok=True)
@@ -379,15 +407,16 @@ class FoamCaseRunBase(FoamCaseBase):
                 if cpus is None:
                     cpus = 1
 
-            with self.__output(cmd, log=log) as (stdout, stderr):
+            with self.__output(cmd, log=log) as (stdout, stderr), self.__process_stdout(
+                cmd
+            ) as process_stdout:
                 if parallel:
                     if isinstance(cmd, str):
                         cmd = [
                             "mpiexec",
                             "-n",
                             str(cpus),
-                            "/bin/sh",
-                            "-c",
+                            *FoamCaseRunBase._SHELL,
                             f"{cmd} -parallel",
                         ]
                     else:
@@ -396,11 +425,11 @@ class FoamCaseRunBase(FoamCaseBase):
                 yield self._run(
                     cmd,
                     cpus=cpus,
+                    case=self,
                     check=check,
-                    cwd=self.path,
-                    env=self.__env(shell=isinstance(cmd, str)),
                     stdout=stdout,
                     stderr=stderr,
+                    process_stdout=process_stdout,
                     **kwargs,
                 )
 

{foamlib-0.8.5 → foamlib-0.8.7}/foamlib/_cases/_slurm.py

@@ -31,10 +31,10 @@ class AsyncSlurmFoamCase(AsyncFoamCase):
             await AsyncFoamCase._run(cmd, cpus=cpus, **kwargs)
             return
 
-        if cpus >= 1:
-            if isinstance(cmd, str):
-                cmd = ["/bin/sh", "-c", cmd]
+        if isinstance(cmd, str):
+            cmd = [*AsyncSlurmFoamCase._SHELL, cmd]
 
+        if cpus >= 1:
             if cpus == 1:
                 cmd = ["srun", *cmd]
 

foamlib-0.8.7/foamlib/_cases/_subprocess.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+import asyncio
+import os
+import selectors
+import subprocess
+import sys
+from io import StringIO
+from pathlib import Path
+from typing import IO
+
+if sys.version_info >= (3, 9):
+    from collections.abc import Callable, Mapping, Sequence
+else:
+    from typing import Callable, Mapping, Sequence
+
+CompletedProcess = subprocess.CompletedProcess
+
+
+class CalledProcessError(subprocess.CalledProcessError):
+    def __str__(self) -> str:
+        if self.stderr:
+            if isinstance(self.stderr, bytes):
+                return super().__str__() + "\n" + self.stderr.decode()
+            if isinstance(self.stderr, str):
+                return super().__str__() + "\n" + self.stderr
+        return super().__str__()
+
+
+DEVNULL = subprocess.DEVNULL
+PIPE = subprocess.PIPE
+STDOUT = subprocess.STDOUT
+
+
+def _env(case: os.PathLike[str]) -> Mapping[str, str]:
+    env = os.environ.copy()
+
+    env["PWD"] = str(Path(case))
+
+    if os.environ.get("FOAM_LD_LIBRARY_PATH", "") and not os.environ.get(
+        "DYLD_LIBRARY_PATH", ""
+    ):
+        env["DYLD_LIBRARY_PATH"] = env["FOAM_LD_LIBRARY_PATH"]
+
+    return env
+
+
+def run_sync(
+    cmd: Sequence[str | os.PathLike[str]],
+    *,
+    case: os.PathLike[str],
+    check: bool = True,
+    stdout: int | IO[str] = DEVNULL,
+    stderr: int | IO[str] = STDOUT,
+    process_stdout: Callable[[str], None] = lambda _: None,
+) -> CompletedProcess[str]:
+    if sys.version_info < (3, 8):
+        cmd = [str(arg) for arg in cmd]
+
+    with subprocess.Popen(
+        cmd,
+        cwd=case,
+        env=_env(case),
+        stdout=PIPE,
+        stderr=PIPE,
+        text=True,
+    ) as proc:
+        assert proc.stdout is not None
+        assert proc.stderr is not None
+
+        output = StringIO() if stdout is PIPE else None
+        error = StringIO()
+
+        if stderr is STDOUT:
+            stderr = stdout
+
+        with selectors.DefaultSelector() as selector:
+            selector.register(proc.stdout, selectors.EVENT_READ)
+            selector.register(proc.stderr, selectors.EVENT_READ)
+            open_streams = {proc.stdout, proc.stderr}
+            while open_streams:
+                for key, _ in selector.select():
+                    assert key.fileobj in open_streams
+                    line = key.fileobj.readline()  # type: ignore [union-attr]
+                    if not line:
+                        selector.unregister(key.fileobj)
+                        open_streams.remove(key.fileobj)  # type: ignore [arg-type]
+                    elif key.fileobj is proc.stdout:
+                        process_stdout(line)
+                        if output is not None:
+                            output.write(line)
+                        if stdout not in (DEVNULL, PIPE):
+                            assert not isinstance(stdout, int)
+                            stdout.write(line)
+                    else:
+                        assert key.fileobj is proc.stderr
+                        error.write(line)
+                        if stderr not in (DEVNULL, PIPE):
+                            assert not isinstance(stderr, int)
+                            stderr.write(line)
+
+    assert proc.returncode is not None
+
+    if check and proc.returncode != 0:
+        raise CalledProcessError(
+            returncode=proc.returncode,
+            cmd=cmd,
+            output=output.getvalue() if output is not None else None,
+            stderr=error.getvalue(),
+        )
+
+    return CompletedProcess(
+        cmd,
+        returncode=proc.returncode,
+        stdout=output.getvalue() if output is not None else None,
+        stderr=error.getvalue(),
+    )
+
+
+async def run_async(
+    cmd: Sequence[str | os.PathLike[str]],
+    *,
+    case: os.PathLike[str],
+    check: bool = True,
+    stdout: int | IO[str] = DEVNULL,
+    stderr: int | IO[str] = STDOUT,
+    process_stdout: Callable[[str], None] = lambda _: None,
+) -> CompletedProcess[str]:
+    if sys.version_info < (3, 8):
+        cmd = [str(arg) for arg in cmd]
+
+    proc = await asyncio.create_subprocess_exec(
+        *cmd,
+        cwd=case,
+        env=_env(case),
+        stdout=PIPE,
+        stderr=PIPE,
+    )
+
+    if stderr is STDOUT:
+        stderr = stdout
+
+    output = StringIO() if stdout is PIPE else None
+    error = StringIO()
+
+    async def tee_stdout() -> None:
+        while True:
+            assert proc.stdout is not None
+            line = (await proc.stdout.readline()).decode()
+            if not line:
+                break
+            process_stdout(line)
+            if output is not None:
+                output.write(line)
+            if stdout not in (DEVNULL, PIPE):
+                assert not isinstance(stdout, int)
+                stdout.write(line)
+
+    async def tee_stderr() -> None:
+        while True:
+            assert proc.stderr is not None
+            line = (await proc.stderr.readline()).decode()
+            if not line:
+                break
+            error.write(line)
+            if stderr not in (DEVNULL, PIPE):
+                assert not isinstance(stderr, int)
+                stderr.write(line)
+
+    await asyncio.gather(tee_stdout(), tee_stderr())
+
+    await proc.wait()
+    assert proc.returncode is not None
+
+    if check and proc.returncode != 0:
+        raise CalledProcessError(
+            returncode=proc.returncode,
+            cmd=cmd,
+            output=output.getvalue() if output is not None else None,
+            stderr=error.getvalue(),
+        )
+
+    return CompletedProcess(
+        cmd,
+        returncode=proc.returncode,
+        stdout=output.getvalue() if output is not None else None,
+        stderr=error.getvalue(),
+    )

{foamlib-0.8.5 → foamlib-0.8.7}/foamlib/_cases/_sync.py

@@ -58,6 +58,9 @@ class FoamCase(FoamCaseRunBase):
         cpus: int,
         **kwargs: Any,
     ) -> None:
+        if isinstance(cmd, str):
+            cmd = [*FoamCase._SHELL, cmd]
+
         run_sync(cmd, **kwargs)
 
     @staticmethod

{foamlib-0.8.5 → foamlib-0.8.7}/foamlib/_cases/_util.py

@@ -2,7 +2,17 @@ from __future__ import annotations
 
 import functools
 import sys
-from typing import TYPE_CHECKING, Any, AsyncContextManager, Callable, Generic, TypeVar
+import threading
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    AsyncContextManager,
+    Callable,
+    ContextManager,
+    Generic,
+    TypeVar,
+    cast,
+)
 
 if TYPE_CHECKING:
     from types import TracebackType
@@ -54,3 +64,33 @@ def awaitableasynccontextmanager(
         return _AwaitableAsyncContextManager(cm(*args, **kwargs))
 
     return f
+
+
+class SingletonContextManager(Generic[R]):
+    def __init__(self, factory: Callable[[], ContextManager[R]]) -> None:
+        self._factory = factory
+        self._users = 0
+        self._cm: ContextManager[R] | None = None
+        self._ret: R | None = None
+        self._lock = threading.Lock()
+
+    def __enter__(self) -> R:
+        with self._lock:
+            if self._users == 0:
+                self._cm = self._factory()
+                self._ret = self._cm.__enter__()
+            self._users += 1
+            return cast("R", self._ret)
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool | None:
+        with self._lock:
+            self._users -= 1
+            if self._users == 0:
+                assert self._cm is not None
+                return self._cm.__exit__(exc_type, exc_val, exc_tb)
+            return False

{foamlib-0.8.5 → foamlib-0.8.7}/foamlib/_files/_files.py

@@ -100,9 +100,9 @@ class FoamFile(
                 assert isinstance(ret, dict)
                 v = ret[k]
                 assert isinstance(v, dict)
-                ret = cast(File, v)
+                ret = cast("File", v)
 
-            return cast(Dict_, ret)
+            return cast("Dict_", ret)
 
     @property
     def version(self) -> float:
@@ -127,7 +127,7 @@ class FoamFile(
         if ret not in ("ascii", "binary"):
             msg = "format is not 'ascii' or 'binary'"
             raise ValueError(msg)
-        return cast(Literal["ascii", "binary"], ret)
+        return cast("Literal['ascii', 'binary']", ret)
 
     @format.setter
     def format(self, value: Literal["ascii", "binary"]) -> None:
@@ -412,7 +412,7 @@ class FoamFieldFile(FoamFile):
         ) -> Field:
             """Alias of `self["value"]`."""
             return cast(
-                Field,
+                "Field",
                 self["value"],
             )
 
@@ -461,7 +461,7 @@ class FoamFieldFile(FoamFile):
         self,
     ) -> Field:
         """Alias of `self["internalField"]`."""
-        return cast(Field, self["internalField"])
+        return cast("Field", self["internalField"])
 
     @internal_field.setter
     def internal_field(

{foamlib-0.8.5 → foamlib-0.8.7}/foamlib/_files/_parsing.py

@@ -16,6 +16,7 @@ else:
 
 import numpy as np
 from pyparsing import (
+    CaselessKeyword,
     Combine,
     Dict,
     Forward,
@@ -157,6 +158,7 @@ def _dict_of(
     data: ParserElement,
     *,
     directive: ParserElement | None = None,
+    data_entry: ParserElement | None = None,
     located: bool = False,
 ) -> ParserElement:
     dict_ = Forward()
@@ -164,7 +166,8 @@ def _dict_of(
     keyword_entry = keyword + (dict_ | (data + Literal(";").suppress()))
 
     if directive is not None:
-        keyword_entry |= directive + data + LineEnd().suppress()  # type: ignore [no-untyped-call]
+        assert data_entry is not None
+        keyword_entry |= directive + data_entry + LineEnd().suppress()
 
     if located:
         keyword_entry = Located(keyword_entry)
@@ -183,15 +186,19 @@ def _keyword_entry_of(
     data: ParserElement,
     *,
     directive: ParserElement | None = None,
+    data_entry: ParserElement | None = None,
     located: bool = False,
 ) -> ParserElement:
     keyword_entry = keyword + (
-        _dict_of(keyword, data, directive=directive, located=located)
+        _dict_of(
+            keyword, data, directive=directive, data_entry=data_entry, located=located
+        )
         | (data + Literal(";").suppress())
     )
 
     if directive is not None:
-        keyword_entry |= directive + data + LineEnd().suppress()  # type: ignore [no-untyped-call]
+        assert data_entry is not None
+        keyword_entry |= directive + data_entry + LineEnd().suppress()
 
     if located:
         keyword_entry = Located(keyword_entry)
@@ -261,7 +268,16 @@ _DICT = _dict_of(_TOKEN, _DATA)
 _DATA_ENTRY = Forward()
 _LIST_ENTRY = _DICT | _KEYWORD_ENTRY | _DATA_ENTRY
 _LIST = _list_of(_LIST_ENTRY)
-_NUMBER = common.signed_integer ^ common.ieee_float
+_NUMBER = (
+    common.number
+    | CaselessKeyword("nan").set_parse_action(lambda: np.nan)
+    | (CaselessKeyword("inf") | CaselessKeyword("infinity")).set_parse_action(
+        lambda: np.inf
+    )
+    | (CaselessKeyword("-inf") | CaselessKeyword("-infinity")).set_parse_action(
+        lambda: -np.inf
+    )
+)
 _DATA_ENTRY <<= _FIELD | _LIST | _DIMENSIONED | _DIMENSIONS | _NUMBER | _SWITCH | _TOKEN
 
 _DATA <<= (
@@ -275,12 +291,16 @@ _DATA <<= (
 def parse_data(s: str) -> Data:
     if not s.strip():
         return ""
-    return cast(Data, _DATA.parse_string(s, parse_all=True)[0])
+    return cast("Data", _DATA.parse_string(s, parse_all=True)[0])
 
 
 _LOCATED_DICTIONARY = Group(
     _keyword_entry_of(
-        _TOKEN, Opt(_DATA, default=""), directive=_DIRECTIVE, located=True
+        _TOKEN,
+        Opt(_DATA, default=""),
+        directive=_DIRECTIVE,
+        data_entry=_DATA_ENTRY,
+        located=True,
     )
 )[...]
 _LOCATED_DATA = Group(Located(_DATA.copy().add_parse_action(lambda tks: ["", tks[0]])))
@@ -421,7 +441,7 @@ class Parsed(Mapping[Tuple[str, ...], Union[Data, EllipsisType]]):
             for k in keywords[:-1]:
                 v = r[k]
                 assert isinstance(v, dict)
-                r = cast(File, v)
+                r = cast("File", v)
 
             assert isinstance(r, dict)
             if keywords:

{foamlib-0.8.5 → foamlib-0.8.7}/pyproject.toml

@@ -34,6 +34,7 @@ dependencies = [
     "numpy>=1,<3",
     "pyparsing>=3.1.2,<4",
     "typing-extensions>=4,<5; python_version<'3.11'",
+    "rich>=13,<14",
 ]
 
 dynamic = ["version"]

{foamlib-0.8.5 → foamlib-0.8.7}/tests/test_files/test_files.py

@@ -163,7 +163,7 @@ def test_internal_field(cavity: FoamCase) -> None:
     p_arr = np.zeros(size)
     U_arr = np.zeros((size, 3))
 
-    cavity[0]["p"].internal_field = p_arr  # type: ignore [assignment]
+    cavity[0]["p"].internal_field = p_arr
     cavity[0]["U"].internal_field = U_arr  # type: ignore [assignment]
 
     assert cavity[0]["p"].internal_field == pytest.approx(p_arr)
@@ -174,7 +174,7 @@ def test_internal_field(cavity: FoamCase) -> None:
     p_arr = np.arange(size) * 1e-6  # type: ignore [assignment]
     U_arr = np.full((size, 3), [-1e-6, 1e-6, 0]) * np.arange(size)[:, np.newaxis]
 
-    cavity[0]["p"].internal_field = p_arr  # type: ignore [assignment]
+    cavity[0]["p"].internal_field = p_arr
     cavity[0]["U"].internal_field = U_arr  # type: ignore [assignment]
 
     assert cavity[0]["p"].internal_field == pytest.approx(p_arr)

{foamlib-0.8.5 → foamlib-0.8.7}/tests/test_files/test_parsing.py

@@ -10,6 +10,7 @@ def test_parse_value() -> None:
     assert Parsed(b"yes")[()] is True
     assert Parsed(b"no")[()] is False
     assert Parsed(b"word")[()] == "word"
+    assert Parsed(b"inference")[()] == "inference"
     assert Parsed(b"word word")[()] == ("word", "word")
     assert Parsed(b'"a string"')[()] == '"a string"'
     assert Parsed(b"uniform 1")[()] == 1
@@ -104,6 +105,8 @@ def test_parse_value() -> None:
 def test_parse_directive() -> None:
     assert Parsed(b'#include "filename"')[("#include",)] == '"filename"'
     assert (
-        Parsed(b"functions\n{\n#includeFunc funcName\n}")[("functions", "#includeFunc")]
+        Parsed(b"functions\n{\n#includeFunc funcName\nsubdict{}}")[
+            ("functions", "#includeFunc")
+        ]
         == "funcName"
     )

foamlib-0.8.5/foamlib/_cases/_subprocess.py

@@ -1,152 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import subprocess
-import sys
-from io import BytesIO
-from typing import IO, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    import os
-
-if sys.version_info >= (3, 9):
-    from collections.abc import Mapping, Sequence
-else:
-    from typing import Mapping, Sequence
-
-CompletedProcess = subprocess.CompletedProcess
-
-
-class CalledProcessError(subprocess.CalledProcessError):
-    def __str__(self) -> str:
-        if self.stderr:
-            if isinstance(self.stderr, bytes):
-                return super().__str__() + "\n" + self.stderr.decode()
-            if isinstance(self.stderr, str):
-                return super().__str__() + "\n" + self.stderr
-        return super().__str__()
-
-
-DEVNULL = subprocess.DEVNULL
-PIPE = subprocess.PIPE
-STDOUT = subprocess.STDOUT
-
-
-def run_sync(
-    cmd: Sequence[str | os.PathLike[str]] | str,
-    *,
-    check: bool = True,
-    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]
-
-    proc = subprocess.Popen(
-        cmd,
-        cwd=cwd,
-        env=env,
-        stdout=stdout,
-        stderr=PIPE,
-        shell=isinstance(cmd, str),
-    )
-
-    if stderr == STDOUT:
-        stderr = stdout
-    if stderr not in (PIPE, DEVNULL):
-        stderr_copy = BytesIO()
-
-        assert not isinstance(stderr, int)
-        if stderr is None:
-            stderr = sys.stderr.buffer
-
-        assert proc.stderr is not None
-        for line in proc.stderr:
-            stderr.write(line)
-            stderr_copy.write(line)
-
-        output, _ = proc.communicate()
-        assert not _
-        error = stderr_copy.getvalue()
-    else:
-        output, error = proc.communicate()
-
-    assert proc.returncode is not None
-
-    if check and proc.returncode != 0:
-        raise CalledProcessError(
-            returncode=proc.returncode,
-            cmd=cmd,
-            output=output,
-            stderr=error,
-        )
-
-    return CompletedProcess(
-        cmd, returncode=proc.returncode, stdout=output, stderr=error
-    )
-
-
-async def run_async(
-    cmd: Sequence[str | os.PathLike[str]] | str,
-    *,
-    check: bool = True,
-    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,
-            cwd=cwd,
-            env=env,
-            stdout=stdout,
-            stderr=PIPE,
-        )
-
-    else:
-        if sys.version_info < (3, 8):
-            cmd = [str(arg) for arg in cmd]
-        proc = await asyncio.create_subprocess_exec(
-            *cmd,
-            cwd=cwd,
-            env=env,
-            stdout=stdout,
-            stderr=PIPE,
-        )
-
-    if stderr == STDOUT:
-        stderr = stdout
-    if stderr not in (PIPE, DEVNULL):
-        stderr_copy = BytesIO()
-
-        assert not isinstance(stderr, int)
-        if stderr is None:
-            stderr = sys.stderr.buffer
-
-        assert proc.stderr is not None
-        async for line in proc.stderr:
-            stderr.write(line)
-            stderr_copy.write(line)
-
-        output, _ = await proc.communicate()
-        assert not _
-        error = stderr_copy.getvalue()
-    else:
-        output, error = await proc.communicate()
-
-    assert proc.returncode is not None
-
-    if check and proc.returncode != 0:
-        raise CalledProcessError(
-            returncode=proc.returncode,
-            cmd=cmd,
-            output=output,
-            stderr=error,
-        )
-
-    return CompletedProcess(
-        cmd, returncode=proc.returncode, stdout=output, stderr=error
-    )