foamlib 0.8.10__tar.gz → 0.9.0__tar.gz

{foamlib-0.8.10 → foamlib-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: foamlib
-Version: 0.8.10
+Version: 0.9.0
 Summary: A Python interface for interacting with OpenFOAM
 Project-URL: Homepage, https://github.com/gerlero/foamlib
 Project-URL: Repository, https://github.com/gerlero/foamlib
@@ -30,35 +30,10 @@ Requires-Dist: numpy<3,>=1
 Requires-Dist: pyparsing<4,>=3.1.2
 Requires-Dist: rich<15,>=13
 Requires-Dist: typing-extensions<5,>=4; python_version < '3.11'
-Provides-Extra: dev
-Requires-Dist: mypy<2,>=1; extra == 'dev'
-Requires-Dist: pytest-asyncio<0.27,>=0.21; extra == 'dev'
-Requires-Dist: pytest-cov; extra == 'dev'
-Requires-Dist: pytest<9,>=7; extra == 'dev'
-Requires-Dist: ruff; extra == 'dev'
-Requires-Dist: scipy-stubs; (python_version >= '3.10') and extra == 'dev'
-Requires-Dist: scipy<2,>=1; extra == 'dev'
-Requires-Dist: sphinx-rtd-theme; extra == 'dev'
-Requires-Dist: sphinx<9,>=5; extra == 'dev'
 Provides-Extra: docs
 Requires-Dist: ruff; extra == 'docs'
 Requires-Dist: sphinx-rtd-theme; extra == 'docs'
 Requires-Dist: sphinx<9,>=5; extra == 'docs'
-Provides-Extra: lint
-Requires-Dist: ruff; extra == 'lint'
-Provides-Extra: test
-Requires-Dist: mypy<2,>=1; extra == 'test'
-Requires-Dist: pytest-asyncio<0.27,>=0.21; extra == 'test'
-Requires-Dist: pytest-cov; extra == 'test'
-Requires-Dist: pytest<9,>=7; extra == 'test'
-Requires-Dist: scipy<2,>=1; extra == 'test'
-Provides-Extra: typing
-Requires-Dist: mypy<2,>=1; extra == 'typing'
-Requires-Dist: pytest-asyncio<0.27,>=0.21; extra == 'typing'
-Requires-Dist: pytest-cov; extra == 'typing'
-Requires-Dist: pytest<9,>=7; extra == 'typing'
-Requires-Dist: scipy-stubs; (python_version >= '3.10') and extra == 'typing'
-Requires-Dist: scipy<2,>=1; extra == 'typing'
 Description-Content-Type: text/markdown
 
 [<img alt="foamlib" src="https://github.com/gerlero/foamlib/raw/main/logo.png" height="65">](https://github.com/gerlero/foamlib)

{foamlib-0.8.10 → foamlib-0.9.0}/foamlib/__init__.py

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

{foamlib-0.8.10 → foamlib-0.9.0}/foamlib/_files/_parsing.py

@@ -25,6 +25,7 @@ from pyparsing import (
     LineEnd,
     Literal,
     Located,
+    NoMatch,
     Opt,
     ParserElement,
     ParseResults,
@@ -37,119 +38,194 @@ from pyparsing import (
     printables,
 )
 
-from ._types import Data, Dimensioned, DimensionSet, File, TensorKind
+from ._types import Data, Dimensioned, DimensionSet, File
 
 
-def _tensor(tensor_kind: TensorKind, *, ignore: Regex | None = None) -> Regex:
+def _numeric_list(
+    *, nested: int | None = None, ignore: Regex | None = None, force_float: bool = False
+) -> ParserElement:
+    if not force_float:
+        int_pattern = r"(?:-?\d+)"
     float_pattern = r"(?i:[+-]?(?:(?:\d+\.?\d*(?:e[+-]?\d+)?)|nan|inf(?:inity)?))"
+    spacing_pattern = (
+        rf"(?:(?:\s|{ignore.re.pattern})+)" if ignore is not None else r"\s+"
+    )
 
-    if tensor_kind == TensorKind.SCALAR:
-        ret = Regex(float_pattern)
-        ret.add_parse_action(lambda tks: [float(tks[0])])
-        return ret
+    if nested is None:
+        if not force_float:
+            int_element_pattern = int_pattern
+            int_element = common.integer
+        float_element_pattern = float_pattern
+        float_element = common.ieee_float
+    else:
+        if not force_float:
+            int_element_pattern = rf"(?:(?:{nested})?{spacing_pattern}?\({spacing_pattern}?(?:{int_pattern}{spacing_pattern}){{{nested - 1}}}{int_pattern}{spacing_pattern}?\))"
+            int_element = (
+                Opt(Literal(str(nested))).suppress()
+                + Literal("(").suppress()
+                + Group(common.integer[nested])
+                + Literal(")").suppress()
+            )
+        float_element_pattern = rf"(?:(?:{nested})?{spacing_pattern}?\({spacing_pattern}?(?:{float_pattern}{spacing_pattern}){{{nested - 1}}}{float_pattern}{spacing_pattern}?\))"
+        float_element = (
+            Opt(Literal(str(nested))).suppress()
+            + Literal("(").suppress()
+            + Group(common.ieee_float[nested])
+            + Literal(")").suppress()
+        )
 
-    ignore_pattern = rf"(?:\s|{ignore.re.pattern})+" if ignore is not None else r"\s+"
+    if not force_float:
+        int_list = Forward()
+    float_list = Forward()
 
-    ret = Regex(
-        rf"\((?:{ignore_pattern})?(?:{float_pattern}{ignore_pattern}){{{tensor_kind.size - 1}}}{float_pattern}(?:{ignore_pattern})?\)"
-    )
-    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=" ",
-        )
-    )
-    return ret
+    def process_count(tks: ParseResults) -> None:
+        nonlocal int_list, float_list
 
+        if not tks:
+            count = None
+        else:
+            (count,) = tks
+            assert isinstance(count, int)
 
-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()
+        if count is None:
+            if not force_float:
+                int_list_pattern = rf"\({spacing_pattern}?(?:{int_element_pattern}{spacing_pattern})*{int_element_pattern}{spacing_pattern}?\)"
+                float_list_pattern = rf"\({spacing_pattern}?(?:{float_element_pattern}{spacing_pattern})*{float_element_pattern}{spacing_pattern}?\)"
+            else:
+                float_list_pattern = rf"\({spacing_pattern}?(?:{float_element_pattern}{spacing_pattern})*{float_element_pattern}?{spacing_pattern}?\)"
+
+        elif count == 0:
+            if not force_float:
+                int_list <<= NoMatch()
+                float_list <<= NoMatch()
+            else:
+                float_list <<= (Literal("(") + Literal(")")).add_parse_action(
+                    lambda: np.empty((0, nested) if nested else 0, dtype=float)
+                )
+            return
+
+        else:
+            if not force_float:
+                int_list_pattern = rf"\({spacing_pattern}?(?:{int_element_pattern}{spacing_pattern}){{{count - 1}}}{int_element_pattern}{spacing_pattern}?\)"
+            float_list_pattern = rf"\({spacing_pattern}?(?:{float_element_pattern}{spacing_pattern}){{{count - 1}}}{float_element_pattern}{spacing_pattern}?\)"
+
+        if not force_float:
+            int_list <<= Regex(int_list_pattern).add_parse_action(
+                lambda tks: to_array(tks, dtype=int)
+            )
+        float_list <<= Regex(float_list_pattern).add_parse_action(
+            lambda tks: to_array(tks, dtype=float)
         )
-        | (
-            common.integer + Literal("{").suppress() + entry + Literal("}").suppress()
-        ).set_parse_action(lambda tks: [[tks[1]] * tks[0]])
-    )
 
+    def to_array(
+        tks: ParseResults, *, dtype: type
+    ) -> np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.int64 | np.float64]]:
+        (s,) = tks
+        s = s.replace("(", "").replace(")", "")
 
-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(")", " ")
+        if ignore is not None:
+            s = re.sub(ignore.re, " ", s)
 
-    return np.fromstring(s, sep=" ").reshape(-1, *tensor_kind.shape)  # type: ignore [return-value]
+        ret: np.ndarray[
+            tuple[int] | tuple[int, int], np.dtype[np.int64 | np.float64]
+        ] = np.fromstring(s, sep=" ", dtype=dtype)  # type: ignore[assignment]
 
+        if nested is not None:
+            ret = ret.reshape(-1, nested)
 
-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)
+        return ret
 
-    dtype = np.float32 if float_size == 4 else float
-    return np.frombuffer(b, dtype=dtype).reshape(-1, *tensor_kind.shape)  # type: ignore [return-value]
+    def to_full_array(
+        tks: ParseResults, *, dtype: type
+    ) -> np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.int64 | np.float64]]:
+        count, lst = tks
+        assert isinstance(count, int)
 
+        if nested is None:
+            return np.full(count, lst, dtype=dtype)
 
-def _tensor_list(
-    tensor_kind: TensorKind, *, ignore: Regex | None = None
-) -> ParserElement:
-    tensor = _tensor(tensor_kind, ignore=ignore)
-    ignore_pattern = rf"(?:\s|{ignore.re.pattern})+" if ignore is not None else r"\s+"
+        return np.full((count, nested), lst, dtype=dtype)  # type: ignore[return-value]
 
-    list_ = Forward()
+    count = Opt(common.integer).add_parse_action(process_count)
 
-    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)]
+    ret = count.suppress() + (
+        (int_list | float_list) if not force_float else float_list
     )
 
-    def count_parse_action(tks: ParseResults) -> None:
-        nonlocal list_
-        length = tks[0]
-        assert isinstance(length, int)
+    if not force_float:
+        ret |= (
+            common.integer
+            + Literal("{").suppress()
+            + int_element
+            + Literal("}").suppress()
+        ).add_parse_action(lambda tks: to_full_array(tks, dtype=int))
+    ret |= (
+        common.integer
+        + Literal("{").suppress()
+        + float_element
+        + Literal("}").suppress()
+    ).add_parse_action(lambda tks: to_full_array(tks, dtype=float))
 
-        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)]
-            )
+    if ignore is not None:
+        ret.ignore(ignore)
+
+    return ret
+
+
+def _binary_field(*, nested: int | None = None) -> ParserElement:
+    elsize = nested if nested is not None else 1
+
+    binary_field = Forward()
+
+    def process_count(tks: ParseResults) -> None:
+        nonlocal binary_field
+        (size,) = tks
+        assert isinstance(size, int)
+
+        binary_field <<= Regex(
+            rf"\((?s:({'.' * 8 * elsize}|{'.' * 4 * 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.float64 | np.float32]]:
+        size, s = tks
+        assert isinstance(size, int)
+        assert isinstance(s, str)
+        assert s[0] == "("
+        assert s[-1] == ")"
+        s = s[1:-1]
+
+        float_size = len(s) / elsize / size
+        assert float_size in (4, 8)
+
+        dtype = np.float32 if float_size == 4 else float
+        ret = np.frombuffer(s.encode("latin-1"), dtype=dtype)
+
+        if nested is not None:
+            ret = ret.reshape(-1, nested)
+
+        return ret  # type: ignore[return-value]
 
+    count = common.integer.copy().add_parse_action(process_count)
+
+    return (count + binary_field).add_parse_action(to_array)
+
+
+def _list_of(entry: ParserElement) -> ParserElement:
     return (
-        Opt(Literal("List") + Literal("<") + str(tensor_kind) + Literal(">")).suppress()
-        + Opt(count).suppress()
-        + list_
+        (
+            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]])
     )
 
 
@@ -238,12 +314,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(
@@ -258,12 +333,46 @@ _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()
+            + (_numeric_list(force_float=True, ignore=_COMMENT) | _binary_field())
+        )
+        | (
+            Opt(
+                Literal("List") + Literal("<") + Literal("vector") + Literal(">")
+            ).suppress()
+            + (
+                _numeric_list(nested=3, force_float=True, ignore=_COMMENT)
+                | _binary_field(nested=3)
+            )
+        )
+        | (
+            Opt(
+                Literal("List") + Literal("<") + Literal("symmTensor") + Literal(">")
+            ).suppress()
+            + (
+                _numeric_list(
+                    nested=6,
+                    force_float=True,
+                    ignore=_COMMENT,
+                )
+                | _binary_field(nested=6)
+            )
+        )
+        | (
+            Opt(
+                Literal("List") + Literal("<") + Literal("tensor") + Literal(">")
+            ).suppress()
+            + (
+                _numeric_list(nested=9, force_float=True, ignore=_COMMENT)
+                | _binary_field(nested=9)
+            )
+        )
     )
 )
+
 _DIRECTIVE = Word("#", _IDENTBODYCHARS)
 _TOKEN = dbl_quoted_string | _DIRECTIVE | _IDENTIFIER
 _DATA = Forward()
@@ -271,7 +380,12 @@ _KEYWORD_ENTRY = _keyword_entry_of(_TOKEN | _list_of(_IDENTIFIER), _DATA)
 _DICT = _dict_of(_TOKEN, _DATA)
 _DATA_ENTRY = Forward()
 _LIST_ENTRY = _DICT | _KEYWORD_ENTRY | _DATA_ENTRY
-_LIST = _list_of(_LIST_ENTRY)
+_LIST = (
+    _numeric_list(ignore=_COMMENT)
+    | _numeric_list(nested=3, ignore=_COMMENT)
+    | _numeric_list(nested=4, ignore=_COMMENT)
+    | _list_of(_LIST_ENTRY)
+)
 _NUMBER = (
     common.number
     | CaselessKeyword("nan").set_parse_action(lambda: np.nan)

{foamlib-0.8.10 → foamlib-0.9.0}/pyproject.toml

@@ -39,36 +39,34 @@ dependencies = [
 dynamic = ["version"]
 
 [dependency-groups]
-dev = ["foamlib[dev]"]
-lint = ["foamlib[lint]"]
-test = ["foamlib[test]"]
-typing = ["foamlib[typing]"]
-docs = ["foamlib[docs]"]
-
-[project.optional-dependencies]
 lint = ["ruff"]
-test = [
+typing = [
     "mypy>=1,<2",
+    "scipy-stubs; python_version>='3.10'",
+]
+test = [
     "pytest>=7,<9",
     "pytest-asyncio>=0.21,<0.27",
     "pytest-cov",
     "scipy>=1,<2",
 ]
-typing = [
-    "foamlib[test]",
-    "mypy>=1,<2",
-    "scipy-stubs; python_version>='3.10'",
-]
 docs = [
     "ruff",
     "sphinx>=5,<9",
     "sphinx_rtd_theme",
 ]
 dev = [
-    "foamlib[lint]",
-    "foamlib[test]",
-    "foamlib[typing]",
-    "foamlib[docs]",
+    {include-group = "lint"},
+    {include-group = "typing"},
+    {include-group = "test"},
+    {include-group = "docs"},
+]
+
+[project.optional-dependencies]
+docs = [
+    "ruff",
+    "sphinx>=5,<9",
+    "sphinx_rtd_theme",
 ]
 
 [project.urls]
@@ -80,7 +78,10 @@ Documentation = "https://foamlib.readthedocs.io"
 path = "foamlib/__init__.py"
 
 [tool.mypy]
-packages = ["foamlib"]
+packages = [
+    "foamlib",
+    "tests",
+]
 strict = true
 
 [tool.ruff.lint]

{foamlib-0.8.10 → foamlib-0.9.0}/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,16 @@ 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)
+    assert isinstance(sizes, np.ndarray)
     size = np.prod(sizes)
 
     p_arr = np.zeros(size)

{foamlib-0.8.10 → foamlib-0.9.0}/tests/test_files/test_parsing/test_advanced.py

@@ -17,10 +17,10 @@ def test_dict_strange_name() -> None:
     """
     )
     assert parsed[
-        (("div(phi,ft_b_ha_hau)", "Gauss", "multivariateSelection"), "ft")
+        (("div(phi,ft_b_ha_hau)", "Gauss", "multivariateSelection"), "ft")  # type: ignore[index]
     ] == ("limitedLinear01", 1)
     assert parsed[
-        (("div(phi,ft_b_ha_hau)", "Gauss", "multivariateSelection"), "b")
+        (("div(phi,ft_b_ha_hau)", "Gauss", "multivariateSelection"), "b")  # type: ignore[index]
     ] == ("limitedLinear01", 1)
 
 
@@ -263,7 +263,7 @@ def test_list_triple_named() -> None:
         """
     )
     assert parsed[("velocity-inlet-5", "type")] == "fixedValue"
-    assert np.allclose(parsed[("velocity-inlet-5", "value")], [1, 0, 0])
+    assert parsed[("velocity-inlet-5", "value")] == pytest.approx([1, 0, 0])
 
 
 def test_assignment_strange_name() -> None:
@@ -277,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]]
     )
 
 
@@ -332,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:
@@ -356,9 +363,9 @@ def test_list_as_write_cell_centers() -> None:
         );
         """
     )
-    assert np.allclose(parsed[("value",)], [47.619, 142.857])
+    assert parsed[("value",)] == pytest.approx([47.619, 142.857])
 
 
 def test_list_as_write_cell_centers_short() -> None:
     parsed = Parsed(b"value           nonuniform List<scalar> 4(250 750 1250 1750);")
-    assert np.allclose(parsed[("value",)], [250, 750, 1250, 1750])
+    assert parsed[("value",)] == pytest.approx([250, 750, 1250, 1750])