foamlib 0.9.2__tar.gz → 0.9.4__tar.gz

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

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

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

{foamlib-0.9.2 → foamlib-0.9.4}/foamlib/_files/_files.py

@@ -22,14 +22,17 @@ from ._serialization import dumps, normalize_data, normalize_keyword
 from ._types import (
     Data,
     DataLike,
-    Dict_,
     Dimensioned,
     DimensionSet,
-    EntryLike,
     Field,
     FieldLike,
     File,
-    MutableEntry,
+    FileLike,
+    MutableSubDict,
+    StandaloneData,
+    StandaloneDataLike,
+    SubDict,
+    SubDictLike,
 )
 
 
@@ -62,7 +65,7 @@ def _tensor_kind_for_field(
 class FoamFile(
     MutableMapping[
         Optional[Union[str, Tuple[str, ...]]],
-        MutableEntry,
+        Union[Data, MutableSubDict],
     ],
     FoamFileIO,
 ):
@@ -115,7 +118,7 @@ class FoamFile(
     DimensionSet = DimensionSet
 
     class SubDict(
-        MutableMapping[str, MutableEntry],
+        MutableMapping[str, Union[Data, MutableSubDict]],
     ):
         """
         An OpenFOAM sub-dictionary within a file.
@@ -154,7 +157,7 @@ class FoamFile(
         def __setitem__(
             self,
             keyword: str,
-            data: EntryLike,
+            data: DataLike | SubDictLike,
         ) -> None:
             self._file[(*self._keywords, keyword)] = data
 
@@ -183,7 +186,7 @@ class FoamFile(
         def __repr__(self) -> str:
             return f"{type(self).__qualname__}('{self._file}', {self._keywords})"
 
-        def as_dict(self) -> Dict_:
+        def as_dict(self) -> SubDict:
             """Return a nested dict representation of the sub-dictionary."""
             ret = self._file.as_dict(include_header=True)
 
@@ -193,7 +196,7 @@ class FoamFile(
                 assert isinstance(v, dict)
                 ret = cast("File", v)
 
-            return cast("Dict_", ret)
+            return cast("SubDict", ret)
 
     @property
     def version(self) -> float:
@@ -282,7 +285,7 @@ class FoamFile(
         return deepcopy(value)
 
     def __setitem__(
-        self, keywords: str | tuple[str, ...] | None, data: EntryLike
+        self, keywords: str | tuple[str, ...] | None, data: DataLike | SubDictLike
     ) -> None:
         if not keywords:
             keywords = ()
@@ -463,7 +466,7 @@ class FoamFile(
         s: bytes | str,
         *,
         include_header: bool = False,
-    ) -> File | Data:
+    ) -> File | StandaloneData:
         """
         Standalone deserializing function.
 
@@ -486,7 +489,9 @@ class FoamFile(
         return ret
 
     @staticmethod
-    def dumps(file: File | DataLike, *, ensure_header: bool = True) -> bytes:
+    def dumps(
+        file: FileLike | StandaloneDataLike, *, ensure_header: bool = True
+    ) -> bytes:
         """
         Standalone serializing function.
 
@@ -498,21 +503,23 @@ class FoamFile(
             If `True`, a header will be included if it is not already present in the
             input object.
         """
+        header: SubDict | None
         if isinstance(file, Mapping):
-            header = file.get("FoamFile", None)
-            assert isinstance(header, FoamFile.SubDict) or header is None
+            header = file.get("FoamFile", None)  # type: ignore [assignment]
+
             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)
+                        dumps((k, v), keywords=(), header=header, tuple_is_entry=True)  # type: ignore [arg-type]
                     )
                 else:
+                    assert not isinstance(v, Mapping)
                     entries.append(dumps(v, keywords=(), header=header))
             ret = b" ".join(entries)
         else:
             header = None
-            ret = dumps(file)
+            ret = dumps(file, keywords=(), header=header)
 
         if header is None and ensure_header:
             class_ = "dictionary"
@@ -670,5 +677,5 @@ class FoamFieldFile(FoamFile):
         return ret
 
     @boundary_field.setter
-    def boundary_field(self, value: Mapping[str, Dict_]) -> None:
+    def boundary_field(self, value: Mapping[str, SubDict]) -> None:
         self["boundaryField"] = value

{foamlib-0.9.2 → foamlib-0.9.4}/foamlib/_files/_parsing.py

@@ -363,7 +363,9 @@ _FIELD = (Keyword("uniform", _IDENTBODYCHARS).suppress() + _TENSOR) | (
 _DIRECTIVE = Word("#", _IDENTBODYCHARS)
 _TOKEN = dbl_quoted_string | _DIRECTIVE | _IDENTIFIER
 _DATA = Forward()
-_KEYWORD_ENTRY = _keyword_entry_of(_TOKEN | _list_of(_IDENTIFIER), _DATA)
+_KEYWORD_ENTRY = _keyword_entry_of(
+    _TOKEN | _list_of(_IDENTIFIER), Opt(_DATA, default="")
+)
 _DICT = _dict_of(_TOKEN, _DATA)
 _DATA_ENTRY = Forward()
 _LIST_ENTRY = _DICT | _KEYWORD_ENTRY | _DATA_ENTRY

{foamlib-0.9.2 → foamlib-0.9.4}/foamlib/_files/_serialization.py

@@ -16,8 +16,10 @@ from ._types import (
     DataLike,
     Dimensioned,
     DimensionSet,
-    Entry,
-    EntryLike,
+    StandaloneData,
+    StandaloneDataLike,
+    SubDict,
+    SubDictLike,
     is_sequence,
 )
 
@@ -30,13 +32,37 @@ def normalize_data(
 
 @overload
 def normalize_data(
-    data: EntryLike, *, keywords: tuple[str, ...] | None = None
-) -> Entry: ...
+    data: StandaloneDataLike, *, keywords: tuple[str, ...] | None = None
+) -> StandaloneData: ...
 
 
+@overload
 def normalize_data(
-    data: EntryLike, *, keywords: tuple[str, ...] | None = None
-) -> Entry:
+    data: SubDictLike, *, keywords: tuple[str, ...] | None = None
+) -> SubDict: ...
+
+
+def normalize_data(
+    data: DataLike | StandaloneDataLike | SubDictLike,
+    *,
+    keywords: tuple[str, ...] | None = None,
+) -> Data | StandaloneData | SubDict:
+    if isinstance(data, Mapping):
+        return {normalize_keyword(k): normalize_data(v) for k, v in data.items()}  # type: ignore [arg-type, misc]
+
+    if keywords == () and is_sequence(data) and not isinstance(data, tuple):
+        try:
+            arr = np.asarray(data)
+        except ValueError:
+            pass
+        else:
+            if np.issubdtype(arr.dtype, np.integer) and arr.ndim == 1:
+                return arr  # type: ignore [return-value]
+            if arr.ndim == 2 and arr.shape[1] == 3:
+                if not np.issubdtype(arr.dtype, np.floating):
+                    arr = arr.astype(float)
+                return arr  # type: ignore [return-value]
+
     if keywords is not None and (
         keywords == ("internalField",)
         or (
@@ -49,7 +75,7 @@ def normalize_data(
             )
         )
     ):
-        if is_sequence(data):
+        if is_sequence(data) and not isinstance(data, tuple):
             try:
                 arr = np.asarray(data)
             except ValueError:
@@ -61,20 +87,17 @@ def normalize_data(
                 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]
+            return [normalize_data(d) for d in data]  # type: ignore [arg-type]
 
         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
+        return ret  # type: ignore [return-value]
 
     if (
         not isinstance(data, DimensionSet)
@@ -90,16 +113,19 @@ def normalize_data(
         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]
+            normalize_keyword(k),  # type: ignore [arg-type]
+            normalize_data(v) if not isinstance(v, Mapping) else v,  # type: ignore [arg-type, misc]
+        )
 
     if (
         is_sequence(data)
         and not isinstance(data, DimensionSet)
-        and (keywords is None or not isinstance(data, tuple))
+        and not isinstance(data, tuple)
     ):
-        return [normalize_data(d) for d in data]
+        return [normalize_data(d) for d in data]  # type: ignore [arg-type]
+
+    if isinstance(data, tuple) and not isinstance(data, DimensionSet):
+        return tuple(normalize_data(d) for d in data)
 
     if isinstance(data, str):
         s = loads(data)
@@ -108,7 +134,7 @@ def normalize_data(
 
     if isinstance(
         data,
-        (int, float, bool, tuple, DimensionSet, Dimensioned),
+        (int, float, bool, DimensionSet, Dimensioned),
     ):
         return data
 
@@ -126,13 +152,13 @@ def normalize_keyword(data: DataLike) -> Data:
 
 
 def dumps(
-    data: EntryLike,
+    data: DataLike | StandaloneDataLike | SubDictLike,
     *,
     keywords: tuple[str, ...] | None = None,
-    header: Mapping[str, Entry] | None = None,
+    header: SubDictLike | None = None,
     tuple_is_entry: bool = False,
 ) -> bytes:
-    data = normalize_data(data, keywords=keywords)
+    data = normalize_data(data, keywords=keywords)  # type: ignore [arg-type, misc]
 
     if isinstance(data, Mapping):
         return (
@@ -148,6 +174,12 @@ def dumps(
             + b"}"
         )
 
+    if keywords == () and isinstance(data, np.ndarray):
+        if (header.get("format", "") if header else "") == "binary":
+            return dumps(len(data)) + b"(" + data.tobytes() + b")"
+
+        return dumps(data.tolist())
+
     if (
         keywords is not None
         and (
@@ -231,7 +263,7 @@ def dumps(
         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")"
+        return b"(" + b" ".join(dumps(v, tuple_is_entry=True) for v in data) + b")"  # type: ignore [arg-type]
 
     if data is True:
         return b"yes"

foamlib-0.9.4/foamlib/_files/_types.py

@@ -0,0 +1,250 @@
+from __future__ import annotations
+
+import sys
+from typing import Any, Dict, List, NamedTuple, Optional, Tuple, Union
+
+import numpy as np
+
+if sys.version_info >= (3, 9):
+    from collections.abc import Mapping, MutableMapping, Sequence
+else:
+    from typing import Mapping, MutableMapping, Sequence
+
+if sys.version_info >= (3, 10):
+    from typing import TypeGuard
+else:
+    from typing_extensions import TypeGuard
+
+
+class DimensionSet(NamedTuple):
+    mass: float = 0
+    length: float = 0
+    time: float = 0
+    temperature: float = 0
+    moles: float = 0
+    current: float = 0
+    luminous_intensity: float = 0
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}({', '.join(f'{n}={v}' for n, v in zip(self._fields, self) if v != 0)})"
+
+    def __add__(self, other: DimensionSet) -> DimensionSet:  # type: ignore[override]
+        if not isinstance(other, DimensionSet):
+            return NotImplemented
+
+        if self != other:
+            msg = f"Cannot add DimensionSet with different dimensions: {self} + {other}"
+            raise ValueError(msg)
+
+        return self
+
+    def __sub__(self, other: DimensionSet) -> DimensionSet:
+        if not isinstance(other, DimensionSet):
+            return NotImplemented
+
+        if self != other:
+            msg = f"Cannot subtract DimensionSet with different dimensions: {self} - {other}"
+            raise ValueError(msg)
+
+        return self
+
+    def __mul__(self, other: DimensionSet) -> DimensionSet:  # type: ignore[override]
+        if not isinstance(other, DimensionSet):
+            return NotImplemented
+
+        return DimensionSet(*(a + b for a, b in zip(self, other)))
+
+    def __truediv__(self, other: DimensionSet) -> DimensionSet:
+        if not isinstance(other, DimensionSet):
+            return NotImplemented
+
+        return DimensionSet(*(a - b for a, b in zip(self, other)))
+
+    def __pow__(self, exponent: float) -> DimensionSet:
+        if not isinstance(exponent, (int, float)):
+            return NotImplemented
+
+        return DimensionSet(*(a * exponent for a in self))
+
+    def __bool__(self) -> bool:
+        return any(v != 0 for v in self)
+
+
+Tensor = Union[
+    float,
+    "np.ndarray[tuple[int], np.dtype[np.float64]]",
+]
+
+TensorLike = Union[
+    Tensor,
+    Sequence[float],
+]
+
+
+class Dimensioned:
+    def __init__(
+        self,
+        value: TensorLike,
+        dimensions: DimensionSet | Sequence[float],
+        name: str | None = None,
+    ) -> None:
+        if is_sequence(value):
+            self.value: Tensor = np.array(value, dtype=float)  # type: ignore [assignment]
+        else:
+            assert isinstance(value, (int, float, np.ndarray))
+            self.value = float(value)
+
+        if not isinstance(dimensions, DimensionSet):
+            self.dimensions = DimensionSet(*dimensions)
+        else:
+            self.dimensions = dimensions
+
+        self.name = name
+
+    def __repr__(self) -> str:
+        if self.name is not None:
+            return (
+                f"{type(self).__name__}({self.value}, {self.dimensions}, {self.name})"
+            )
+        return f"{type(self).__name__}({self.value}, {self.dimensions})"
+
+    def __add__(self, other: Dimensioned | Tensor) -> Dimensioned:
+        if not isinstance(other, Dimensioned):
+            other = Dimensioned(other, DimensionSet())
+
+        return Dimensioned(
+            self.value + other.value,  # type: ignore [arg-type]
+            self.dimensions + other.dimensions,
+            f"{self.name}+{other.name}"
+            if self.name is not None and other.name is not None
+            else None,
+        )
+
+    def __sub__(self, other: Dimensioned | Tensor) -> Dimensioned:
+        if not isinstance(other, Dimensioned):
+            other = Dimensioned(other, DimensionSet())
+
+        return Dimensioned(
+            self.value - other.value,  # type: ignore [arg-type]
+            self.dimensions - other.dimensions,
+            f"{self.name}-{other.name}"
+            if self.name is not None and other.name is not None
+            else None,
+        )
+
+    def __mul__(self, other: Dimensioned | Tensor) -> Dimensioned:
+        if not isinstance(other, Dimensioned):
+            other = Dimensioned(other, DimensionSet())
+
+        return Dimensioned(
+            self.value * other.value,  # type: ignore [arg-type]
+            self.dimensions * other.dimensions,
+            f"{self.name}*{other.name}"
+            if self.name is not None and other.name is not None
+            else None,
+        )
+
+    def __truediv__(self, other: Dimensioned | Tensor) -> Dimensioned:
+        if not isinstance(other, Dimensioned):
+            other = Dimensioned(other, DimensionSet())
+
+        return Dimensioned(
+            self.value / other.value,  # type: ignore [arg-type]
+            self.dimensions / other.dimensions,
+            f"{self.name}/{other.name}"
+            if self.name is not None and other.name is not None
+            else None,
+        )
+
+    def __pow__(self, exponent: float) -> Dimensioned:
+        if not isinstance(exponent, (int, float)):
+            return NotImplemented
+
+        return Dimensioned(
+            self.value**exponent,  # type: ignore [arg-type]
+            self.dimensions**exponent,
+            f"pow({self.name},{exponent})" if self.name is not None else None,
+        )
+
+    def __float__(self) -> float:
+        if self.dimensions:
+            msg = f"Cannot convert non-dimensionless Dimensioned object to float: {self.dimensions}"
+            raise ValueError(msg)
+        return float(self.value)
+
+    def __int__(self) -> int:
+        if self.dimensions:
+            msg = f"Cannot convert non-dimensionless Dimensioned object to int: {self.dimensions}"
+            raise ValueError(msg)
+        return int(self.value)
+
+    def __array__(
+        self, dtype: Any = None, *, copy: Any = None
+    ) -> np.ndarray[tuple[()] | tuple[int], np.dtype[np.float64]]:
+        if self.dimensions:
+            msg = f"Cannot convert non-dimensionless Dimensioned object to array: {self.dimensions}"
+            raise ValueError(msg)
+        return np.array(self.value, dtype=dtype, copy=copy)
+
+
+Field = Union[
+    float,
+    "np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.float64 | np.float32]]",
+]
+
+FieldLike = Union[
+    Field,
+    TensorLike,
+    Sequence[TensorLike],
+]
+
+
+Data = Union[
+    str,
+    int,
+    float,
+    bool,
+    Dimensioned,
+    DimensionSet,
+    Tuple["Data", ...],
+    List[Union["Data", Tuple["Data", Union["Data", "SubDict"]]]],
+    Field,
+]
+
+DataLike = Union[
+    Data,
+    Tuple["DataLike", ...],
+    Sequence[Union["DataLike", Tuple["DataLike", Union["DataLike", "SubDictLike"]]]],
+    FieldLike,
+]
+
+StandaloneData = Union[
+    Data,
+    "np.ndarray[tuple[int], np.dtype[np.int64 | np.int32]]",
+    "np.ndarray[tuple[int], np.dtype[np.float64 | np.float32]]",
+]
+
+StandaloneDataLike = Union[
+    DataLike,
+    "np.ndarray[tuple[int], np.dtype[np.int64 | np.int32]]",
+    "np.ndarray[tuple[int], np.dtype[np.float64 | np.float32]]",
+]
+
+
+def is_sequence(
+    value: DataLike | StandaloneDataLike | SubDictLike,
+) -> TypeGuard[
+    Sequence[DataLike | tuple[DataLike, DataLike | SubDictLike]]
+    | np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.float64 | np.float32]]
+]:
+    return (isinstance(value, Sequence) and not isinstance(value, str)) or (
+        isinstance(value, np.ndarray) and value.ndim > 0
+    )
+
+
+SubDict = Dict[str, Union[Data, "SubDict"]]
+SubDictLike = Mapping[str, Union[DataLike, "SubDictLike"]]
+MutableSubDict = MutableMapping[str, Union[Data, "MutableSubDict"]]
+
+File = Dict[Optional[str], Union[StandaloneData, Data, "SubDict"]]
+FileLike = Mapping[Optional[str], Union[StandaloneDataLike, DataLike, "FileLike"]]

{foamlib-0.9.2 → foamlib-0.9.4}/tests/test_example.py

@@ -82,7 +82,7 @@ def test_example(tmp_path: Path) -> None:
             [1, 1, 1],
         ]
         f["edges"] = []
-        f["boundary"] = [
+        boundary: list[tuple[str, dict[str, str | list[list[int]]]]] = [
             ("inletUp", {"type": "patch", "faces": [[5, 4, 10, 11]]}),
             ("inletDown", {"type": "patch", "faces": [[0, 5, 11, 6]]}),
             ("outletUp", {"type": "patch", "faces": [[2, 3, 9, 8]]}),
@@ -101,6 +101,7 @@ def test_example(tmp_path: Path) -> None:
                 },
             ),
         ]
+        f["boundary"] = boundary
         f["mergePatchPairs"] = []
 
     with case.transport_properties as f:

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

@@ -92,7 +92,6 @@ def test_serialize_data() -> None:
     assert dumps([("a", "b"), ("c", "d")]) == b"(a b; c d;)"
     assert dumps([("a", {"b": "c"}), ("d", {"e": "g"})]) == b"(a {b c;} d {e g;})"
     assert dumps([("a", [0, 1, 2]), ("b", {})]) == b"(a (0 1 2); b {})"
-    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)"
 
@@ -104,10 +103,25 @@ def test_serialize_file() -> None:
         == 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;})"
+        FoamFile.dumps({"a": "b", "c": "d"})
+        == b"{FoamFile {version 2.0; format ascii; class dictionary;}} a b; c d;"
     )
     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));"
     )
+    assert (
+        FoamFile.dumps([[1, 2, 3], [4, 5, 6]])
+        == b"{FoamFile {version 2.0; format ascii; class dictionary;}} ((1.0 2.0 3.0) (4.0 5.0 6.0))"
+    )
+    assert FoamFile.dumps([1, 2, 3], ensure_header=False) == b"(1 2 3)"
+    assert (
+        FoamFile.dumps(
+            {
+                "FoamFile": {"format": "binary"},
+                None: np.array([1, 2, 3], dtype=np.int32),  # type: ignore[dict-item]
+            },
+            ensure_header=False,
+        )
+        == b"FoamFile {format binary;} 3(\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00)"
+    )

{foamlib-0.9.2 → foamlib-0.9.4}/tests/test_files/test_files.py

@@ -78,13 +78,12 @@ def test_write_read(tmp_path: Path) -> None:
     assert sd["nestedList"] == [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
 
     sd["g"] = FoamFile.Dimensioned(
-        name="g", dimensions=[1, 1, -2, 0, 0, 0, 0], value=[0, 0, -9.81]
-    )
-    assert sd["g"] == FoamFile.Dimensioned(
-        name="g",
-        dimensions=FoamFile.DimensionSet(mass=1, length=1, time=-2),
-        value=[0, 0, -9.81],
+        name="g", dimensions=[0, 1, -2, 0, 0, 0, 0], value=[0, 0, -9.81]
     )
+    assert isinstance(sd["g"], FoamFile.Dimensioned)
+    assert sd["g"].name == "g"
+    assert sd["g"].dimensions == FoamFile.DimensionSet(length=1, time=-2)
+    assert np.array_equal(sd["g"].value, [0, 0, -9.81])
 
     sd["n"] = 1
     sd["y"] = 2
@@ -162,7 +161,8 @@ def test_internal_field(cavity: FoamCase) -> None:
     blocks = cavity.block_mesh_dict["blocks"]
     assert isinstance(blocks, list)
     sizes = blocks[2]
-    size = np.prod(sizes)
+    assert isinstance(sizes, list)
+    size = np.prod(sizes)  # type: ignore [arg-type]
 
     p_arr = np.zeros(size)
     U_arr = np.zeros((size, 3))

{foamlib-0.9.2 → foamlib-0.9.4}/tests/test_files/test_parsing/test_advanced.py

@@ -280,7 +280,8 @@ def test_assignment_strange_name() -> None:
     assert isinstance(parsed[("equations", '"(U|e|k|epsilon).*"')], tuple)
     assert parsed[("equations", '"(U|e|k|epsilon).*"')][0] == "table"
     assert np.array_equal(
-        parsed[("equations", '"(U|e|k|epsilon).*"')][1], [[0, 0.4], [0.5, 0.7]]
+        parsed[("equations", '"(U|e|k|epsilon).*"')][1],  # type: ignore[arg-type]
+        [[0, 0.4], [0.5, 0.7]],
     )
 
 

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

@@ -95,14 +95,16 @@ def test_parse_value() -> None:
     assert Parsed(b"[1 1 -2 0 0 0 0]")[()] == FoamFile.DimensionSet(
         mass=1, length=1, time=-2
     )
-    assert Parsed(b"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 Parsed(b"[1 1 -2 0 0 0 0] 9.81")[()] == FoamFile.Dimensioned(
-        dimensions=FoamFile.DimensionSet(mass=1, length=1, time=-2), value=9.81
-    )
+    dimensioned = Parsed(b"g [1 1 -2 0 0 0 0] (0 0 -9.81)")[()]
+    assert isinstance(dimensioned, FoamFile.Dimensioned)
+    assert dimensioned.dimensions == FoamFile.DimensionSet(mass=1, length=1, time=-2)
+    assert np.array_equal(dimensioned.value, [0, 0, -9.81])
+    assert dimensioned.name == "g"
+    dimensioned = Parsed(b"[1 1 -2 0 0 0 0] 9.81")[()]
+    assert isinstance(dimensioned, FoamFile.Dimensioned)
+    assert dimensioned.dimensions == FoamFile.DimensionSet(mass=1, length=1, time=-2)
+    assert dimensioned.value == 9.81
+    assert dimensioned.name is None
     tpl = Parsed(b"hex (0 1 2 3 4 5 6 7) (1 1 1) simpleGrading (1 1 1)")[()]
     assert isinstance(tpl, tuple)
     assert len(tpl) == 5

{foamlib-0.9.2 → foamlib-0.9.4}/tests/test_files/test_parsing/test_intermediate.py

@@ -157,10 +157,10 @@ def test_list_with_dict() -> None:
     assert len(boundary) == 1
 
     upper_boundary = boundary[0]
-    assert upper_boundary[0] == "upperBoundary"
-    assert upper_boundary[1]["type"] == "cyclic"
-    assert upper_boundary[1]["neighbourPatch"] == "lowerBoundary"
-    assert np.array_equal(upper_boundary[1]["faces"], [[3, 7, 6, 2]])
+    assert upper_boundary[0] == "upperBoundary"  # type: ignore[index]
+    assert upper_boundary[1]["type"] == "cyclic"  # type: ignore[index, call-overload]
+    assert upper_boundary[1]["neighbourPatch"] == "lowerBoundary"  # type: ignore[index, call-overload]
+    assert np.array_equal(upper_boundary[1]["faces"], [[3, 7, 6, 2]])  # type: ignore[arg-type, index, call-overload]
 
 
 def test_list_with_str() -> None:
@@ -174,10 +174,10 @@ def test_list_with_str() -> None:
     assert len(blocks) == 5
 
     assert blocks[0] == "hex"
-    assert np.array_equal(blocks[1], [0, 1, 2, 3, 4, 5, 6, 7])
-    assert np.array_equal(blocks[2], [40, 40, 40])
+    assert np.array_equal(blocks[1], [0, 1, 2, 3, 4, 5, 6, 7])  # type: ignore[arg-type]
+    assert np.array_equal(blocks[2], [40, 40, 40])  # type: ignore[arg-type]
     assert blocks[3] == "simpleGrading"
-    assert np.array_equal(blocks[4], [1, 1, 1])
+    assert np.array_equal(blocks[4], [1, 1, 1])  # type: ignore[arg-type]
 
 
 def test_file_simple() -> None:
@@ -457,7 +457,7 @@ def test_for_blockmesh() -> None:
     assert len(blocks) == 4
 
     assert blocks[0] == "hex"
-    assert np.array_equal(blocks[1], [4, 6, 14, 12, 0, 2, 10, 8])
+    assert np.array_equal(blocks[1], [4, 6, 14, 12, 0, 2, 10, 8])  # type: ignore[arg-type]
     assert blocks[2] == [1, "$upstreamCells", "$cylinderBoxCells"]
     assert blocks[3] == "$expandBlock"
 
@@ -487,27 +487,27 @@ def test_blocks() -> None:
     assert len(blocks) == 22
 
     assert blocks[0] == "hex"
-    assert np.array_equal(blocks[1], [0, 1, 2, 3, 4, 5, 6, 7])
+    assert np.array_equal(blocks[1], [0, 1, 2, 3, 4, 5, 6, 7])  # type: ignore[arg-type]
     assert blocks[2] == "inletChannel"
-    assert np.array_equal(blocks[3], [40, 1, 64])
+    assert np.array_equal(blocks[3], [40, 1, 64])  # type: ignore[arg-type]
     assert blocks[4] == "simpleGrading"
-    assert np.array_equal(blocks[5], [1, 1, 1])
+    assert np.array_equal(blocks[5], [1, 1, 1])  # type: ignore[arg-type]
     assert blocks[6] == "hex"
-    assert np.array_equal(blocks[7], [4, 5, 6, 7, 8, 9, 10, 11, 12])
+    assert np.array_equal(blocks[7], [4, 5, 6, 7, 8, 9, 10, 11, 12])  # type: ignore[arg-type]
     assert blocks[8] == "inletChannel"
-    assert np.array_equal(blocks[9], [40, 1, 16])
+    assert np.array_equal(blocks[9], [40, 1, 16])  # type: ignore[arg-type]
     assert blocks[10] == "simpleGrading"
-    assert np.array_equal(blocks[11], [1, 1, 1])
+    assert np.array_equal(blocks[11], [1, 1, 1])  # type: ignore[arg-type]
     assert blocks[12] == "hex"
-    assert np.array_equal(blocks[13], [12, 13, 14, 15, 16, 17, 18, 19])
-    assert np.array_equal(blocks[14], [96, 1, 8])
+    assert np.array_equal(blocks[13], [12, 13, 14, 15, 16, 17, 18, 19])  # type: ignore[arg-type]
+    assert np.array_equal(blocks[14], [96, 1, 8])  # type: ignore[arg-type]
     assert blocks[15] == "simpleGrading"
-    assert np.array_equal(blocks[16], [1, 1, 1])
+    assert np.array_equal(blocks[16], [1, 1, 1])  # type: ignore[arg-type]
     assert blocks[17] == "hex"
-    assert np.array_equal(blocks[18], [16, 17, 18, 19, 20, 21, 22, 23])
-    assert np.array_equal(blocks[19], [96, 1, 72])
+    assert np.array_equal(blocks[18], [16, 17, 18, 19, 20, 21, 22, 23])  # type: ignore[arg-type]
+    assert np.array_equal(blocks[19], [96, 1, 72])  # type: ignore[arg-type]
     assert blocks[20] == "simpleGrading"
-    assert np.array_equal(blocks[21], [1, 1, 1])
+    assert np.array_equal(blocks[21], [1, 1, 1])  # type: ignore[arg-type]
 
 
 @pytest.mark.xfail(reason="Not currently supported")
@@ -595,7 +595,7 @@ def test_list_edges() -> None:
     assert edges[1] == 1
     assert edges[2] == 2
     assert np.array_equal(
-        edges[3],
+        edges[3],  # type: ignore[arg-type]
         [
             [0.6, 0.0124, 0.0],
             [0.7, 0.0395, 0.0],
@@ -612,7 +612,7 @@ def test_list_edges() -> None:
     assert edges[5] == 6
     assert edges[6] == 5
     assert np.array_equal(
-        edges[7],
+        edges[7],  # type: ignore[arg-type]
         [
             [0.6, 0.0124, 0.05],
             [0.7, 0.0395, 0.05],
@@ -642,12 +642,12 @@ def test_list_edges_arcs() -> None:
     assert edges[1] == 0
     assert edges[2] == 5
     assert edges[3] == "origin"
-    assert np.array_equal(edges[4], [0, 0, 0])
+    assert np.array_equal(edges[4], [0, 0, 0])  # type: ignore[arg-type]
     assert edges[5] == "arc"
     assert edges[6] == 5
     assert edges[7] == 10
     assert edges[8] == "origin"
-    assert np.array_equal(edges[9], [0, 0, 0])
+    assert np.array_equal(edges[9], [0, 0, 0])  # type: ignore[arg-type]
 
 
 def test_list_blocks() -> None:
@@ -665,31 +665,31 @@ def test_list_blocks() -> None:
     assert len(blocks) == 15
 
     assert blocks[0] == "hex"
-    assert np.array_equal(blocks[1], [0, 1, 9, 8, 7, 6, 14, 15])
-    assert np.array_equal(blocks[2], [50, 100, 1])
+    assert np.array_equal(blocks[1], [0, 1, 9, 8, 7, 6, 14, 15])  # type: ignore[arg-type]
+    assert np.array_equal(blocks[2], [50, 100, 1])  # type: ignore[arg-type]
     assert blocks[3] == "simpleGrading"
     assert isinstance(blocks[4], list)
     assert len(blocks[4]) == 3
     assert blocks[4][0] == 1
-    assert np.array_equal(blocks[4][1], [[0.1, 0.25, 41.9], [0.9, 0.75, 1]])
+    assert np.array_equal(blocks[4][1], [[0.1, 0.25, 41.9], [0.9, 0.75, 1]])  # type: ignore[arg-type]
     assert blocks[4][2] == 1
     assert blocks[5] == "hex"
-    assert np.array_equal(blocks[6], [1, 2, 10, 9, 6, 5, 13, 14])
-    assert np.array_equal(blocks[7], [50, 100, 1])
+    assert np.array_equal(blocks[6], [1, 2, 10, 9, 6, 5, 13, 14])  # type: ignore[arg-type]
+    assert np.array_equal(blocks[7], [50, 100, 1])  # type: ignore[arg-type]
     assert blocks[8] == "simpleGrading"
     assert isinstance(blocks[9], list)
     assert len(blocks[9]) == 3
     assert blocks[9][0] == 1
-    assert np.array_equal(blocks[9][1], [[0.1, 0.25, 41.9], [0.9, 0.75, 1]])
+    assert np.array_equal(blocks[9][1], [[0.1, 0.25, 41.9], [0.9, 0.75, 1]])  # type: ignore[arg-type]
     assert blocks[9][2] == 1
     assert blocks[10] == "hex"
-    assert np.array_equal(blocks[11], [2, 3, 11, 10, 5, 4, 12, 13])
-    assert np.array_equal(blocks[12], [225, 100, 1])
+    assert np.array_equal(blocks[11], [2, 3, 11, 10, 5, 4, 12, 13])  # type: ignore[arg-type]
+    assert np.array_equal(blocks[12], [225, 100, 1])  # type: ignore[arg-type]
     assert blocks[13] == "simpleGrading"
     assert isinstance(blocks[14], list)
     assert len(blocks[14]) == 3
     assert blocks[14][0] == 1
-    assert np.array_equal(blocks[14][1], [[0.1, 0.25, 41.9], [0.9, 0.75, 1]])
+    assert np.array_equal(blocks[14][1], [[0.1, 0.25, 41.9], [0.9, 0.75, 1]])  # type: ignore[arg-type]
     assert blocks[14][2] == 1
 
 

{foamlib-0.9.2 → foamlib-0.9.4}/tests/test_files/test_parsing/test_loads.py

@@ -18,6 +18,7 @@ def test_loads() -> None:
     assert FoamFile.loads("word word") == ("word", "word")
     assert FoamFile.loads('"a string"') == '"a string"'
     assert FoamFile.loads("(word word)") == ["word", "word"]
+    assert FoamFile.loads("keyword value;") == {"keyword": "value"}
     assert FoamFile.loads("uniform 1") == 1
     assert FoamFile.loads("uniform 1.0") == 1.0
     assert FoamFile.loads("uniform 1.0e-3") == 1.0e-3
@@ -57,13 +58,16 @@ def test_loads() -> None:
     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
-    )
+    dimensioned = FoamFile.loads("g [1 1 -2 0 0 0 0] (0 0 -9.81)")
+    assert isinstance(dimensioned, FoamFile.Dimensioned)
+    assert dimensioned.dimensions == FoamFile.DimensionSet(mass=1, length=1, time=-2)
+    assert np.array_equal(dimensioned.value, [0, 0, -9.81])
+    assert dimensioned.name == "g"
+    dimensioned = FoamFile.loads("[1 1 -2 0 0 0 0] 9.81")
+    assert isinstance(dimensioned, FoamFile.Dimensioned)
+    assert dimensioned.dimensions == FoamFile.DimensionSet(mass=1, length=1, time=-2)
+    assert dimensioned.value == 9.81
+    assert dimensioned.name is None
     assert FoamFile.loads("a {b c; d e;}") == {"a": {"b": "c", "d": "e"}}
     assert FoamFile.loads("(a b; c d;)") == [("a", "b"), ("c", "d")]
+    assert FoamFile.loads("keyword;") == {"keyword": ""}

foamlib-0.9.4/tests/test_files/test_types.py

@@ -0,0 +1,62 @@
+import numpy as np
+import pytest
+from foamlib import FoamFile
+
+
+def test_dimension_set() -> None:
+    dims = FoamFile.DimensionSet(length=1, time=-2)
+    assert dims.length == 1
+    assert dims.time == -2
+    assert dims.mass == 0
+
+    assert dims + dims == dims
+    assert dims - dims == dims
+    assert dims * dims == FoamFile.DimensionSet(length=2, time=-4)
+    assert dims / dims == FoamFile.DimensionSet()
+    assert dims**2 == FoamFile.DimensionSet(length=2, time=-4)
+
+    assert dims
+    assert not FoamFile.DimensionSet()
+
+
+def test_dimensioned() -> None:
+    dimensioned = FoamFile.Dimensioned(
+        9.81, FoamFile.DimensionSet(length=1, time=-2), "g"
+    )
+    assert dimensioned.value == 9.81
+    assert dimensioned.dimensions == FoamFile.DimensionSet(length=1, time=-2)
+    assert dimensioned.name == "g"
+
+    result = dimensioned + dimensioned
+    assert result.value == 9.81 * 2
+    assert result.dimensions == FoamFile.DimensionSet(length=1, time=-2)
+    assert result.name == "g+g"
+
+    result = dimensioned - dimensioned
+    assert result.value == 0.0
+    assert result.dimensions == FoamFile.DimensionSet(length=1, time=-2)
+    assert result.name == "g-g"
+
+    result = dimensioned * dimensioned
+    assert result.value == 9.81**2
+    assert result.dimensions == FoamFile.DimensionSet(length=2, time=-4)
+    assert result.name == "g*g"
+
+    result = dimensioned / dimensioned
+    assert result.value == 1.0
+    assert result.dimensions == FoamFile.DimensionSet()
+    assert result.name == "g/g"
+
+    result = dimensioned**2
+    assert result.value == 9.81**2
+    assert result.dimensions == FoamFile.DimensionSet(length=2, time=-4)
+    assert result.name == "pow(g,2)"
+
+    with pytest.raises(ValueError, match="dimension"):
+        dimensioned + 1
+
+    with pytest.raises(ValueError, match="dimension"):
+        float(dimensioned)
+
+    with pytest.raises(ValueError, match="dimension"):
+        np.array(dimensioned)

foamlib-0.9.2/foamlib/_files/_types.py

@@ -1,136 +0,0 @@
-from __future__ import annotations
-
-import sys
-from typing import Dict, NamedTuple, Optional, Union
-
-import numpy as np
-
-if sys.version_info >= (3, 9):
-    from collections.abc import Mapping, MutableMapping, Sequence
-else:
-    from typing import Mapping, MutableMapping, Sequence
-
-if sys.version_info >= (3, 10):
-    from typing import TypeGuard
-else:
-    from typing_extensions import TypeGuard
-
-
-class DimensionSet(NamedTuple):
-    mass: float = 0
-    length: float = 0
-    time: float = 0
-    temperature: float = 0
-    moles: float = 0
-    current: float = 0
-    luminous_intensity: float = 0
-
-    def __repr__(self) -> str:
-        return f"{type(self).__name__}({', '.join(f'{n}={v}' for n, v in zip(self._fields, self) if v != 0)})"
-
-
-Tensor = Union[
-    float,
-    "np.ndarray[tuple[int], np.dtype[np.float64]]",
-]
-
-TensorLike = Union[
-    Sequence[float],
-    "np.ndarray[tuple[()], np.dtype[np.float64]]",
-    Tensor,
-]
-
-
-class Dimensioned:
-    def __init__(
-        self,
-        value: TensorLike,
-        dimensions: DimensionSet | Sequence[float],
-        name: str | None = None,
-    ) -> None:
-        if is_sequence(value):
-            self.value: Tensor = np.array(value, dtype=float)  # type: ignore [assignment]
-        else:
-            assert isinstance(value, (int, float, np.ndarray))
-            self.value = float(value)
-
-        if not isinstance(dimensions, DimensionSet):
-            self.dimensions = DimensionSet(*dimensions)
-        else:
-            self.dimensions = dimensions
-
-        self.name = name
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, Dimensioned):
-            return NotImplemented
-
-        return (
-            self.dimensions == other.dimensions
-            and np.array_equal(self.value, other.value)
-            and self.name == other.name
-        )
-
-
-Field = Union[
-    float,
-    "np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.float64 | np.float32]]",
-]
-
-FieldLike = Union[
-    TensorLike,
-    Sequence[TensorLike],
-    Sequence[Sequence[TensorLike]],
-    Field,
-]
-
-
-Data = Union[
-    str,
-    int,
-    float,
-    bool,
-    Dimensioned,
-    DimensionSet,
-    Sequence["Entry"],
-    Field,
-]
-
-Entry = Union[
-    Data,
-    Mapping[str, "Entry"],
-]
-"""
-A value that can be stored in an OpenFOAM file.
-"""
-
-DataLike = Union[
-    FieldLike,
-    Sequence["EntryLike"],
-    Data,
-]
-
-EntryLike = Union[
-    DataLike,
-    Mapping[str, "EntryLike"],
-]
-
-
-def is_sequence(
-    value: EntryLike,
-) -> TypeGuard[
-    Sequence[EntryLike]
-    | np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.float64 | np.float32]]
-]:
-    return (isinstance(value, Sequence) and not isinstance(value, str)) or (
-        isinstance(value, np.ndarray) and value.ndim > 0
-    )
-
-
-MutableEntry = Union[
-    Data,
-    MutableMapping[str, "MutableEntry"],
-]
-
-Dict_ = Dict[str, Union["Entry", "Dict_"]]
-File = Dict[Optional[str], Union["Entry", "Dict_"]]