foamlib 0.8.6__tar.gz → 0.8.8__tar.gz

{foamlib-0.8.6 → foamlib-0.8.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: foamlib
-Version: 0.8.6
+Version: 0.8.8
 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,10 +29,11 @@ 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<15,>=13
 Requires-Dist: typing-extensions<5,>=4; python_version < '3.11'
 Provides-Extra: dev
 Requires-Dist: mypy<2,>=1; extra == 'dev'
-Requires-Dist: pytest-asyncio<0.26,>=0.21; extra == 'dev'
+Requires-Dist: pytest-asyncio<0.27,>=0.21; extra == 'dev'
 Requires-Dist: pytest-cov; extra == 'dev'
 Requires-Dist: pytest<9,>=7; extra == 'dev'
 Requires-Dist: ruff; extra == 'dev'
@@ -44,12 +45,12 @@ Requires-Dist: sphinx<9,>=5; extra == 'docs'
 Provides-Extra: lint
 Requires-Dist: ruff; extra == 'lint'
 Provides-Extra: test
-Requires-Dist: pytest-asyncio<0.26,>=0.21; extra == 'test'
+Requires-Dist: pytest-asyncio<0.27,>=0.21; extra == 'test'
 Requires-Dist: pytest-cov; extra == 'test'
 Requires-Dist: pytest<9,>=7; extra == 'test'
 Provides-Extra: typing
 Requires-Dist: mypy<2,>=1; extra == 'typing'
-Requires-Dist: pytest-asyncio<0.26,>=0.21; extra == 'typing'
+Requires-Dist: pytest-asyncio<0.27,>=0.21; extra == 'typing'
 Requires-Dist: pytest-cov; extra == 'typing'
 Requires-Dist: pytest<9,>=7; extra == 'typing'
 Description-Content-Type: text/markdown

{foamlib-0.8.6 → foamlib-0.8.8}/foamlib/__init__.py

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

{foamlib-0.8.6 → foamlib-0.8.8}/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.6 → foamlib-0.8.8}/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,59 @@ 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"]
+    @staticmethod
+    def __cmd_name(cmd: Sequence[str | os.PathLike[str]] | str) -> str:
+        if isinstance(cmd, str):
+            cmd = shlex.split(cmd)
 
-            return env
-        return None
+        return Path(cmd[0]).name
 
     @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.{self.__cmd_name(cmd)}").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]:
+        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 {self.__cmd_name(cmd)}...", 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 +406,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 +424,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.6 → foamlib-0.8.8}/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.8/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.6 → foamlib-0.8.8}/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.6 → foamlib-0.8.8}/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.6 → foamlib-0.8.8}/foamlib/_files/_parsing.py

@@ -167,7 +167,7 @@ def _dict_of(
 
     if directive is not None:
         assert data_entry is not None
-        keyword_entry |= directive + data_entry + LineEnd().suppress()  # type: ignore [no-untyped-call]
+        keyword_entry |= directive + data_entry + LineEnd().suppress()
 
     if located:
         keyword_entry = Located(keyword_entry)
@@ -198,7 +198,7 @@ def _keyword_entry_of(
 
     if directive is not None:
         assert data_entry is not None
-        keyword_entry |= directive + data_entry + LineEnd().suppress()  # type: ignore [no-untyped-call]
+        keyword_entry |= directive + data_entry + LineEnd().suppress()
 
     if located:
         keyword_entry = Located(keyword_entry)
@@ -214,6 +214,8 @@ _COMMENT = Regex(r"(?:/\*(?:[^*]|\*(?!/))*\*/)|(?://(?:\\\n|[^\n])*)")
 _IDENTCHARS = identchars + "$"
 _IDENTBODYCHARS = (
     printables.replace(";", "")
+    .replace("(", "")
+    .replace(")", "")
     .replace("{", "")
     .replace("}", "")
     .replace("[", "")
@@ -243,10 +245,12 @@ _TENSOR = (
     | _tensor(TensorKind.TENSOR)
 )
 _PARENTHESIZED = Forward()
-_IDENTIFIER = Combine(
-    Word(_IDENTCHARS, _IDENTBODYCHARS, exclude_chars="()") + Opt(_PARENTHESIZED)
+_IDENTIFIER = Combine(Word(_IDENTCHARS, _IDENTBODYCHARS) + Opt(_PARENTHESIZED))
+_PARENTHESIZED <<= Combine(
+    Literal("(")
+    + (_PARENTHESIZED | Word(_IDENTBODYCHARS) + Opt(_PARENTHESIZED))
+    + Literal(")")
 )
-_PARENTHESIZED <<= Combine(Literal("(") + (_PARENTHESIZED | _IDENTIFIER) + Literal(")"))
 
 _DIMENSIONED = (Opt(_IDENTIFIER) + _DIMENSIONS + _TENSOR).set_parse_action(
     lambda tks: Dimensioned(*reversed(tks.as_list()))
@@ -261,7 +265,7 @@ _FIELD = (Keyword("uniform", _IDENTBODYCHARS).suppress() + _TENSOR) | (
     )
 )
 _DIRECTIVE = Word("#", _IDENTBODYCHARS)
-_TOKEN = dbl_quoted_string | _IDENTIFIER | _DIRECTIVE
+_TOKEN = dbl_quoted_string | _DIRECTIVE | _IDENTIFIER
 _DATA = Forward()
 _KEYWORD_ENTRY = _keyword_entry_of(_TOKEN | _list_of(_IDENTIFIER), _DATA)
 _DICT = _dict_of(_TOKEN, _DATA)

{foamlib-0.8.6 → foamlib-0.8.8}/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,<15",
 ]
 
 dynamic = ["version"]
@@ -42,7 +43,7 @@ dynamic = ["version"]
 lint = ["ruff"]
 test = [
     "pytest>=7,<9",
-    "pytest-asyncio>=0.21,<0.26",
+    "pytest-asyncio>=0.21,<0.27",
     "pytest-cov",
 ]
 typing = [

{foamlib-0.8.6 → foamlib-0.8.8}/tests/test_files/test_parsing.py

@@ -93,6 +93,7 @@ def test_parse_value() -> None:
     assert Parsed(b"({a b; c d;} {e g;})")[()] == [{"a": "b", "c": "d"}, {"e": "g"}]
     assert Parsed(b"(water oil mercury air)")[()] == ["water", "oil", "mercury", "air"]
     assert Parsed(b"div(phi,U)")[()] == "div(phi,U)"
+    assert Parsed(b"U.component(1)")[()] == "U.component(1)"
     assert Parsed(b"div(nuEff*dev(T(grad(U))))")[()] == "div(nuEff*dev(T(grad(U))))"
     assert Parsed(b"div((nuEff*dev(T(grad(U)))))")[()] == "div((nuEff*dev(T(grad(U)))))"
     assert Parsed(b"((air and water) { type constant; sigma 0.07; })")[()] == [

foamlib-0.8.6/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
-    )