foamlib 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

foamlib/__init__.py

@@ -1,7 +1,9 @@
-__version__ = "0.2.5"
+"""A Python interface for interacting with OpenFOAM."""
 
-from ._cases import FoamCase, AsyncFoamCase, FoamCaseBase
-from ._dictionaries import FoamFile, FoamFieldFile, FoamDictionaryBase
+__version__ = "0.2.7"
+
+from ._cases import AsyncFoamCase, FoamCase, FoamCaseBase
+from ._dictionaries import FoamDictionaryBase, FoamFieldFile, FoamFile
 
 __all__ = [
     "FoamCase",

foamlib/_cases.py

@@ -1,11 +1,10 @@
-import sys
-import os
 import asyncio
 import multiprocessing
+import os
 import shutil
-
-from pathlib import Path
+import sys
 from contextlib import asynccontextmanager
+from pathlib import Path
 from typing import (
     Optional,
     Union,
@@ -14,22 +13,22 @@ from typing import (
 
 if sys.version_info >= (3, 9):
     from collections.abc import (
-        Collection,
-        Mapping,
-        Set,
-        Sequence,
         AsyncGenerator,
         Callable,
+        Collection,
         Iterator,
+        Mapping,
+        Sequence,
+        Set,
     )
 else:
-    from typing import Collection, Mapping, Sequence, AsyncGenerator, Callable, Iterator
     from typing import AbstractSet as Set
+    from typing import AsyncGenerator, Callable, Collection, Iterator, Mapping, Sequence
 
 import aioshutil
 
-from ._util import is_sequence, run_process, run_process_async, CalledProcessError
-from ._dictionaries import FoamFile, FoamFieldFile
+from ._dictionaries import FoamFieldFile, FoamFile
+from ._util import CalledProcessError, is_sequence, run_process, run_process_async
 
 
 class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
@@ -54,16 +53,12 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
 
         @property
         def time(self) -> float:
-            """
-            The time that corresponds to this directory.
-            """
+            """The time that corresponds to this directory."""
             return float(self.path.name)
 
         @property
         def name(self) -> str:
-            """
-            The name of this time directory.
-            """
+            """The name of this time directory."""
             return self.path.name
 
         def __getitem__(self, key: str) -> FoamFieldFile:
@@ -172,9 +167,7 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
         return ignore
 
     def _clean_script(self) -> Optional[Path]:
-        """
-        Return the path to the (All)clean script, or None if no clean script is found.
-        """
+        """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"
 
@@ -186,9 +179,7 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
             return None
 
     def _run_script(self, *, parallel: Optional[bool]) -> Optional[Path]:
-        """
-        Return the path to the (All)run script, or None if no run script is found.
-        """
+        """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"
         all_run = self.path / "Allrun"
@@ -213,9 +204,7 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
             return None
 
     def _env(self) -> Mapping[str, str]:
-        """
-        Return the environment variables for this case.
-        """
+        """Return the environment variables for this case."""
         env = os.environ.copy()
         env["PWD"] = str(self.path)
         return env
@@ -237,22 +226,16 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
 
     @property
     def name(self) -> str:
-        """
-        The name of the case.
-        """
+        """The name of the case."""
         return self.path.name
 
     def file(self, path: Union[Path, str]) -> FoamFile:
-        """
-        Return a FoamFile object for the given path in the case.
-        """
+        """Return a FoamFile object for the given path in the case."""
         return FoamFile(self.path / path)
 
     @property
     def _nsubdomains(self) -> Optional[int]:
-        """
-        Return the number of subdomains as set in the decomposeParDict, or None if no decomposeParDict is found.
-        """
+        """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):
@@ -265,16 +248,12 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
 
     @property
     def _nprocessors(self) -> int:
-        """
-        Return the number of processor directories in the case.
-        """
+        """Return the number of processor directories in the case."""
         return len(list(self.path.glob("processor*")))
 
     @property
     def application(self) -> str:
-        """
-        The application name as set in the controlDict.
-        """
+        """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")
@@ -282,51 +261,37 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
 
     @property
     def control_dict(self) -> FoamFile:
-        """
-        The controlDict file.
-        """
+        """The controlDict file."""
         return self.file("system/controlDict")
 
     @property
     def fv_schemes(self) -> FoamFile:
-        """
-        The fvSchemes file.
-        """
+        """The fvSchemes file."""
         return self.file("system/fvSchemes")
 
     @property
     def fv_solution(self) -> FoamFile:
-        """
-        The fvSolution file.
-        """
+        """The fvSolution file."""
         return self.file("system/fvSolution")
 
     @property
     def decompose_par_dict(self) -> FoamFile:
-        """
-        The decomposeParDict file.
-        """
+        """The decomposeParDict file."""
         return self.file("system/decomposeParDict")
 
     @property
     def block_mesh_dict(self) -> FoamFile:
-        """
-        The blockMeshDict file.
-        """
+        """The blockMeshDict file."""
         return self.file("system/blockMeshDict")
 
     @property
     def transport_properties(self) -> FoamFile:
-        """
-        The transportProperties file.
-        """
+        """The transportProperties file."""
         return self.file("constant/transportProperties")
 
     @property
     def turbulence_properties(self) -> FoamFile:
-        """
-        The turbulenceProperties file.
-        """
+        """The turbulenceProperties file."""
         return self.file("constant/turbulenceProperties")
 
     def __fspath__(self) -> str:
@@ -399,7 +364,7 @@ class FoamCase(FoamCaseBase):
                 )
             except CalledProcessError as e:
                 raise RuntimeError(
-                    f"{e.cmd} failed with return code {e.returncode}\n{e.stderr.decode()}"
+                    f"{e.cmd} failed with return code {e.returncode}\n{e.stderr}"
                 ) from None
 
         else:
@@ -432,21 +397,15 @@ class FoamCase(FoamCaseBase):
                 )
 
     def block_mesh(self, *, check: bool = True) -> None:
-        """
-        Run blockMesh on this case.
-        """
+        """Run blockMesh on this case."""
         self.run(["blockMesh"], check=check)
 
     def decompose_par(self, *, check: bool = True) -> None:
-        """
-        Decompose this case for parallel running.
-        """
+        """Decompose this case for parallel running."""
         self.run(["decomposePar"], check=check)
 
     def reconstruct_par(self, *, check: bool = True) -> None:
-        """
-        Reconstruct this case after parallel running.
-        """
+        """Reconstruct this case after parallel running."""
         self.run(["reconstructPar"], check=check)
 
     def copy(self, dest: Union[Path, str]) -> "FoamCase":
@@ -574,7 +533,7 @@ class AsyncFoamCase(FoamCaseBase):
                     )
             except CalledProcessError as e:
                 raise RuntimeError(
-                    f"{e.cmd} failed with return code {e.returncode}\n{e.stderr.decode()}"
+                    f"{e.cmd} failed with return code {e.returncode}\n{e.stderr}"
                 ) from None
 
         else:
@@ -624,21 +583,15 @@ class AsyncFoamCase(FoamCaseBase):
                 )
 
     async def block_mesh(self, *, check: bool = True) -> None:
-        """
-        Run blockMesh on this case.
-        """
+        """Run blockMesh on this case."""
         await self.run(["blockMesh"], check=check)
 
     async def decompose_par(self, *, check: bool = True) -> None:
-        """
-        Decompose this case for parallel running.
-        """
+        """Decompose this case for parallel running."""
         await self.run(["decomposePar"], check=check)
 
     async def reconstruct_par(self, *, check: bool = True) -> None:
-        """
-        Reconstruct this case after parallel running.
-        """
+        """Reconstruct this case after parallel running."""
         await self.run(["reconstructPar"], check=check)
 
     async def copy(self, dest: Union[Path, str]) -> "AsyncFoamCase":

foamlib/_dictionaries/__init__.py

@@ -1,5 +1,5 @@
-from ._files import FoamFile, FoamFieldFile
 from ._base import FoamDictionaryBase
+from ._files import FoamFieldFile, FoamFile
 
 __all__ = [
     "FoamFile",

foamlib/_dictionaries/_base.py

@@ -1,13 +1,18 @@
 import sys
-
 from abc import abstractmethod
 from dataclasses import dataclass
 from typing import Dict, NamedTuple, Optional, Union
 
 if sys.version_info >= (3, 9):
-    from collections.abc import Sequence
+    from collections.abc import Mapping, Sequence
 else:
-    from typing import Sequence
+    from typing import Mapping, Sequence
+
+try:
+    import numpy as np
+    from numpy.typing import NDArray
+except ModuleNotFoundError:
+    pass
 
 
 class FoamDictionaryBase:
@@ -40,11 +45,13 @@ class FoamDictionaryBase:
     A value that can be stored in an OpenFOAM dictionary.
     """
 
-    _Dict = Dict[str, Union["FoamDictionaryBase.Value", "_Dict"]]
+    _Dict = Dict[str, Union["Value", "_Dict"]]
 
     @abstractmethod
     def as_dict(self) -> _Dict:
-        """
-        Return a nested dict representation of the dictionary.
-        """
+        """Return a nested dict representation of the dictionary."""
         raise NotImplementedError
+
+    _SetValue = Union[Value, "NDArray[np.generic]"]
+
+    _SetMapping = Mapping[str, Union["_SetValue", "_SetMapping"]]

foamlib/_dictionaries/_files.py

@@ -1,10 +1,11 @@
 import sys
-
 from pathlib import Path
+from types import TracebackType
 from typing import (
     Any,
     Optional,
     Tuple,
+    Type,
     Union,
     cast,
 )
@@ -49,7 +50,12 @@ class _FoamFileBase:
         self.__defer_io += 1
         return self
 
-    def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
         self.__defer_io -= 1
         if self.__defer_io == 0 and self.__dirty:
             assert self.__contents is not None
@@ -99,9 +105,7 @@ class FoamFile(
         FoamDictionaryBase,
         MutableMapping[str, Union["FoamFile.Value", "FoamFile.Dictionary"]],
     ):
-        """
-        An OpenFOAM dictionary within a file as a mutable mapping.
-        """
+        """An OpenFOAM dictionary within a file as a mutable mapping."""
 
         def __init__(self, _file: "FoamFile", _keywords: Sequence[str]) -> None:
             self._file = _file
@@ -127,7 +131,11 @@ class FoamFile(
                 assume_dimensions=assume_dimensions,
             )
 
-        def __setitem__(self, keyword: str, value: Any) -> None:
+        def __setitem__(
+            self,
+            keyword: str,
+            value: Union["FoamFile._SetValue", "FoamFile._SetMapping"],
+        ) -> None:
             self._setitem(keyword, value)
 
         def __delitem__(self, keyword: str) -> None:
@@ -154,9 +162,7 @@ class FoamFile(
             return f"{type(self).__qualname__}({self._file}, {self._keywords})"
 
         def as_dict(self) -> FoamDictionaryBase._Dict:
-            """
-            Return a nested dict representation of the dictionary.
-            """
+            """Return a nested dict representation of the dictionary."""
             ret = self._file.as_dict()
 
             for k in self._keywords:
@@ -185,7 +191,7 @@ class FoamFile(
     def _setitem(
         self,
         keywords: Union[str, Tuple[str, ...]],
-        value: Any,
+        value: Union["FoamFile._SetValue", "FoamFile._SetMapping"],
         *,
         assume_field: bool = False,
         assume_dimensions: bool = False,
@@ -215,7 +221,11 @@ class FoamFile(
                 f"{contents[:start]}\n{serialize_entry(keywords[-1], value, assume_field=assume_field, assume_dimensions=assume_dimensions)}\n{contents[end:]}"
             )
 
-    def __setitem__(self, keywords: Union[str, Tuple[str, ...]], value: Any) -> None:
+    def __setitem__(
+        self,
+        keywords: Union[str, Tuple[str, ...]],
+        value: Union["FoamFile._SetValue", "FoamFile._SetMapping"],
+    ) -> None:
         self._setitem(keywords, value)
 
     def __delitem__(self, keywords: Union[str, Tuple[str, ...]]) -> None:
@@ -264,9 +274,7 @@ class FoamFile(
         return f"{type(self).__name__}({self.path})"
 
     def as_dict(self) -> FoamDictionaryBase._Dict:
-        """
-        Return a nested dict representation of the file.
-        """
+        """Return a nested dict representation of the file."""
         _, parsed = self._read()
         return as_dict(parsed)
 
@@ -281,7 +289,11 @@ class FoamFieldFile(FoamFile):
     class BoundaryDictionary(FoamFile.Dictionary):
         """An OpenFOAM dictionary representing a boundary condition as a mutable mapping."""
 
-        def __setitem__(self, key: str, value: Any) -> None:
+        def __setitem__(
+            self,
+            key: str,
+            value: Union[FoamFile._SetValue, FoamFile._SetMapping],
+        ) -> None:
             if key == "value":
                 self._setitem(key, value, assume_field=True)
             else:
@@ -289,9 +301,7 @@ class FoamFieldFile(FoamFile):
 
         @property
         def type(self) -> str:
-            """
-            Alias of `self["type"]`.
-            """
+            """Alias of `self["type"]`."""
             ret = self["type"]
             if not isinstance(ret, str):
                 raise TypeError("type is not a string")
@@ -310,9 +320,7 @@ class FoamFieldFile(FoamFile):
             Sequence[Union[int, float, Sequence[Union[int, float]]]],
             "NDArray[np.generic]",
         ]:
-            """
-            Alias of `self["value"]`.
-            """
+            """Alias of `self["value"]`."""
             ret = self["value"]
             if not isinstance(ret, (int, float, Sequence)):
                 raise TypeError("value is not a field")
@@ -361,9 +369,7 @@ class FoamFieldFile(FoamFile):
 
     @property
     def dimensions(self) -> FoamFile.DimensionSet:
-        """
-        Alias of `self["dimensions"]`.
-        """
+        """Alias of `self["dimensions"]`."""
         ret = self["dimensions"]
         if not isinstance(ret, FoamFile.DimensionSet):
             raise TypeError("dimensions is not a DimensionSet")
@@ -384,9 +390,7 @@ class FoamFieldFile(FoamFile):
         Sequence[Union[int, float, Sequence[Union[int, float]]]],
         "NDArray[np.generic]",
     ]:
-        """
-        Alias of `self["internalField"]`.
-        """
+        """Alias of `self["internalField"]`."""
         ret = self["internalField"]
         if not isinstance(ret, (int, float, Sequence)):
             raise TypeError("internalField is not a field")
@@ -406,9 +410,7 @@ class FoamFieldFile(FoamFile):
 
     @property
     def boundary_field(self) -> "FoamFieldFile.BoundariesDictionary":
-        """
-        Alias of `self["boundaryField"]`.
-        """
+        """Alias of `self["boundaryField"]`."""
         ret = self["boundaryField"]
         if not isinstance(ret, FoamFieldFile.BoundariesDictionary):
             assert not isinstance(ret, FoamFile.Dictionary)

foamlib/_dictionaries/_parsing.py

@@ -1,5 +1,4 @@
 import sys
-
 from typing import Optional, Tuple
 
 if sys.version_info >= (3, 9):
@@ -16,8 +15,8 @@ from pyparsing import (
     Literal,
     Located,
     Opt,
-    ParseResults,
     ParserElement,
+    ParseResults,
     QuotedString,
     Word,
     c_style_comment,
@@ -29,8 +28,11 @@ from pyparsing import (
 
 from ._base import FoamDictionaryBase
 
-_YES = Keyword("yes").set_parse_action(lambda: True)
-_NO = Keyword("no").set_parse_action(lambda: False)
+_SWITCH = (
+    Keyword("yes") | Keyword("true") | Keyword("on") | Keyword("y") | Keyword("t")
+).set_parse_action(lambda: True) | (
+    Keyword("no") | Keyword("false") | Keyword("off") | Keyword("n") | Keyword("f")
+).set_parse_action(lambda: False)
 _DIMENSIONS = (
     Literal("[").suppress() + common.number * 7 + Literal("]").suppress()
 ).set_parse_action(lambda tks: FoamDictionaryBase.DimensionSet(*tks))
@@ -65,9 +67,7 @@ _FIELD = (Keyword("uniform").suppress() + _TENSOR) | (
 _TOKEN = QuotedString('"', unquote_results=False) | _IDENTIFIER
 _ITEM = Forward()
 _LIST = _list_of(_ITEM)
-_ITEM <<= (
-    _FIELD | _LIST | _DIMENSIONED | _DIMENSIONS | common.number | _YES | _NO | _TOKEN
-)
+_ITEM <<= _FIELD | _LIST | _DIMENSIONED | _DIMENSIONS | common.number | _SWITCH | _TOKEN
 _TOKENS = (
     QuotedString('"', unquote_results=False) | Word(printables.replace(";", ""))
 )[2, ...].set_parse_action(lambda tks: " ".join(tks))
@@ -131,9 +131,7 @@ def get_value(
     parsed: Parsed,
     keywords: Tuple[str, ...],
 ) -> Optional[FoamDictionaryBase.Value]:
-    """
-    Value of an entry.
-    """
+    """Value of an entry."""
     _, value, _ = parsed[keywords]
     return value
 
@@ -144,9 +142,7 @@ def get_entry_locn(
     *,
     missing_ok: bool = False,
 ) -> Tuple[int, int]:
-    """
-    Location of an entry or where it should be inserted.
-    """
+    """Location of an entry or where it should be inserted."""
     try:
         start, _, end = parsed[keywords]
     except KeyError:
@@ -165,9 +161,7 @@ def get_entry_locn(
 
 
 def as_dict(parsed: Parsed) -> FoamDictionaryBase._Dict:
-    """
-    Return a nested dict representation of the file.
-    """
+    """Return a nested dict representation of the file."""
     ret: FoamDictionaryBase._Dict = {}
     for keywords, (_, value, _) in parsed.items():
         r = ret

foamlib/_dictionaries/_serialization.py

@@ -1,18 +1,19 @@
 import sys
-
 from contextlib import suppress
-from typing import Any
+from typing import Union
 
 if sys.version_info >= (3, 9):
     from collections.abc import Mapping
 else:
     from typing import Mapping
 
-from ._base import FoamDictionaryBase
 from .._util import is_sequence
+from ._base import FoamDictionaryBase
 
 
-def _serialize_bool(value: Any) -> str:
+def _serialize_switch(
+    value: Union[FoamDictionaryBase._SetValue, FoamDictionaryBase._SetMapping],
+) -> str:
     if value is True:
         return "yes"
     elif value is False:
@@ -21,24 +22,28 @@ def _serialize_bool(value: Any) -> str:
         raise TypeError(f"Not a bool: {type(value)}")
 
 
-def _serialize_list(value: Any) -> str:
+def _serialize_list(
+    value: Union[FoamDictionaryBase._SetValue, FoamDictionaryBase._SetMapping],
+) -> str:
     if is_sequence(value):
         return f"({' '.join(_serialize_value(v) for v in value)})"
     else:
         raise TypeError(f"Not a valid sequence: {type(value)}")
 
 
-def _serialize_field(value: Any) -> str:
+def _serialize_field(
+    value: Union[FoamDictionaryBase._SetValue, FoamDictionaryBase._SetMapping],
+) -> str:
     if is_sequence(value):
         try:
             s = _serialize_list(value)
         except TypeError:
             raise TypeError(f"Not a valid field: {type(value)}") from None
         else:
-            if len(value) < 10:
+            if not is_sequence(value[0]) and len(value) < 10:
                 return f"uniform {s}"
             else:
-                if isinstance(value[0], (int, float)):
+                if not is_sequence(value[0]):
                     kind = "scalar"
                 elif len(value[0]) == 3:
                     kind = "vector"
@@ -55,14 +60,18 @@ def _serialize_field(value: Any) -> str:
         return f"uniform {value}"
 
 
-def _serialize_dimensions(value: Any) -> str:
+def _serialize_dimensions(
+    value: Union[FoamDictionaryBase._SetValue, FoamDictionaryBase._SetMapping],
+) -> str:
     if is_sequence(value) and len(value) == 7:
         return f"[{' '.join(str(v) for v in value)}]"
     else:
         raise TypeError(f"Not a valid dimension set: {type(value)}")
 
 
-def _serialize_dimensioned(value: Any) -> str:
+def _serialize_dimensioned(
+    value: Union[FoamDictionaryBase._SetValue, FoamDictionaryBase._SetMapping],
+) -> str:
     if isinstance(value, FoamDictionaryBase.Dimensioned):
         if value.name is not None:
             return f"{value.name} {_serialize_dimensions(value.dimensions)} {_serialize_value(value.value)}"
@@ -73,7 +82,10 @@ def _serialize_dimensioned(value: Any) -> str:
 
 
 def _serialize_value(
-    value: Any, *, assume_field: bool = False, assume_dimensions: bool = False
+    value: Union[FoamDictionaryBase._SetValue, FoamDictionaryBase._SetMapping],
+    *,
+    assume_field: bool = False,
+    assume_dimensions: bool = False,
 ) -> str:
     if isinstance(value, FoamDictionaryBase.DimensionSet) or assume_dimensions:
         with suppress(TypeError):
@@ -90,12 +102,14 @@ def _serialize_value(
         return _serialize_list(value)
 
     with suppress(TypeError):
-        return _serialize_bool(value)
+        return _serialize_switch(value)
 
     return str(value)
 
 
-def _serialize_dictionary(value: Any) -> str:
+def _serialize_dictionary(
+    value: Union[FoamDictionaryBase._SetValue, FoamDictionaryBase._SetMapping],
+) -> str:
     if isinstance(value, Mapping):
         return "\n".join(serialize_entry(k, v) for k, v in value.items())
     else:
@@ -104,7 +118,7 @@ def _serialize_dictionary(value: Any) -> str:
 
 def serialize_entry(
     keyword: str,
-    value: Any,
+    value: Union[FoamDictionaryBase._SetValue, FoamDictionaryBase._SetMapping],
     *,
     assume_field: bool = False,
     assume_dimensions: bool = False,

foamlib/_util.py

@@ -1,7 +1,6 @@
 import asyncio
-import sys
 import subprocess
-
+import sys
 from pathlib import Path
 from typing import Any, Union
 
@@ -36,6 +35,11 @@ def is_sequence(
 
 CalledProcessError = subprocess.CalledProcessError
 
+if sys.version_info >= (3, 9):
+    CompletedProcess = subprocess.CompletedProcess[str]
+else:
+    CompletedProcess = subprocess.CompletedProcess
+
 
 def run_process(
     cmd: Union[Sequence[Union[str, Path]], str, Path],
@@ -43,7 +47,7 @@ def run_process(
     check: bool = True,
     cwd: Union[None, str, Path] = None,
     env: Union[None, Mapping[str, str]] = None,
-) -> "subprocess.CompletedProcess[bytes]":
+) -> CompletedProcess:
     shell = not is_sequence(cmd)
 
     if sys.version_info < (3, 8):
@@ -56,7 +60,9 @@ def run_process(
         cmd,
         cwd=cwd,
         env=env,
-        capture_output=True,
+        stdout=asyncio.subprocess.DEVNULL,
+        stderr=asyncio.subprocess.PIPE,
+        text=True,
         shell=shell,
         check=check,
     )
@@ -70,13 +76,13 @@ async def run_process_async(
     check: bool = True,
     cwd: Union[None, str, Path] = None,
     env: Union[None, Mapping[str, str]] = None,
-) -> "subprocess.CompletedProcess[bytes]":
+) -> CompletedProcess:
     if not is_sequence(cmd):
         proc = await asyncio.create_subprocess_shell(
             str(cmd),
             cwd=cwd,
             env=env,
-            stdout=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.DEVNULL,
             stderr=asyncio.subprocess.PIPE,
         )
 
@@ -87,15 +93,16 @@ async def run_process_async(
             *cmd,
             cwd=cwd,
             env=env,
-            stdout=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.DEVNULL,
             stderr=asyncio.subprocess.PIPE,
         )
 
     stdout, stderr = await proc.communicate()
 
+    assert stdout is None
     assert proc.returncode is not None
 
-    ret = subprocess.CompletedProcess(cmd, proc.returncode, stdout, stderr)
+    ret = CompletedProcess(cmd, proc.returncode, None, stderr.decode())
 
     if check:
         ret.check_returncode()

{foamlib-0.2.5.dist-info → foamlib-0.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.2.5
+Version: 0.2.7
 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.2.7.dist-info/RECORD

@@ -0,0 +1,14 @@
+foamlib/__init__.py,sha256=ZWFEP5x2m2c9zMrODOS9_vL4bf6FPnK7BY-DTLXu3JU,344
+foamlib/_cases.py,sha256=SjDTVauOlcrtyvnt5uxWGSu2RYZ0lhKRmvMnuRnRuzI,20973
+foamlib/_util.py,sha256=PBTpBwt_j1GXASncSDZUR8pH2u_h8UyJXm8GeFKebTY,2552
+foamlib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+foamlib/_dictionaries/__init__.py,sha256=vxGpA7uaEbJwKFGOYdLFR6R9jcUj_HW60YzZBMjNXRo,160
+foamlib/_dictionaries/_base.py,sha256=i_RRwJYP11fG-e9jAqH2lN5wz4BOPNWs_frqyLInSrc,1809
+foamlib/_dictionaries/_files.py,sha256=ZIIImssk9Xqgx8kYz_mr2e3IHGze1J96BvDQxQeNVaA,12912
+foamlib/_dictionaries/_parsing.py,sha256=s6t9JJxAjsSp3ypeQNeskgtYWsbb52iBjrVDTUv56jc,5008
+foamlib/_dictionaries/_serialization.py,sha256=kaec7AzGOERmPAeMP3Li1ZU7jyectsUS5WHgQbeT-2Y,4045
+foamlib-0.2.7.dist-info/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
+foamlib-0.2.7.dist-info/METADATA,sha256=wwLtfgXWX2iXnqLI7jVNZHIpoVE52ZDpWvhibNc6wmA,4650
+foamlib-0.2.7.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+foamlib-0.2.7.dist-info/top_level.txt,sha256=ZdVYtetXGwPwyfL-WhlhbTFQGAwKX5P_gXxtH9JYFPI,8
+foamlib-0.2.7.dist-info/RECORD,,

foamlib-0.2.5.dist-info/RECORD

@@ -1,14 +0,0 @@
-foamlib/__init__.py,sha256=ncl1G6iN85s3zP7aVBqzekY5wHCoOn8dpJxXW2e36vI,287
-foamlib/_cases.py,sha256=SbMaaKdhYbgmgdxWZNB7j47P04QxZ3VVq4sP9HbTLpA,21422
-foamlib/_util.py,sha256=ICs_Bc2jXpxzOUos6Cnl0blUwz1P6r1f1swP8k9Bex0,2347
-foamlib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-foamlib/_dictionaries/__init__.py,sha256=6UWBGe1t7cq-d6WWQrVm0Xpi7Whpkr-mkTWgAM4NwcE,160
-foamlib/_dictionaries/_base.py,sha256=0Qic347JzJBMgBc0gHfuAGmQMWYGEn7IfJ9vKd4pm_I,1606
-foamlib/_dictionaries/_files.py,sha256=Qyw04I5hqGRkHR7KWGmMdX6LyVtat1zKf50bo7CRIoU,12626
-foamlib/_dictionaries/_parsing.py,sha256=w7AOyoPPghsG06WK_1fXU-udU_F8J_zuvV9eIf07P8M,4905
-foamlib/_dictionaries/_serialization.py,sha256=8YInaQ0HnlDe4RnwocvTlJJkVFR7XDqGsuN4ABAyUCE,3452
-foamlib-0.2.5.dist-info/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
-foamlib-0.2.5.dist-info/METADATA,sha256=PuzWIZKasSyaUKpO0H_g67r6wqLyswQyOzzelaiHLpQ,4650
-foamlib-0.2.5.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-foamlib-0.2.5.dist-info/top_level.txt,sha256=ZdVYtetXGwPwyfL-WhlhbTFQGAwKX5P_gXxtH9JYFPI,8
-foamlib-0.2.5.dist-info/RECORD,,