foamlib 0.7.2__py3-none-any.whl → 0.8.0__py3-none-any.whl

foamlib/__init__.py

@@ -1,6 +1,6 @@
 """A Python interface for interacting with OpenFOAM."""
 
-__version__ = "0.7.2"
+__version__ = "0.8.0"
 
 from ._cases import (
     AsyncFoamCase,
@@ -16,9 +16,9 @@ __all__ = [
     "AsyncFoamCase",
     "AsyncSlurmFoamCase",
     "CalledProcessError",
-    "FoamFile",
     "FoamCase",
     "FoamCaseBase",
     "FoamCaseRunBase",
     "FoamFieldFile",
+    "FoamFile",
 ]

foamlib/_cases/__init__.py

@@ -7,9 +7,9 @@ from ._sync import FoamCase
 
 __all__ = [
     "AsyncFoamCase",
-    "FoamCaseBase",
-    "FoamCaseRunBase",
     "AsyncSlurmFoamCase",
     "CalledProcessError",
     "FoamCase",
+    "FoamCaseBase",
+    "FoamCaseRunBase",
 ]

foamlib/_cases/_base.py

@@ -6,17 +6,10 @@ from pathlib import Path
 from typing import TYPE_CHECKING, overload
 
 if sys.version_info >= (3, 9):
-    from collections.abc import (
-        Iterator,
-        Sequence,
-    )
+    from collections.abc import Iterator, Sequence
     from collections.abc import Set as AbstractSet
 else:
-    from typing import (
-        AbstractSet,
-        Iterator,
-        Sequence,
-    )
+    from typing import AbstractSet, Iterator, Sequence
 
 from .._files import FoamFieldFile, FoamFile
 

foamlib/_cases/_util.py

@@ -2,14 +2,7 @@ from __future__ import annotations
 
 import functools
 import sys
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    AsyncContextManager,
-    Callable,
-    Generic,
-    TypeVar,
-)
+from typing import TYPE_CHECKING, Any, AsyncContextManager, Callable, Generic, TypeVar
 
 if TYPE_CHECKING:
     from types import TracebackType

foamlib/_files/__init__.py

@@ -1,6 +1,6 @@
 from ._files import FoamFieldFile, FoamFile
 
 __all__ = [
-    "FoamFile",
     "FoamFieldFile",
+    "FoamFile",
 ]

foamlib/_files/_files.py

@@ -19,13 +19,13 @@ from ._io import FoamFileIO
 from ._serialization import Kind, dumps, normalize
 from ._types import (
     Data,
-    DataEntry,
     Dict_,
     Dimensioned,
     DimensionSet,
+    Entry,
     Field,
     File,
-    MutableData,
+    MutableEntry,
 )
 from ._util import is_sequence
 
@@ -33,7 +33,7 @@ from ._util import is_sequence
 class FoamFile(
     MutableMapping[
         Optional[Union[str, Tuple[str, ...]]],
-        MutableData,
+        MutableEntry,
     ],
     FoamFileIO,
 ):
@@ -49,7 +49,7 @@ class FoamFile(
     DimensionSet = DimensionSet
 
     class SubDict(
-        MutableMapping[str, MutableData],
+        MutableMapping[str, MutableEntry],
     ):
         """An OpenFOAM dictionary within a file as a mutable mapping."""
 
@@ -57,13 +57,13 @@ class FoamFile(
             self._file = _file
             self._keywords = _keywords
 
-        def __getitem__(self, keyword: str) -> DataEntry | FoamFile.SubDict:
+        def __getitem__(self, keyword: str) -> Data | FoamFile.SubDict:
             return self._file[(*self._keywords, keyword)]
 
         def __setitem__(
             self,
             keyword: str,
-            data: Data,
+            data: Entry,
         ) -> None:
             self._file[(*self._keywords, keyword)] = data
 
@@ -174,7 +174,7 @@ class FoamFile(
 
     def __getitem__(
         self, keywords: str | tuple[str, ...] | None
-    ) -> DataEntry | FoamFile.SubDict:
+    ) -> Data | FoamFile.SubDict:
         if not keywords:
             keywords = ()
         elif not isinstance(keywords, tuple):
@@ -190,7 +190,7 @@ class FoamFile(
             return FoamFile.SubDict(self, keywords)
         return deepcopy(value)
 
-    def __setitem__(self, keywords: str | tuple[str, ...] | None, data: Data) -> None:
+    def __setitem__(self, keywords: str | tuple[str, ...] | None, data: Entry) -> None:
         if not keywords:
             keywords = ()
         elif not isinstance(keywords, tuple):
@@ -438,7 +438,7 @@ class FoamFieldFile(FoamFile):
 
     def __getitem__(
         self, keywords: str | tuple[str, ...] | None
-    ) -> DataEntry | FoamFile.SubDict:
+    ) -> Data | FoamFile.SubDict:
         if not keywords:
             keywords = ()
         elif not isinstance(keywords, tuple):

foamlib/_files/_io.py

@@ -3,9 +3,7 @@ from __future__ import annotations
 import gzip
 import sys
 from pathlib import Path
-from typing import (
-    TYPE_CHECKING,
-)
+from typing import TYPE_CHECKING
 
 if sys.version_info >= (3, 11):
     from typing import Self

foamlib/_files/_parsing.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import array
 import re
 import sys
+from enum import Enum, auto
 from typing import Tuple, Union, cast
 
 if sys.version_info >= (3, 9):
@@ -13,10 +14,9 @@ else:
 if sys.version_info >= (3, 10):
     from types import EllipsisType
 else:
-    from typing import Any as EllipsisType
+    EllipsisType = type(...)
 
 from pyparsing import (
-    CharsNotIn,
     Combine,
     Dict,
     Forward,
@@ -28,16 +28,71 @@ from pyparsing import (
     Opt,
     ParserElement,
     ParseResults,
-    QuotedString,
     Regex,
     Word,
     common,
     counted_array,
+    dbl_quoted_string,
     identchars,
     printables,
 )
 
-from ._types import DataEntry, Dimensioned, DimensionSet, File
+from ._types import Data, Dimensioned, DimensionSet, File
+
+
+class Tensor(Enum):
+    SCALAR = auto()
+    VECTOR = auto()
+    SYMM_TENSOR = auto()
+    TENSOR = auto()
+
+    @property
+    def shape(self) -> tuple[int, ...]:
+        return {
+            Tensor.SCALAR: (),
+            Tensor.VECTOR: (3,),
+            Tensor.SYMM_TENSOR: (6,),
+            Tensor.TENSOR: (9,),
+        }[self]
+
+    @property
+    def size(self) -> int:
+        return {
+            Tensor.SCALAR: 1,
+            Tensor.VECTOR: 3,
+            Tensor.SYMM_TENSOR: 6,
+            Tensor.TENSOR: 9,
+        }[self]
+
+    def pattern(self, *, ignore: Regex | None = None) -> str:
+        float_pattern = r"(?i:[+-]?(?:(?:\d+\.?\d*(?:e[+-]?\d+)?)|nan|inf(?:inity)?))"
+
+        if self == Tensor.SCALAR:
+            return float_pattern
+
+        ignore_pattern = (
+            rf"(?:\s|{ignore.re.pattern})+" if ignore is not None else r"\s+"
+        )
+
+        return rf"\((?:{ignore_pattern})?(?:{float_pattern}{ignore_pattern}){{{self.size - 1}}}{float_pattern}(?:{ignore_pattern})?\)"
+
+    def parser(self) -> ParserElement:
+        if self == Tensor.SCALAR:
+            return common.ieee_float
+
+        return (
+            Literal("(").suppress()
+            + Group(common.ieee_float[self.size], aslist=True)
+            + Literal(")").suppress()
+        )
+
+    def __str__(self) -> str:
+        return {
+            Tensor.SCALAR: "scalar",
+            Tensor.VECTOR: "vector",
+            Tensor.SYMM_TENSOR: "symmTensor",
+            Tensor.TENSOR: "tensor",
+        }[self]
 
 
 def _list_of(entry: ParserElement) -> ParserElement:
@@ -59,96 +114,135 @@ def _list_of(entry: ParserElement) -> ParserElement:
     )
 
 
-def _counted_tensor_list(*, size: int, ignore: Regex) -> ParserElement:
-    float_pattern = r"[+-]?((\d+\.?\d*(e[+-]?\d+)?)|nan|inf(inity)?)"
-    ignore_pattern = rf"(?:\s|{ignore.re.pattern})+"
+def _parse_ascii_field(
+    s: str, tensor_kind: Tensor, *, ignore: Regex | None
+) -> list[float] | list[list[float]]:
+    values = [
+        float(v)
+        for v in (re.sub(ignore.re, " ", s) if ignore is not None else s)
+        .replace("(", " ")
+        .replace(")", " ")
+        .split()
+    ]
 
-    if size == 1:
-        tensor_pattern = float_pattern
-        tensor = common.ieee_float
-    else:
-        tensor_pattern = rf"\((?:{ignore_pattern})?(?:{float_pattern}{ignore_pattern}){{{size - 1}}}{float_pattern}(?:{ignore_pattern})?\)"
-        tensor = (
-            Literal("(").suppress()
-            + Group(common.ieee_float[size], aslist=True)
-            + Literal(")").suppress()
+    if tensor_kind == Tensor.SCALAR:
+        return values
+
+    return [
+        values[i : i + tensor_kind.size]
+        for i in range(0, len(values), tensor_kind.size)
+    ]
+
+
+def _unpack_binary_field(
+    b: bytes, tensor_kind: Tensor, *, length: int
+) -> list[float] | list[list[float]]:
+    float_size = len(b) / tensor_kind.size / length
+    assert float_size in (4, 8)
+
+    arr = array.array("f" if float_size == 4 else "d", b)
+    values = arr.tolist()
+
+    if tensor_kind == Tensor.SCALAR:
+        return values
+
+    return [
+        values[i : i + tensor_kind.size]
+        for i in range(0, len(values), tensor_kind.size)
+    ]
+
+
+def _tensor_list(
+    tensor_kind: Tensor | None = None, *, ignore: Regex | None = None
+) -> ParserElement:
+    if tensor_kind is None:
+        return (
+            _tensor_list(Tensor.SCALAR, ignore=ignore)
+            | _tensor_list(Tensor.VECTOR, ignore=ignore)
+            | _tensor_list(Tensor.SYMM_TENSOR, ignore=ignore)
+            | _tensor_list(Tensor.TENSOR, ignore=ignore)
         )
 
+    tensor_pattern = tensor_kind.pattern(ignore=ignore)
+    ignore_pattern = rf"(?:\s|{ignore.re.pattern})+" if ignore is not None else r"\s+"
+
     list_ = Forward()
 
+    list_ <<= Regex(
+        rf"\((?:{ignore_pattern})?(?:{tensor_pattern}{ignore_pattern})*{tensor_pattern}(?:{ignore_pattern})?\)"
+    ).add_parse_action(
+        lambda tks: [_parse_ascii_field(tks[0], tensor_kind, ignore=ignore)]
+    )
+
     def count_parse_action(tks: ParseResults) -> None:
         nonlocal list_
         length = tks[0]
         assert isinstance(length, int)
 
-        list_ <<= Regex(
-            rf"\((?:{ignore_pattern})?(?:{tensor_pattern}{ignore_pattern}){{{length - 1}}}{tensor_pattern}(?:{ignore_pattern})?\)",
-            flags=re.IGNORECASE,
+        list_ <<= (
+            Regex(
+                rf"\((?:{ignore_pattern})?(?:{tensor_pattern}{ignore_pattern}){{{length - 1}}}{tensor_pattern}(?:{ignore_pattern})?\)"
+            ).add_parse_action(
+                lambda tks: [_parse_ascii_field(tks[0], tensor_kind, ignore=ignore)]
+            )
+            | Regex(
+                rf"\((?s:.{{{length * tensor_kind.size * 8}}}|.{{{length * tensor_kind.size * 4}}})\)"
+            ).set_parse_action(
+                lambda tks: [
+                    _unpack_binary_field(
+                        tks[0][1:-1].encode("latin-1"), tensor_kind, length=length
+                    )
+                ]
+            )
+            | (
+                Literal("{").suppress() + tensor_kind.parser() + Literal("}").suppress()
+            ).set_parse_action(lambda tks: [[tks[0]] * length])
         )
 
-    count = common.integer.add_parse_action(count_parse_action)
+    count = common.integer.copy().add_parse_action(count_parse_action)
+
+    return (
+        Opt(Literal("List") + Literal("<") + str(tensor_kind) + Literal(">")).suppress()
+        + Opt(count).suppress()
+        + list_
+    )
+
 
-    def list_parse_action(
-        tks: ParseResults,
-    ) -> list[list[float]] | list[list[list[float]]]:
-        values = [
-            float(v)
-            for v in re.sub(ignore.re, " ", tks[0])
-            .replace("(", " ")
-            .replace(")", " ")
-            .split()
-        ]
+def _dict_of(
+    keyword: ParserElement, data: ParserElement, *, located: bool = False
+) -> ParserElement:
+    dict_ = Forward()
 
-        if size == 1:
-            return [values]
+    keyword_entry = keyword + (dict_ | (data + Literal(";").suppress()))
 
-        return [[values[i : i + size] for i in range(0, len(values), size)]]
+    if located:
+        keyword_entry = Located(keyword_entry)
 
-    list_.add_parse_action(list_parse_action)
+    dict_ <<= (
+        Literal("{").suppress()
+        + Dict(Group(keyword_entry)[...], asdict=not located)
+        + Literal("}").suppress()
+    )
 
-    return (count.suppress() + list_) | (
-        common.integer + Literal("{").suppress() + tensor + Literal("}").suppress()
-    ).set_parse_action(lambda tks: [[tks[1]] * tks[0]])
+    return dict_
 
 
 def _keyword_entry_of(
     keyword: ParserElement,
-    data_entries: ParserElement,
+    data: ParserElement,
     *,
     located: bool = False,
 ) -> ParserElement:
-    subdict = Forward()
-
     keyword_entry = keyword + (
-        (Literal("{").suppress() + subdict + Literal("}").suppress())
-        | (data_entries + Literal(";").suppress())
+        _dict_of(keyword, data, located=located) | (data + Literal(";").suppress())
     )
 
     if located:
         keyword_entry = Located(keyword_entry)
-
-    subdict <<= Dict(Group(keyword_entry)[...], asdict=not located)
-
-    return keyword_entry
-
-
-def _unpack_binary_field(
-    tks: ParseResults,
-    *,
-    elsize: int = 1,
-) -> Sequence[Sequence[float] | Sequence[Sequence[float]]]:
-    float_size = len(tks[0]) // elsize
-
-    arr = array.array("f" if float_size == 4 else "d", "".join(tks).encode("latin-1"))
-
-    values: Sequence[float] | Sequence[Sequence[float]]
-
-    if elsize != 1:
-        values = [arr[i : i + elsize].tolist() for i in range(0, len(arr), elsize)]
     else:
-        values = arr.tolist()
+        keyword_entry = keyword_entry.copy().set_parse_action(lambda tks: tuple(tks))
 
-    return [values]
+    return keyword_entry
 
 
 # https://github.com/pyparsing/pyparsing/pull/584
@@ -179,12 +273,11 @@ _SWITCH = (
 _DIMENSIONS = (
     Literal("[").suppress() + common.number[0, 7] + Literal("]").suppress()
 ).set_parse_action(lambda tks: DimensionSet(*tks))
-_TENSOR = common.ieee_float | (
-    Literal("(").suppress()
-    + Group(
-        common.ieee_float[3] | common.ieee_float[6] | common.ieee_float[9], aslist=True
-    )
-    + Literal(")").suppress()
+_TENSOR = (
+    Tensor.SCALAR.parser()
+    | Tensor.VECTOR.parser()
+    | Tensor.SYMM_TENSOR.parser()
+    | Tensor.TENSOR.parser()
 )
 _IDENTIFIER = Combine(
     Word(_IDENTCHARS, _IDENTBODYCHARS, exclude_chars="()")
@@ -194,150 +287,43 @@ _DIMENSIONED = (Opt(_IDENTIFIER) + _DIMENSIONS + _TENSOR).set_parse_action(
     lambda tks: Dimensioned(*reversed(tks.as_list()))
 )
 _FIELD = (Keyword("uniform", _IDENTBODYCHARS).suppress() + _TENSOR) | (
-    Keyword("nonuniform", _IDENTBODYCHARS).suppress()
-    + (
-        Literal("List").suppress()
-        + Literal("<").suppress()
-        + (
-            (
-                Literal("scalar").suppress()
-                + Literal(">").suppress()
-                + (
-                    _counted_tensor_list(size=1, ignore=_COMMENT)
-                    | (
-                        (
-                            (
-                                counted_array(
-                                    CharsNotIn(exact=8),
-                                    common.integer + Literal("(").suppress(),
-                                )
-                            )
-                            | (
-                                counted_array(
-                                    CharsNotIn(exact=4),
-                                    common.integer + Literal("(").suppress(),
-                                )
-                            )
-                        )
-                        + Literal(")").suppress()
-                    ).set_parse_action(_unpack_binary_field)
-                )
-            )
-            | (
-                Literal("vector").suppress()
-                + Literal(">").suppress()
-                + (
-                    _counted_tensor_list(size=3, ignore=_COMMENT)
-                    | (
-                        (
-                            (
-                                counted_array(
-                                    CharsNotIn(exact=8 * 3),
-                                    common.integer + Literal("(").suppress(),
-                                )
-                            )
-                            | (
-                                counted_array(
-                                    CharsNotIn(exact=4 * 3),
-                                    common.integer + Literal("(").suppress(),
-                                )
-                            )
-                        )
-                        + Literal(")").suppress()
-                    ).set_parse_action(lambda tks: _unpack_binary_field(tks, elsize=3))
-                )
-            )
-            | (
-                Literal("symmTensor").suppress()
-                + Literal(">").suppress()
-                + (
-                    _counted_tensor_list(size=6, ignore=_COMMENT)
-                    | (
-                        (
-                            (
-                                counted_array(
-                                    CharsNotIn(exact=8 * 6),
-                                    common.integer + Literal("(").suppress(),
-                                )
-                            )
-                            | (
-                                counted_array(
-                                    CharsNotIn(exact=4 * 6),
-                                    common.integer + Literal("(").suppress(),
-                                )
-                            )
-                        )
-                        + Literal(")").suppress()
-                    ).set_parse_action(lambda tks: _unpack_binary_field(tks, elsize=6))
-                )
-            )
-            | (
-                Literal("tensor").suppress()
-                + Literal(">").suppress()
-                + (
-                    _counted_tensor_list(size=9, ignore=_COMMENT)
-                    | (
-                        (
-                            (
-                                counted_array(
-                                    CharsNotIn(exact=8 * 9),
-                                    common.integer + Literal("(").suppress(),
-                                )
-                            )
-                            | (
-                                counted_array(
-                                    CharsNotIn(exact=4 * 9),
-                                    common.integer + Literal("(").suppress(),
-                                )
-                            )
-                        )
-                        + Literal(")").suppress()
-                    ).set_parse_action(lambda tks: _unpack_binary_field(tks, elsize=9))
-                )
-            )
-        )
-    )
+    Keyword("nonuniform", _IDENTBODYCHARS).suppress() + _tensor_list(ignore=_COMMENT)
 )
-_TOKEN = QuotedString('"', unquote_results=False) | _IDENTIFIER
+TOKEN = dbl_quoted_string | _IDENTIFIER
 DATA = Forward()
-KEYWORD = (
-    _TOKEN
-    | _list_of(_IDENTIFIER)
-    .set_parse_action(lambda tks: "(" + " ".join(tks[0]) + ")")
-    .ignore(_COMMENT)
-    .parse_with_tabs()
-)
-_KEYWORD_ENTRY = Dict(Group(_keyword_entry_of(KEYWORD, DATA)), asdict=True)
+_KEYWORD_ENTRY = _keyword_entry_of(TOKEN | _list_of(_IDENTIFIER), DATA)
+_DICT = _dict_of(TOKEN, DATA)
 _DATA_ENTRY = Forward()
-_LIST_ENTRY = _KEYWORD_ENTRY | _DATA_ENTRY
+_LIST_ENTRY = _DICT | _KEYWORD_ENTRY | _DATA_ENTRY
 _LIST = _list_of(_LIST_ENTRY)
 _NUMBER = common.signed_integer ^ common.ieee_float
-_DATA_ENTRY <<= _FIELD | _LIST | _DIMENSIONED | _DIMENSIONS | _NUMBER | _SWITCH | _TOKEN
+_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]])
+    .set_parse_action(lambda tks: [tuple(tks)] if len(tks) > 1 else [tks[0]])
     .ignore(_COMMENT)
     .parse_with_tabs()
 )
 
+_LOCATED_DICTIONARY = Group(
+    _keyword_entry_of(TOKEN, Opt(DATA, default=""), located=True)
+)[...]
+_LOCATED_DATA = Group(Located(DATA.copy().add_parse_action(lambda tks: ["", tks[0]])))
+
 _FILE = (
-    Dict(
-        Group(_keyword_entry_of(KEYWORD, Opt(DATA, default=""), located=True))[...]
-        + Opt(Group(Located(DATA.copy().add_parse_action(lambda tks: ["", tks[0]]))))
-        + Group(_keyword_entry_of(KEYWORD, Opt(DATA, default=""), located=True))[...]
-    )
+    Dict(_LOCATED_DICTIONARY + Opt(_LOCATED_DATA) + _LOCATED_DICTIONARY)
     .ignore(_COMMENT)
     .ignore(Literal("#include") + ... + LineEnd())  # type: ignore [no-untyped-call]
     .parse_with_tabs()
 )
 
 
-class Parsed(Mapping[Tuple[str, ...], Union[DataEntry, EllipsisType]]):
+class Parsed(Mapping[Tuple[str, ...], Union[Data, EllipsisType]]):
     def __init__(self, contents: bytes) -> None:
         self._parsed: MutableMapping[
             tuple[str, ...],
-            tuple[int, DataEntry | EllipsisType, int],
+            tuple[int, Data | EllipsisType, int],
         ] = {}
         for parse_result in _FILE.parse_string(
             contents.decode("latin-1"), parse_all=True
@@ -350,10 +336,10 @@ class Parsed(Mapping[Tuple[str, ...], Union[DataEntry, EllipsisType]]):
     @staticmethod
     def _flatten_result(
         parse_result: ParseResults, *, _keywords: tuple[str, ...] = ()
-    ) -> Mapping[tuple[str, ...], tuple[int, DataEntry | EllipsisType, int]]:
+    ) -> Mapping[tuple[str, ...], tuple[int, Data | EllipsisType, int]]:
         ret: MutableMapping[
             tuple[str, ...],
-            tuple[int, DataEntry | EllipsisType, int],
+            tuple[int, Data | EllipsisType, int],
         ] = {}
         start = parse_result.locn_start
         assert isinstance(start, int)
@@ -380,14 +366,14 @@ class Parsed(Mapping[Tuple[str, ...], Union[DataEntry, EllipsisType]]):
                     ret[(*_keywords, keyword)] = (start, d, end)
         return ret
 
-    def __getitem__(self, keywords: tuple[str, ...]) -> DataEntry | EllipsisType:
+    def __getitem__(self, keywords: tuple[str, ...]) -> Data | EllipsisType:
         _, data, _ = self._parsed[keywords]
         return data
 
     def put(
         self,
         keywords: tuple[str, ...],
-        data: DataEntry | EllipsisType,
+        data: Data | EllipsisType,
         content: bytes,
     ) -> None:
         start, end = self.entry_location(keywords, missing_ok=True)

foamlib/_files/_serialization.py

@@ -11,8 +11,8 @@ if sys.version_info >= (3, 9):
 else:
     from typing import Mapping, Sequence
 
-from ._parsing import DATA, KEYWORD
-from ._types import Data, DataEntry, Dimensioned, DimensionSet
+from ._parsing import DATA, TOKEN
+from ._types import Data, Dimensioned, DimensionSet, Entry
 from ._util import is_sequence
 
 try:
@@ -34,14 +34,14 @@ class Kind(Enum):
 
 
 @overload
-def normalize(data: DataEntry, *, kind: Kind = Kind.DEFAULT) -> DataEntry: ...
+def normalize(data: Data, *, kind: Kind = Kind.DEFAULT) -> Data: ...
 
 
 @overload
-def normalize(data: Data, *, kind: Kind = Kind.DEFAULT) -> Data: ...
+def normalize(data: Entry, *, kind: Kind = Kind.DEFAULT) -> Entry: ...
 
 
-def normalize(data: Data, *, kind: Kind = Kind.DEFAULT) -> Data:
+def normalize(data: Entry, *, kind: Kind = Kind.DEFAULT) -> Entry:
     if numpy and isinstance(data, np.ndarray):
         ret = data.tolist()
         assert isinstance(ret, list)
@@ -59,10 +59,11 @@ def normalize(data: Data, *, kind: Kind = Kind.DEFAULT) -> Data:
         data = cast(Sequence[float], data)
         return DimensionSet(*data)
 
-    if is_sequence(data) and (kind == Kind.SINGLE_ENTRY or not isinstance(data, tuple)):
-        if len(data) == 1 and isinstance(data[0], Mapping) and len(data[0]) > 1:
-            return [normalize({k: v}) for k, v in data[0].items()]
+    if isinstance(data, tuple) and kind == Kind.SINGLE_ENTRY and len(data) == 2:
+        k, v = data
+        return (normalize(k, kind=Kind.KEYWORD), 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, Dimensioned):
@@ -72,11 +73,11 @@ def normalize(data: Data, *, kind: Kind = Kind.DEFAULT) -> Data:
 
     if isinstance(data, str):
         if kind == Kind.KEYWORD:
-            data = KEYWORD.parse_string(data, parse_all=True)[0]
+            data = TOKEN.parse_string(data, parse_all=True)[0]
             assert isinstance(data, str)
             return data
 
-        return cast(DataEntry, DATA.parse_string(data, parse_all=True)[0])
+        return cast(Data, DATA.parse_string(data, parse_all=True)[0])
 
     if isinstance(
         data,
@@ -89,26 +90,25 @@ def normalize(data: Data, *, kind: Kind = Kind.DEFAULT) -> Data:
 
 
 def dumps(
-    data: Data,
+    data: Entry,
     *,
     kind: Kind = Kind.DEFAULT,
 ) -> bytes:
     data = normalize(data, kind=kind)
 
     if isinstance(data, Mapping):
-        entries = []
-        for k, v in data.items():
-            value = normalize(v)
-            if isinstance(value, Mapping):
-                entries.append(
-                    dumps(k, kind=Kind.KEYWORD) + b" {" + dumps(value) + b"}"
-                )
-            elif not value:
-                entries.append(dumps(k, kind=Kind.KEYWORD) + b";")
-            else:
-                entries.append(dumps(k, kind=Kind.KEYWORD) + b" " + dumps(value) + b";")
+        return (
+            b"{"
+            + b" ".join(dumps((k, v), kind=Kind.SINGLE_ENTRY) for k, v in data.items())
+            + b"}"
+        )
 
-        return b" ".join(entries)
+    if isinstance(data, tuple) and kind == Kind.SINGLE_ENTRY and len(data) == 2:
+        k, v = data
+        ret = dumps(k, kind=Kind.KEYWORD) + b" " + dumps(v)
+        if not isinstance(v, Mapping):
+            ret += b";"
+        return ret
 
     if isinstance(data, DimensionSet):
         return b"[" + b" ".join(dumps(v) for v in data) + b"]"
@@ -119,10 +119,12 @@ def dumps(
         Kind.SINGLE_PRECISION_BINARY_FIELD,
     ) and (
         isinstance(data, (int, float))
-        or is_sequence(data)
-        and data
-        and isinstance(data[0], (int, float))
-        and len(data) in (3, 6, 9)
+        or (
+            is_sequence(data)
+            and data
+            and isinstance(data[0], (int, float))
+            and len(data) in (3, 6, 9)
+        )
     ):
         return b"uniform " + dumps(data, kind=Kind.SINGLE_ENTRY)
 
@@ -185,7 +187,7 @@ def dumps(
     if isinstance(data, tuple):
         return b" ".join(dumps(v) for v in data)
 
-    if is_sequence(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:

foamlib/_files/_types.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import sys
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Dict, NamedTuple, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Dict, NamedTuple, Optional, Union
 
 if TYPE_CHECKING:
     import numpy as np
@@ -29,8 +29,7 @@ class DimensionSet(NamedTuple):
 Tensor = Union[
     float,
     Sequence[float],
-    "np.ndarray[Tuple[()], np.dtype[np.generic]]",
-    "np.ndarray[Tuple[int], np.dtype[np.generic]]",
+    "np.ndarray[tuple[()] | tuple[int], np.dtype[np.float64 | np.int_]]",
 ]
 
 
@@ -46,33 +45,35 @@ class Dimensioned:
 
 
 Field = Union[
-    Tensor, Sequence[Tensor], "np.ndarray[Tuple[int, int], np.dtype[np.generic]]"
+    Tensor,
+    Sequence[Tensor],
+    "np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.float64 | np.int_]]",
 ]
 
-DataEntry = Union[
+Data = Union[
     str,
     int,
     float,
     bool,
     Dimensioned,
     DimensionSet,
-    Sequence["Data"],
+    Sequence["Entry"],
     Tensor,
     Field,
 ]
 
-Data = Union[
-    DataEntry,
-    Mapping[str, "Data"],
+Entry = Union[
+    Data,
+    Mapping[str, "Entry"],
 ]
 """
 A value that can be stored in an OpenFOAM file.
 """
 
-MutableData = Union[
-    DataEntry,
-    MutableMapping[str, "MutableData"],
+MutableEntry = Union[
+    Data,
+    MutableMapping[str, "MutableEntry"],
 ]
 
-Dict_ = Dict[str, Union["Data", "Dict_"]]
-File = Dict[Optional[str], Union["Data", "Dict_"]]
+Dict_ = Dict[str, Union["Entry", "Dict_"]]
+File = Dict[Optional[str], Union["Entry", "Dict_"]]

foamlib/_files/_util.py

@@ -14,10 +14,10 @@ else:
     from typing_extensions import TypeGuard
 
 if TYPE_CHECKING:
-    from ._types import Data
+    from ._types import Entry
 
 
 def is_sequence(
-    value: Data,
-) -> TypeGuard[Sequence[Data]]:
+    value: Entry,
+) -> TypeGuard[Sequence[Entry]]:
     return isinstance(value, Sequence) and not isinstance(value, str)

{foamlib-0.7.2.dist-info → foamlib-0.8.0.dist-info}/METADATA

@@ -1,15 +1,15 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: foamlib
-Version: 0.7.2
+Version: 0.8.0
 Summary: A Python interface for interacting with OpenFOAM
-Author-email: "Gabriel S. Gerlero" <ggerlero@cimec.unl.edu.ar>
 Project-URL: Homepage, https://github.com/gerlero/foamlib
 Project-URL: Repository, https://github.com/gerlero/foamlib
 Project-URL: Documentation, https://foamlib.readthedocs.io
+Author-email: "Gabriel S. Gerlero" <ggerlero@cimec.unl.edu.ar>
 Classifier: Development Status :: 4 - Beta
 Classifier: Framework :: AsyncIO
-Classifier: Intended Audience :: Science/Research
 Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: POSIX
 Classifier: Programming Language :: Python :: 3 :: Only
@@ -24,34 +24,43 @@ Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development
 Classifier: Typing :: Typed
 Requires-Python: >=3.7
-Description-Content-Type: text/markdown
-License-File: LICENSE.txt
-Requires-Dist: aioshutil <2,>=1
-Requires-Dist: pyparsing <4,>=3
-Requires-Dist: typing-extensions <5,>=4 ; python_version < "3.11"
+Requires-Dist: aioshutil<2,>=1
+Requires-Dist: pyparsing<4,>=3
+Requires-Dist: typing-extensions<5,>=4; python_version < '3.11'
 Provides-Extra: dev
-Requires-Dist: foamlib[numpy] ; extra == 'dev'
-Requires-Dist: foamlib[lint] ; extra == 'dev'
-Requires-Dist: foamlib[test] ; extra == 'dev'
-Requires-Dist: foamlib[typing] ; extra == 'dev'
-Requires-Dist: foamlib[docs] ; extra == 'dev'
+Requires-Dist: mypy<2,>=1; extra == 'dev'
+Requires-Dist: numpy<3,>=1; extra == 'dev'
+Requires-Dist: numpy<3,>=1.25.0; (python_version >= '3.10') and extra == 'dev'
+Requires-Dist: pytest-asyncio<0.25,>=0.21; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest<9,>=7; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: sphinx-rtd-theme; extra == 'dev'
+Requires-Dist: sphinx<9,>=5; extra == 'dev'
 Provides-Extra: docs
-Requires-Dist: foamlib[numpy] ; extra == 'docs'
-Requires-Dist: sphinx <9,>=5 ; extra == 'docs'
-Requires-Dist: sphinx-rtd-theme ; extra == 'docs'
+Requires-Dist: numpy<3,>=1; extra == 'docs'
+Requires-Dist: numpy<3,>=1.25.0; (python_version >= '3.10') and extra == 'docs'
+Requires-Dist: sphinx-rtd-theme; extra == 'docs'
+Requires-Dist: sphinx<9,>=5; extra == 'docs'
 Provides-Extra: lint
-Requires-Dist: ruff ; extra == 'lint'
+Requires-Dist: ruff; extra == 'lint'
 Provides-Extra: numpy
-Requires-Dist: numpy <3,>=1 ; extra == 'numpy'
-Requires-Dist: numpy <3,>=1.25.0 ; (python_version >= "3.10") and extra == 'numpy'
+Requires-Dist: numpy<3,>=1; extra == 'numpy'
+Requires-Dist: numpy<3,>=1.25.0; (python_version >= '3.10') and extra == 'numpy'
 Provides-Extra: test
-Requires-Dist: foamlib[numpy] ; extra == 'test'
-Requires-Dist: pytest <9,>=7 ; extra == 'test'
-Requires-Dist: pytest-asyncio <0.25,>=0.21 ; extra == 'test'
-Requires-Dist: pytest-cov ; extra == 'test'
+Requires-Dist: numpy<3,>=1; extra == 'test'
+Requires-Dist: numpy<3,>=1.25.0; (python_version >= '3.10') and extra == 'test'
+Requires-Dist: pytest-asyncio<0.25,>=0.21; extra == 'test'
+Requires-Dist: pytest-cov; extra == 'test'
+Requires-Dist: pytest<9,>=7; extra == 'test'
 Provides-Extra: typing
-Requires-Dist: foamlib[test] ; extra == 'typing'
-Requires-Dist: mypy <2,>=1 ; extra == 'typing'
+Requires-Dist: mypy<2,>=1; extra == 'typing'
+Requires-Dist: numpy<3,>=1; extra == 'typing'
+Requires-Dist: numpy<3,>=1.25.0; (python_version >= '3.10') and extra == 'typing'
+Requires-Dist: pytest-asyncio<0.25,>=0.21; extra == 'typing'
+Requires-Dist: pytest-cov; extra == 'typing'
+Requires-Dist: pytest<9,>=7; extra == 'typing'
+Description-Content-Type: text/markdown
 
 [<img alt="foamlib" src="https://github.com/gerlero/foamlib/raw/main/logo.png" height="65">](https://github.com/gerlero/foamlib)
 

foamlib-0.8.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+foamlib/__init__.py,sha256=iN_p0PYnIJNOiwBl-JcsqwLyxvZMD2qW6X7alo-YOO4,452
+foamlib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+foamlib/_cases/__init__.py,sha256=_A1TTHuQfS9FH2_33lSEyLtOJZGFHZBco1tWJCVOHks,358
+foamlib/_cases/_async.py,sha256=i6g4EBHqvI-1PkdrxsRto2ynW7sxsOga2bSYk1XVG1U,7795
+foamlib/_cases/_base.py,sha256=37oBbM3NM-hpG7dKewZvyJNtqSAogMurcbmX-wLIgMU,6727
+foamlib/_cases/_run.py,sha256=lveqKZium_qK_eTxYE8jOjwx0eiIoolCBbi56-zLw1o,14420
+foamlib/_cases/_slurm.py,sha256=kj4wqgr3foMyAoUkoHOZODRBmVqH1B9KqAIEEjM8ZBg,2328
+foamlib/_cases/_subprocess.py,sha256=6BlBRxknj2-BFcGkx7oVcuL63_utSaY1Axmsc1qV9j8,3887
+foamlib/_cases/_sync.py,sha256=2BJXB7Nzldb4OgPukqupgYqdceUGkI2mYhhtGPWEBrc,5901
+foamlib/_cases/_util.py,sha256=tK4SM5WT3eEgGsFLnidIySbom1qowBAua9z13gipKJk,1518
+foamlib/_files/__init__.py,sha256=q1vkjXnjnSZvo45jPAICpWeF2LZv5V6xfzAR6S8fS5A,96
+foamlib/_files/_files.py,sha256=Afkv9X8Om-AxIe9Ojqbz203_69okdlMNIlSeEAMnkzY,15832
+foamlib/_files/_io.py,sha256=BGbbm6HKxL2ka0YMCmHqZQZ1R4PPQlkvWWb4FHMAS8k,2217
+foamlib/_files/_parsing.py,sha256=Go-gwu5HAZF__iF29l_EiPWouBIhjeQG8e6P9vM2cXY,13833
+foamlib/_files/_serialization.py,sha256=gc0ybQFKU68Ytdv1Uwa1kA8GgunI69XnIch259K4ing,5826
+foamlib/_files/_types.py,sha256=jvXegp5vKLMJpN8I3jTpAhnT2WQ5FJ5WVBcqw5pRjdQ,1666
+foamlib/_files/_util.py,sha256=lkoSJHXjd6MvDxx39ZF75mhPq-_QX9AjrruVcQ7I9WI,496
+foamlib-0.8.0.dist-info/METADATA,sha256=RZN9GJjprIVwmk39qVXBNJq3yr9Sy9LhuVjHAIPcHfc,8499
+foamlib-0.8.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+foamlib-0.8.0.dist-info/licenses/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
+foamlib-0.8.0.dist-info/RECORD,,

{foamlib-0.7.2.dist-info → foamlib-0.8.0.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.5.0)
+Generator: hatchling 1.26.3
 Root-Is-Purelib: true
 Tag: py3-none-any
-

foamlib-0.7.2.dist-info/RECORD

@@ -1,22 +0,0 @@
-foamlib/__init__.py,sha256=YrFnCARXwvjW-QZzK9cS_ivto2gvTEJwdSVU5ZfCBkM,452
-foamlib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-foamlib/_cases/__init__.py,sha256=wTUHcUgU1CBgpu0cUMtksQ5VKG6B8CFu9xc3dWwsQuo,358
-foamlib/_cases/_async.py,sha256=i6g4EBHqvI-1PkdrxsRto2ynW7sxsOga2bSYk1XVG1U,7795
-foamlib/_cases/_base.py,sha256=FKfZxP7HspWfSswQ6yZ5bGJRdZUlupQxj2tDqngXPmc,6785
-foamlib/_cases/_run.py,sha256=lveqKZium_qK_eTxYE8jOjwx0eiIoolCBbi56-zLw1o,14420
-foamlib/_cases/_slurm.py,sha256=kj4wqgr3foMyAoUkoHOZODRBmVqH1B9KqAIEEjM8ZBg,2328
-foamlib/_cases/_subprocess.py,sha256=6BlBRxknj2-BFcGkx7oVcuL63_utSaY1Axmsc1qV9j8,3887
-foamlib/_cases/_sync.py,sha256=2BJXB7Nzldb4OgPukqupgYqdceUGkI2mYhhtGPWEBrc,5901
-foamlib/_cases/_util.py,sha256=lhVca3ERY0zwYjDam6W2QMROt0yX5vAF-9_DS5RuMbM,1547
-foamlib/_files/__init__.py,sha256=GDkYkF3F-ADhkCRT3j9dQQHPP5LyJJYb8TaBbZTQ6fo,96
-foamlib/_files/_files.py,sha256=LVLMeP9Zt9esuVGhntnjBA4_u_NhiX5xkm09Qemcle8,15846
-foamlib/_files/_io.py,sha256=IQLqoqnA1TpHf21NbUho2wsYWevyqC6MKo-wfpaObUU,2226
-foamlib/_files/_parsing.py,sha256=D1l7j_KldD6h-iJvFT6c0CiwctWvUxeGJxh-J93zDs8,15430
-foamlib/_files/_serialization.py,sha256=0vqJxltjscqp16mIvd0iKXbeRMbq3a7uLG2INWxzCBg,5861
-foamlib/_files/_types.py,sha256=eY06nox8cZe6FixUQigvZRV9Fc7gwehJxuQz_wCCnqo,1678
-foamlib/_files/_util.py,sha256=O9t2W26XDs63cVLroW8rZ35Puas20NhnKr_gLMlZixI,493
-foamlib-0.7.2.dist-info/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
-foamlib-0.7.2.dist-info/METADATA,sha256=dK_DN2ZLU49org-G_XI4kdNDg551I8b68d52Q4cAePU,7957
-foamlib-0.7.2.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
-foamlib-0.7.2.dist-info/top_level.txt,sha256=ZdVYtetXGwPwyfL-WhlhbTFQGAwKX5P_gXxtH9JYFPI,8
-foamlib-0.7.2.dist-info/RECORD,,

foamlib-0.7.2.dist-info/top_level.txt

@@ -1 +0,0 @@
-foamlib