foamlib 0.9.0__py3-none-any.whl → 0.9.2__py3-none-any.whl

foamlib/__init__.py

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

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/_files/_parsing.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import re
 import sys
-from typing import Tuple, Union, cast
+from typing import TYPE_CHECKING, Tuple, Union, cast
 
 if sys.version_info >= (3, 9):
     from collections.abc import Iterator, Mapping, MutableMapping, Sequence
@@ -40,46 +40,43 @@ from pyparsing import (
 
 from ._types import Data, Dimensioned, DimensionSet, File
 
+if TYPE_CHECKING:
+    from numpy.typing import DTypeLike
 
-def _numeric_list(
-    *, nested: int | None = None, ignore: Regex | None = None, force_float: bool = False
+
+def _ascii_numeric_list(
+    dtype: DTypeLike,
+    *,
+    nested: int | None = None,
+    ignore: Regex | None = None,
+    empty_ok: bool = False,
 ) -> ParserElement:
-    if not force_float:
-        int_pattern = r"(?:-?\d+)"
-    float_pattern = r"(?i:[+-]?(?:(?:\d+\.?\d*(?:e[+-]?\d+)?)|nan|inf(?:inity)?))"
+    dtype = np.dtype(dtype)
+
+    if np.issubdtype(dtype, np.floating):
+        element = common.ieee_float
+        element_pattern = r"(?i:[+-]?(?:(?:\d+\.?\d*(?:e[+-]?\d+)?)|nan|inf(?:inity)?))"
+    elif np.issubdtype(dtype, np.integer):
+        element = common.integer
+        element_pattern = r"(?:-?\d+)"
+    else:
+        msg = f"Unsupported dtype: {dtype}"
+        raise TypeError(msg)
+
     spacing_pattern = (
-        rf"(?:(?:\s|{ignore.re.pattern})+)" if ignore is not None else r"\s+"
+        rf"(?:(?:\s|{ignore.re.pattern})+)" if ignore is not None else r"(?:\s+)"
     )
 
-    if nested is None:
-        if not force_float:
-            int_element_pattern = int_pattern
-            int_element = common.integer
-        float_element_pattern = float_pattern
-        float_element = common.ieee_float
-    else:
-        if not force_float:
-            int_element_pattern = rf"(?:(?:{nested})?{spacing_pattern}?\({spacing_pattern}?(?:{int_pattern}{spacing_pattern}){{{nested - 1}}}{int_pattern}{spacing_pattern}?\))"
-            int_element = (
-                Opt(Literal(str(nested))).suppress()
-                + Literal("(").suppress()
-                + Group(common.integer[nested])
-                + Literal(")").suppress()
-            )
-        float_element_pattern = rf"(?:(?:{nested})?{spacing_pattern}?\({spacing_pattern}?(?:{float_pattern}{spacing_pattern}){{{nested - 1}}}{float_pattern}{spacing_pattern}?\))"
-        float_element = (
-            Opt(Literal(str(nested))).suppress()
-            + Literal("(").suppress()
-            + Group(common.ieee_float[nested])
-            + Literal(")").suppress()
+    if nested is not None:
+        element = (
+            Literal("(").suppress() + Group(element[nested]) + Literal(")").suppress()
         )
+        element_pattern = rf"(?:{spacing_pattern}?\({element_pattern}?(?:{element_pattern}{spacing_pattern}){{{nested - 1}}}{element_pattern}{spacing_pattern}?\))"
 
-    if not force_float:
-        int_list = Forward()
-    float_list = Forward()
+    list_ = Forward()
 
     def process_count(tks: ParseResults) -> None:
-        nonlocal int_list, float_list
+        nonlocal list_
 
         if not tks:
             count = None
@@ -88,46 +85,41 @@ def _numeric_list(
             assert isinstance(count, int)
 
         if count is None:
-            if not force_float:
-                int_list_pattern = rf"\({spacing_pattern}?(?:{int_element_pattern}{spacing_pattern})*{int_element_pattern}{spacing_pattern}?\)"
-                float_list_pattern = rf"\({spacing_pattern}?(?:{float_element_pattern}{spacing_pattern})*{float_element_pattern}{spacing_pattern}?\)"
+            if not empty_ok:
+                list_pattern = rf"\({spacing_pattern}?(?:{element_pattern}{spacing_pattern})*{element_pattern}{spacing_pattern}?\)"
             else:
-                float_list_pattern = rf"\({spacing_pattern}?(?:{float_element_pattern}{spacing_pattern})*{float_element_pattern}?{spacing_pattern}?\)"
+                list_pattern = rf"\({spacing_pattern}?(?:{element_pattern}{spacing_pattern})*{element_pattern}?{spacing_pattern}?\)"
 
         elif count == 0:
-            if not force_float:
-                int_list <<= NoMatch()
-                float_list <<= NoMatch()
+            if not empty_ok:
+                list_ <<= NoMatch()
             else:
-                float_list <<= (Literal("(") + Literal(")")).add_parse_action(
-                    lambda: np.empty((0, nested) if nested else 0, dtype=float)
+                list_ <<= (Literal("(") + Literal(")")).add_parse_action(
+                    lambda: np.empty((0, nested) if nested else 0, dtype=dtype)
                 )
             return
 
         else:
-            if not force_float:
-                int_list_pattern = rf"\({spacing_pattern}?(?:{int_element_pattern}{spacing_pattern}){{{count - 1}}}{int_element_pattern}{spacing_pattern}?\)"
-            float_list_pattern = rf"\({spacing_pattern}?(?:{float_element_pattern}{spacing_pattern}){{{count - 1}}}{float_element_pattern}{spacing_pattern}?\)"
+            list_pattern = rf"\({spacing_pattern}?(?:{element_pattern}{spacing_pattern}){{{count - 1}}}{element_pattern}{spacing_pattern}?\)"
 
-        if not force_float:
-            int_list <<= Regex(int_list_pattern).add_parse_action(
-                lambda tks: to_array(tks, dtype=int)
-            )
-        float_list <<= Regex(float_list_pattern).add_parse_action(
-            lambda tks: to_array(tks, dtype=float)
+        list_ <<= Regex(list_pattern).add_parse_action(
+            lambda tks: to_array(tks, dtype=dtype)
         )
 
     def to_array(
-        tks: ParseResults, *, dtype: type
-    ) -> np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.int64 | np.float64]]:
+        tks: ParseResults, *, dtype: DTypeLike
+    ) -> np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.integer | np.floating]]:
         (s,) = tks
-        s = s.replace("(", "").replace(")", "")
-
+        assert s.startswith("(")
+        assert s.endswith(")")
+        s = s[1:-1]
         if ignore is not None:
             s = re.sub(ignore.re, " ", s)
+        if nested is not None:
+            s = s.replace("(", " ").replace(")", " ")
 
         ret: np.ndarray[
-            tuple[int] | tuple[int, int], np.dtype[np.int64 | np.float64]
+            tuple[int] | tuple[int, int], np.dtype[np.integer | np.floating]
         ] = np.fromstring(s, sep=" ", dtype=dtype)  # type: ignore[assignment]
 
         if nested is not None:
@@ -137,7 +129,7 @@ def _numeric_list(
 
     def to_full_array(
         tks: ParseResults, *, dtype: type
-    ) -> np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.int64 | np.float64]]:
+    ) -> np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.integer | np.floating]]:
         count, lst = tks
         assert isinstance(count, int)
 
@@ -146,24 +138,8 @@ def _numeric_list(
 
         return np.full((count, nested), lst, dtype=dtype)  # type: ignore[return-value]
 
-    count = Opt(common.integer).add_parse_action(process_count)
-
-    ret = count.suppress() + (
-        (int_list | float_list) if not force_float else float_list
-    )
-
-    if not force_float:
-        ret |= (
-            common.integer
-            + Literal("{").suppress()
-            + int_element
-            + Literal("}").suppress()
-        ).add_parse_action(lambda tks: to_full_array(tks, dtype=int))
-    ret |= (
-        common.integer
-        + Literal("{").suppress()
-        + float_element
-        + Literal("}").suppress()
+    ret = ((Opt(common.integer).add_parse_action(process_count)).suppress() + list_) | (
+        common.integer + Literal("{").suppress() + element + Literal("}").suppress()
     ).add_parse_action(lambda tks: to_full_array(tks, dtype=float))
 
     if ignore is not None:
@@ -172,23 +148,29 @@ def _numeric_list(
     return ret
 
 
-def _binary_field(*, nested: int | None = None) -> ParserElement:
+def _binary_numeric_list(
+    dtype: DTypeLike, *, nested: int | None = None, empty_ok: bool = False
+) -> ParserElement:
+    dtype = np.dtype(dtype)
+
     elsize = nested if nested is not None else 1
 
-    binary_field = Forward()
+    list_ = Forward()
 
     def process_count(tks: ParseResults) -> None:
-        nonlocal binary_field
+        nonlocal list_
         (size,) = tks
         assert isinstance(size, int)
 
-        binary_field <<= Regex(
-            rf"\((?s:({'.' * 8 * elsize}|{'.' * 4 * elsize}){{{size}}})\)"
-        )
+        if size == 0 and not empty_ok:
+            list_ <<= NoMatch()
+            return
+
+        list_ <<= Regex(rf"\((?s:{'.' * dtype.itemsize * elsize}){{{size}}}\)")
 
     def to_array(
         tks: ParseResults,
-    ) -> np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.float64 | np.float32]]:
+    ) -> np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.integer | np.floating]]:
         size, s = tks
         assert isinstance(size, int)
         assert isinstance(s, str)
@@ -196,10 +178,6 @@ def _binary_field(*, nested: int | None = None) -> ParserElement:
         assert s[-1] == ")"
         s = s[1:-1]
 
-        float_size = len(s) / elsize / size
-        assert float_size in (4, 8)
-
-        dtype = np.float32 if float_size == 4 else float
         ret = np.frombuffer(s.encode("latin-1"), dtype=dtype)
 
         if nested is not None:
@@ -207,9 +185,9 @@ def _binary_field(*, nested: int | None = None) -> ParserElement:
 
         return ret  # type: ignore[return-value]
 
-    count = common.integer.copy().add_parse_action(process_count)
-
-    return (count + binary_field).add_parse_action(to_array)
+    return (
+        common.integer.copy().add_parse_action(process_count) + list_
+    ).add_parse_action(to_array)
 
 
 def _list_of(entry: ParserElement) -> ParserElement:
@@ -337,15 +315,22 @@ _FIELD = (Keyword("uniform", _IDENTBODYCHARS).suppress() + _TENSOR) | (
             Opt(
                 Literal("List") + Literal("<") + Literal("scalar") + Literal(">")
             ).suppress()
-            + (_numeric_list(force_float=True, ignore=_COMMENT) | _binary_field())
+            + (
+                _ascii_numeric_list(dtype=float, ignore=_COMMENT, empty_ok=True)
+                | _binary_numeric_list(dtype=np.float64, empty_ok=True)
+                | _binary_numeric_list(dtype=np.float32, empty_ok=True)
+            )
         )
         | (
             Opt(
                 Literal("List") + Literal("<") + Literal("vector") + Literal(">")
             ).suppress()
             + (
-                _numeric_list(nested=3, force_float=True, ignore=_COMMENT)
-                | _binary_field(nested=3)
+                _ascii_numeric_list(
+                    dtype=float, nested=3, ignore=_COMMENT, empty_ok=True
+                )
+                | _binary_numeric_list(np.float64, nested=3, empty_ok=True)
+                | _binary_numeric_list(np.float32, nested=3, empty_ok=True)
             )
         )
         | (
@@ -353,12 +338,11 @@ _FIELD = (Keyword("uniform", _IDENTBODYCHARS).suppress() + _TENSOR) | (
                 Literal("List") + Literal("<") + Literal("symmTensor") + Literal(">")
             ).suppress()
             + (
-                _numeric_list(
-                    nested=6,
-                    force_float=True,
-                    ignore=_COMMENT,
+                _ascii_numeric_list(
+                    dtype=float, nested=6, ignore=_COMMENT, empty_ok=True
                 )
-                | _binary_field(nested=6)
+                | _binary_numeric_list(np.float64, nested=6, empty_ok=True)
+                | _binary_numeric_list(np.float32, nested=6, empty_ok=True)
             )
         )
         | (
@@ -366,8 +350,11 @@ _FIELD = (Keyword("uniform", _IDENTBODYCHARS).suppress() + _TENSOR) | (
                 Literal("List") + Literal("<") + Literal("tensor") + Literal(">")
             ).suppress()
             + (
-                _numeric_list(nested=9, force_float=True, ignore=_COMMENT)
-                | _binary_field(nested=9)
+                _ascii_numeric_list(
+                    dtype=float, nested=9, ignore=_COMMENT, empty_ok=True
+                )
+                | _binary_numeric_list(np.float64, nested=9, empty_ok=True)
+                | _binary_numeric_list(np.float32, nested=9, empty_ok=True)
             )
         )
     )
@@ -380,12 +367,7 @@ _KEYWORD_ENTRY = _keyword_entry_of(_TOKEN | _list_of(_IDENTIFIER), _DATA)
 _DICT = _dict_of(_TOKEN, _DATA)
 _DATA_ENTRY = Forward()
 _LIST_ENTRY = _DICT | _KEYWORD_ENTRY | _DATA_ENTRY
-_LIST = (
-    _numeric_list(ignore=_COMMENT)
-    | _numeric_list(nested=3, ignore=_COMMENT)
-    | _numeric_list(nested=4, ignore=_COMMENT)
-    | _list_of(_LIST_ENTRY)
-)
+_LIST = _list_of(_LIST_ENTRY)
 _NUMBER = (
     common.number
     | CaselessKeyword("nan").set_parse_action(lambda: np.nan)
@@ -398,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]
 
-_LOCATED_DICTIONARY = Group(
+    return file
+
+
+_LOCATED_KEYWORD_ENTRIES = Group(
     _keyword_entry_of(
         _TOKEN,
         Opt(_DATA, default=""),
@@ -421,10 +423,14 @@ _LOCATED_DICTIONARY = Group(
         located=True,
     )
 )[...]
-_LOCATED_DATA = Group(Located(_DATA.copy().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()
 )
@@ -436,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))
@@ -459,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/_files/_serialization.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import sys
-from enum import Enum, auto
 from typing import overload
 
 if sys.version_info >= (3, 9):
@@ -11,7 +10,7 @@ else:
 
 import numpy as np
 
-from ._parsing import parse_data
+from ._parsing import loads
 from ._types import (
     Data,
     DataLike,
@@ -23,31 +22,32 @@ from ._types import (
 )
 
 
-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: ...
+def normalize_data(
+    data: DataLike, *, keywords: tuple[str, ...] | None = None
+) -> 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,
+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:
@@ -61,41 +61,50 @@ def normalize(data: EntryLike, *, kind: Kind = Kind.DEFAULT) -> Entry:
                 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]
+            return [normalize_data(d) for d in data]
 
         if isinstance(data, int):
             return float(data)
 
-        return normalize(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 isinstance(data, Mapping):
-        return {k: normalize(v, kind=kind) for k, v in data.items()}
-
     if (
-        kind == Kind.DIMENSIONS
+        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 isinstance(data, tuple) and kind == Kind.SINGLE_ENTRY and len(data) == 2:
+    if keywords is None and isinstance(data, tuple) and len(data) == 2:
         k, v = data
-        return (normalize(k), normalize(v))
+        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 (kind == Kind.SINGLE_ENTRY or not isinstance(data, tuple)):
-        return [normalize(d, kind=Kind.SINGLE_ENTRY) for d in data]
+    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):
-        parsed_data = parse_data(data)
-        if kind == Kind.KEYWORD and isinstance(parsed_data, bool):
-            return data
-        return parsed_data
+        s = loads(data)
+        if isinstance(s, (str, tuple, bool)):
+            return s
 
     if isinstance(
         data,
@@ -107,52 +116,70 @@ def normalize(data: EntryLike, *, kind: Kind = Kind.DEFAULT) -> Entry:
     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,
     *,
-    kind: Kind = Kind.DEFAULT,
+    keywords: tuple[str, ...] | None = None,
+    header: Mapping[str, Entry] | None = None,
+    tuple_is_entry: bool = False,
 ) -> bytes:
-    data = normalize(data, kind=kind)
+    data = normalize_data(data, keywords=keywords)
 
     if isinstance(data, Mapping):
         return (
             b"{"
-            + b" ".join(dumps((k, v), kind=Kind.SINGLE_ENTRY) for k, v in data.items())
+            + b" ".join(
+                dumps(
+                    (k, v),
+                    keywords=keywords,
+                    tuple_is_entry=True,
+                )
+                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 (
+        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_
 
-    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)
+        if not shape or (not scalar and shape in ((3,), (6,), (9,))):
+            return b"uniform " + dumps(data)
 
         assert isinstance(data, np.ndarray)
-        ndim = len(shape)
+        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:
@@ -165,34 +192,46 @@ def dumps(
         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)
+        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, kind=Kind.DIMENSIONS)
+                + dumps(data.dimensions)
                 + b" "
-                + dumps(data.value, kind=Kind.SINGLE_ENTRY)
+                + dumps(data.value)
             )
-        return (
-            dumps(data.dimensions, kind=Kind.DIMENSIONS)
-            + b" "
-            + dumps(data.value, kind=Kind.SINGLE_ENTRY)
-        )
+        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) and not isinstance(data, tuple):
-        return b"(" + b" ".join(dumps(v, kind=Kind.SINGLE_ENTRY) for v in data) + b")"
+    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"

foamlib/_files/_types.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import sys
-from enum import Enum
 from typing import Dict, NamedTuple, Optional, Union
 
 import numpy as np
@@ -42,39 +41,6 @@ TensorLike = Union[
 ]
 
 
-class TensorKind(Enum):
-    SCALAR = ()
-    VECTOR = (3,)
-    SYMM_TENSOR = (6,)
-    TENSOR = (9,)
-
-    @property
-    def shape(self) -> tuple[()] | tuple[int]:
-        shape: tuple[()] | tuple[int] = self.value
-        return shape
-
-    @property
-    def size(self) -> int:
-        return int(np.prod(self.shape))
-
-    def __str__(self) -> str:
-        return {
-            TensorKind.SCALAR: "scalar",
-            TensorKind.VECTOR: "vector",
-            TensorKind.SYMM_TENSOR: "symmTensor",
-            TensorKind.TENSOR: "tensor",
-        }[self]
-
-    @staticmethod
-    def from_shape(shape: tuple[int, ...]) -> TensorKind:
-        for kind in TensorKind:
-            if kind.shape == shape:
-                return kind
-
-        msg = f"No tensor kind for shape {shape!r}"
-        raise ValueError(msg)
-
-
 class Dimensioned:
     def __init__(
         self,

{foamlib-0.9.0.dist-info → foamlib-0.9.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: foamlib
-Version: 0.9.0
+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.0.dist-info → foamlib-0.9.2.dist-info}/RECORD

@@ -1,4 +1,4 @@
-foamlib/__init__.py,sha256=gSk-v_a_STLCffHq4oHQOi00Pj2TrxcMBOThu5S7ATY,452
+foamlib/__init__.py,sha256=75bXvyciN5IbxNdsJ4XEBETcI5ojrnjWQhQco2Xmqy4,452
 foamlib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 foamlib/_cases/__init__.py,sha256=_A1TTHuQfS9FH2_33lSEyLtOJZGFHZBco1tWJCVOHks,358
 foamlib/_cases/_async.py,sha256=e4lGTcQBbFGwfG6SmJks5aa5LWd_0dy01kgKZWAgTGQ,11655
@@ -9,12 +9,12 @@ foamlib/_cases/_subprocess.py,sha256=VHV2SuOLqa711an6kCuvN6UlIkeh4qqFfdrpNoKzQps
 foamlib/_cases/_sync.py,sha256=yhrkwStKri7u41YImYCGBH4REcKn8Ar-32VW_WPa40c,9641
 foamlib/_cases/_util.py,sha256=QCizfbuJdOCeF9ogU2R-y-iWX5kfaOA4U2W68t6QlOM,2544
 foamlib/_files/__init__.py,sha256=q1vkjXnjnSZvo45jPAICpWeF2LZv5V6xfzAR6S8fS5A,96
-foamlib/_files/_files.py,sha256=gSJQjvB1f7N2yJtCTx9kpivKqSSNjDj37qNMpned5CM,19505
+foamlib/_files/_files.py,sha256=7Si-C-2O0h27Ga4bC0W-i6_PKq7B4K2Gg1tDGh8AZFo,22416
 foamlib/_files/_io.py,sha256=BGbbm6HKxL2ka0YMCmHqZQZ1R4PPQlkvWWb4FHMAS8k,2217
-foamlib/_files/_parsing.py,sha256=VLPyK11J57C02zJu1YfiLR0Xv1qRxw0sYYNsmmluFg0,17880
-foamlib/_files/_serialization.py,sha256=QJ-F6BKizVe0gpjnpIfPxNGTqWwalY4PQtCKdDY9D70,5502
-foamlib/_files/_types.py,sha256=PDhFW5hUzcoQsLx7M0Va1oaYV6km02jFgrvKJof0JKQ,3750
-foamlib-0.9.0.dist-info/METADATA,sha256=xyisPf6vPUB497hmKtJngw_Z2QiuX7DCSvzZI5T3gQg,12906
-foamlib-0.9.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-foamlib-0.9.0.dist-info/licenses/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
-foamlib-0.9.0.dist-info/RECORD,,
+foamlib/_files/_parsing.py,sha256=ftaAh8WJ816Y6ej9ntoUzBOn6hC22qHLgN00568Hc2w,17636
+foamlib/_files/_serialization.py,sha256=R9-oXYywZubevuPkYaTIAyM0_BfF9rC819j9AXOCcg8,6451
+foamlib/_files/_types.py,sha256=q5O_x680XhGfvPHCNF_3objK1imUG2kgQYNRF2Z4qJ0,2918
+foamlib-0.9.2.dist-info/METADATA,sha256=c1itaOTpgA5-3jV5ADxqg02_th-qPhry2mA4M7fR9rk,12906
+foamlib-0.9.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+foamlib-0.9.2.dist-info/licenses/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
+foamlib-0.9.2.dist-info/RECORD,,