foamlib 0.9.0__tar.gz → 0.9.1__tar.gz

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

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

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

{foamlib-0.9.0 → 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
@@ -40,46 +40,43 @@ from pyparsing import (
 
 from ._types import Data, Dimensioned, DimensionSet, File
 
+if TYPE_CHECKING:
+    from numpy.typing import DTypeLike
 
-def _numeric_list(
-    *, nested: int | None = None, ignore: Regex | None = None, force_float: bool = False
+
+def _ascii_numeric_list(
+    dtype: DTypeLike,
+    *,
+    nested: int | None = None,
+    ignore: Regex | None = None,
+    empty_ok: bool = False,
 ) -> ParserElement:
-    if not force_float:
-        int_pattern = r"(?:-?\d+)"
-    float_pattern = r"(?i:[+-]?(?:(?:\d+\.?\d*(?:e[+-]?\d+)?)|nan|inf(?:inity)?))"
+    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)
+
     spacing_pattern = (
-        rf"(?:(?:\s|{ignore.re.pattern})+)" if ignore is not None else r"\s+"
+        rf"(?:(?:\s|{ignore.re.pattern})+)" if ignore is not None else r"(?:\s+)"
     )
 
-    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()
+    if nested is not None:
+        element = (
+            Literal("(").suppress() + Group(element[nested]) + Literal(")").suppress()
         )
+        element_pattern = rf"(?:{spacing_pattern}?\({element_pattern}?(?:{element_pattern}{spacing_pattern}){{{nested - 1}}}{element_pattern}{spacing_pattern}?\))"
 
-    if not force_float:
-        int_list = Forward()
-    float_list = Forward()
+    list_ = Forward()
 
     def process_count(tks: ParseResults) -> None:
-        nonlocal int_list, float_list
+        nonlocal list_
 
         if not tks:
             count = None
@@ -88,46 +85,41 @@ def _numeric_list(
             assert isinstance(count, int)
 
         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}?\)"
+            if not empty_ok:
+                list_pattern = rf"\({spacing_pattern}?(?:{element_pattern}{spacing_pattern})*{element_pattern}{spacing_pattern}?\)"
             else:
-                float_list_pattern = rf"\({spacing_pattern}?(?:{float_element_pattern}{spacing_pattern})*{float_element_pattern}?{spacing_pattern}?\)"
+                list_pattern = rf"\({spacing_pattern}?(?:{element_pattern}{spacing_pattern})*{element_pattern}?{spacing_pattern}?\)"
 
         elif count == 0:
-            if not force_float:
-                int_list <<= NoMatch()
-                float_list <<= NoMatch()
+            if not empty_ok:
+                list_ <<= NoMatch()
             else:
-                float_list <<= (Literal("(") + Literal(")")).add_parse_action(
-                    lambda: np.empty((0, nested) if nested else 0, dtype=float)
+                list_ <<= (Literal("(") + Literal(")")).add_parse_action(
+                    lambda: np.empty((0, nested) if nested else 0, dtype=dtype)
                 )
             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}?\)"
+            list_pattern = rf"\({spacing_pattern}?(?:{element_pattern}{spacing_pattern}){{{count - 1}}}{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)
+        list_ <<= Regex(list_pattern).add_parse_action(
+            lambda tks: to_array(tks, dtype=dtype)
         )
 
     def to_array(
-        tks: ParseResults, *, dtype: type
-    ) -> np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.int64 | np.float64]]:
+        tks: ParseResults, *, dtype: DTypeLike
+    ) -> np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.integer | np.floating]]:
         (s,) = tks
-        s = s.replace("(", "").replace(")", "")
-
+        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.int64 | np.float64]
+            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:
@@ -137,7 +129,7 @@ def _numeric_list(
 
     def to_full_array(
         tks: ParseResults, *, dtype: type
-    ) -> np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.int64 | np.float64]]:
+    ) -> np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.integer | np.floating]]:
         count, lst = tks
         assert isinstance(count, int)
 
@@ -146,24 +138,8 @@ def _numeric_list(
 
         return np.full((count, nested), lst, dtype=dtype)  # type: ignore[return-value]
 
-    count = Opt(common.integer).add_parse_action(process_count)
-
-    ret = count.suppress() + (
-        (int_list | float_list) if not force_float else float_list
-    )
-
-    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()
+    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:
@@ -172,23 +148,29 @@ def _numeric_list(
     return ret
 
 
-def _binary_field(*, nested: int | None = None) -> ParserElement:
+def _binary_numeric_list(
+    dtype: DTypeLike, *, nested: int | None = None, empty_ok: bool = False
+) -> ParserElement:
+    dtype = np.dtype(dtype)
+
     elsize = nested if nested is not None else 1
 
-    binary_field = Forward()
+    list_ = Forward()
 
     def process_count(tks: ParseResults) -> None:
-        nonlocal binary_field
+        nonlocal list_
         (size,) = tks
         assert isinstance(size, int)
 
-        binary_field <<= Regex(
-            rf"\((?s:({'.' * 8 * elsize}|{'.' * 4 * elsize}){{{size}}})\)"
-        )
+        if size == 0 and not empty_ok:
+            list_ <<= NoMatch()
+            return
+
+        list_ <<= Regex(rf"\((?s:{'.' * dtype.itemsize * elsize}){{{size}}}\)")
 
     def to_array(
         tks: ParseResults,
-    ) -> np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.float64 | np.float32]]:
+    ) -> np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.integer | np.floating]]:
         size, s = tks
         assert isinstance(size, int)
         assert isinstance(s, str)
@@ -196,10 +178,6 @@ def _binary_field(*, nested: int | None = None) -> ParserElement:
         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:
@@ -207,9 +185,9 @@ def _binary_field(*, nested: int | None = None) -> ParserElement:
 
         return ret  # type: ignore[return-value]
 
-    count = common.integer.copy().add_parse_action(process_count)
-
-    return (count + binary_field).add_parse_action(to_array)
+    return (
+        common.integer.copy().add_parse_action(process_count) + list_
+    ).add_parse_action(to_array)
 
 
 def _list_of(entry: ParserElement) -> ParserElement:
@@ -337,15 +315,22 @@ _FIELD = (Keyword("uniform", _IDENTBODYCHARS).suppress() + _TENSOR) | (
             Opt(
                 Literal("List") + Literal("<") + Literal("scalar") + Literal(">")
             ).suppress()
-            + (_numeric_list(force_float=True, ignore=_COMMENT) | _binary_field())
+            + (
+                _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()
             + (
-                _numeric_list(nested=3, force_float=True, ignore=_COMMENT)
-                | _binary_field(nested=3)
+                _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)
             )
         )
         | (
@@ -353,12 +338,11 @@ _FIELD = (Keyword("uniform", _IDENTBODYCHARS).suppress() + _TENSOR) | (
                 Literal("List") + Literal("<") + Literal("symmTensor") + Literal(">")
             ).suppress()
             + (
-                _numeric_list(
-                    nested=6,
-                    force_float=True,
-                    ignore=_COMMENT,
+                _ascii_numeric_list(
+                    dtype=float, nested=6, ignore=_COMMENT, empty_ok=True
                 )
-                | _binary_field(nested=6)
+                | _binary_numeric_list(np.float64, nested=6, empty_ok=True)
+                | _binary_numeric_list(np.float32, nested=6, empty_ok=True)
             )
         )
         | (
@@ -366,8 +350,11 @@ _FIELD = (Keyword("uniform", _IDENTBODYCHARS).suppress() + _TENSOR) | (
                 Literal("List") + Literal("<") + Literal("tensor") + Literal(">")
             ).suppress()
             + (
-                _numeric_list(nested=9, force_float=True, ignore=_COMMENT)
-                | _binary_field(nested=9)
+                _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)
             )
         )
     )
@@ -380,12 +367,7 @@ _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 = (
-    _numeric_list(ignore=_COMMENT)
-    | _numeric_list(nested=3, ignore=_COMMENT)
-    | _numeric_list(nested=4, ignore=_COMMENT)
-    | _list_of(_LIST_ENTRY)
-)
+_LIST = _list_of(_LIST_ENTRY)
 _NUMBER = (
     common.number
     | CaselessKeyword("nan").set_parse_action(lambda: np.nan)
@@ -421,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.9.0 → 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.9.0 → foamlib-0.9.1}/tests/test_files/test_files.py

@@ -162,7 +162,6 @@ def test_internal_field(cavity: FoamCase) -> None:
     blocks = cavity.block_mesh_dict["blocks"]
     assert isinstance(blocks, list)
     sizes = blocks[2]
-    assert isinstance(sizes, np.ndarray)
     size = np.prod(sizes)
 
     p_arr = np.zeros(size)

{foamlib-0.9.0 → 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:
@@ -18,13 +19,9 @@ def test_parse_value() -> None:
     assert Parsed(b"uniform 1.0e-3")[()] == 1.0e-3
     assert Parsed(b"(word word)")[()] == ["word", "word"]
     lst = Parsed(b"(1 2 3)")[()]
-    assert isinstance(lst, np.ndarray)
-    assert lst.dtype == np.int64
-    assert np.array_equal(lst, [1, 2, 3])
+    assert np.array_equal(lst, [1, 2, 3])  # type: ignore[arg-type]
     lst = Parsed(b"(1.0 2 3)")[()]
-    assert isinstance(lst, np.ndarray)
-    assert lst.dtype == np.float64
-    assert np.array_equal(lst, [1.0, 2.0, 3.0])
+    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)
@@ -109,16 +106,13 @@ def test_parse_value() -> None:
     assert isinstance(tpl, tuple)
     assert len(tpl) == 5
     assert tpl[0] == "hex"
-    assert isinstance(tpl[1], np.ndarray)
-    assert tpl[1].dtype == np.int64
-    assert np.array_equal(tpl[1], [0, 1, 2, 3, 4, 5, 6, 7])
-    assert isinstance(tpl[2], np.ndarray)
-    assert tpl[2].dtype == np.int64
-    assert np.array_equal(tpl[2], [1, 1, 1])
+    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 isinstance(tpl[4], np.ndarray)
-    assert tpl[4].dtype == np.int64
-    assert np.array_equal(tpl[4], [1, 1, 1])
+    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"}),

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

@@ -44,8 +44,7 @@ def test_simple(tmp_path: Path) -> None:
 
     assert decompose_par_dict["numberOfSubdomains"] == 8
     assert decompose_par_dict["method"] == "simple"
-    assert isinstance(decompose_par_dict["coeffs", "n"], np.ndarray)
-    assert np.array_equal(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.9.0 → foamlib-0.9.1}/tests/test_files/test_parsing/test_intermediate.py

@@ -69,9 +69,7 @@ def test_list_simple() -> None:
             (2 3 4 5)
         );
     """)[("faces",)]
-
-    assert isinstance(faces, np.ndarray)
-    assert np.array_equal(faces, [[1, 5, 4, 0], [2, 3, 4, 5]])
+    assert np.array_equal(faces, [[1, 5, 4, 0], [2, 3, 4, 5]])  # type: ignore[arg-type]
 
 
 def test_list_assignment() -> None:
@@ -84,8 +82,7 @@ def test_list_assignment() -> None:
             0
         );
     """)[("faces",)]
-    assert isinstance(faces, np.ndarray)
-    assert np.array_equal(faces, [1, 5, 4, 0])
+    assert np.array_equal(faces, [1, 5, 4, 0])  # type: ignore[arg-type]
 
 
 def test_dict_simple() -> None:
@@ -138,8 +135,7 @@ def test_dict_with_list() -> None:
             pRefValue                   0;
         }
     """)
-    assert isinstance(parsed[("PISO", "pRefPoint")], np.ndarray)
-    assert np.array_equal(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:
@@ -164,7 +160,6 @@ def test_list_with_dict() -> None:
     assert upper_boundary[0] == "upperBoundary"
     assert upper_boundary[1]["type"] == "cyclic"
     assert upper_boundary[1]["neighbourPatch"] == "lowerBoundary"
-    assert isinstance(upper_boundary[1]["faces"], np.ndarray)
     assert np.array_equal(upper_boundary[1]["faces"], [[3, 7, 6, 2]])
 
 
@@ -179,12 +174,9 @@ def test_list_with_str() -> None:
     assert len(blocks) == 5
 
     assert blocks[0] == "hex"
-    assert isinstance(blocks[1], np.ndarray)
     assert np.array_equal(blocks[1], [0, 1, 2, 3, 4, 5, 6, 7])
-    assert isinstance(blocks[2], np.ndarray)
     assert np.array_equal(blocks[2], [40, 40, 40])
     assert blocks[3] == "simpleGrading"
-    assert isinstance(blocks[4], np.ndarray)
     assert np.array_equal(blocks[4], [1, 1, 1])
 
 
@@ -238,8 +230,7 @@ def test_file() -> None:
     assert parsed[("a",)] == 1
     assert parsed[("b",)] == 2
     faces = parsed[("faces",)]
-    assert isinstance(faces, np.ndarray)
-    assert np.array_equal(faces, [[1, 5, 4, 0], [2, 3, 4, 5]])
+    assert np.array_equal(faces, [[1, 5, 4, 0], [2, 3, 4, 5]])  # type: ignore[arg-type]
     assert parsed[("my_dict", "a")] == 1
 
 
@@ -466,7 +457,6 @@ def test_for_blockmesh() -> None:
     assert len(blocks) == 4
 
     assert blocks[0] == "hex"
-    assert isinstance(blocks[1], np.ndarray)
     assert np.array_equal(blocks[1], [4, 6, 14, 12, 0, 2, 10, 8])
     assert blocks[2] == [1, "$upstreamCells", "$cylinderBoxCells"]
     assert blocks[3] == "$expandBlock"
@@ -497,38 +487,26 @@ def test_blocks() -> None:
     assert len(blocks) == 22
 
     assert blocks[0] == "hex"
-    assert isinstance(blocks[1], np.ndarray)
     assert np.array_equal(blocks[1], [0, 1, 2, 3, 4, 5, 6, 7])
     assert blocks[2] == "inletChannel"
-    assert isinstance(blocks[3], np.ndarray)
     assert np.array_equal(blocks[3], [40, 1, 64])
     assert blocks[4] == "simpleGrading"
-    assert isinstance(blocks[5], np.ndarray)
     assert np.array_equal(blocks[5], [1, 1, 1])
     assert blocks[6] == "hex"
-    assert isinstance(blocks[7], np.ndarray)
     assert np.array_equal(blocks[7], [4, 5, 6, 7, 8, 9, 10, 11, 12])
     assert blocks[8] == "inletChannel"
-    assert isinstance(blocks[9], np.ndarray)
     assert np.array_equal(blocks[9], [40, 1, 16])
     assert blocks[10] == "simpleGrading"
-    assert isinstance(blocks[11], np.ndarray)
     assert np.array_equal(blocks[11], [1, 1, 1])
     assert blocks[12] == "hex"
-    assert isinstance(blocks[13], np.ndarray)
     assert np.array_equal(blocks[13], [12, 13, 14, 15, 16, 17, 18, 19])
-    assert isinstance(blocks[14], np.ndarray)
     assert np.array_equal(blocks[14], [96, 1, 8])
     assert blocks[15] == "simpleGrading"
-    assert isinstance(blocks[16], np.ndarray)
     assert np.array_equal(blocks[16], [1, 1, 1])
     assert blocks[17] == "hex"
-    assert isinstance(blocks[18], np.ndarray)
     assert np.array_equal(blocks[18], [16, 17, 18, 19, 20, 21, 22, 23])
-    assert isinstance(blocks[19], np.ndarray)
     assert np.array_equal(blocks[19], [96, 1, 72])
     assert blocks[20] == "simpleGrading"
-    assert isinstance(blocks[21], np.ndarray)
     assert np.array_equal(blocks[21], [1, 1, 1])
 
 
@@ -616,7 +594,6 @@ def test_list_edges() -> None:
     assert edges[0] == "spline"
     assert edges[1] == 1
     assert edges[2] == 2
-    assert isinstance(edges[3], np.ndarray)
     assert np.array_equal(
         edges[3],
         [
@@ -634,7 +611,6 @@ def test_list_edges() -> None:
     assert edges[4] == "spline"
     assert edges[5] == 6
     assert edges[6] == 5
-    assert isinstance(edges[7], np.ndarray)
     assert np.array_equal(
         edges[7],
         [
@@ -666,13 +642,11 @@ def test_list_edges_arcs() -> None:
     assert edges[1] == 0
     assert edges[2] == 5
     assert edges[3] == "origin"
-    assert isinstance(edges[4], np.ndarray)
     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 isinstance(edges[9], np.ndarray)
     assert np.array_equal(edges[9], [0, 0, 0])
 
 
@@ -691,39 +665,30 @@ def test_list_blocks() -> None:
     assert len(blocks) == 15
 
     assert blocks[0] == "hex"
-    assert isinstance(blocks[1], np.ndarray)
     assert np.array_equal(blocks[1], [0, 1, 9, 8, 7, 6, 14, 15])
-    assert isinstance(blocks[2], np.ndarray)
     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 isinstance(blocks[4][1], np.ndarray)
     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 isinstance(blocks[6], np.ndarray)
     assert np.array_equal(blocks[6], [1, 2, 10, 9, 6, 5, 13, 14])
-    assert isinstance(blocks[7], np.ndarray)
     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 isinstance(blocks[9][1], np.ndarray)
     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 isinstance(blocks[11], np.ndarray)
     assert np.array_equal(blocks[11], [2, 3, 11, 10, 5, 4, 12, 13])
-    assert isinstance(blocks[12], np.ndarray)
     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 isinstance(blocks[14][1], np.ndarray)
     assert np.array_equal(blocks[14][1], [[0.1, 0.25, 41.9], [0.9, 0.75, 1]])
     assert blocks[14][2] == 1