foamlib 0.3.3__tar.gz → 0.3.5__tar.gz

{foamlib-0.3.3 → foamlib-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.3.3
+Version: 0.3.5
 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
@@ -58,11 +58,11 @@ Requires-Dist: numpy<2,>=1; extra == "docs"
 
 **foamlib** provides a simple, modern and ergonomic Python interface for interacting with [OpenFOAM](https://www.openfoam.com).
 
-It offers the following classes (among a few others):
+It offers the following classes:
 
+* [`FoamFile`](https://foamlib.readthedocs.io/en/stable/#foamlib.FoamFile) (and [`FoamFieldFile`](https://foamlib.readthedocs.io/en/stable/#foamlib.FoamFieldFile)): read-write access to OpenFOAM configuration and field files as if they were Python `dict`s, using `foamlib`'s own parser. Supports both ASCII and binary field formats.
 * [`FoamCase`](https://foamlib.readthedocs.io/en/stable/#foamlib.FoamCase): a class for manipulating, executing and accessing the results of OpenFOAM cases.
 * [`AsyncFoamCase`](https://foamlib.readthedocs.io/en/stable/#foamlib.AsyncFoamCase): variant of `FoamCase` with asynchronous methods for running multiple cases at once.
-* [`FoamFile`](https://foamlib.readthedocs.io/en/stable/#foamlib.FoamFile): read-write access to OpenFOAM configuration and field files as if they were Python `dict`s.
 
 ## Get started
 
@@ -130,6 +130,16 @@ async def run_case():
 asyncio.run(run_case())
 ```
 
+### Parse a field using the [`FoamFieldFile`](https://foamlib.readthedocs.io/en/stable/#foamlib.FoamFieldFile) class directly
+
+```python
+from foamlib import FoamFieldFile
+
+U = FoamFieldFile(Path(my_pitz) / "0/U")
+
+print(U.internal_field)
+```
+
 ## Documentation
 
 For more information, check out the [documentation](https://foamlib.readthedocs.io/).

{foamlib-0.3.3 → foamlib-0.3.5}/README.md

@@ -11,11 +11,11 @@
 
 **foamlib** provides a simple, modern and ergonomic Python interface for interacting with [OpenFOAM](https://www.openfoam.com).
 
-It offers the following classes (among a few others):
+It offers the following classes:
 
+* [`FoamFile`](https://foamlib.readthedocs.io/en/stable/#foamlib.FoamFile) (and [`FoamFieldFile`](https://foamlib.readthedocs.io/en/stable/#foamlib.FoamFieldFile)): read-write access to OpenFOAM configuration and field files as if they were Python `dict`s, using `foamlib`'s own parser. Supports both ASCII and binary field formats.
 * [`FoamCase`](https://foamlib.readthedocs.io/en/stable/#foamlib.FoamCase): a class for manipulating, executing and accessing the results of OpenFOAM cases.
 * [`AsyncFoamCase`](https://foamlib.readthedocs.io/en/stable/#foamlib.AsyncFoamCase): variant of `FoamCase` with asynchronous methods for running multiple cases at once.
-* [`FoamFile`](https://foamlib.readthedocs.io/en/stable/#foamlib.FoamFile): read-write access to OpenFOAM configuration and field files as if they were Python `dict`s.
 
 ## Get started
 
@@ -83,6 +83,16 @@ async def run_case():
 asyncio.run(run_case())
 ```
 
+### Parse a field using the [`FoamFieldFile`](https://foamlib.readthedocs.io/en/stable/#foamlib.FoamFieldFile) class directly
+
+```python
+from foamlib import FoamFieldFile
+
+U = FoamFieldFile(Path(my_pitz) / "0/U")
+
+print(U.internal_field)
+```
+
 ## Documentation
 
 For more information, check out the [documentation](https://foamlib.readthedocs.io/).

{foamlib-0.3.3 → foamlib-0.3.5}/foamlib/__init__.py

@@ -1,6 +1,6 @@
 """A Python interface for interacting with OpenFOAM."""
 
-__version__ = "0.3.3"
+__version__ = "0.3.5"
 
 from ._cases import AsyncFoamCase, FoamCase, FoamCaseBase
 from ._files import FoamDict, FoamFieldFile, FoamFile

{foamlib-0.3.3 → foamlib-0.3.5}/foamlib/_cases.py

@@ -1,6 +1,5 @@
 import asyncio
 import multiprocessing
-import os
 import shutil
 import sys
 from contextlib import asynccontextmanager
@@ -17,13 +16,12 @@ if sys.version_info >= (3, 9):
         Callable,
         Collection,
         Iterator,
-        Mapping,
         Sequence,
         Set,
     )
 else:
     from typing import AbstractSet as Set
-    from typing import AsyncGenerator, Callable, Collection, Iterator, Mapping, Sequence
+    from typing import AsyncGenerator, Callable, Collection, Iterator, Sequence
 
 import aioshutil
 
@@ -87,7 +85,7 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
             return str(self.path)
 
         def __repr__(self) -> str:
-            return f"{type(self).__name__}({self.path})"
+            return f"{type(self).__qualname__}('{self.path}')"
 
         def __str__(self) -> str:
             return str(self.path)
@@ -203,12 +201,6 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
         else:
             return None
 
-    def _env(self) -> Mapping[str, str]:
-        """Return the environment variables for this case."""
-        env = os.environ.copy()
-        env["PWD"] = str(self.path)
-        return env
-
     def _parallel_cmd(
         self, cmd: Union[Sequence[Union[str, Path]], str, Path]
     ) -> Union[Sequence[Union[str, Path]], str]:
@@ -298,7 +290,7 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
         return str(self.path)
 
     def __repr__(self) -> str:
-        return f"{type(self).__name__}({self.path})"
+        return f"{type(self).__qualname__}('{self.path}')"
 
     def __str__(self) -> str:
         return str(self.path)
@@ -359,7 +351,6 @@ class FoamCase(FoamCaseBase):
                 cmd,
                 check=check,
                 cwd=self.path,
-                env=self._env(),
             )
         else:
             script_path = self._run_script(parallel=parallel) if script else None
@@ -522,7 +513,6 @@ class AsyncFoamCase(FoamCaseBase):
                     cmd,
                     check=check,
                     cwd=self.path,
-                    env=self._env(),
                 )
         else:
             script_path = self._run_script(parallel=parallel) if script else None

{foamlib-0.3.3 → foamlib-0.3.5}/foamlib/_files/__init__.py

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

foamlib-0.3.5/foamlib/_files/_files.py

@@ -0,0 +1,340 @@
+import sys
+from typing import Any, Tuple, Union, cast
+
+if sys.version_info >= (3, 9):
+    from collections.abc import Iterator, Mapping, MutableMapping, Sequence
+else:
+    from typing import Iterator, Mapping, MutableMapping, Sequence
+
+from ._base import FoamDict
+from ._io import FoamFileIO
+from ._serialization import Kind, dumpb
+
+try:
+    import numpy as np
+except ModuleNotFoundError:
+    pass
+
+
+class FoamFile(
+    FoamDict,
+    MutableMapping[
+        Union[str, Tuple[str, ...]], Union["FoamFile.Data", "FoamFile.SubDict"]
+    ],
+    FoamFileIO,
+):
+    """
+    An OpenFOAM dictionary file.
+
+    Use as a mutable mapping (i.e., like a dict) to access and modify entries.
+
+    Use as a context manager to make multiple changes to the file while saving all changes only once at the end.
+    """
+
+    class SubDict(
+        FoamDict,
+        MutableMapping[str, Union["FoamFile.Data", "FoamFile.SubDict"]],
+    ):
+        """An OpenFOAM dictionary within a file as a mutable mapping."""
+
+        def __init__(self, _file: "FoamFile", _keywords: Tuple[str, ...]) -> None:
+            self._file = _file
+            self._keywords = _keywords
+
+        def __getitem__(
+            self, keyword: str
+        ) -> Union["FoamFile.Data", "FoamFile.SubDict"]:
+            return self._file[(*self._keywords, keyword)]
+
+        def __setitem__(
+            self,
+            keyword: str,
+            data: "FoamFile._SetData",
+        ) -> None:
+            self._file[(*self._keywords, keyword)] = data
+
+        def __delitem__(self, keyword: str) -> None:
+            del self._file[(*self._keywords, keyword)]
+
+        def __iter__(self) -> Iterator[str]:
+            return self._file._iter(self._keywords)
+
+        def __contains__(self, keyword: object) -> bool:
+            return (*self._keywords, keyword) in self._file
+
+        def __len__(self) -> int:
+            return len(list(iter(self)))
+
+        def update(self, *args: Any, **kwargs: Any) -> None:
+            with self._file:
+                super().update(*args, **kwargs)
+
+        def clear(self) -> None:
+            with self._file:
+                super().clear()
+
+        def __repr__(self) -> str:
+            return f"{type(self).__qualname__}('{self._file}', {self._keywords})"
+
+        def as_dict(self) -> FoamDict._Dict:
+            """Return a nested dict representation of the dictionary."""
+            ret = self._file.as_dict()
+
+            for k in self._keywords:
+                assert isinstance(ret, dict)
+                v = ret[k]
+                assert isinstance(v, dict)
+                ret = v
+
+            return ret
+
+    def __getitem__(
+        self, keywords: Union[str, Tuple[str, ...]]
+    ) -> Union["FoamFile.Data", "FoamFile.SubDict"]:
+        if not isinstance(keywords, tuple):
+            keywords = (keywords,)
+
+        _, parsed = self._read()
+
+        value = parsed[keywords]
+
+        if value is ...:
+            return FoamFile.SubDict(self, keywords)
+        else:
+            return value  # type: ignore [return-value]
+
+    @property
+    def _binary(self) -> bool:
+        return self.get(("FoamFile", "format"), None) == "binary"
+
+    def __setitem__(
+        self,
+        keywords: Union[str, Tuple[str, ...]],
+        data: "FoamFile._SetData",
+        *,
+        assume_field: bool = False,
+        assume_dimensions: bool = False,
+    ) -> None:
+        if not isinstance(keywords, tuple):
+            keywords = (keywords,)
+
+        kind = Kind.DEFAULT
+        if keywords == ("internalField",) or (
+            len(keywords) == 3
+            and keywords[0] == "boundaryField"
+            and keywords[2] == "value"
+        ):
+            kind = Kind.BINARY_FIELD if self._binary else Kind.FIELD
+        elif keywords == ("dimensions",):
+            kind = Kind.DIMENSIONS
+
+        contents, parsed = self._read()
+
+        if isinstance(data, Mapping):
+            with self:
+                if isinstance(data, FoamDict):
+                    data = data.as_dict()
+
+                start, end = parsed.entry_location(keywords, missing_ok=True)
+
+                self._write(
+                    contents[:start]
+                    + b"\n"
+                    + dumpb({keywords[-1]: {}})
+                    + b"\n"
+                    + contents[end:]
+                )
+
+                for k, v in data.items():
+                    self[(*keywords, k)] = v
+        else:
+            start, end = parsed.entry_location(keywords, missing_ok=True)
+
+            self._write(
+                contents[:start]
+                + b"\n"
+                + dumpb({keywords[-1]: data}, kind=kind)
+                + b"\n"
+                + contents[end:]
+            )
+
+    def __delitem__(self, keywords: Union[str, Tuple[str, ...]]) -> None:
+        if not isinstance(keywords, tuple):
+            keywords = (keywords,)
+
+        contents, parsed = self._read()
+
+        start, end = parsed.entry_location(keywords)
+
+        self._write(contents[:start] + contents[end:])
+
+    def _iter(self, keywords: Union[str, Tuple[str, ...]] = ()) -> Iterator[str]:
+        if not isinstance(keywords, tuple):
+            keywords = (keywords,)
+
+        _, parsed = self._read()
+
+        yield from (k[-1] for k in parsed if k[:-1] == keywords)
+
+    def __iter__(self) -> Iterator[str]:
+        return self._iter()
+
+    def __contains__(self, keywords: object) -> bool:
+        if not isinstance(keywords, tuple):
+            keywords = (keywords,)
+        _, parsed = self._read()
+        return keywords in parsed
+
+    def __len__(self) -> int:
+        return len(list(iter(self)))
+
+    def update(self, *args: Any, **kwargs: Any) -> None:
+        with self:
+            super().update(*args, **kwargs)
+
+    def clear(self) -> None:
+        with self:
+            super().clear()
+
+    def __fspath__(self) -> str:
+        return str(self.path)
+
+    def as_dict(self) -> FoamDict._Dict:
+        """Return a nested dict representation of the file."""
+        _, parsed = self._read()
+        return parsed.as_dict()
+
+
+class FoamFieldFile(FoamFile):
+    """An OpenFOAM dictionary file representing a field as a mutable mapping."""
+
+    class BoundariesSubDict(FoamFile.SubDict):
+        def __getitem__(self, keyword: str) -> "FoamFieldFile.BoundarySubDict":
+            value = super().__getitem__(keyword)
+            if not isinstance(value, FoamFieldFile.BoundarySubDict):
+                assert not isinstance(value, FoamFile.SubDict)
+                raise TypeError(f"boundary {keyword} is not a dictionary")
+            return value
+
+    class BoundarySubDict(FoamFile.SubDict):
+        """An OpenFOAM dictionary representing a boundary condition as a mutable mapping."""
+
+        @property
+        def type(self) -> str:
+            """Alias of `self["type"]`."""
+            ret = self["type"]
+            if not isinstance(ret, str):
+                raise TypeError("type is not a string")
+            return ret
+
+        @type.setter
+        def type(self, data: str) -> None:
+            self["type"] = data
+
+        @property
+        def value(
+            self,
+        ) -> Union[
+            int,
+            float,
+            Sequence[Union[int, float, Sequence[Union[int, float]]]],
+            "np.ndarray[Tuple[()], np.dtype[np.generic]]",
+            "np.ndarray[Tuple[int], np.dtype[np.generic]]",
+            "np.ndarray[Tuple[int, int], np.dtype[np.generic]]",
+        ]:
+            """Alias of `self["value"]`."""
+            ret = self["value"]
+            if not isinstance(ret, (int, float, Sequence)):
+                raise TypeError("value is not a field")
+            return cast(
+                Union[
+                    int, float, Sequence[Union[int, float, Sequence[Union[int, float]]]]
+                ],
+                ret,
+            )
+
+        @value.setter
+        def value(
+            self,
+            value: Union[
+                int,
+                float,
+                Sequence[Union[int, float, Sequence[Union[int, float]]]],
+                "np.ndarray[Tuple[()], np.dtype[np.generic]]",
+                "np.ndarray[Tuple[int], np.dtype[np.generic]]",
+                "np.ndarray[Tuple[int, int], np.dtype[np.generic]]",
+            ],
+        ) -> None:
+            self["value"] = value
+
+        @value.deleter
+        def value(self) -> None:
+            del self["value"]
+
+    def __getitem__(
+        self, keywords: Union[str, Tuple[str, ...]]
+    ) -> Union[FoamFile.Data, FoamFile.SubDict]:
+        if not isinstance(keywords, tuple):
+            keywords = (keywords,)
+
+        ret = super().__getitem__(keywords)
+        if keywords[0] == "boundaryField" and isinstance(ret, FoamFile.SubDict):
+            if len(keywords) == 1:
+                ret = FoamFieldFile.BoundariesSubDict(self, keywords)
+            elif len(keywords) == 2:
+                ret = FoamFieldFile.BoundarySubDict(self, keywords)
+        return ret
+
+    @property
+    def dimensions(self) -> Union[FoamFile.DimensionSet, Sequence[Union[int, float]]]:
+        """Alias of `self["dimensions"]`."""
+        ret = self["dimensions"]
+        if not isinstance(ret, FoamFile.DimensionSet):
+            raise TypeError("dimensions is not a DimensionSet")
+        return ret
+
+    @dimensions.setter
+    def dimensions(
+        self, value: Union[FoamFile.DimensionSet, Sequence[Union[int, float]]]
+    ) -> None:
+        self["dimensions"] = value
+
+    @property
+    def internal_field(
+        self,
+    ) -> Union[
+        int,
+        float,
+        Sequence[Union[int, float, Sequence[Union[int, float]]]],
+        "np.ndarray[Tuple[()], np.dtype[np.generic]]",
+        "np.ndarray[Tuple[int], np.dtype[np.generic]]",
+        "np.ndarray[Tuple[int, int], np.dtype[np.generic]]",
+    ]:
+        """Alias of `self["internalField"]`."""
+        ret = self["internalField"]
+        if not isinstance(ret, (int, float, Sequence)):
+            raise TypeError("internalField is not a field")
+        return cast(Union[int, float, Sequence[Union[int, float]]], ret)
+
+    @internal_field.setter
+    def internal_field(
+        self,
+        value: Union[
+            int,
+            float,
+            Sequence[Union[int, float, Sequence[Union[int, float]]]],
+            "np.ndarray[Tuple[()], np.dtype[np.generic]]",
+            "np.ndarray[Tuple[int], np.dtype[np.generic]]",
+            "np.ndarray[Tuple[int, int], np.dtype[np.generic]]",
+        ],
+    ) -> None:
+        self["internalField"] = value
+
+    @property
+    def boundary_field(self) -> "FoamFieldFile.BoundariesSubDict":
+        """Alias of `self["boundaryField"]`."""
+        ret = self["boundaryField"]
+        if not isinstance(ret, FoamFieldFile.BoundariesSubDict):
+            assert not isinstance(ret, FoamFile.SubDict)
+            raise TypeError("boundaryField is not a dictionary")
+        return ret

{foamlib-0.3.3 → foamlib-0.3.5}/foamlib/_files/_io.py

@@ -25,7 +25,7 @@ class FoamFileIO:
         elif not self.path.is_file():
             raise FileNotFoundError(self.path)
 
-        self.__contents: Optional[str] = None
+        self.__contents: Optional[bytes] = None
         self.__parsed: Optional[Parsed] = None
         self.__defer_io = 0
         self.__dirty = False
@@ -48,9 +48,9 @@ class FoamFileIO:
             self._write(self.__contents)
         assert not self.__dirty
 
-    def _read(self) -> Tuple[str, Parsed]:
+    def _read(self) -> Tuple[bytes, Parsed]:
         if not self.__defer_io:
-            contents = self.path.read_text()
+            contents = self.path.read_bytes()
             if contents != self.__contents:
                 self.__contents = contents
                 self.__parsed = None
@@ -63,11 +63,14 @@ class FoamFileIO:
 
         return self.__contents, deepcopy(self.__parsed)
 
-    def _write(self, contents: str) -> None:
+    def _write(self, contents: bytes) -> None:
         self.__contents = contents
         self.__parsed = None
         if not self.__defer_io:
-            self.path.write_text(contents)
+            self.path.write_bytes(contents)
             self.__dirty = False
         else:
             self.__dirty = True
+
+    def __repr__(self) -> str:
+        return f"{type(self).__qualname__}('{self.path}')"

{foamlib-0.3.3 → foamlib-0.3.5}/foamlib/_files/_parsing.py

@@ -1,3 +1,4 @@
+import array
 import sys
 from typing import Tuple, Union
 
@@ -12,6 +13,7 @@ else:
     from typing import Any as EllipsisType
 
 from pyparsing import (
+    CharsNotIn,
     Dict,
     Forward,
     Group,
@@ -74,6 +76,56 @@ def _dictionary_of(
     return Dict(Group(keyword_entry)[len], asdict=not located)
 
 
+_binary_contents = Forward()
+
+
+def _binary_field_parse_action(tks: ParseResults) -> None:
+    global _binary_contents
+
+    kind, count = tks
+    if kind == "scalar":
+        elsize = 1
+    elif kind == "vector":
+        elsize = 3
+    elif kind == "symmTensor":
+        elsize = 6
+    elif kind == "tensor":
+        elsize = 9
+
+    def unpack(
+        tks: ParseResults,
+    ) -> Sequence[Union[Sequence[float], Sequence[Sequence[float]]]]:
+        bytes_ = tks[0].encode("latin-1")
+
+        arr = array.array("d", bytes_)
+
+        if elsize != 1:
+            all = [arr[i : i + elsize].tolist() for i in range(0, len(arr), elsize)]
+        else:
+            all = arr.tolist()
+
+        return [all]
+
+    _binary_contents <<= CharsNotIn(exact=count * elsize * 8).set_parse_action(unpack)
+
+    tks.clear()  # type: ignore [no-untyped-call]
+
+
+_BINARY_FIELD = (
+    (
+        Keyword("nonuniform").suppress()
+        + Literal("List").suppress()
+        + Literal("<").suppress()
+        + common.identifier
+        + Literal(">").suppress()
+        + common.integer
+        + Literal("(").suppress()
+    ).set_parse_action(_binary_field_parse_action, call_during_try=True)
+    + _binary_contents
+    + Literal(")").suppress()
+)
+
+
 _SWITCH = (
     Keyword("yes") | Keyword("true") | Keyword("on") | Keyword("y") | Keyword("t")
 ).set_parse_action(lambda: True) | (
@@ -87,8 +139,10 @@ _IDENTIFIER = Word(identchars + "$", printables, exclude_chars=";")
 _DIMENSIONED = (Opt(_IDENTIFIER) + _DIMENSIONS + _TENSOR).set_parse_action(
     lambda tks: FoamDict.Dimensioned(*reversed(tks.as_list()))
 )
-_FIELD = (Keyword("uniform").suppress() + _TENSOR) | (
-    Keyword("nonuniform").suppress() + _list_of(_TENSOR)
+_FIELD = (
+    (Keyword("uniform").suppress() + _TENSOR)
+    | (Keyword("nonuniform").suppress() + _list_of(_TENSOR))
+    | _BINARY_FIELD
 )
 _TOKEN = QuotedString('"', unquote_results=False) | _IDENTIFIER
 _DATA = Forward()
@@ -109,16 +163,19 @@ _FILE = (
     .ignore(c_style_comment)
     .ignore(cpp_style_comment)
     .ignore(Literal("#include") + ... + LineEnd())  # type: ignore [no-untyped-call]
+    .parse_with_tabs()
 )
 
 
 class Parsed(Mapping[Tuple[str, ...], Union[FoamDict.Data, EllipsisType]]):
-    def __init__(self, contents: str) -> None:
+    def __init__(self, contents: bytes) -> None:
         self._parsed: MutableMapping[
             Tuple[str, ...],
             Tuple[int, Union[FoamDict.Data, EllipsisType], int],
         ] = {}
-        for parse_result in _FILE.parse_string(contents, parse_all=True):
+        for parse_result in _FILE.parse_string(
+            contents.decode("latin-1"), parse_all=True
+        ):
             self._parsed.update(self._flatten_result(parse_result))
 
     @staticmethod

foamlib-0.3.5/foamlib/_files/_serialization.py

@@ -0,0 +1,117 @@
+import array
+import itertools
+import sys
+from enum import Enum, auto
+
+if sys.version_info >= (3, 9):
+    from collections.abc import Mapping
+else:
+    from typing import Mapping
+
+from .._util import is_sequence
+from ._base import FoamDict
+
+try:
+    import numpy as np
+
+    numpy = True
+except ModuleNotFoundError:
+    numpy = False
+
+
+class Kind(Enum):
+    DEFAULT = auto()
+    LIST_ENTRY = auto()
+    FIELD = auto()
+    BINARY_FIELD = auto()
+    DIMENSIONS = auto()
+
+
+def dumpb(
+    data: FoamDict._SetData,
+    *,
+    kind: Kind = Kind.DEFAULT,
+) -> bytes:
+    if numpy and isinstance(data, np.ndarray):
+        return dumpb(data.tolist(), kind=kind)
+
+    elif isinstance(data, Mapping):
+        entries = []
+        for k, v in data.items():
+            b = dumpb(v, kind=kind)
+            if isinstance(v, Mapping):
+                entries.append(dumpb(k) + b"\n" + b"{\n" + b + b"\n}")
+            elif b:
+                entries.append(dumpb(k) + b" " + b + b";")
+            else:
+                entries.append(dumpb(k) + b";")
+
+        return b"\n".join(entries)
+
+    elif isinstance(data, FoamDict.DimensionSet) or (
+        kind == Kind.DIMENSIONS and is_sequence(data) and len(data) == 7
+    ):
+        return b"[" + b" ".join(dumpb(v) for v in data) + b"]"
+
+    elif (kind == Kind.FIELD or kind == Kind.BINARY_FIELD) and (
+        isinstance(data, (int, float))
+        or is_sequence(data)
+        and data
+        and isinstance(data[0], (int, float))
+        and len(data) in (3, 6, 9)
+    ):
+        return b"uniform " + dumpb(data)
+
+    elif (kind == Kind.FIELD or kind == Kind.BINARY_FIELD) and is_sequence(data):
+        if isinstance(data[0], (int, float)):
+            tensor_kind = b"scalar"
+        elif len(data[0]) == 3:
+            tensor_kind = b"vector"
+        elif len(data[0]) == 6:
+            tensor_kind = b"symmTensor"
+        elif len(data[0]) == 9:
+            tensor_kind = b"tensor"
+        else:
+            return dumpb(data)
+
+        if kind == Kind.BINARY_FIELD:
+            if tensor_kind == b"scalar":
+                contents = b"(" + array.array("d", data).tobytes() + b")"
+            else:
+                contents = (
+                    b"("
+                    + array.array("d", itertools.chain.from_iterable(data)).tobytes()
+                    + b")"
+                )
+        else:
+            contents = dumpb(data)
+
+        return b"nonuniform List<" + tensor_kind + b"> " + dumpb(len(data)) + contents
+
+    elif kind != Kind.LIST_ENTRY and isinstance(data, tuple):
+        return b" ".join(dumpb(v) for v in data)
+
+    elif isinstance(data, FoamDict.Dimensioned):
+        if data.name is not None:
+            return (
+                dumpb(data.name)
+                + b" "
+                + dumpb(data.dimensions, kind=Kind.DIMENSIONS)
+                + b" "
+                + dumpb(data.value)
+            )
+        else:
+            return (
+                dumpb(data.dimensions, kind=Kind.DIMENSIONS) + b" " + dumpb(data.value)
+            )
+
+    elif is_sequence(data):
+        return b"(" + b" ".join(dumpb(v, kind=Kind.LIST_ENTRY) for v in data) + b")"
+
+    elif data is True:
+        return b"yes"
+    elif data is False:
+        return b"no"
+
+    else:
+        return str(data).encode("latin-1")

{foamlib-0.3.3 → foamlib-0.3.5}/foamlib/_util.py

@@ -1,4 +1,5 @@
 import asyncio
+import os
 import subprocess
 import sys
 from pathlib import Path
@@ -47,12 +48,20 @@ def _check(
         warn(f"Command {cmd} printed to stderr.\n{stderr}", CalledProcessWarning)
 
 
+def _env(cwd: Optional[Union[str, Path]] = None) -> Optional[Mapping[str, str]]:
+    if cwd is not None:
+        env = os.environ.copy()
+        env["PWD"] = str(cwd)
+        return env
+    else:
+        return None
+
+
 def run_process(
     cmd: Union[Sequence[Union[str, Path]], str, Path],
     *,
     check: bool = True,
     cwd: Union[None, str, Path] = None,
-    env: Union[None, Mapping[str, str]] = None,
 ) -> None:
     shell = not is_sequence(cmd)
 
@@ -65,8 +74,8 @@ def run_process(
     proc = subprocess.run(
         cmd,
         cwd=cwd,
-        env=env,
-        stdout=subprocess.DEVNULL,
+        env=_env(cwd),
+        stdout=None,
         stderr=subprocess.PIPE if check else subprocess.DEVNULL,
         text=True,
         shell=shell,
@@ -81,13 +90,12 @@ async def run_process_async(
     *,
     check: bool = True,
     cwd: Union[None, str, Path] = None,
-    env: Union[None, Mapping[str, str]] = None,
 ) -> None:
     if not is_sequence(cmd):
         proc = await asyncio.create_subprocess_shell(
             str(cmd),
             cwd=cwd,
-            env=env,
+            env=_env(cwd),
             stdout=asyncio.subprocess.DEVNULL,
             stderr=asyncio.subprocess.PIPE if check else asyncio.subprocess.DEVNULL,
         )
@@ -98,7 +106,7 @@ async def run_process_async(
         proc = await asyncio.create_subprocess_exec(
             *cmd,
             cwd=cwd,
-            env=env,
+            env=_env(cwd),
             stdout=asyncio.subprocess.DEVNULL,
             stderr=asyncio.subprocess.PIPE if check else asyncio.subprocess.DEVNULL,
         )

{foamlib-0.3.3 → foamlib-0.3.5}/foamlib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.3.3
+Version: 0.3.5
 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
@@ -58,11 +58,11 @@ Requires-Dist: numpy<2,>=1; extra == "docs"
 
 **foamlib** provides a simple, modern and ergonomic Python interface for interacting with [OpenFOAM](https://www.openfoam.com).
 
-It offers the following classes (among a few others):
+It offers the following classes:
 
+* [`FoamFile`](https://foamlib.readthedocs.io/en/stable/#foamlib.FoamFile) (and [`FoamFieldFile`](https://foamlib.readthedocs.io/en/stable/#foamlib.FoamFieldFile)): read-write access to OpenFOAM configuration and field files as if they were Python `dict`s, using `foamlib`'s own parser. Supports both ASCII and binary field formats.
 * [`FoamCase`](https://foamlib.readthedocs.io/en/stable/#foamlib.FoamCase): a class for manipulating, executing and accessing the results of OpenFOAM cases.
 * [`AsyncFoamCase`](https://foamlib.readthedocs.io/en/stable/#foamlib.AsyncFoamCase): variant of `FoamCase` with asynchronous methods for running multiple cases at once.
-* [`FoamFile`](https://foamlib.readthedocs.io/en/stable/#foamlib.FoamFile): read-write access to OpenFOAM configuration and field files as if they were Python `dict`s.
 
 ## Get started
 
@@ -130,6 +130,16 @@ async def run_case():
 asyncio.run(run_case())
 ```
 
+### Parse a field using the [`FoamFieldFile`](https://foamlib.readthedocs.io/en/stable/#foamlib.FoamFieldFile) class directly
+
+```python
+from foamlib import FoamFieldFile
+
+U = FoamFieldFile(Path(my_pitz) / "0/U")
+
+print(U.internal_field)
+```
+
 ## Documentation
 
 For more information, check out the [documentation](https://foamlib.readthedocs.io/).

{foamlib-0.3.3 → foamlib-0.3.5}/foamlib.egg-info/SOURCES.txt

@@ -12,7 +12,6 @@ foamlib.egg-info/requires.txt
 foamlib.egg-info/top_level.txt
 foamlib/_files/__init__.py
 foamlib/_files/_base.py
-foamlib/_files/_fields.py
 foamlib/_files/_files.py
 foamlib/_files/_io.py
 foamlib/_files/_parsing.py

foamlib-0.3.3/foamlib/_files/_fields.py

@@ -1,165 +0,0 @@
-import sys
-from typing import Any, Tuple, Union, cast
-
-if sys.version_info >= (3, 9):
-    from collections.abc import Sequence
-else:
-    from typing import Sequence
-
-from ._files import FoamFile
-
-try:
-    import numpy as np
-except ModuleNotFoundError:
-    pass
-
-
-class FoamFieldFile(FoamFile):
-    """An OpenFOAM dictionary file representing a field as a mutable mapping."""
-
-    class BoundariesSubDict(FoamFile.SubDict):
-        def __getitem__(self, keyword: str) -> "FoamFieldFile.BoundarySubDict":
-            value = super().__getitem__(keyword)
-            if not isinstance(value, FoamFieldFile.BoundarySubDict):
-                assert not isinstance(value, FoamFile.SubDict)
-                raise TypeError(f"boundary {keyword} is not a dictionary")
-            return value
-
-    class BoundarySubDict(FoamFile.SubDict):
-        """An OpenFOAM dictionary representing a boundary condition as a mutable mapping."""
-
-        def __setitem__(
-            self,
-            keyword: str,
-            data: FoamFile._SetData,
-        ) -> None:
-            if keyword == "value":
-                self._setitem(keyword, data, assume_field=True)
-            else:
-                self._setitem(keyword, data)
-
-        @property
-        def type(self) -> str:
-            """Alias of `self["type"]`."""
-            ret = self["type"]
-            if not isinstance(ret, str):
-                raise TypeError("type is not a string")
-            return ret
-
-        @type.setter
-        def type(self, data: str) -> None:
-            self["type"] = data
-
-        @property
-        def value(
-            self,
-        ) -> Union[
-            int,
-            float,
-            Sequence[Union[int, float, Sequence[Union[int, float]]]],
-            "np.ndarray[Tuple[()], np.dtype[np.generic]]",
-            "np.ndarray[Tuple[int], np.dtype[np.generic]]",
-            "np.ndarray[Tuple[int, int], np.dtype[np.generic]]",
-        ]:
-            """Alias of `self["value"]`."""
-            ret = self["value"]
-            if not isinstance(ret, (int, float, Sequence)):
-                raise TypeError("value is not a field")
-            return cast(Union[int, float, Sequence[Union[int, float]]], ret)
-
-        @value.setter
-        def value(
-            self,
-            value: Union[
-                int,
-                float,
-                Sequence[Union[int, float, Sequence[Union[int, float]]]],
-                "np.ndarray[Tuple[()], np.dtype[np.generic]]",
-                "np.ndarray[Tuple[int], np.dtype[np.generic]]",
-                "np.ndarray[Tuple[int, int], np.dtype[np.generic]]",
-            ],
-        ) -> None:
-            self["value"] = value
-
-        @value.deleter
-        def value(self) -> None:
-            del self["value"]
-
-    def __getitem__(
-        self, keywords: Union[str, Tuple[str, ...]]
-    ) -> Union[FoamFile.Data, FoamFile.SubDict]:
-        if not isinstance(keywords, tuple):
-            keywords = (keywords,)
-
-        ret = super().__getitem__(keywords)
-        if keywords[0] == "boundaryField" and isinstance(ret, FoamFile.SubDict):
-            if len(keywords) == 1:
-                ret = FoamFieldFile.BoundariesSubDict(self, keywords)
-            elif len(keywords) == 2:
-                ret = FoamFieldFile.BoundarySubDict(self, keywords)
-        return ret
-
-    def __setitem__(self, keywords: Union[str, Tuple[str, ...]], value: Any) -> None:
-        if not isinstance(keywords, tuple):
-            keywords = (keywords,)
-
-        if keywords == ("internalField",):
-            self._setitem(keywords, value, assume_field=True)
-        elif keywords == ("dimensions",):
-            self._setitem(keywords, value, assume_dimensions=True)
-        else:
-            self._setitem(keywords, value)
-
-    @property
-    def dimensions(self) -> FoamFile.DimensionSet:
-        """Alias of `self["dimensions"]`."""
-        ret = self["dimensions"]
-        if not isinstance(ret, FoamFile.DimensionSet):
-            raise TypeError("dimensions is not a DimensionSet")
-        return ret
-
-    @dimensions.setter
-    def dimensions(
-        self, value: Union[FoamFile.DimensionSet, Sequence[Union[int, float]]]
-    ) -> None:
-        self["dimensions"] = value
-
-    @property
-    def internal_field(
-        self,
-    ) -> Union[
-        int,
-        float,
-        Sequence[Union[int, float, Sequence[Union[int, float]]]],
-        "np.ndarray[Tuple[()], np.dtype[np.generic]]",
-        "np.ndarray[Tuple[int], np.dtype[np.generic]]",
-        "np.ndarray[Tuple[int, int], np.dtype[np.generic]]",
-    ]:
-        """Alias of `self["internalField"]`."""
-        ret = self["internalField"]
-        if not isinstance(ret, (int, float, Sequence)):
-            raise TypeError("internalField is not a field")
-        return cast(Union[int, float, Sequence[Union[int, float]]], ret)
-
-    @internal_field.setter
-    def internal_field(
-        self,
-        value: Union[
-            int,
-            float,
-            Sequence[Union[int, float, Sequence[Union[int, float]]]],
-            "np.ndarray[Tuple[()], np.dtype[np.generic]]",
-            "np.ndarray[Tuple[int], np.dtype[np.generic]]",
-            "np.ndarray[Tuple[int, int], np.dtype[np.generic]]",
-        ],
-    ) -> None:
-        self["internalField"] = value
-
-    @property
-    def boundary_field(self) -> "FoamFieldFile.BoundariesSubDict":
-        """Alias of `self["boundaryField"]`."""
-        ret = self["boundaryField"]
-        if not isinstance(ret, FoamFieldFile.BoundariesSubDict):
-            assert not isinstance(ret, FoamFile.SubDict)
-            raise TypeError("boundaryField is not a dictionary")
-        return ret

foamlib-0.3.3/foamlib/_files/_files.py

@@ -1,203 +0,0 @@
-import sys
-from typing import (
-    Any,
-    Tuple,
-    Union,
-)
-
-if sys.version_info >= (3, 9):
-    from collections.abc import Iterator, Mapping, MutableMapping
-else:
-    from typing import Iterator, Mapping, MutableMapping
-
-from ._base import FoamDict
-from ._io import FoamFileIO
-from ._serialization import dumps
-
-
-class FoamFile(
-    FoamDict,
-    MutableMapping[
-        Union[str, Tuple[str, ...]], Union["FoamFile.Data", "FoamFile.SubDict"]
-    ],
-    FoamFileIO,
-):
-    """
-    An OpenFOAM dictionary file.
-
-    Use as a mutable mapping (i.e., like a dict) to access and modify entries.
-
-    Use as a context manager to make multiple changes to the file while saving all changes only once at the end.
-    """
-
-    class SubDict(
-        FoamDict,
-        MutableMapping[str, Union["FoamFile.Data", "FoamFile.SubDict"]],
-    ):
-        """An OpenFOAM dictionary within a file as a mutable mapping."""
-
-        def __init__(self, _file: "FoamFile", _keywords: Tuple[str, ...]) -> None:
-            self._file = _file
-            self._keywords = _keywords
-
-        def __getitem__(
-            self, keyword: str
-        ) -> Union["FoamFile.Data", "FoamFile.SubDict"]:
-            return self._file[(*self._keywords, keyword)]
-
-        def _setitem(
-            self,
-            keyword: str,
-            data: Any,
-            *,
-            assume_field: bool = False,
-            assume_dimensions: bool = False,
-        ) -> None:
-            self._file._setitem(
-                (*self._keywords, keyword),
-                data,
-                assume_field=assume_field,
-                assume_dimensions=assume_dimensions,
-            )
-
-        def __setitem__(self, keyword: str, value: "FoamFile._SetData") -> None:
-            self._setitem(keyword, value)
-
-        def __delitem__(self, keyword: str) -> None:
-            del self._file[(*self._keywords, keyword)]
-
-        def __iter__(self) -> Iterator[str]:
-            return self._file._iter(self._keywords)
-
-        def __contains__(self, keyword: object) -> bool:
-            return (*self._keywords, keyword) in self._file
-
-        def __len__(self) -> int:
-            return len(list(iter(self)))
-
-        def update(self, *args: Any, **kwargs: Any) -> None:
-            with self._file:
-                super().update(*args, **kwargs)
-
-        def clear(self) -> None:
-            with self._file:
-                super().clear()
-
-        def __repr__(self) -> str:
-            return f"{type(self).__qualname__}({self._file}, {self._keywords})"
-
-        def as_dict(self) -> FoamDict._Dict:
-            """Return a nested dict representation of the dictionary."""
-            ret = self._file.as_dict()
-
-            for k in self._keywords:
-                assert isinstance(ret, dict)
-                v = ret[k]
-                assert isinstance(v, dict)
-                ret = v
-
-            return ret
-
-    def __getitem__(
-        self, keywords: Union[str, Tuple[str, ...]]
-    ) -> Union["FoamFile.Data", "FoamFile.SubDict"]:
-        if not isinstance(keywords, tuple):
-            keywords = (keywords,)
-
-        _, parsed = self._read()
-
-        value = parsed[keywords]
-
-        if value is ...:
-            return FoamFile.SubDict(self, keywords)
-        else:
-            return value  # type: ignore [return-value]
-
-    def _setitem(
-        self,
-        keywords: Union[str, Tuple[str, ...]],
-        data: "FoamFile._SetData",
-        *,
-        assume_field: bool = False,
-        assume_dimensions: bool = False,
-    ) -> None:
-        if not isinstance(keywords, tuple):
-            keywords = (keywords,)
-
-        contents, parsed = self._read()
-
-        if isinstance(data, Mapping):
-            with self:
-                if isinstance(data, FoamDict):
-                    data = data.as_dict()
-
-                start, end = parsed.entry_location(keywords, missing_ok=True)
-
-                self._write(
-                    f"{contents[:start]}\n{dumps({keywords[-1]: {}})}\n{contents[end:]}"
-                )
-
-                for k, v in data.items():
-                    self[(*keywords, k)] = v
-        else:
-            start, end = parsed.entry_location(keywords, missing_ok=True)
-
-            self._write(
-                f"{contents[:start]}\n{dumps({keywords[-1]: data}, assume_field=assume_field, assume_dimensions=assume_dimensions)}\n{contents[end:]}"
-            )
-
-    def __setitem__(
-        self,
-        keywords: Union[str, Tuple[str, ...]],
-        data: "FoamFile._SetData",
-    ) -> None:
-        self._setitem(keywords, data)
-
-    def __delitem__(self, keywords: Union[str, Tuple[str, ...]]) -> None:
-        if not isinstance(keywords, tuple):
-            keywords = (keywords,)
-
-        contents, parsed = self._read()
-
-        start, end = parsed.entry_location(keywords)
-
-        self._write(contents[:start] + contents[end:])
-
-    def _iter(self, keywords: Union[str, Tuple[str, ...]] = ()) -> Iterator[str]:
-        if not isinstance(keywords, tuple):
-            keywords = (keywords,)
-
-        _, parsed = self._read()
-
-        yield from (k[-1] for k in parsed if k[:-1] == keywords)
-
-    def __iter__(self) -> Iterator[str]:
-        return self._iter()
-
-    def __contains__(self, keywords: object) -> bool:
-        if not isinstance(keywords, tuple):
-            keywords = (keywords,)
-        _, parsed = self._read()
-        return keywords in parsed
-
-    def __len__(self) -> int:
-        return len(list(iter(self)))
-
-    def update(self, *args: Any, **kwargs: Any) -> None:
-        with self:
-            super().update(*args, **kwargs)
-
-    def clear(self) -> None:
-        with self:
-            super().clear()
-
-    def __fspath__(self) -> str:
-        return str(self.path)
-
-    def __repr__(self) -> str:
-        return f"{type(self).__name__}({self.path})"
-
-    def as_dict(self) -> FoamDict._Dict:
-        """Return a nested dict representation of the file."""
-        _, parsed = self._read()
-        return parsed.as_dict()

foamlib-0.3.3/foamlib/_files/_serialization.py

@@ -1,99 +0,0 @@
-import sys
-
-if sys.version_info >= (3, 9):
-    from collections.abc import Mapping
-else:
-    from typing import Mapping
-
-from .._util import is_sequence
-from ._base import FoamDict
-
-try:
-    import numpy as np
-
-    numpy = True
-except ModuleNotFoundError:
-    numpy = False
-
-
-def dumps(
-    data: FoamDict._SetData,
-    *,
-    assume_field: bool = False,
-    assume_dimensions: bool = False,
-    assume_data_entries: bool = False,
-) -> str:
-    if numpy and isinstance(data, np.ndarray):
-        return dumps(
-            data.tolist(),
-            assume_field=assume_field,
-            assume_dimensions=assume_dimensions,
-        )
-
-    elif isinstance(data, Mapping):
-        entries = []
-        for k, v in data.items():
-            s = dumps(
-                v,
-                assume_field=assume_field,
-                assume_dimensions=assume_dimensions,
-                assume_data_entries=True,
-            )
-            if isinstance(v, Mapping):
-                entries.append(f"{k}\n{{\n{s}\n}}")
-            elif s:
-                entries.append(f"{k} {s};")
-            else:
-                entries.append(f"{k};")
-        return "\n".join(entries)
-
-    elif isinstance(data, FoamDict.DimensionSet) or (
-        assume_dimensions and is_sequence(data) and len(data) == 7
-    ):
-        return f"[{' '.join(str(v) for v in data)}]"
-
-    elif assume_field and isinstance(data, (int, float)):
-        return f"uniform {data}"
-
-    elif assume_field and is_sequence(data):
-        if isinstance(data[0], (int, float)) and len(data) in (3, 6, 9):
-            return f"uniform {dumps(data)}"
-        elif isinstance(data[0], (int, float)):
-            return f"nonuniform List<scalar> {len(data)}{dumps(data)}"
-        elif len(data[0]) == 3:
-            return f"nonuniform List<vector> {len(data)}{dumps(data)}"
-        elif len(data[0]) == 6:
-            return f"nonuniform List<symmTensor> {len(data)}{dumps(data)}"
-        elif len(data[0]) == 9:
-            return f"nonuniform List<tensor> {len(data)}{dumps(data)}"
-        else:
-            return dumps(
-                data,
-                assume_dimensions=assume_dimensions,
-                assume_data_entries=assume_data_entries,
-            )
-
-    elif assume_data_entries and isinstance(data, tuple):
-        return " ".join(
-            dumps(v, assume_field=assume_field, assume_dimensions=assume_dimensions)
-            for v in data
-        )
-
-    elif isinstance(data, FoamDict.Dimensioned):
-        if data.name is not None:
-            return f"{data.name} {dumps(data.dimensions, assume_dimensions=True)} {dumps(data.value)}"
-        else:
-            return (
-                f"{dumps(data.dimensions, assume_dimensions=True)} {dumps(data.value)}"
-            )
-
-    elif is_sequence(data):
-        return f"({' '.join(dumps(v) for v in data)})"
-
-    elif data is True:
-        return "yes"
-    elif data is False:
-        return "no"
-
-    else:
-        return str(data)