foamlib 0.9.1__tar.gz → 0.9.3__tar.gz

{foamlib-0.9.1 → foamlib-0.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: foamlib
-Version: 0.9.1
+Version: 0.9.3
 Summary: A Python interface for interacting with OpenFOAM
 Project-URL: Homepage, https://github.com/gerlero/foamlib
 Project-URL: Repository, https://github.com/gerlero/foamlib

{foamlib-0.9.1 → foamlib-0.9.3}/foamlib/__init__.py

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

{foamlib-0.9.1 → foamlib-0.9.3}/foamlib/_files/_files.py

@@ -17,9 +17,11 @@ else:
 import numpy as np
 
 from ._io import FoamFileIO
-from ._serialization import Kind, dumps, normalize
+from ._parsing import loads
+from ._serialization import dumps, normalize_data, normalize_keyword
 from ._types import (
     Data,
+    DataLike,
     Dict_,
     Dimensioned,
     DimensionSet,
@@ -31,6 +33,32 @@ from ._types import (
 )
 
 
+def _tensor_kind_for_field(
+    field: FieldLike,
+) -> str:
+    shape = np.shape(field)  # type: ignore [arg-type]
+    if not shape:
+        return "scalar"
+    if shape == (3,):
+        return "vector"
+    if shape == (6,):
+        return "symmTensor"
+    if shape == (9,):
+        return "tensor"
+    if len(shape) == 1:
+        return "scalar"
+    if len(shape) == 2:
+        if shape[1] == 3:
+            return "vector"
+        if shape[1] == 6:
+            return "symmTensor"
+        if shape[1] == 9:
+            return "tensor"
+
+    msg = f"Invalid field shape: {shape}"
+    raise ValueError(msg)
+
+
 class FoamFile(
     MutableMapping[
         Optional[Union[str, Tuple[str, ...]]],
@@ -261,7 +289,7 @@ class FoamFile(
         elif not isinstance(keywords, tuple):
             keywords = (keywords,)
 
-        if keywords and not isinstance(normalize(keywords[-1], kind=Kind.KEYWORD), str):
+        if keywords and not isinstance(normalize_keyword(keywords[-1]), str):
             msg = f"Invalid keyword: {keywords[-1]}"
             raise ValueError(msg)
 
@@ -283,52 +311,26 @@ class FoamFile(
                     self.path.stem if self.path.suffix == ".gz" else self.path.name
                 )
 
-            kind = Kind.DEFAULT
-            if keywords == ("internalField",) or (
-                len(keywords) == 3
-                and keywords[0] == "boundaryField"
-                and (
-                    keywords[2] in ("value", "gradient")
-                    or keywords[2].endswith("Value")
-                    or keywords[2].endswith("Gradient")
-                )
-            ):
-                kind = (
-                    Kind.BINARY_FIELD if self.format == "binary" else Kind.ASCII_FIELD
-                )
-            elif keywords == ("dimensions",):
-                kind = Kind.DIMENSIONS
-
             if (
-                kind in (Kind.ASCII_FIELD, Kind.BINARY_FIELD)
+                keywords == ("internalField",)
+                or (
+                    len(keywords) == 3
+                    and keywords[0] == "boundaryField"
+                    and (
+                        keywords[2] == "value"
+                        or keywords[2] == "gradient"
+                        or keywords[2].endswith(("Value", "Gradient"))
+                    )
+                )
             ) and self.class_ == "dictionary":
                 try:
-                    shape = np.shape(data)  # type: ignore [arg-type]
+                    tensor_kind = _tensor_kind_for_field(data)  # type: ignore [arg-type]
                 except ValueError:
                     pass
                 else:
-                    if not shape:
-                        self.class_ = "volScalarField"
-                    elif shape == (3,):
-                        self.class_ = "volVectorField"
-                    elif shape == (6,):
-                        self.class_ = "volSymmTensorField"
-                    elif shape == (9,):
-                        self.class_ = "volTensorField"
-                    elif len(shape) == 1:
-                        self.class_ = "volScalarField"
-                    elif len(shape) == 2:
-                        if shape[1] == 3:
-                            self.class_ = "volVectorField"
-                        elif shape[1] == 6:
-                            self.class_ = "volSymmTensorField"
-                        elif shape[1] == 9:
-                            self.class_ = "volTensorField"
-
-            if kind == Kind.ASCII_FIELD and self.class_.endswith("scalarField"):
-                kind = Kind.SCALAR_ASCII_FIELD
-            elif kind == Kind.BINARY_FIELD and self.class_.endswith("scalarField"):
-                kind = Kind.SCALAR_BINARY_FIELD
+                    self.class_ = (
+                        "vol" + tensor_kind[0].upper() + tensor_kind[1:] + "Field"
+                    )
 
             parsed = self._get_parsed(missing_ok=True)
 
@@ -360,7 +362,7 @@ class FoamFile(
                     ...,
                     before
                     + indentation
-                    + dumps(keywords[-1])
+                    + dumps(normalize_keyword(keywords[-1]))
                     + b"\n"
                     + indentation
                     + b"{\n"
@@ -373,23 +375,37 @@ class FoamFile(
                     self[(*keywords, k)] = v
 
             elif keywords:
-                val = dumps(data, kind=kind)
+                header = self.get("FoamFile", None)
+                assert header is None or isinstance(header, FoamFile.SubDict)
+                val = dumps(
+                    data,
+                    keywords=keywords,
+                    header=header,
+                )
                 parsed.put(
                     keywords,
-                    normalize(data, kind=kind),
+                    normalize_data(data, keywords=keywords),
                     before
                     + indentation
-                    + dumps(keywords[-1])
+                    + dumps(normalize_keyword(keywords[-1]))
                     + ((b" " + val) if val else b"")
                     + (b";" if not keywords[-1].startswith("#") else b"")
                     + after,
                 )
 
             else:
+                header = self.get("FoamFile", None)
+                assert header is None or isinstance(header, FoamFile.SubDict)
                 parsed.put(
                     (),
-                    normalize(data, kind=kind),
-                    before + dumps(data, kind=kind) + after,
+                    normalize_data(data, keywords=keywords),
+                    before
+                    + dumps(
+                        data,
+                        keywords=(),
+                        header=header,
+                    )
+                    + after,
                 )
 
     def __delitem__(self, keywords: str | tuple[str, ...] | None) -> None:
@@ -442,6 +458,85 @@ class FoamFile(
             d.pop("FoamFile", None)
         return deepcopy(d)
 
+    @staticmethod
+    def loads(
+        s: bytes | str,
+        *,
+        include_header: bool = False,
+    ) -> File | Data:
+        """
+        Standalone deserializing function.
+
+        Deserialize the OpenFOAM FoamFile format to Python objects.
+
+        :param s: The string to deserialize. This can be a dictionary, list, or any
+            other object that can be serialized to the OpenFOAM format.
+        :param include_header: Whether to include the "FoamFile" header in the output.
+            If `True`, the header will be included if it is present in the input object.
+        """
+        ret = loads(s)
+
+        if not include_header and isinstance(ret, Mapping) and "FoamFile" in ret:
+            del ret["FoamFile"]
+            if len(ret) == 1 and None in ret:
+                val = ret[None]
+                assert not isinstance(val, Mapping)
+                return val
+
+        return ret
+
+    @staticmethod
+    def dumps(file: File | DataLike, *, ensure_header: bool = True) -> bytes:
+        """
+        Standalone serializing function.
+
+        Serialize Python objects to the OpenFOAM FoamFile format.
+
+        :param file: The Python object to serialize. This can be a dictionary, list,
+            or any other object that can be serialized to the OpenFOAM format.
+        :param ensure_header: Whether to include the "FoamFile" header in the output.
+            If `True`, a header will be included if it is not already present in the
+            input object.
+        """
+        if isinstance(file, Mapping):
+            header = file.get("FoamFile", None)
+            assert isinstance(header, FoamFile.SubDict) or header is None
+            entries: list[bytes] = []
+            for k, v in file.items():
+                if k is not None:
+                    entries.append(
+                        dumps((k, v), keywords=(), header=header, tuple_is_entry=True)
+                    )
+                else:
+                    entries.append(dumps(v, keywords=(), header=header))
+            ret = b" ".join(entries)
+        else:
+            header = None
+            ret = dumps(file)
+
+        if header is None and ensure_header:
+            class_ = "dictionary"
+            if isinstance(file, Mapping) and "internalField" in file:
+                try:
+                    tensor_kind = _tensor_kind_for_field(file["internalField"])  # type: ignore [arg-type]
+                except (ValueError, TypeError):
+                    pass
+                else:
+                    class_ = "vol" + tensor_kind[0].upper() + tensor_kind[1:] + "Field"
+
+            header = {"version": 2.0, "format": "ascii", "class": class_}
+
+            ret = (
+                dumps(
+                    {"FoamFile": header},
+                    keywords=(),
+                )
+                + b" "
+                + ret
+            )
+
+        return ret
+
 
 class FoamFieldFile(FoamFile):
     """

{foamlib-0.9.1 → foamlib-0.9.3}/foamlib/_files/_parsing.py

@@ -363,7 +363,9 @@ _FIELD = (Keyword("uniform", _IDENTBODYCHARS).suppress() + _TENSOR) | (
 _DIRECTIVE = Word("#", _IDENTBODYCHARS)
 _TOKEN = dbl_quoted_string | _DIRECTIVE | _IDENTIFIER
 _DATA = Forward()
-_KEYWORD_ENTRY = _keyword_entry_of(_TOKEN | _list_of(_IDENTIFIER), _DATA)
+_KEYWORD_ENTRY = _keyword_entry_of(
+    _TOKEN | _list_of(_IDENTIFIER), Opt(_DATA, default="")
+)
 _DICT = _dict_of(_TOKEN, _DATA)
 _DATA_ENTRY = Forward()
 _LIST_ENTRY = _DICT | _KEYWORD_ENTRY | _DATA_ENTRY
@@ -380,21 +382,41 @@ _NUMBER = (
 )
 _DATA_ENTRY <<= _FIELD | _LIST | _DIMENSIONED | _DIMENSIONS | _NUMBER | _SWITCH | _TOKEN
 
-_DATA <<= (
-    _DATA_ENTRY[1, ...]
-    .set_parse_action(lambda tks: [tuple(tks)] if len(tks) > 1 else [tks[0]])
+_DATA <<= _DATA_ENTRY[1, ...].set_parse_action(
+    lambda tks: [tuple(tks)] if len(tks) > 1 else [tks[0]]
+)
+
+_STANDALONE_DATA = (
+    _ascii_numeric_list(dtype=int, ignore=_COMMENT)
+    | _binary_numeric_list(dtype=np.int64)
+    | _binary_numeric_list(dtype=np.int32)
+    | _ascii_numeric_list(dtype=float, nested=3, ignore=_COMMENT)
+    | _binary_numeric_list(dtype=np.float64, nested=3)
+    | _binary_numeric_list(dtype=np.float32, nested=3)
+    | _DATA
+).add_parse_action(lambda tks: [None, tks[0]])
+
+
+_FILE = (
+    Dict(_KEYWORD_ENTRY[...] + Opt(Group(_STANDALONE_DATA)) + _KEYWORD_ENTRY[...])
     .ignore(_COMMENT)
     .parse_with_tabs()
 )
 
 
-def parse_data(s: str) -> Data:
-    if not s.strip():
-        return ""
-    return cast("Data", _DATA.parse_string(s, parse_all=True)[0])
+def loads(s: bytes | str) -> File | Data:
+    if isinstance(s, bytes):
+        s = s.decode("latin-1")
+
+    file = _FILE.parse_string(s, parse_all=True).as_dict()
 
+    if len(file) == 1 and None in file:
+        return file[None]  # type: ignore[no-any-return]
 
-_LOCATED_DICTIONARY = Group(
+    return file
+
+
+_LOCATED_KEYWORD_ENTRIES = Group(
     _keyword_entry_of(
         _TOKEN,
         Opt(_DATA, default=""),
@@ -403,22 +425,14 @@ _LOCATED_DICTIONARY = Group(
         located=True,
     )
 )[...]
-_LOCATED_DATA = Group(
-    Located(
-        (
-            _ascii_numeric_list(dtype=int, ignore=_COMMENT)
-            | _binary_numeric_list(dtype=np.int64)
-            | _binary_numeric_list(dtype=np.int32)
-            | _ascii_numeric_list(dtype=float, nested=3, ignore=_COMMENT)
-            | _binary_numeric_list(dtype=np.float64, nested=3)
-            | _binary_numeric_list(dtype=np.float32, nested=3)
-            | _DATA
-        ).add_parse_action(lambda tks: ["", tks[0]])
-    )
-)
+_LOCATED_STANDALONE_DATA = Group(Located(_STANDALONE_DATA))
 
-_FILE = (
-    Dict(_LOCATED_DICTIONARY + Opt(_LOCATED_DATA) + _LOCATED_DICTIONARY)
+_LOCATED_FILE = (
+    Dict(
+        _LOCATED_KEYWORD_ENTRIES
+        + Opt(_LOCATED_STANDALONE_DATA)
+        + _LOCATED_KEYWORD_ENTRIES
+    )
     .ignore(_COMMENT)
     .parse_with_tabs()
 )
@@ -430,7 +444,7 @@ class Parsed(Mapping[Tuple[str, ...], Union[Data, EllipsisType]]):
             tuple[str, ...],
             tuple[int, Data | EllipsisType, int],
         ] = {}
-        for parse_result in _FILE.parse_string(
+        for parse_result in _LOCATED_FILE.parse_string(
             contents.decode("latin-1"), parse_all=True
         ):
             self._parsed.update(self._flatten_result(parse_result))
@@ -453,8 +467,7 @@ class Parsed(Mapping[Tuple[str, ...], Union[Data, EllipsisType]]):
         end = parse_result.locn_end
         assert isinstance(end, int)
         keyword, *data = item
-        assert isinstance(keyword, str)
-        if not keyword:
+        if keyword is None:
             assert not _keywords
             assert len(data) == 1
             assert not isinstance(data[0], ParseResults)

foamlib-0.9.3/foamlib/_files/_serialization.py

@@ -0,0 +1,241 @@
+from __future__ import annotations
+
+import sys
+from typing import overload
+
+if sys.version_info >= (3, 9):
+    from collections.abc import Mapping
+else:
+    from typing import Mapping
+
+import numpy as np
+
+from ._parsing import loads
+from ._types import (
+    Data,
+    DataLike,
+    Dimensioned,
+    DimensionSet,
+    Entry,
+    EntryLike,
+    is_sequence,
+)
+
+
+@overload
+def normalize_data(
+    data: DataLike, *, keywords: tuple[str, ...] | None = None
+) -> Data: ...
+
+
+@overload
+def normalize_data(
+    data: EntryLike, *, keywords: tuple[str, ...] | None = None
+) -> Entry: ...
+
+
+def normalize_data(
+    data: EntryLike, *, keywords: tuple[str, ...] | None = None
+) -> Entry:
+    if keywords is not None and (
+        keywords == ("internalField",)
+        or (
+            len(keywords) == 3
+            and keywords[0] == "boundaryField"
+            and (
+                keywords[2] == "value"
+                or keywords[2] == "gradient"
+                or keywords[2].endswith(("Value", "Gradient"))
+            )
+        )
+    ):
+        if is_sequence(data):
+            try:
+                arr = np.asarray(data)
+            except ValueError:
+                pass
+            else:
+                if not np.issubdtype(arr.dtype, np.floating):
+                    arr = arr.astype(float)
+
+                if arr.ndim == 1 or (arr.ndim == 2 and arr.shape[1] in (3, 6, 9)):
+                    return arr  # type: ignore [return-value]
+
+            return [normalize_data(d) for d in data]
+
+        if isinstance(data, int):
+            return float(data)
+
+        return normalize_data(data)
+
+    if isinstance(data, Mapping):
+        return {normalize_keyword(k): normalize_data(v) for k, v in data.items()}  # type: ignore [misc]
+
+    if isinstance(data, np.ndarray):
+        ret = data.tolist()
+        assert isinstance(ret, (int, float, list))
+        return ret
+
+    if (
+        not isinstance(data, DimensionSet)
+        and keywords is not None
+        and keywords == ("dimensions",)
+        and is_sequence(data)
+        and len(data) <= 7
+        and all(isinstance(d, (int, float)) for d in data)
+    ):
+        return DimensionSet(*data)
+
+    if keywords is None and isinstance(data, tuple) and len(data) == 2:
+        k, v = data
+        assert not isinstance(k, Mapping)
+        return (
+            normalize_keyword(k),
+            normalize_data(v) if not isinstance(v, Mapping) else v,
+        )  # type: ignore [return-value]
+
+    if (
+        is_sequence(data)
+        and not isinstance(data, DimensionSet)
+        and (keywords is None or not isinstance(data, tuple))
+    ):
+        return [normalize_data(d) for d in data]
+
+    if isinstance(data, str):
+        s = loads(data)
+        if isinstance(s, (str, tuple, bool)):
+            return s
+
+    if isinstance(
+        data,
+        (int, float, bool, tuple, DimensionSet, Dimensioned),
+    ):
+        return data
+
+    msg = f"Unsupported data type: {type(data)}"
+    raise TypeError(msg)
+
+
+def normalize_keyword(data: DataLike) -> Data:
+    ret = normalize_data(data)
+
+    if isinstance(data, str) and isinstance(ret, bool):
+        return data
+
+    return ret
+
+
+def dumps(
+    data: EntryLike,
+    *,
+    keywords: tuple[str, ...] | None = None,
+    header: Mapping[str, Entry] | None = None,
+    tuple_is_entry: bool = False,
+) -> bytes:
+    data = normalize_data(data, keywords=keywords)
+
+    if isinstance(data, Mapping):
+        return (
+            b"{"
+            + b" ".join(
+                dumps(
+                    (k, v),
+                    keywords=keywords,
+                    tuple_is_entry=True,
+                )
+                for k, v in data.items()
+            )
+            + b"}"
+        )
+
+    if (
+        keywords is not None
+        and (
+            keywords == ("internalField",)
+            or (
+                len(keywords) == 3
+                and keywords[0] == "boundaryField"
+                and (
+                    keywords[2] == "value"
+                    or keywords[2] == "gradient"
+                    or keywords[2].endswith(("Value", "Gradient"))
+                )
+            )
+        )
+        and isinstance(data, (int, float, np.ndarray))
+    ):
+        data = np.asarray(data)  # type: ignore [assignment]
+        class_ = header.get("class", "") if header else ""
+        assert isinstance(class_, str)
+        scalar = "Scalar" in class_
+
+        shape = np.shape(data)
+        if not shape or (not scalar and shape in ((3,), (6,), (9,))):
+            return b"uniform " + dumps(data)
+
+        assert isinstance(data, np.ndarray)
+        ndim = np.ndim(data)
+        if ndim == 1:
+            tensor_kind = b"scalar"
+
+        elif ndim == 2:
+            assert len(shape) == 2
+            if shape[1] == 3:
+                tensor_kind = b"vector"
+            elif shape[1] == 6:
+                tensor_kind = b"symmTensor"
+            elif shape[1] == 9:
+                tensor_kind = b"tensor"
+            else:
+                return dumps(data)
+
+        else:
+            return dumps(data)
+
+        binary = (header.get("format", "") if header else "") == "binary"
+
+        contents = b"(" + data.tobytes() + b")" if binary else dumps(data)
+
+        return b"nonuniform List<" + tensor_kind + b"> " + dumps(len(data)) + contents
+
+    if isinstance(data, DimensionSet):
+        return b"[" + b" ".join(dumps(v) for v in data) + b"]"
+
+    if isinstance(data, Dimensioned):
+        if data.name is not None:
+            return (
+                dumps(data.name)
+                + b" "
+                + dumps(data.dimensions)
+                + b" "
+                + dumps(data.value)
+            )
+        return dumps(data.dimensions) + b" " + dumps(data.value)
+
+    if isinstance(data, tuple):
+        if tuple_is_entry:
+            k, v = data
+            ret = dumps(k)
+            val = dumps(
+                v,
+                keywords=(*keywords, k)
+                if keywords is not None and isinstance(k, str)
+                else None,
+            )
+            if val:
+                ret += b" " + val
+            if not isinstance(v, Mapping):
+                ret += b";"
+            return ret
+
+        return b" ".join(dumps(v) for v in data)
+
+    if is_sequence(data):
+        return b"(" + b" ".join(dumps(v, tuple_is_entry=True) for v in data) + b")"
+
+    if data is True:
+        return b"yes"
+    if data is False:
+        return b"no"
+
+    return str(data).encode("latin-1")