foamlib 0.9.3__tar.gz → 0.9.4__tar.gz

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

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

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

{foamlib-0.9.3 → 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.3 → 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.3 → foamlib-0.9.4}/foamlib/_files/_types.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import sys
-from typing import Any, Dict, NamedTuple, Optional, Union
+from typing import Any, Dict, List, NamedTuple, Optional, Tuple, Union
 
 import numpy as np
 
@@ -76,9 +76,8 @@ Tensor = Union[
 ]
 
 TensorLike = Union[
-    Sequence[float],
-    "np.ndarray[tuple[()], np.dtype[np.float64]]",
     Tensor,
+    Sequence[float],
 ]
 
 
@@ -116,7 +115,7 @@ class Dimensioned:
         return Dimensioned(
             self.value + other.value,  # type: ignore [arg-type]
             self.dimensions + other.dimensions,
-            f"{self.name} + {other.name}"
+            f"{self.name}+{other.name}"
             if self.name is not None and other.name is not None
             else None,
         )
@@ -128,7 +127,7 @@ class Dimensioned:
         return Dimensioned(
             self.value - other.value,  # type: ignore [arg-type]
             self.dimensions - other.dimensions,
-            f"{self.name} - {other.name}"
+            f"{self.name}-{other.name}"
             if self.name is not None and other.name is not None
             else None,
         )
@@ -140,7 +139,7 @@ class Dimensioned:
         return Dimensioned(
             self.value * other.value,  # type: ignore [arg-type]
             self.dimensions * other.dimensions,
-            f"{self.name} * {other.name}"
+            f"{self.name}*{other.name}"
             if self.name is not None and other.name is not None
             else None,
         )
@@ -152,7 +151,7 @@ class Dimensioned:
         return Dimensioned(
             self.value / other.value,  # type: ignore [arg-type]
             self.dimensions / other.dimensions,
-            f"{self.name} / {other.name}"
+            f"{self.name}/{other.name}"
             if self.name is not None and other.name is not None
             else None,
         )
@@ -164,7 +163,7 @@ class Dimensioned:
         return Dimensioned(
             self.value**exponent,  # type: ignore [arg-type]
             self.dimensions**exponent,
-            f"{self.name} ** {exponent}" if self.name is not None else None,
+            f"pow({self.name},{exponent})" if self.name is not None else None,
         )
 
     def __float__(self) -> float:
@@ -194,10 +193,9 @@ Field = Union[
 ]
 
 FieldLike = Union[
+    Field,
     TensorLike,
     Sequence[TensorLike],
-    Sequence[Sequence[TensorLike]],
-    Field,
 ]
 
 
@@ -208,34 +206,35 @@ Data = Union[
     bool,
     Dimensioned,
     DimensionSet,
-    Sequence["Entry"],
+    Tuple["Data", ...],
+    List[Union["Data", Tuple["Data", Union["Data", "SubDict"]]]],
     Field,
 ]
 
-Entry = Union[
+DataLike = Union[
     Data,
-    Mapping[str, "Entry"],
+    Tuple["DataLike", ...],
+    Sequence[Union["DataLike", Tuple["DataLike", Union["DataLike", "SubDictLike"]]]],
+    FieldLike,
 ]
-"""
-A value that can be stored in an OpenFOAM file.
-"""
 
-DataLike = Union[
-    FieldLike,
-    Sequence["EntryLike"],
+StandaloneData = Union[
     Data,
+    "np.ndarray[tuple[int], np.dtype[np.int64 | np.int32]]",
+    "np.ndarray[tuple[int], np.dtype[np.float64 | np.float32]]",
 ]
 
-EntryLike = Union[
+StandaloneDataLike = Union[
     DataLike,
-    Mapping[str, "EntryLike"],
+    "np.ndarray[tuple[int], np.dtype[np.int64 | np.int32]]",
+    "np.ndarray[tuple[int], np.dtype[np.float64 | np.float32]]",
 ]
 
 
 def is_sequence(
-    value: EntryLike,
+    value: DataLike | StandaloneDataLike | SubDictLike,
 ) -> TypeGuard[
-    Sequence[EntryLike]
+    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 (
@@ -243,10 +242,9 @@ def is_sequence(
     )
 
 
-MutableEntry = Union[
-    Data,
-    MutableMapping[str, "MutableEntry"],
-]
+SubDict = Dict[str, Union[Data, "SubDict"]]
+SubDictLike = Mapping[str, Union[DataLike, "SubDictLike"]]
+MutableSubDict = MutableMapping[str, Union[Data, "MutableSubDict"]]
 
-Dict_ = Dict[str, Union["Entry", "Dict_"]]
-File = Dict[Optional[str], Union["Entry", "Dict_"]]
+File = Dict[Optional[str], Union[StandaloneData, Data, "SubDict"]]
+FileLike = Mapping[Optional[str], Union[StandaloneDataLike, DataLike, "FileLike"]]

{foamlib-0.9.3 → 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.3 → 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.3 → foamlib-0.9.4}/tests/test_files/test_files.py

@@ -161,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.3 → 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.3 → 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.3 → foamlib-0.9.4}/tests/test_files/test_types.py

@@ -30,27 +30,27 @@ def test_dimensioned() -> None:
     result = dimensioned + dimensioned
     assert result.value == 9.81 * 2
     assert result.dimensions == FoamFile.DimensionSet(length=1, time=-2)
-    assert result.name == "g + g"
+    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"
+    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"
+    assert result.name == "g*g"
 
     result = dimensioned / dimensioned
     assert result.value == 1.0
     assert result.dimensions == FoamFile.DimensionSet()
-    assert result.name == "g / g"
+    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 == "g ** 2"
+    assert result.name == "pow(g,2)"
 
     with pytest.raises(ValueError, match="dimension"):
         dimensioned + 1