foamlib 0.8.11__tar.gz → 0.9.1__tar.gz

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

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

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

{foamlib-0.8.11 → foamlib-0.9.1}/foamlib/_files/_parsing.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import re
 import sys
-from typing import Tuple, Union, cast
+from typing import TYPE_CHECKING, Tuple, Union, cast
 
 if sys.version_info >= (3, 9):
     from collections.abc import Iterator, Mapping, MutableMapping, Sequence
@@ -25,6 +25,7 @@ from pyparsing import (
     LineEnd,
     Literal,
     Located,
+    NoMatch,
     Opt,
     ParserElement,
     ParseResults,
@@ -37,131 +38,172 @@ from pyparsing import (
     printables,
 )
 
-from ._types import Data, Dimensioned, DimensionSet, File, TensorKind
+from ._types import Data, Dimensioned, DimensionSet, File
 
+if TYPE_CHECKING:
+    from numpy.typing import DTypeLike
 
-def _tensor(tensor_kind: TensorKind, *, ignore: Regex | None = None) -> Regex:
-    float_pattern = r"(?i:[+-]?(?:(?:\d+\.?\d*(?:e[+-]?\d+)?)|nan|inf(?:inity)?))"
 
-    if tensor_kind == TensorKind.SCALAR:
-        ret = Regex(float_pattern)
-        ret.add_parse_action(lambda tks: [float(tks[0])])
-        return ret
-
-    ignore_pattern = rf"(?:\s|{ignore.re.pattern})+" if ignore is not None else r"\s+"
+def _ascii_numeric_list(
+    dtype: DTypeLike,
+    *,
+    nested: int | None = None,
+    ignore: Regex | None = None,
+    empty_ok: bool = False,
+) -> ParserElement:
+    dtype = np.dtype(dtype)
+
+    if np.issubdtype(dtype, np.floating):
+        element = common.ieee_float
+        element_pattern = r"(?i:[+-]?(?:(?:\d+\.?\d*(?:e[+-]?\d+)?)|nan|inf(?:inity)?))"
+    elif np.issubdtype(dtype, np.integer):
+        element = common.integer
+        element_pattern = r"(?:-?\d+)"
+    else:
+        msg = f"Unsupported dtype: {dtype}"
+        raise TypeError(msg)
 
-    ret = Regex(
-        rf"\((?:{ignore_pattern})?(?:{float_pattern}{ignore_pattern}){{{tensor_kind.size - 1}}}{float_pattern}(?:{ignore_pattern})?\)"
+    spacing_pattern = (
+        rf"(?:(?:\s|{ignore.re.pattern})+)" if ignore is not None else r"(?:\s+)"
     )
-    ret.add_parse_action(
-        lambda tks: np.fromstring(
-            re.sub(ignore.re, " ", tks[0][1:-1])
-            if ignore is not None
-            else tks[0][1:-1],
-            sep=" ",
+
+    if nested is not None:
+        element = (
+            Literal("(").suppress() + Group(element[nested]) + Literal(")").suppress()
         )
-    )
-    return ret
+        element_pattern = rf"(?:{spacing_pattern}?\({element_pattern}?(?:{element_pattern}{spacing_pattern}){{{nested - 1}}}{element_pattern}{spacing_pattern}?\))"
 
+    list_ = Forward()
 
-def _list_of(entry: ParserElement) -> ParserElement:
-    return Opt(
-        Literal("List") + Literal("<") + _IDENTIFIER + Literal(">")
-    ).suppress() + (
-        (
-            counted_array(entry, common.integer + Literal("(").suppress())
-            + Literal(")").suppress()
-        ).set_parse_action(lambda tks: [tks.as_list()])
-        | (
-            Literal("(").suppress()
-            + Group((entry)[...], aslist=True)
-            + Literal(")").suppress()
+    def process_count(tks: ParseResults) -> None:
+        nonlocal list_
+
+        if not tks:
+            count = None
+        else:
+            (count,) = tks
+            assert isinstance(count, int)
+
+        if count is None:
+            if not empty_ok:
+                list_pattern = rf"\({spacing_pattern}?(?:{element_pattern}{spacing_pattern})*{element_pattern}{spacing_pattern}?\)"
+            else:
+                list_pattern = rf"\({spacing_pattern}?(?:{element_pattern}{spacing_pattern})*{element_pattern}?{spacing_pattern}?\)"
+
+        elif count == 0:
+            if not empty_ok:
+                list_ <<= NoMatch()
+            else:
+                list_ <<= (Literal("(") + Literal(")")).add_parse_action(
+                    lambda: np.empty((0, nested) if nested else 0, dtype=dtype)
+                )
+            return
+
+        else:
+            list_pattern = rf"\({spacing_pattern}?(?:{element_pattern}{spacing_pattern}){{{count - 1}}}{element_pattern}{spacing_pattern}?\)"
+
+        list_ <<= Regex(list_pattern).add_parse_action(
+            lambda tks: to_array(tks, dtype=dtype)
         )
-        | (
-            common.integer + Literal("{").suppress() + entry + Literal("}").suppress()
-        ).set_parse_action(lambda tks: [[tks[1]] * tks[0]])
-    )
 
+    def to_array(
+        tks: ParseResults, *, dtype: DTypeLike
+    ) -> np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.integer | np.floating]]:
+        (s,) = tks
+        assert s.startswith("(")
+        assert s.endswith(")")
+        s = s[1:-1]
+        if ignore is not None:
+            s = re.sub(ignore.re, " ", s)
+        if nested is not None:
+            s = s.replace("(", " ").replace(")", " ")
+
+        ret: np.ndarray[
+            tuple[int] | tuple[int, int], np.dtype[np.integer | np.floating]
+        ] = np.fromstring(s, sep=" ", dtype=dtype)  # type: ignore[assignment]
+
+        if nested is not None:
+            ret = ret.reshape(-1, nested)
 
-def _parse_ascii_field(
-    s: str, tensor_kind: TensorKind, *, ignore: Regex | None
-) -> np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.float64]]:
-    if ignore is not None:
-        s = re.sub(ignore.re, " ", s)
-    s = s.replace("(", " ").replace(")", " ")
+        return ret
+
+    def to_full_array(
+        tks: ParseResults, *, dtype: type
+    ) -> np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.integer | np.floating]]:
+        count, lst = tks
+        assert isinstance(count, int)
 
-    return np.fromstring(s, sep=" ").reshape(-1, *tensor_kind.shape)  # type: ignore [return-value]
+        if nested is None:
+            return np.full(count, lst, dtype=dtype)
 
+        return np.full((count, nested), lst, dtype=dtype)  # type: ignore[return-value]
 
-def _unpack_binary_field(
-    b: bytes, tensor_kind: TensorKind, *, length: int
-) -> np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.float64 | np.float32]]:
-    float_size = len(b) / tensor_kind.size / length
-    assert float_size in (4, 8)
+    ret = ((Opt(common.integer).add_parse_action(process_count)).suppress() + list_) | (
+        common.integer + Literal("{").suppress() + element + Literal("}").suppress()
+    ).add_parse_action(lambda tks: to_full_array(tks, dtype=float))
+
+    if ignore is not None:
+        ret.ignore(ignore)
 
-    dtype = np.float32 if float_size == 4 else float
-    return np.frombuffer(b, dtype=dtype).reshape(-1, *tensor_kind.shape)  # type: ignore [return-value]
+    return ret
 
 
-def _tensor_list(
-    tensor_kind: TensorKind, *, ignore: Regex | None = None
+def _binary_numeric_list(
+    dtype: DTypeLike, *, nested: int | None = None, empty_ok: bool = False
 ) -> ParserElement:
-    tensor = _tensor(tensor_kind, ignore=ignore)
-    ignore_pattern = rf"(?:\s|{ignore.re.pattern})+" if ignore is not None else r"\s+"
+    dtype = np.dtype(dtype)
 
-    list_ = Forward()
+    elsize = nested if nested is not None else 1
 
-    list_ <<= Regex(
-        rf"\((?:{ignore_pattern})?(?:{tensor.re.pattern}{ignore_pattern})*{tensor.re.pattern}(?:{ignore_pattern})?\)"
-    ).add_parse_action(
-        lambda tks: [_parse_ascii_field(tks[0], tensor_kind, ignore=ignore)]
-    ) | (
-        (Literal("(") + Literal(")"))
-        .suppress()
-        .add_parse_action(lambda: np.array([]).reshape(0, *tensor_kind.shape))
-    )
+    list_ = Forward()
 
-    def count_parse_action(tks: ParseResults) -> None:
+    def process_count(tks: ParseResults) -> None:
         nonlocal list_
-        length = tks[0]
-        assert isinstance(length, int)
-
-        if not length:
-            list_ <<= (
-                ((Literal("(") + Literal(")")) | (Literal("{") + Literal("}")))
-                .suppress()
-                .add_parse_action(lambda: np.array([]).reshape(0, *tensor_kind.shape))
-            )
+        (size,) = tks
+        assert isinstance(size, int)
+
+        if size == 0 and not empty_ok:
+            list_ <<= NoMatch()
             return
 
-        list_ <<= (
-            Regex(
-                rf"\((?:{ignore_pattern})?(?:{tensor.re.pattern}{ignore_pattern}){{{length - 1}}}{tensor.re.pattern}(?:{ignore_pattern})?\)"
-            ).add_parse_action(
-                lambda tks: [_parse_ascii_field(tks[0], tensor_kind, ignore=ignore)]
-            )
-            | Regex(
-                rf"\((?s:({'.' * 8 * tensor_kind.size}|{'.' * 4 * tensor_kind.size}){{{length}}})\)"
-            ).add_parse_action(
-                lambda tks: [
-                    _unpack_binary_field(
-                        tks[0][1:-1].encode("latin-1"), tensor_kind, length=length
-                    )
-                ]
-            )
-            | (
-                Literal("{").suppress() + tensor + Literal("}").suppress()
-            ).add_parse_action(
-                lambda tks: [np.full((length, *tensor_kind.shape), tks[0], dtype=float)]
-            )
-        )
+        list_ <<= Regex(rf"\((?s:{'.' * dtype.itemsize * elsize}){{{size}}}\)")
 
-    count = common.integer.copy().add_parse_action(count_parse_action)
+    def to_array(
+        tks: ParseResults,
+    ) -> np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.integer | np.floating]]:
+        size, s = tks
+        assert isinstance(size, int)
+        assert isinstance(s, str)
+        assert s[0] == "("
+        assert s[-1] == ")"
+        s = s[1:-1]
+
+        ret = np.frombuffer(s.encode("latin-1"), dtype=dtype)
+
+        if nested is not None:
+            ret = ret.reshape(-1, nested)
+
+        return ret  # type: ignore[return-value]
 
     return (
-        Opt(Literal("List") + Literal("<") + str(tensor_kind) + Literal(">")).suppress()
-        + Opt(count).suppress()
-        + list_
+        common.integer.copy().add_parse_action(process_count) + list_
+    ).add_parse_action(to_array)
+
+
+def _list_of(entry: ParserElement) -> ParserElement:
+    return (
+        (
+            counted_array(entry, common.integer + Literal("(").suppress())
+            + Literal(")").suppress()
+        ).set_parse_action(lambda tks: [tks.as_list()])
+        | (
+            Literal("(").suppress()
+            + Group((entry)[...], aslist=True)
+            + Literal(")").suppress()
+        )
+        | (
+            common.integer + Literal("{").suppress() + entry + Literal("}").suppress()
+        ).set_parse_action(lambda tks: [[tks[1]] * tks[0]])
     )
 
 
@@ -250,12 +292,11 @@ _SWITCH = (
 _DIMENSIONS = (
     Literal("[").suppress() + common.number[0, 7] + Literal("]").suppress()
 ).set_parse_action(lambda tks: DimensionSet(*tks))
-_TENSOR = (
-    _tensor(TensorKind.SCALAR)
-    | _tensor(TensorKind.VECTOR)
-    | _tensor(TensorKind.SYMM_TENSOR)
-    | _tensor(TensorKind.TENSOR)
-)
+_TENSOR = common.ieee_float | (
+    Literal("(").suppress()
+    + Group(common.ieee_float[3] | common.ieee_float[6] | common.ieee_float[9])
+    + Literal(")").suppress()
+).add_parse_action(lambda tks: np.array(tks[0], dtype=float))
 _PARENTHESIZED = Forward()
 _IDENTIFIER = Combine(Word(_IDENTCHARS, _IDENTBODYCHARS) + Opt(_PARENTHESIZED))
 _PARENTHESIZED <<= Combine(
@@ -270,12 +311,55 @@ _DIMENSIONED = (Opt(_IDENTIFIER) + _DIMENSIONS + _TENSOR).set_parse_action(
 _FIELD = (Keyword("uniform", _IDENTBODYCHARS).suppress() + _TENSOR) | (
     Keyword("nonuniform", _IDENTBODYCHARS).suppress()
     + (
-        _tensor_list(TensorKind.SCALAR, ignore=_COMMENT)
-        | _tensor_list(TensorKind.VECTOR, ignore=_COMMENT)
-        | _tensor_list(TensorKind.SYMM_TENSOR, ignore=_COMMENT)
-        | _tensor_list(TensorKind.TENSOR, ignore=_COMMENT)
+        (
+            Opt(
+                Literal("List") + Literal("<") + Literal("scalar") + Literal(">")
+            ).suppress()
+            + (
+                _ascii_numeric_list(dtype=float, ignore=_COMMENT, empty_ok=True)
+                | _binary_numeric_list(dtype=np.float64, empty_ok=True)
+                | _binary_numeric_list(dtype=np.float32, empty_ok=True)
+            )
+        )
+        | (
+            Opt(
+                Literal("List") + Literal("<") + Literal("vector") + Literal(">")
+            ).suppress()
+            + (
+                _ascii_numeric_list(
+                    dtype=float, nested=3, ignore=_COMMENT, empty_ok=True
+                )
+                | _binary_numeric_list(np.float64, nested=3, empty_ok=True)
+                | _binary_numeric_list(np.float32, nested=3, empty_ok=True)
+            )
+        )
+        | (
+            Opt(
+                Literal("List") + Literal("<") + Literal("symmTensor") + Literal(">")
+            ).suppress()
+            + (
+                _ascii_numeric_list(
+                    dtype=float, nested=6, ignore=_COMMENT, empty_ok=True
+                )
+                | _binary_numeric_list(np.float64, nested=6, empty_ok=True)
+                | _binary_numeric_list(np.float32, nested=6, empty_ok=True)
+            )
+        )
+        | (
+            Opt(
+                Literal("List") + Literal("<") + Literal("tensor") + Literal(">")
+            ).suppress()
+            + (
+                _ascii_numeric_list(
+                    dtype=float, nested=9, ignore=_COMMENT, empty_ok=True
+                )
+                | _binary_numeric_list(np.float64, nested=9, empty_ok=True)
+                | _binary_numeric_list(np.float32, nested=9, empty_ok=True)
+            )
+        )
     )
 )
+
 _DIRECTIVE = Word("#", _IDENTBODYCHARS)
 _TOKEN = dbl_quoted_string | _DIRECTIVE | _IDENTIFIER
 _DATA = Forward()
@@ -319,7 +403,19 @@ _LOCATED_DICTIONARY = Group(
         located=True,
     )
 )[...]
-_LOCATED_DATA = Group(Located(_DATA.copy().add_parse_action(lambda tks: ["", tks[0]])))
+_LOCATED_DATA = Group(
+    Located(
+        (
+            _ascii_numeric_list(dtype=int, ignore=_COMMENT)
+            | _binary_numeric_list(dtype=np.int64)
+            | _binary_numeric_list(dtype=np.int32)
+            | _ascii_numeric_list(dtype=float, nested=3, ignore=_COMMENT)
+            | _binary_numeric_list(dtype=np.float64, nested=3)
+            | _binary_numeric_list(dtype=np.float32, nested=3)
+            | _DATA
+        ).add_parse_action(lambda tks: ["", tks[0]])
+    )
+)
 
 _FILE = (
     Dict(_LOCATED_DICTIONARY + Opt(_LOCATED_DATA) + _LOCATED_DICTIONARY)

{foamlib-0.8.11 → foamlib-0.9.1}/foamlib/_files/_types.py

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

{foamlib-0.8.11 → foamlib-0.9.1}/tests/test_files/test_files.py

@@ -3,9 +3,9 @@ import sys
 from pathlib import Path
 
 if sys.version_info >= (3, 9):
-    from collections.abc import Generator, Sequence
+    from collections.abc import Generator
 else:
-    from typing import Generator, Sequence
+    from typing import Generator
 
 import numpy as np
 import pytest
@@ -153,16 +153,15 @@ def test_mesh(cavity: FoamCase) -> None:
 
     points = file[None]
 
-    assert isinstance(points, Sequence)
-    assert isinstance(points[0], Sequence)
-    assert len(points[0]) == 3
+    assert isinstance(points, np.ndarray)
+    assert points.ndim == 2
+    assert points.shape[-1] == 3
 
 
 def test_internal_field(cavity: FoamCase) -> None:
     blocks = cavity.block_mesh_dict["blocks"]
     assert isinstance(blocks, list)
     sizes = blocks[2]
-    assert isinstance(sizes, list)
     size = np.prod(sizes)
 
     p_arr = np.zeros(size)

{foamlib-0.8.11 → foamlib-0.9.1}/tests/test_files/test_parsing/test_advanced.py

@@ -1,5 +1,6 @@
 # Based on https://foss.heptapod.net/fluiddyn/fluidsimfoam/-/blob/branch/default/tests/test_parser_advanced.py
 
+import numpy as np
 import pytest
 from foamlib._files._parsing import Parsed
 
@@ -276,9 +277,10 @@ def test_assignment_strange_name() -> None:
     """
     )
     assert parsed[("equations", '"(U|e|k).*"')] == 0.7
-    assert parsed[("equations", '"(U|e|k|epsilon).*"')] == (
-        "table",
-        [[0, 0.4], [0.5, 0.7]],
+    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]]
     )
 
 
@@ -331,17 +333,23 @@ def test_list_u() -> None:
         )
         """
     )
-    assert parsed[()] == [
-        [4.50773, 1.79963, 0.0],
-        [6.06208, 2.40831, 0.0],
-        [6.874, 2.72079, 0.0],
-        [7.42929, 2.931, 0.0],
-        [7.85095, 3.08805, 0.0],
-        [8.19202, 3.21306, 0.0],
-        [17.5, 1.92559e-09, 0.0],
-        [17.5, 6.81045e-12, 0.0],
-        [17.5, 6.81045e-12, 0.0],
-    ]
+    data = parsed[()]
+    assert isinstance(data, np.ndarray)
+    assert data.shape == (9, 3)
+    assert np.array_equal(
+        data,
+        [
+            [4.507730000e00, 1.799630000e00, 0.000000000e00],
+            [6.062080000e00, 2.408310000e00, 0.000000000e00],
+            [6.874000000e00, 2.720790000e00, 0.000000000e00],
+            [7.429290000e00, 2.931000000e00, 0.000000000e00],
+            [7.850950000e00, 3.088050000e00, 0.000000000e00],
+            [8.192020000e00, 3.213060000e00, 0.000000000e00],
+            [1.750000000e01, 1.925590000e-09, 0.000000000e00],
+            [1.750000000e01, 6.810450000e-12, 0.000000000e00],
+            [1.750000000e01, 6.810450000e-12, 0.000000000e00],
+        ],
+    )
 
 
 def test_list_as_write_cell_centers() -> None:

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

@@ -1,6 +1,7 @@
 import numpy as np
 from foamlib import FoamFile
 from foamlib._files._parsing import Parsed
+from foamlib._files._types import is_sequence
 
 
 def test_parse_value() -> None:
@@ -16,7 +17,12 @@ def test_parse_value() -> None:
     assert Parsed(b"uniform 1")[()] == 1
     assert Parsed(b"uniform 1.0")[()] == 1.0
     assert Parsed(b"uniform 1.0e-3")[()] == 1.0e-3
-    assert Parsed(b"(1.0 2.0 3.0)")[()] == [1.0, 2.0, 3.0]
+    assert Parsed(b"(word word)")[()] == ["word", "word"]
+    lst = Parsed(b"(1 2 3)")[()]
+    assert np.array_equal(lst, [1, 2, 3])  # type: ignore[arg-type]
+    lst = Parsed(b"(1.0 2 3)")[()]
+    assert np.array_equal(lst, [1.0, 2.0, 3.0])  # type: ignore[arg-type]
+    assert Parsed(b"()")[()] == []
     field = Parsed(b"uniform (1 2 3)")[()]
     assert isinstance(field, np.ndarray)
     assert np.array_equal(field, [1, 2, 3])
@@ -32,15 +38,28 @@ def test_parse_value() -> None:
     field = Parsed(b"nonuniform List<tensor> ()")[()]
     assert isinstance(field, np.ndarray)
     assert field.shape == (0, 9)
-    assert Parsed(b"3(1 2 3)")[()] == [1, 2, 3]
-    assert Parsed(b"2((1 2 3) (4 5 6))")[()] == [
-        [1, 2, 3],
-        [4, 5, 6],
-    ]
-    assert Parsed(b"2{(1 2 3)}")[()] == [
-        [1, 2, 3],
-        [1, 2, 3],
-    ]
+    lst = Parsed(b"3(1 2 3)")[()]
+    assert isinstance(lst, np.ndarray)
+    assert np.array_equal(lst, [1, 2, 3])
+    lst = Parsed(b"2((1 2 3) (4 5 6))")[()]
+    assert isinstance(lst, np.ndarray)
+    assert np.array_equal(
+        lst,
+        [
+            [1, 2, 3],
+            [4, 5, 6],
+        ],
+    )
+    lst = Parsed(b"2{(1 2 3)}")[()]
+    assert isinstance(lst, np.ndarray)
+    assert np.array_equal(
+        lst,
+        [
+            [1, 2, 3],
+            [1, 2, 3],
+        ],
+    )
+    assert Parsed(b"0()")[()] == []
     field = Parsed(b"nonuniform List<vector> 2((1 2 3) (4 5 6))")[()]
     assert isinstance(field, np.ndarray)
     assert np.array_equal(
@@ -83,19 +102,23 @@ def test_parse_value() -> None:
     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
     )
-    assert Parsed(b"hex (0 1 2 3 4 5 6 7) (1 1 1) simpleGrading (1 1 1)")[()] == (
-        "hex",
-        [0, 1, 2, 3, 4, 5, 6, 7],
-        [1, 1, 1],
-        "simpleGrading",
-        [1, 1, 1],
-    )
+    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
+    assert tpl[0] == "hex"
+    assert is_sequence(tpl[1])
+    assert np.array_equal(tpl[1], [0, 1, 2, 3, 4, 5, 6, 7])  # type: ignore[arg-type]
+    assert is_sequence(tpl[2])
+    assert np.array_equal(tpl[2], [1, 1, 1])  # type: ignore[arg-type]
+    assert tpl[3] == "simpleGrading"
+    assert is_sequence(tpl[4])
+    assert np.array_equal(tpl[4], [1, 1, 1])  # type: ignore[arg-type]
     assert Parsed(b"(a b; c d;)")[()] == [("a", "b"), ("c", "d")]
     assert Parsed(b"(a {b c;} d {e g;})")[()] == [
         ("a", {"b": "c"}),
         ("d", {"e": "g"}),
     ]
-    assert Parsed(b"(a (0 1 2); b {})")[()] == [("a", [0, 1, 2]), ("b", {})]
+    assert Parsed(b"(a (b c d); e {})")[()] == [("a", ["b", "c", "d"]), ("e", {})]
     assert Parsed(b"({a b; c d;} {e g;})")[()] == [{"a": "b", "c": "d"}, {"e": "g"}]
     assert Parsed(b"(water oil mercury air)")[()] == ["water", "oil", "mercury", "air"]
     assert Parsed(b"div(phi,U)")[()] == "div(phi,U)"

{foamlib-0.8.11 → foamlib-0.9.1}/tests/test_files/test_parsing/test_decompose_par.py

@@ -3,6 +3,7 @@
 from pathlib import Path
 from textwrap import dedent
 
+import numpy as np
 from foamlib import FoamFile
 
 
@@ -43,7 +44,7 @@ def test_simple(tmp_path: Path) -> None:
 
     assert decompose_par_dict["numberOfSubdomains"] == 8
     assert decompose_par_dict["method"] == "simple"
-    assert decompose_par_dict["coeffs", "n"] == [4, 2, 1]
+    assert np.array_equal(decompose_par_dict["coeffs", "n"], [4, 2, 1])  # type: ignore[arg-type]
     assert decompose_par_dict["coeffs", "order"] == "xyz"
     assert decompose_par_dict["coeffs", "delta"] == 0.001
 

{foamlib-0.8.11 → foamlib-0.9.1}/tests/test_files/test_parsing/test_intermediate.py

@@ -1,5 +1,6 @@
 # Based on https://foss.heptapod.net/fluiddyn/fluidsimfoam/-/blob/branch/default/tests/test_parser.py
 
+import numpy as np
 import pytest
 from foamlib import FoamFile
 from foamlib._files._parsing import Parsed
@@ -61,20 +62,18 @@ def test_strange_names() -> None:
 
 
 def test_list_simple() -> None:
-    assert Parsed(b"""
+    faces = Parsed(b"""
         faces
         (
             (1 5 4 0)
             (2 3 4 5)
         );
-    """)[("faces",)] == [
-        [1, 5, 4, 0],
-        [2, 3, 4, 5],
-    ]
+    """)[("faces",)]
+    assert np.array_equal(faces, [[1, 5, 4, 0], [2, 3, 4, 5]])  # type: ignore[arg-type]
 
 
 def test_list_assignment() -> None:
-    assert Parsed(b"""
+    faces = Parsed(b"""
         faces
         (
             1
@@ -82,7 +81,8 @@ def test_list_assignment() -> None:
             4
             0
         );
-    """)[("faces",)] == [1, 5, 4, 0]
+    """)[("faces",)]
+    assert np.array_equal(faces, [1, 5, 4, 0])  # type: ignore[arg-type]
 
 
 def test_dict_simple() -> None:
@@ -135,11 +135,11 @@ def test_dict_with_list() -> None:
             pRefValue                   0;
         }
     """)
-    assert parsed[("PISO", "pRefPoint")] == [0, 0, 0]
+    assert np.array_equal(parsed[("PISO", "pRefPoint")], [0, 0, 0])  # type: ignore[arg-type]
 
 
 def test_list_with_dict() -> None:
-    assert Parsed(b"""
+    boundary = Parsed(b"""
         boundary
         (
             upperBoundary
@@ -152,33 +152,32 @@ def test_list_with_dict() -> None:
                 );
             }
         );
-    """)[("boundary",)] == [
-        (
-            "upperBoundary",
-            {
-                "type": "cyclic",
-                "neighbourPatch": "lowerBoundary",
-                "faces": [
-                    [3, 7, 6, 2],
-                ],
-            },
-        ),
-    ]
+    """)[("boundary",)]
+    assert isinstance(boundary, list)
+    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]])
 
 
 def test_list_with_str() -> None:
-    assert Parsed(b"""
+    blocks = Parsed(b"""
         blocks
         (
             hex (0 1 2 3 4 5 6 7) (40 40 40) simpleGrading (1 1 1)
         );
-    """)[("blocks",)] == [
-        "hex",
-        [0, 1, 2, 3, 4, 5, 6, 7],
-        [40, 40, 40],
-        "simpleGrading",
-        [1, 1, 1],
-    ]
+    """)[("blocks",)]
+    assert isinstance(blocks, list)
+    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 blocks[3] == "simpleGrading"
+    assert np.array_equal(blocks[4], [1, 1, 1])
 
 
 def test_file_simple() -> None:
@@ -230,10 +229,8 @@ def test_file() -> None:
     """)
     assert parsed[("a",)] == 1
     assert parsed[("b",)] == 2
-    assert parsed[("faces",)] == [
-        [1, 5, 4, 0],
-        [2, 3, 4, 5],
-    ]
+    faces = parsed[("faces",)]
+    assert np.array_equal(faces, [[1, 5, 4, 0], [2, 3, 4, 5]])  # type: ignore[arg-type]
     assert parsed[("my_dict", "a")] == 1
 
 
@@ -455,12 +452,14 @@ def test_for_blockmesh() -> None:
         );
     """)
     assert parsed[("negHalfWidth",)] == ("#neg", "$halfWidth")
-    assert parsed[("blocks",)] == [
-        "hex",
-        [4, 6, 14, 12, 0, 2, 10, 8],
-        [1, "$upstreamCells", "$cylinderBoxCells"],
-        "$expandBlock",
-    ]
+    blocks = parsed[("blocks",)]
+    assert isinstance(blocks, list)
+    assert len(blocks) == 4
+
+    assert blocks[0] == "hex"
+    assert np.array_equal(blocks[1], [4, 6, 14, 12, 0, 2, 10, 8])
+    assert blocks[2] == [1, "$upstreamCells", "$cylinderBoxCells"]
+    assert blocks[3] == "$expandBlock"
 
 
 def test_for_u() -> None:
@@ -483,30 +482,32 @@ def test_blocks() -> None:
             hex (16 17 18 19 20 21 22 23) (96 1 72) simpleGrading (1 1 1)
         );
     """)
-    assert parsed[("blocks",)] == [
-        "hex",
-        [0, 1, 2, 3, 4, 5, 6, 7],
-        "inletChannel",
-        [40, 1, 64],
-        "simpleGrading",
-        [1, 1, 1],
-        "hex",
-        [4, 5, 6, 7, 8, 9, 10, 11, 12],
-        "inletChannel",
-        [40, 1, 16],
-        "simpleGrading",
-        [1, 1, 1],
-        "hex",
-        [12, 13, 14, 15, 16, 17, 18, 19],
-        [96, 1, 8],
-        "simpleGrading",
-        [1, 1, 1],
-        "hex",
-        [16, 17, 18, 19, 20, 21, 22, 23],
-        [96, 1, 72],
-        "simpleGrading",
-        [1, 1, 1],
-    ]
+    blocks = parsed[("blocks",)]
+    assert isinstance(blocks, list)
+    assert len(blocks) == 22
+
+    assert blocks[0] == "hex"
+    assert np.array_equal(blocks[1], [0, 1, 2, 3, 4, 5, 6, 7])
+    assert blocks[2] == "inletChannel"
+    assert np.array_equal(blocks[3], [40, 1, 64])
+    assert blocks[4] == "simpleGrading"
+    assert np.array_equal(blocks[5], [1, 1, 1])
+    assert blocks[6] == "hex"
+    assert np.array_equal(blocks[7], [4, 5, 6, 7, 8, 9, 10, 11, 12])
+    assert blocks[8] == "inletChannel"
+    assert np.array_equal(blocks[9], [40, 1, 16])
+    assert blocks[10] == "simpleGrading"
+    assert np.array_equal(blocks[11], [1, 1, 1])
+    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 blocks[15] == "simpleGrading"
+    assert np.array_equal(blocks[16], [1, 1, 1])
+    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 blocks[20] == "simpleGrading"
+    assert np.array_equal(blocks[21], [1, 1, 1])
 
 
 @pytest.mark.xfail(reason="Not currently supported")
@@ -586,10 +587,15 @@ def test_list_edges() -> None:
             spline 6 5 ((0.6 0.0124 0.05) (0.7 0.0395 0.05) (0.8 0.0724 0.05) (0.9 0.132 0.05) (1 0.172 0.05) (1.1 0.132 0.05) (1.2 0.0724 0.05) (1.3 0.0395 0.05) (1.4 0.0124 0.05))
         );
     """)
-    assert parsed[("edges",)] == [
-        "spline",
-        1,
-        2,
+    edges = parsed[("edges",)]
+    assert isinstance(edges, list)
+    assert len(edges) == 8
+
+    assert edges[0] == "spline"
+    assert edges[1] == 1
+    assert edges[2] == 2
+    assert np.array_equal(
+        edges[3],
         [
             [0.6, 0.0124, 0.0],
             [0.7, 0.0395, 0.0],
@@ -601,9 +607,12 @@ def test_list_edges() -> None:
             [1.3, 0.0395, 0.0],
             [1.4, 0.0124, 0.0],
         ],
-        "spline",
-        6,
-        5,
+    )
+    assert edges[4] == "spline"
+    assert edges[5] == 6
+    assert edges[6] == 5
+    assert np.array_equal(
+        edges[7],
         [
             [0.6, 0.0124, 0.05],
             [0.7, 0.0395, 0.05],
@@ -615,7 +624,7 @@ def test_list_edges() -> None:
             [1.3, 0.0395, 0.05],
             [1.4, 0.0124, 0.05],
         ],
-    ]
+    )
 
 
 def test_list_edges_arcs() -> None:
@@ -626,18 +635,19 @@ def test_list_edges_arcs() -> None:
             arc 5 10 origin (0 0 0)
         );
     """)
-    assert parsed[("edges",)] == [
-        "arc",
-        0,
-        5,
-        "origin",
-        [0, 0, 0],
-        "arc",
-        5,
-        10,
-        "origin",
-        [0, 0, 0],
-    ]
+    edges = parsed[("edges",)]
+    assert isinstance(edges, list)
+    assert len(edges) == 10
+    assert edges[0] == "arc"
+    assert edges[1] == 0
+    assert edges[2] == 5
+    assert edges[3] == "origin"
+    assert np.array_equal(edges[4], [0, 0, 0])
+    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])
 
 
 def test_list_blocks() -> None:
@@ -649,23 +659,38 @@ def test_list_blocks() -> None:
             hex (2 3 11 10 5 4 12 13) (225 100 1) simpleGrading (1 ((0.1 0.25 41.9) (0.9 0.75 1)) 1)
         );
     """)
-    assert parsed[("blocks",)] == [
-        "hex",
-        [0, 1, 9, 8, 7, 6, 14, 15],
-        [50, 100, 1],
-        "simpleGrading",
-        [1, [[0.1, 0.25, 41.9], [0.9, 0.75, 1]], 1],
-        "hex",
-        [1, 2, 10, 9, 6, 5, 13, 14],
-        [50, 100, 1],
-        "simpleGrading",
-        [1, [[0.1, 0.25, 41.9], [0.9, 0.75, 1]], 1],
-        "hex",
-        [2, 3, 11, 10, 5, 4, 12, 13],
-        [225, 100, 1],
-        "simpleGrading",
-        [1, [[0.1, 0.25, 41.9], [0.9, 0.75, 1]], 1],
-    ]
+    blocks = parsed[("blocks",)]
+
+    assert isinstance(blocks, list)
+    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 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 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 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 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 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 blocks[14][2] == 1
 
 
 @pytest.mark.xfail(reason="Not currently supported")

{foamlib-0.8.11 → foamlib-0.9.1}/tests/test_files/test_parsing/test_poly_mesh.py

@@ -2,6 +2,7 @@
 
 from pathlib import Path
 
+import numpy as np
 from foamlib import FoamFile
 
 contents = r"""
@@ -49,18 +50,18 @@ def test_get_cells_coords(tmp_path: Path) -> None:
     file = FoamFile(path)
 
     points = file[None]
-    assert isinstance(points, list)
+    assert isinstance(points, np.ndarray)
 
-    assert points[0] == [0, 0, 0]
-    assert points[1] == [0.15707963268, 0, 0]
-    assert points[2] == [0.314159265359, 0, 0]
-    assert points[3] == [0.471238898038, 0, 0]
-    assert points[4] == [0.628318530718, 0, 0]
-    assert points[5] == [0, 0, 0]
-    assert points[6] == [0.15707963268, 0, 0]
-    assert points[7] == [0.314159265359, 0, 0]
-    assert points[8] == [0.471238898038, 0, 0]
-    assert points[9] == [0.628318530718, 0, 0]
+    assert np.array_equal(points[0], [0, 0, 0])
+    assert np.array_equal(points[1], [0.15707963268, 0, 0])
+    assert np.array_equal(points[2], [0.314159265359, 0, 0])
+    assert np.array_equal(points[3], [0.471238898038, 0, 0])
+    assert np.array_equal(points[4], [0.628318530718, 0, 0])
+    assert np.array_equal(points[5], [0, 0, 0])
+    assert np.array_equal(points[6], [0.15707963268, 0, 0])
+    assert np.array_equal(points[7], [0.314159265359, 0, 0])
+    assert np.array_equal(points[8], [0.471238898038, 0, 0])
+    assert np.array_equal(points[9], [0.628318530718, 0, 0])
 
     assert len(points) == 10