foamlib 0.9.1__tar.gz → 0.9.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: foamlib
-Version: 0.9.1
+Version: 0.9.2
 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.2}/foamlib/__init__.py

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

{foamlib-0.9.1 → foamlib-0.9.2}/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.2}/foamlib/_files/_parsing.py

@@ -380,21 +380,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]
 
+    return file
 
-_LOCATED_DICTIONARY = Group(
+
+_LOCATED_KEYWORD_ENTRIES = Group(
     _keyword_entry_of(
         _TOKEN,
         Opt(_DATA, default=""),
@@ -403,22 +423,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 +442,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 +465,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.2/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")

{foamlib-0.9.1 → foamlib-0.9.2}/tests/test_files/test_dumps.py

@@ -1,6 +1,6 @@
 import numpy as np
 from foamlib import FoamFile
-from foamlib._files._serialization import Kind, dumps
+from foamlib._files._serialization import dumps
 
 
 def test_serialize_data() -> None:
@@ -10,34 +10,55 @@ def test_serialize_data() -> None:
     assert dumps(True) == b"yes"
     assert dumps(False) == b"no"
     assert dumps("word") == b"word"
-    assert dumps(("word", "word")) == b"word word"
+    assert dumps(("word", "word"), keywords=()) == b"word word"
     assert dumps('"a string"') == b'"a string"'
-    assert dumps(1, kind=Kind.ASCII_FIELD) == b"uniform 1.0"
-    assert dumps(1.0, kind=Kind.ASCII_FIELD) == b"uniform 1.0"
-    assert dumps(1.0e-3, kind=Kind.ASCII_FIELD) == b"uniform 0.001"
+    assert dumps(1, keywords=("internalField",)) == b"uniform 1.0"
+    assert dumps(1.0, keywords=("internalField",)) == b"uniform 1.0"
+    assert dumps(1.0e-3, keywords=("internalField",)) == b"uniform 0.001"
     assert dumps([1.0, 2.0, 3.0]) == b"(1.0 2.0 3.0)"
-    assert dumps([1, 2, 3], kind=Kind.ASCII_FIELD) == b"uniform (1.0 2.0 3.0)"
+    assert dumps([1, 2, 3], keywords=("internalField",)) == b"uniform (1.0 2.0 3.0)"
     assert (
-        dumps([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], kind=Kind.ASCII_FIELD)
+        dumps([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], keywords=("internalField",))
         == b"nonuniform List<scalar> 10(1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0)"
     )
     assert (
-        dumps([[1, 2, 3], [4, 5, 6]], kind=Kind.ASCII_FIELD)
+        dumps([[1, 2, 3], [4, 5, 6]], keywords=("internalField",))
         == b"nonuniform List<vector> 2((1.0 2.0 3.0) (4.0 5.0 6.0))"
     )
-    assert dumps(1, kind=Kind.BINARY_FIELD) == b"uniform 1.0"
-    assert dumps(1.0, kind=Kind.BINARY_FIELD) == b"uniform 1.0"
-    assert dumps([1, 2, 3], kind=Kind.BINARY_FIELD) == b"uniform (1.0 2.0 3.0)"
     assert (
-        dumps([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], kind=Kind.BINARY_FIELD)
+        dumps(1, keywords=("internalField",), header={"format": "binary"})
+        == b"uniform 1.0"
+    )
+    assert (
+        dumps(1.0, keywords=("internalField",), header={"format": "binary"})
+        == b"uniform 1.0"
+    )
+    assert (
+        dumps([1, 2, 3], keywords=("internalField",), header={"format": "binary"})
+        == b"uniform (1.0 2.0 3.0)"
+    )
+    assert (
+        dumps(
+            [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
+            keywords=("internalField",),
+            header={"format": "binary"},
+        )
         == b'nonuniform List<scalar> 10(\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x00\x00\x00\x08@\x00\x00\x00\x00\x00\x00\x10@\x00\x00\x00\x00\x00\x00\x14@\x00\x00\x00\x00\x00\x00\x18@\x00\x00\x00\x00\x00\x00\x1c@\x00\x00\x00\x00\x00\x00 @\x00\x00\x00\x00\x00\x00"@\x00\x00\x00\x00\x00\x00$@)'
     )
     assert (
-        dumps([[1, 2, 3], [4, 5, 6]], kind=Kind.BINARY_FIELD)
+        dumps(
+            [[1, 2, 3], [4, 5, 6]],
+            keywords=("internalField",),
+            header={"format": "binary"},
+        )
         == b"nonuniform List<vector> 2(\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x00\x00\x00\x08@\x00\x00\x00\x00\x00\x00\x10@\x00\x00\x00\x00\x00\x00\x14@\x00\x00\x00\x00\x00\x00\x18@)"
     )
     assert (
-        dumps(np.array([1, 2], dtype=np.float32), kind=Kind.BINARY_FIELD)  # type: ignore [arg-type]
+        dumps(
+            np.array([1, 2], dtype=np.float32),  # type: ignore[arg-type]
+            keywords=("internalField",),
+            header={"format": "binary"},
+        )
         == b"nonuniform List<scalar> 2(\x00\x00\x80?\x00\x00\x00@)"
     )
     assert (
@@ -62,7 +83,10 @@ def test_serialize_data() -> None:
         == b"[1 1 -2 0 0 0 0] 9.81"
     )
     assert (
-        dumps(("hex", [0, 1, 2, 3, 4, 5, 6, 7], [1, 1, 1], "simpleGrading", [1, 1, 1]))
+        dumps(
+            ("hex", [0, 1, 2, 3, 4, 5, 6, 7], [1, 1, 1], "simpleGrading", [1, 1, 1]),
+            keywords=(),
+        )
         == b"hex (0 1 2 3 4 5 6 7) (1 1 1) simpleGrading (1 1 1)"
     )
     assert dumps([("a", "b"), ("c", "d")]) == b"(a b; c d;)"
@@ -71,3 +95,19 @@ def test_serialize_data() -> None:
     assert dumps([{"a": "b", "c": "d"}, {"e": "g"}]) == b"({a b; c d;} {e g;})"
     assert dumps(["water", "oil", "mercury", "air"]) == b"(water oil mercury air)"
     assert dumps("div(phi,U)") == b"div(phi,U)"
+
+
+def test_serialize_file() -> None:
+    assert FoamFile.dumps(1.0, ensure_header=False) == b"1.0"
+    assert (
+        FoamFile.dumps(1.0)
+        == b"{FoamFile {version 2.0; format ascii; class dictionary;}} 1.0"
+    )
+    assert (
+        FoamFile.dumps([{"a": "b", "c": "d"}, {"e": "g"}])
+        == b"{FoamFile {version 2.0; format ascii; class dictionary;}} ({a b; c d;} {e g;})"
+    )
+    assert (
+        FoamFile.dumps({"internalField": [[1, 2, 3], [4, 5, 6]]})
+        == b"{FoamFile {version 2.0; format ascii; class volVectorField;}} internalField nonuniform List<vector> 2((1.0 2.0 3.0) (4.0 5.0 6.0));"
+    )

{foamlib-0.9.1 → foamlib-0.9.2}/tests/test_files/test_parsing/test_basic.py

@@ -5,6 +5,7 @@ from foamlib._files._types import is_sequence
 
 
 def test_parse_value() -> None:
+    assert Parsed(b"1")[()] == 1
     assert Parsed(b"1")[()] == 1
     assert Parsed(b"1.0")[()] == 1.0
     assert Parsed(b"1.0e-3")[()] == 1.0e-3

foamlib-0.9.2/tests/test_files/test_parsing/test_loads.py

@@ -0,0 +1,69 @@
+import numpy as np
+from foamlib import FoamFile
+
+
+def test_loads() -> None:
+    assert FoamFile.loads("") == {}
+    assert FoamFile.loads("1") == 1
+    assert FoamFile.loads("FoamFile {} 1") == 1
+    assert FoamFile.loads("FoamFile {} 1", include_header=True) == {
+        "FoamFile": {},
+        None: 1,
+    }
+    assert FoamFile.loads("1.0") == 1.0
+    assert FoamFile.loads("1.0e-3") == 1.0e-3
+    assert FoamFile.loads("yes") is True
+    assert FoamFile.loads("no") is False
+    assert FoamFile.loads("word") == "word"
+    assert FoamFile.loads("word word") == ("word", "word")
+    assert FoamFile.loads('"a string"') == '"a string"'
+    assert FoamFile.loads("(word word)") == ["word", "word"]
+    assert FoamFile.loads("uniform 1") == 1
+    assert FoamFile.loads("uniform 1.0") == 1.0
+    assert FoamFile.loads("uniform 1.0e-3") == 1.0e-3
+    assert np.array_equal(FoamFile.loads("(1 2 3)"), [1, 2, 3])  # type: ignore[arg-type]
+    assert np.array_equal(FoamFile.loads("3(1 2 3)"), [1, 2, 3])  # type: ignore[arg-type]
+    assert np.array_equal(
+        FoamFile.loads("2((1 2 3) (4 5 6))"),  # type: ignore[arg-type]
+        [
+            [1, 2, 3],
+            [4, 5, 6],
+        ],
+    )
+    assert np.array_equal(
+        FoamFile.loads("2{(1 2 3)}"),  # type: ignore[arg-type]
+        [
+            [1, 2, 3],
+            [1, 2, 3],
+        ],
+    )
+    assert FoamFile.loads("0()") == []
+    assert np.array_equal(
+        FoamFile.loads(
+            b"nonuniform List<scalar> 2(\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00@)"
+        ),  # type: ignore[arg-type]
+        [1, 2],
+    )
+    assert np.array_equal(
+        FoamFile.loads(
+            b"nonuniform List<vector> 2(\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x00\x00\x00\x08@\x00\x00\x00\x00\x00\x00\x10@\x00\x00\x00\x00\x00\x00\x14@\x00\x00\x00\x00\x00\x00\x18@)"
+        ),  # type: ignore[arg-type]
+        [[1, 2, 3], [4, 5, 6]],
+    )
+    assert np.array_equal(
+        FoamFile.loads(b"nonuniform List<scalar> 2(\x00\x00\x80?\x00\x00\x00@)"),  # type: ignore[arg-type]
+        [1, 2],
+    )
+    assert FoamFile.loads("[1 1 -2 0 0 0 0]") == FoamFile.DimensionSet(
+        mass=1, length=1, time=-2
+    )
+    assert FoamFile.loads("g [1 1 -2 0 0 0 0] (0 0 -9.81)") == FoamFile.Dimensioned(
+        name="g",
+        dimensions=FoamFile.DimensionSet(mass=1, length=1, time=-2),
+        value=[0, 0, -9.81],
+    )
+    assert FoamFile.loads("[1 1 -2 0 0 0 0] 9.81") == FoamFile.Dimensioned(
+        dimensions=FoamFile.DimensionSet(mass=1, length=1, time=-2), value=9.81
+    )
+    assert FoamFile.loads("a {b c; d e;}") == {"a": {"b": "c", "d": "e"}}
+    assert FoamFile.loads("(a b; c d;)") == [("a", "b"), ("c", "d")]

foamlib-0.9.1/foamlib/_files/_serialization.py

@@ -1,202 +0,0 @@
-from __future__ import annotations
-
-import sys
-from enum import Enum, auto
-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 parse_data
-from ._types import (
-    Data,
-    DataLike,
-    Dimensioned,
-    DimensionSet,
-    Entry,
-    EntryLike,
-    is_sequence,
-)
-
-
-class Kind(Enum):
-    DEFAULT = auto()
-    SINGLE_ENTRY = auto()
-    ASCII_FIELD = auto()
-    SCALAR_ASCII_FIELD = auto()
-    BINARY_FIELD = auto()
-    SCALAR_BINARY_FIELD = auto()
-    DIMENSIONS = auto()
-    KEYWORD = auto()
-
-
-@overload
-def normalize(data: DataLike, *, kind: Kind = Kind.DEFAULT) -> Data: ...
-
-
-@overload
-def normalize(data: EntryLike, *, kind: Kind = Kind.DEFAULT) -> Entry: ...
-
-
-def normalize(data: EntryLike, *, kind: Kind = Kind.DEFAULT) -> Entry:
-    if kind in (
-        Kind.ASCII_FIELD,
-        Kind.SCALAR_ASCII_FIELD,
-        Kind.BINARY_FIELD,
-        Kind.SCALAR_BINARY_FIELD,
-    ):
-        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(d, kind=Kind.SINGLE_ENTRY) for d in data]
-
-        if isinstance(data, int):
-            return float(data)
-
-        return normalize(data)
-
-    if isinstance(data, np.ndarray):
-        ret = data.tolist()
-        assert isinstance(ret, (int, float, list))
-        return ret
-
-    if isinstance(data, Mapping):
-        return {k: normalize(v, kind=kind) for k, v in data.items()}
-
-    if (
-        kind == Kind.DIMENSIONS
-        and is_sequence(data)
-        and len(data) <= 7
-        and all(isinstance(d, (int, float)) for d in data)
-    ):
-        return DimensionSet(*data)
-
-    if isinstance(data, tuple) and kind == Kind.SINGLE_ENTRY and len(data) == 2:
-        k, v = data
-        return (normalize(k), normalize(v))
-
-    if is_sequence(data) and (kind == Kind.SINGLE_ENTRY or not isinstance(data, tuple)):
-        return [normalize(d, kind=Kind.SINGLE_ENTRY) for d in data]
-
-    if isinstance(data, str):
-        parsed_data = parse_data(data)
-        if kind == Kind.KEYWORD and isinstance(parsed_data, bool):
-            return data
-        return parsed_data
-
-    if isinstance(
-        data,
-        (int, float, bool, tuple, DimensionSet, Dimensioned),
-    ):
-        return data
-
-    msg = f"Unsupported data type: {type(data)}"
-    raise TypeError(msg)
-
-
-def dumps(
-    data: EntryLike,
-    *,
-    kind: Kind = Kind.DEFAULT,
-) -> bytes:
-    data = normalize(data, kind=kind)
-
-    if isinstance(data, Mapping):
-        return (
-            b"{"
-            + b" ".join(dumps((k, v), kind=Kind.SINGLE_ENTRY) for k, v in data.items())
-            + b"}"
-        )
-
-    if isinstance(data, tuple) and kind == Kind.SINGLE_ENTRY and len(data) == 2:
-        k, v = data
-        ret = dumps(k)
-        val = dumps(v)
-        if val:
-            ret += b" " + val
-        if not isinstance(v, Mapping):
-            ret += b";"
-        return ret
-
-    if isinstance(data, DimensionSet):
-        return b"[" + b" ".join(dumps(v) for v in data) + b"]"
-
-    if kind in (
-        Kind.ASCII_FIELD,
-        Kind.SCALAR_ASCII_FIELD,
-        Kind.BINARY_FIELD,
-        Kind.SCALAR_BINARY_FIELD,
-    ) and (isinstance(data, (int, float, np.ndarray))):
-        shape = np.shape(data)
-        if not shape or (
-            kind not in (Kind.SCALAR_ASCII_FIELD, Kind.SCALAR_BINARY_FIELD)
-            and shape in ((3,), (6,), (9,))
-        ):
-            return b"uniform " + dumps(data, kind=Kind.SINGLE_ENTRY)
-
-        assert isinstance(data, np.ndarray)
-        ndim = len(shape)
-        if ndim == 1:
-            tensor_kind = b"scalar"
-
-        elif ndim == 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)
-
-        if kind in (Kind.BINARY_FIELD, Kind.SCALAR_BINARY_FIELD):
-            contents = b"(" + data.tobytes() + b")"
-        else:
-            assert kind in (Kind.ASCII_FIELD, Kind.SCALAR_ASCII_FIELD)
-            contents = dumps(data, kind=Kind.SINGLE_ENTRY)
-
-        return b"nonuniform List<" + tensor_kind + b"> " + dumps(len(data)) + contents
-
-    if isinstance(data, Dimensioned):
-        if data.name is not None:
-            return (
-                dumps(data.name)
-                + b" "
-                + dumps(data.dimensions, kind=Kind.DIMENSIONS)
-                + b" "
-                + dumps(data.value, kind=Kind.SINGLE_ENTRY)
-            )
-        return (
-            dumps(data.dimensions, kind=Kind.DIMENSIONS)
-            + b" "
-            + dumps(data.value, kind=Kind.SINGLE_ENTRY)
-        )
-
-    if isinstance(data, tuple):
-        return b" ".join(dumps(v) for v in data)
-
-    if is_sequence(data) and not isinstance(data, tuple):
-        return b"(" + b" ".join(dumps(v, kind=Kind.SINGLE_ENTRY) 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")