foamlib 0.8.0__tar.gz → 0.8.1__tar.gz

{foamlib-0.8.0 → foamlib-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: foamlib
-Version: 0.8.0
+Version: 0.8.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
@@ -25,12 +25,12 @@ Classifier: Topic :: Software Development
 Classifier: Typing :: Typed
 Requires-Python: >=3.7
 Requires-Dist: aioshutil<2,>=1
+Requires-Dist: numpy<3,>=1
+Requires-Dist: numpy<3,>=1.25.0; python_version >= '3.10'
 Requires-Dist: pyparsing<4,>=3
 Requires-Dist: typing-extensions<5,>=4; python_version < '3.11'
 Provides-Extra: dev
 Requires-Dist: mypy<2,>=1; extra == 'dev'
-Requires-Dist: numpy<3,>=1; extra == 'dev'
-Requires-Dist: numpy<3,>=1.25.0; (python_version >= '3.10') and extra == 'dev'
 Requires-Dist: pytest-asyncio<0.25,>=0.21; extra == 'dev'
 Requires-Dist: pytest-cov; extra == 'dev'
 Requires-Dist: pytest<9,>=7; extra == 'dev'
@@ -38,25 +38,16 @@ Requires-Dist: ruff; extra == 'dev'
 Requires-Dist: sphinx-rtd-theme; extra == 'dev'
 Requires-Dist: sphinx<9,>=5; extra == 'dev'
 Provides-Extra: docs
-Requires-Dist: numpy<3,>=1; extra == 'docs'
-Requires-Dist: numpy<3,>=1.25.0; (python_version >= '3.10') and 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: numpy
-Requires-Dist: numpy<3,>=1; extra == 'numpy'
-Requires-Dist: numpy<3,>=1.25.0; (python_version >= '3.10') and extra == 'numpy'
 Provides-Extra: test
-Requires-Dist: numpy<3,>=1; extra == 'test'
-Requires-Dist: numpy<3,>=1.25.0; (python_version >= '3.10') and extra == 'test'
 Requires-Dist: pytest-asyncio<0.25,>=0.21; extra == 'test'
 Requires-Dist: pytest-cov; extra == 'test'
 Requires-Dist: pytest<9,>=7; extra == 'test'
 Provides-Extra: typing
 Requires-Dist: mypy<2,>=1; extra == 'typing'
-Requires-Dist: numpy<3,>=1; extra == 'typing'
-Requires-Dist: numpy<3,>=1.25.0; (python_version >= '3.10') and extra == 'typing'
 Requires-Dist: pytest-asyncio<0.25,>=0.21; extra == 'typing'
 Requires-Dist: pytest-cov; extra == 'typing'
 Requires-Dist: pytest<9,>=7; extra == 'typing'

{foamlib-0.8.0 → foamlib-0.8.1}/foamlib/__init__.py

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

{foamlib-0.8.0 → foamlib-0.8.1}/foamlib/_files/_files.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import os
 import sys
 from copy import deepcopy
 from typing import Any, Optional, Tuple, Union, cast
@@ -15,6 +14,8 @@ if sys.version_info >= (3, 9):
 else:
     from typing import Iterator, Mapping, MutableMapping, Sequence
 
+import numpy as np
+
 from ._io import FoamFileIO
 from ._serialization import Kind, dumps, normalize
 from ._types import (
@@ -27,7 +28,6 @@ from ._types import (
     File,
     MutableEntry,
 )
-from ._util import is_sequence
 
 
 class FoamFile(
@@ -196,7 +196,7 @@ class FoamFile(
         elif not isinstance(keywords, tuple):
             keywords = (keywords,)
 
-        if keywords and not isinstance(normalize(keywords[-1], kind=Kind.KEYWORD), str):
+        if keywords and not isinstance(normalize(keywords[-1]), str):
             msg = f"Invalid keyword: {keywords[-1]}"
             raise ValueError(msg)
 
@@ -228,50 +228,36 @@ class FoamFile(
                     or keywords[2].endswith("Gradient")
                 )
             ):
-                if self.format == "binary":
-                    arch = self.get(("FoamFile", "arch"), default=None)
-                    assert arch is None or isinstance(arch, str)
-                    if (arch is not None and "scalar=32" in arch) or (
-                        arch is None
-                        and os.environ.get("WM_PRECISION_OPTION", default="DP") == "SP"
-                    ):
-                        kind = Kind.SINGLE_PRECISION_BINARY_FIELD
-                    else:
-                        kind = Kind.DOUBLE_PRECISION_BINARY_FIELD
-                else:
-                    kind = Kind.ASCII_FIELD
+                kind = (
+                    Kind.BINARY_FIELD if self.format == "binary" else Kind.ASCII_FIELD
+                )
             elif keywords == ("dimensions",):
                 kind = Kind.DIMENSIONS
 
             if (
-                kind
-                in (
-                    Kind.ASCII_FIELD,
-                    Kind.DOUBLE_PRECISION_BINARY_FIELD,
-                    Kind.SINGLE_PRECISION_BINARY_FIELD,
-                )
+                kind in (Kind.ASCII_FIELD, Kind.BINARY_FIELD)
             ) and self.class_ == "dictionary":
-                if isinstance(data, (int, float)):
-                    self.class_ = "volScalarField"
-
-                elif is_sequence(data) and data:
-                    if isinstance(data[0], (int, float)):
-                        if len(data) == 3:
-                            self.class_ = "volVectorField"
-                        elif len(data) == 6:
-                            self.class_ = "volSymmTensorField"
-                        elif len(data) == 9:
-                            self.class_ = "volTensorField"
-                    elif (
-                        is_sequence(data[0])
-                        and data[0]
-                        and isinstance(data[0][0], (int, float))
-                    ):
-                        if len(data[0]) == 3:
+                try:
+                    shape = np.shape(data)  # type: ignore [arg-type]
+                except ValueError:
+                    pass
+                else:
+                    if not shape:
+                        self.class_ = "volScalarField"
+                    elif shape == (3,):
+                        self.class_ = "volVectorField"
+                    elif shape == (6,):
+                        self.class_ = "volSymmTensorField"
+                    elif shape == (9,):
+                        self.class_ = "volTensorField"
+                    elif len(shape) == 1:
+                        self.class_ = "volScalarField"
+                    elif len(shape) == 2:
+                        if shape[1] == 3:
                             self.class_ = "volVectorField"
-                        elif len(data[0]) == 6:
+                        elif shape[1] == 6:
                             self.class_ = "volSymmTensorField"
-                        elif len(data[0]) == 9:
+                        elif shape[1] == 9:
                             self.class_ = "volTensorField"
 
             parsed = self._get_parsed(missing_ok=True)
@@ -304,7 +290,7 @@ class FoamFile(
                     ...,
                     before
                     + indentation
-                    + dumps(keywords[-1], kind=Kind.KEYWORD)
+                    + dumps(keywords[-1])
                     + b"\n"
                     + indentation
                     + b"{\n"
@@ -322,7 +308,7 @@ class FoamFile(
                     normalize(data, kind=kind),
                     before
                     + indentation
-                    + dumps(keywords[-1], kind=Kind.KEYWORD)
+                    + dumps(keywords[-1])
                     + b" "
                     + dumps(data, kind=kind)
                     + b";"

{foamlib-0.8.0 → foamlib-0.8.1}/foamlib/_files/_parsing.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import array
 import re
 import sys
 from enum import Enum, auto
@@ -16,6 +15,7 @@ if sys.version_info >= (3, 10):
 else:
     EllipsisType = type(...)
 
+import numpy as np
 from pyparsing import (
     Combine,
     Dict,
@@ -40,34 +40,37 @@ from pyparsing import (
 from ._types import Data, Dimensioned, DimensionSet, File
 
 
-class Tensor(Enum):
+class _Tensor(Enum):
     SCALAR = auto()
     VECTOR = auto()
     SYMM_TENSOR = auto()
     TENSOR = auto()
 
     @property
-    def shape(self) -> tuple[int, ...]:
-        return {
-            Tensor.SCALAR: (),
-            Tensor.VECTOR: (3,),
-            Tensor.SYMM_TENSOR: (6,),
-            Tensor.TENSOR: (9,),
-        }[self]
+    def shape(self) -> tuple[()] | tuple[int]:
+        if self == _Tensor.SCALAR:
+            return ()
+        if self == _Tensor.VECTOR:
+            return (3,)
+        if self == _Tensor.SYMM_TENSOR:
+            return (6,)
+        if self == _Tensor.TENSOR:
+            return (9,)
+        raise NotImplementedError
 
     @property
     def size(self) -> int:
         return {
-            Tensor.SCALAR: 1,
-            Tensor.VECTOR: 3,
-            Tensor.SYMM_TENSOR: 6,
-            Tensor.TENSOR: 9,
+            _Tensor.SCALAR: 1,
+            _Tensor.VECTOR: 3,
+            _Tensor.SYMM_TENSOR: 6,
+            _Tensor.TENSOR: 9,
         }[self]
 
     def pattern(self, *, ignore: Regex | None = None) -> str:
         float_pattern = r"(?i:[+-]?(?:(?:\d+\.?\d*(?:e[+-]?\d+)?)|nan|inf(?:inity)?))"
 
-        if self == Tensor.SCALAR:
+        if self == _Tensor.SCALAR:
             return float_pattern
 
         ignore_pattern = (
@@ -77,21 +80,21 @@ class Tensor(Enum):
         return rf"\((?:{ignore_pattern})?(?:{float_pattern}{ignore_pattern}){{{self.size - 1}}}{float_pattern}(?:{ignore_pattern})?\)"
 
     def parser(self) -> ParserElement:
-        if self == Tensor.SCALAR:
+        if self == _Tensor.SCALAR:
             return common.ieee_float
 
         return (
             Literal("(").suppress()
             + Group(common.ieee_float[self.size], aslist=True)
             + Literal(")").suppress()
-        )
+        ).add_parse_action(lambda tks: np.array(tks[0], dtype=float))
 
     def __str__(self) -> str:
         return {
-            Tensor.SCALAR: "scalar",
-            Tensor.VECTOR: "vector",
-            Tensor.SYMM_TENSOR: "symmTensor",
-            Tensor.TENSOR: "tensor",
+            _Tensor.SCALAR: "scalar",
+            _Tensor.VECTOR: "vector",
+            _Tensor.SYMM_TENSOR: "symmTensor",
+            _Tensor.TENSOR: "tensor",
         }[self]
 
 
@@ -115,52 +118,34 @@ def _list_of(entry: ParserElement) -> ParserElement:
 
 
 def _parse_ascii_field(
-    s: str, tensor_kind: Tensor, *, ignore: Regex | None
-) -> list[float] | list[list[float]]:
-    values = [
-        float(v)
-        for v in (re.sub(ignore.re, " ", s) if ignore is not None else s)
-        .replace("(", " ")
-        .replace(")", " ")
-        .split()
-    ]
+    s: str, tensor_kind: _Tensor, *, 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 tensor_kind == Tensor.SCALAR:
-        return values
-
-    return [
-        values[i : i + tensor_kind.size]
-        for i in range(0, len(values), tensor_kind.size)
-    ]
+    return np.fromstring(s, dtype=float, sep=" ").reshape(-1, *tensor_kind.shape)
 
 
 def _unpack_binary_field(
-    b: bytes, tensor_kind: Tensor, *, length: int
-) -> list[float] | list[list[float]]:
+    b: bytes, tensor_kind: _Tensor, *, 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)
 
-    arr = array.array("f" if float_size == 4 else "d", b)
-    values = arr.tolist()
-
-    if tensor_kind == Tensor.SCALAR:
-        return values
-
-    return [
-        values[i : i + tensor_kind.size]
-        for i in range(0, len(values), tensor_kind.size)
-    ]
+    dtype = np.float32 if float_size == 4 else float
+    return np.frombuffer(b, dtype=dtype).reshape(-1, *tensor_kind.shape)
 
 
 def _tensor_list(
-    tensor_kind: Tensor | None = None, *, ignore: Regex | None = None
+    tensor_kind: _Tensor | None = None, *, ignore: Regex | None = None
 ) -> ParserElement:
     if tensor_kind is None:
         return (
-            _tensor_list(Tensor.SCALAR, ignore=ignore)
-            | _tensor_list(Tensor.VECTOR, ignore=ignore)
-            | _tensor_list(Tensor.SYMM_TENSOR, ignore=ignore)
-            | _tensor_list(Tensor.TENSOR, ignore=ignore)
+            _tensor_list(_Tensor.SCALAR, ignore=ignore)
+            | _tensor_list(_Tensor.VECTOR, ignore=ignore)
+            | _tensor_list(_Tensor.SYMM_TENSOR, ignore=ignore)
+            | _tensor_list(_Tensor.TENSOR, ignore=ignore)
         )
 
     tensor_pattern = tensor_kind.pattern(ignore=ignore)
@@ -187,7 +172,7 @@ def _tensor_list(
             )
             | Regex(
                 rf"\((?s:.{{{length * tensor_kind.size * 8}}}|.{{{length * tensor_kind.size * 4}}})\)"
-            ).set_parse_action(
+            ).add_parse_action(
                 lambda tks: [
                     _unpack_binary_field(
                         tks[0][1:-1].encode("latin-1"), tensor_kind, length=length
@@ -196,7 +181,9 @@ def _tensor_list(
             )
             | (
                 Literal("{").suppress() + tensor_kind.parser() + Literal("}").suppress()
-            ).set_parse_action(lambda tks: [[tks[0]] * length])
+            ).add_parse_action(
+                lambda tks: [np.full((length, *tensor_kind.shape), tks[0], dtype=float)]
+            )
         )
 
     count = common.integer.copy().add_parse_action(count_parse_action)
@@ -274,10 +261,10 @@ _DIMENSIONS = (
     Literal("[").suppress() + common.number[0, 7] + Literal("]").suppress()
 ).set_parse_action(lambda tks: DimensionSet(*tks))
 _TENSOR = (
-    Tensor.SCALAR.parser()
-    | Tensor.VECTOR.parser()
-    | Tensor.SYMM_TENSOR.parser()
-    | Tensor.TENSOR.parser()
+    _Tensor.SCALAR.parser()
+    | _Tensor.VECTOR.parser()
+    | _Tensor.SYMM_TENSOR.parser()
+    | _Tensor.TENSOR.parser()
 )
 _IDENTIFIER = Combine(
     Word(_IDENTCHARS, _IDENTBODYCHARS, exclude_chars="()")
@@ -289,27 +276,32 @@ _DIMENSIONED = (Opt(_IDENTIFIER) + _DIMENSIONS + _TENSOR).set_parse_action(
 _FIELD = (Keyword("uniform", _IDENTBODYCHARS).suppress() + _TENSOR) | (
     Keyword("nonuniform", _IDENTBODYCHARS).suppress() + _tensor_list(ignore=_COMMENT)
 )
-TOKEN = dbl_quoted_string | _IDENTIFIER
-DATA = Forward()
-_KEYWORD_ENTRY = _keyword_entry_of(TOKEN | _list_of(_IDENTIFIER), DATA)
-_DICT = _dict_of(TOKEN, DATA)
+_TOKEN = dbl_quoted_string | _IDENTIFIER
+_DATA = Forward()
+_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)
 _NUMBER = common.signed_integer ^ common.ieee_float
-_DATA_ENTRY <<= _FIELD | _LIST | _DIMENSIONED | _DIMENSIONS | _NUMBER | _SWITCH | TOKEN
+_DATA_ENTRY <<= _FIELD | _LIST | _DIMENSIONED | _DIMENSIONS | _NUMBER | _SWITCH | _TOKEN
 
-DATA <<= (
+_DATA <<= (
     _DATA_ENTRY[1, ...]
     .set_parse_action(lambda tks: [tuple(tks)] if len(tks) > 1 else [tks[0]])
     .ignore(_COMMENT)
     .parse_with_tabs()
 )
 
+
+def parse_data(s: str) -> Data:
+    return cast(Data, _DATA.parse_string(s, parse_all=True)[0])
+
+
 _LOCATED_DICTIONARY = Group(
-    _keyword_entry_of(TOKEN, Opt(DATA, default=""), located=True)
+    _keyword_entry_of(_TOKEN, Opt(_DATA, default=""), located=True)
 )[...]
-_LOCATED_DATA = Group(Located(DATA.copy().add_parse_action(lambda tks: ["", tks[0]])))
+_LOCATED_DATA = Group(Located(_DATA.copy().add_parse_action(lambda tks: ["", tks[0]])))
 
 _FILE = (
     Dict(_LOCATED_DICTIONARY + Opt(_LOCATED_DATA) + _LOCATED_DICTIONARY)

{foamlib-0.8.0 → foamlib-0.8.1}/foamlib/_files/_serialization.py

@@ -1,35 +1,25 @@
 from __future__ import annotations
 
-import array
-import itertools
 import sys
 from enum import Enum, auto
-from typing import cast, overload
+from typing import overload
 
 if sys.version_info >= (3, 9):
-    from collections.abc import Mapping, Sequence
+    from collections.abc import Mapping
 else:
-    from typing import Mapping, Sequence
+    from typing import Mapping
 
-from ._parsing import DATA, TOKEN
-from ._types import Data, Dimensioned, DimensionSet, Entry
-from ._util import is_sequence
+import numpy as np
 
-try:
-    import numpy as np
-
-    numpy = True
-except ModuleNotFoundError:
-    numpy = False
+from ._parsing import parse_data
+from ._types import Data, Dimensioned, DimensionSet, Entry, is_sequence
 
 
 class Kind(Enum):
     DEFAULT = auto()
-    KEYWORD = auto()
     SINGLE_ENTRY = auto()
     ASCII_FIELD = auto()
-    DOUBLE_PRECISION_BINARY_FIELD = auto()
-    SINGLE_PRECISION_BINARY_FIELD = auto()
+    BINARY_FIELD = auto()
     DIMENSIONS = auto()
 
 
@@ -42,9 +32,29 @@ def normalize(data: Entry, *, kind: Kind = Kind.DEFAULT) -> Entry: ...
 
 
 def normalize(data: Entry, *, kind: Kind = Kind.DEFAULT) -> Entry:
-    if numpy and isinstance(data, np.ndarray):
+    if kind in (Kind.ASCII_FIELD, Kind.BINARY_FIELD):
+        if is_sequence(data):
+            try:
+                arr = np.asarray(data)
+            except ValueError:
+                pass
+            else:
+                if not np.issubdtype(arr.dtype, np.floating):
+                    arr = arr.astype(float)
+
+                if arr.ndim == 1 or (arr.ndim == 2 and arr.shape[1] in (3, 6, 9)):
+                    return arr
+
+            return data
+
+        if isinstance(data, int):
+            return float(data)
+
+        return data
+
+    if isinstance(data, np.ndarray):
         ret = data.tolist()
-        assert isinstance(ret, list)
+        assert isinstance(ret, (int, float, list))
         return ret
 
     if isinstance(data, Mapping):
@@ -56,32 +66,21 @@ def normalize(data: Entry, *, kind: Kind = Kind.DEFAULT) -> Entry:
         and len(data) <= 7
         and all(isinstance(d, (int, float)) for d in data)
     ):
-        data = cast(Sequence[float], data)
         return DimensionSet(*data)
 
     if isinstance(data, tuple) and kind == Kind.SINGLE_ENTRY and len(data) == 2:
         k, v = data
-        return (normalize(k, kind=Kind.KEYWORD), normalize(v))
+        return (normalize(k), normalize(v))
 
     if is_sequence(data) and (kind == Kind.SINGLE_ENTRY or not isinstance(data, tuple)):
         return [normalize(d, kind=Kind.SINGLE_ENTRY) for d in data]
 
-    if isinstance(data, Dimensioned):
-        value = normalize(data.value, kind=Kind.SINGLE_ENTRY)
-        assert isinstance(value, (int, float, list))
-        return Dimensioned(value, data.dimensions, data.name)
-
     if isinstance(data, str):
-        if kind == Kind.KEYWORD:
-            data = TOKEN.parse_string(data, parse_all=True)[0]
-            assert isinstance(data, str)
-            return data
-
-        return cast(Data, DATA.parse_string(data, parse_all=True)[0])
+        return parse_data(data)
 
     if isinstance(
         data,
-        (int, float, bool, tuple, DimensionSet),
+        (int, float, bool, tuple, DimensionSet, Dimensioned),
     ):
         return data
 
@@ -105,7 +104,7 @@ def dumps(
 
     if isinstance(data, tuple) and kind == Kind.SINGLE_ENTRY and len(data) == 2:
         k, v = data
-        ret = dumps(k, kind=Kind.KEYWORD) + b" " + dumps(v)
+        ret = dumps(k) + b" " + dumps(v)
         if not isinstance(v, Mapping):
             ret += b";"
         return ret
@@ -113,58 +112,35 @@ def dumps(
     if isinstance(data, DimensionSet):
         return b"[" + b" ".join(dumps(v) for v in data) + b"]"
 
-    if kind in (
-        Kind.ASCII_FIELD,
-        Kind.DOUBLE_PRECISION_BINARY_FIELD,
-        Kind.SINGLE_PRECISION_BINARY_FIELD,
-    ) and (
-        isinstance(data, (int, float))
-        or (
-            is_sequence(data)
-            and data
-            and isinstance(data[0], (int, float))
-            and len(data) in (3, 6, 9)
-        )
+    if kind in (Kind.ASCII_FIELD, Kind.BINARY_FIELD) and (
+        isinstance(data, (int, float, np.ndarray))
     ):
-        return b"uniform " + dumps(data, kind=Kind.SINGLE_ENTRY)
-
-    if kind in (
-        Kind.ASCII_FIELD,
-        Kind.DOUBLE_PRECISION_BINARY_FIELD,
-        Kind.SINGLE_PRECISION_BINARY_FIELD,
-    ) and is_sequence(data):
-        if data and isinstance(data[0], (int, float)):
+        shape = np.shape(data)
+        if shape in ((), (3,), (6,), (9,)):
+            return b"uniform " + dumps(data, kind=Kind.SINGLE_ENTRY)
+
+        assert isinstance(data, np.ndarray)
+        ndim = len(shape)
+        if ndim == 1:
             tensor_kind = b"scalar"
-        elif is_sequence(data[0]) and data[0] and isinstance(data[0][0], (int, float)):
-            if len(data[0]) == 3:
+
+        elif ndim == 2:
+            if shape[1] == 3:
                 tensor_kind = b"vector"
-            elif len(data[0]) == 6:
+            elif shape[1] == 6:
                 tensor_kind = b"symmTensor"
-            elif len(data[0]) == 9:
+            elif shape[1] == 9:
                 tensor_kind = b"tensor"
             else:
                 return dumps(data)
+
         else:
             return dumps(data)
 
-        if kind in (
-            Kind.DOUBLE_PRECISION_BINARY_FIELD,
-            Kind.SINGLE_PRECISION_BINARY_FIELD,
-        ):
-            typecode = "f" if kind == Kind.SINGLE_PRECISION_BINARY_FIELD else "d"
-            if tensor_kind == b"scalar":
-                data = cast(Sequence[float], data)
-                contents = b"(" + array.array(typecode, data).tobytes() + b")"
-            else:
-                data = cast(Sequence[Sequence[float]], data)
-                contents = (
-                    b"("
-                    + array.array(
-                        typecode, itertools.chain.from_iterable(data)
-                    ).tobytes()
-                    + b")"
-                )
+        if kind == Kind.BINARY_FIELD:
+            contents = b"(" + data.tobytes() + b")"
         else:
+            assert kind == Kind.ASCII_FIELD
             contents = dumps(data, kind=Kind.SINGLE_ENTRY)
 
         return b"nonuniform List<" + tensor_kind + b"> " + dumps(len(data)) + contents

{foamlib-0.8.0 → foamlib-0.8.1}/foamlib/_files/_types.py

@@ -2,16 +2,20 @@ from __future__ import annotations
 
 import sys
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Dict, NamedTuple, Optional, Union
+from typing import Dict, NamedTuple, Optional, Tuple, Union
 
-if TYPE_CHECKING:
-    import numpy as np
+import numpy as np
 
 if sys.version_info >= (3, 9):
     from collections.abc import Mapping, MutableMapping, Sequence
 else:
     from typing import Mapping, MutableMapping, Sequence
 
+if sys.version_info >= (3, 10):
+    from typing import TypeGuard
+else:
+    from typing_extensions import TypeGuard
+
 
 class DimensionSet(NamedTuple):
     mass: float = 0
@@ -29,7 +33,7 @@ class DimensionSet(NamedTuple):
 Tensor = Union[
     float,
     Sequence[float],
-    "np.ndarray[tuple[()] | tuple[int], np.dtype[np.float64 | np.int_]]",
+    "np.ndarray[tuple[()] | Tuple[int], np.dtype[np.float64]]",
 ]
 
 
@@ -40,14 +44,30 @@ class Dimensioned:
     name: str | None = None
 
     def __post_init__(self) -> None:
+        if is_sequence(self.value):
+            self.value = np.asarray(self.value, dtype=float)
+        else:
+            assert isinstance(self.value, (int, float, np.ndarray))
+            self.value = float(self.value)
+
         if not isinstance(self.dimensions, DimensionSet):
             self.dimensions = DimensionSet(*self.dimensions)
 
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Dimensioned):
+            return NotImplemented
+
+        return (
+            self.dimensions == other.dimensions
+            and np.array_equal(self.value, other.value)
+            and self.name == other.name
+        )
+
 
 Field = Union[
     Tensor,
     Sequence[Tensor],
-    "np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.float64 | np.int_]]",
+    "np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.float64 | np.float32]]",
 ]
 
 Data = Union[
@@ -58,7 +78,6 @@ Data = Union[
     Dimensioned,
     DimensionSet,
     Sequence["Entry"],
-    Tensor,
     Field,
 ]
 
@@ -70,6 +89,18 @@ Entry = Union[
 A value that can be stored in an OpenFOAM file.
 """
 
+
+def is_sequence(
+    value: Entry,
+) -> TypeGuard[
+    Sequence[Entry]
+    | np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.float64 | np.float32]]
+]:
+    return (isinstance(value, Sequence) and not isinstance(value, str)) or (
+        isinstance(value, np.ndarray) and value.ndim > 0
+    )
+
+
 MutableEntry = Union[
     Data,
     MutableMapping[str, "MutableEntry"],

{foamlib-0.8.0 → foamlib-0.8.1}/pyproject.toml

@@ -30,6 +30,8 @@ classifiers = [
 
 dependencies = [
     "aioshutil>=1,<2",
+    "numpy>=1.25.0,<3; python_version>='3.10'",
+    "numpy>=1,<3",
     "pyparsing>=3,<4",
     "typing-extensions>=4,<5; python_version<'3.11'",
 ]
@@ -37,13 +39,8 @@ dependencies = [
 dynamic = ["version"]
 
 [project.optional-dependencies]
-numpy = [
-    "numpy>=1.25.0,<3; python_version>='3.10'",
-    "numpy>=1,<3"
-]
 lint = ["ruff"]
 test = [
-    "foamlib[numpy]",
     "pytest>=7,<9",
     "pytest-asyncio>=0.21,<0.25",
     "pytest-cov",
@@ -53,12 +50,10 @@ typing = [
     "mypy>=1,<2",
 ]
 docs = [
-    "foamlib[numpy]",
     "sphinx>=5,<9",
     "sphinx_rtd_theme",
 ]
 dev = [
-    "foamlib[numpy]",
     "foamlib[lint]",
     "foamlib[test]",
     "foamlib[typing]",

{foamlib-0.8.0 → foamlib-0.8.1}/tests/test_cases/test_cavity.py

@@ -2,13 +2,13 @@ import os
 import stat
 import sys
 from pathlib import Path
-from typing import Sequence
 
 if sys.version_info >= (3, 9):
     from collections.abc import Generator
 else:
     from typing import Generator
 
+import numpy as np
 import pytest
 from foamlib import FoamCase
 
@@ -48,7 +48,7 @@ def test_run(cavity: FoamCase) -> None:
     cavity.run(parallel=False)
     assert len(cavity) > 0
     internal = cavity[-1]["U"].internal_field
-    assert isinstance(internal, Sequence)
+    assert isinstance(internal, np.ndarray)
     assert len(internal) == 400
 
 
@@ -61,5 +61,5 @@ def test_double_clean(cavity: FoamCase) -> None:
 def test_cell_centers(cavity: FoamCase) -> None:
     cavity.block_mesh()
     C = cavity[0].cell_centers()
-    assert isinstance(C.internal_field, list)
+    assert isinstance(C.internal_field, np.ndarray)
     assert len(C.internal_field) == 400

{foamlib-0.8.0 → foamlib-0.8.1}/tests/test_cases/test_cavity_async.py

@@ -9,6 +9,7 @@ if sys.version_info >= (3, 9):
 else:
     from typing import AsyncGenerator
 
+import numpy as np
 import pytest
 import pytest_asyncio
 from foamlib import AsyncFoamCase
@@ -50,7 +51,7 @@ async def test_run(cavity: AsyncFoamCase) -> None:
     await cavity.run(parallel=False)
     assert len(cavity) > 0
     internal = cavity[-1]["U"].internal_field
-    assert isinstance(internal, Sequence)
+    assert isinstance(internal, np.ndarray)
     assert len(internal) == 400
 
 
@@ -65,7 +66,7 @@ async def test_double_clean(cavity: AsyncFoamCase) -> None:
 async def test_cell_centers(cavity: AsyncFoamCase) -> None:
     await cavity.block_mesh()
     C = await cavity[0].cell_centers()
-    assert isinstance(C.internal_field, list)
+    assert isinstance(C.internal_field, np.ndarray)
     assert len(C.internal_field) == 400
 
 

{foamlib-0.8.0 → foamlib-0.8.1}/tests/test_files/test_dumps.py

@@ -1,3 +1,4 @@
+import numpy as np
 from foamlib import FoamFile
 from foamlib._files._serialization import Kind, dumps
 
@@ -11,34 +12,32 @@ def test_serialize_data() -> None:
     assert dumps("word") == b"word"
     assert dumps(("word", "word")) == b"word word"
     assert dumps('"a string"') == b'"a string"'
-    assert dumps(1, kind=Kind.ASCII_FIELD) == b"uniform 1"
+    assert dumps(1, kind=Kind.ASCII_FIELD) == b"uniform 1.0"
     assert dumps(1.0, kind=Kind.ASCII_FIELD) == b"uniform 1.0"
     assert dumps(1.0e-3, kind=Kind.ASCII_FIELD) == b"uniform 0.001"
     assert dumps([1.0, 2.0, 3.0]) == b"(1.0 2.0 3.0)"
-    assert dumps([1, 2, 3], kind=Kind.ASCII_FIELD) == b"uniform (1 2 3)"
+    assert dumps([1, 2, 3], kind=Kind.ASCII_FIELD) == b"uniform (1.0 2.0 3.0)"
     assert (
         dumps([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], kind=Kind.ASCII_FIELD)
-        == b"nonuniform List<scalar> 10(1 2 3 4 5 6 7 8 9 10)"
+        == b"nonuniform List<scalar> 10(1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0 10.0)"
     )
     assert (
         dumps([[1, 2, 3], [4, 5, 6]], kind=Kind.ASCII_FIELD)
-        == b"nonuniform List<vector> 2((1 2 3) (4 5 6))"
+        == b"nonuniform List<vector> 2((1.0 2.0 3.0) (4.0 5.0 6.0))"
     )
-    assert dumps(1, kind=Kind.DOUBLE_PRECISION_BINARY_FIELD) == b"uniform 1"
-    assert dumps(1.0, kind=Kind.DOUBLE_PRECISION_BINARY_FIELD) == b"uniform 1.0"
+    assert dumps(1, kind=Kind.BINARY_FIELD) == b"uniform 1.0"
+    assert dumps(1.0, kind=Kind.BINARY_FIELD) == b"uniform 1.0"
+    assert dumps([1, 2, 3], kind=Kind.BINARY_FIELD) == b"uniform (1.0 2.0 3.0)"
     assert (
-        dumps([1, 2, 3], kind=Kind.DOUBLE_PRECISION_BINARY_FIELD) == b"uniform (1 2 3)"
-    )
-    assert (
-        dumps([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], kind=Kind.DOUBLE_PRECISION_BINARY_FIELD)
+        dumps([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], kind=Kind.BINARY_FIELD)
         == b'nonuniform List<scalar> 10(\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x00\x00\x00\x08@\x00\x00\x00\x00\x00\x00\x10@\x00\x00\x00\x00\x00\x00\x14@\x00\x00\x00\x00\x00\x00\x18@\x00\x00\x00\x00\x00\x00\x1c@\x00\x00\x00\x00\x00\x00 @\x00\x00\x00\x00\x00\x00"@\x00\x00\x00\x00\x00\x00$@)'
     )
     assert (
-        dumps([[1, 2, 3], [4, 5, 6]], kind=Kind.DOUBLE_PRECISION_BINARY_FIELD)
+        dumps([[1, 2, 3], [4, 5, 6]], kind=Kind.BINARY_FIELD)
         == b"nonuniform List<vector> 2(\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x00\x00\x00\x08@\x00\x00\x00\x00\x00\x00\x10@\x00\x00\x00\x00\x00\x00\x14@\x00\x00\x00\x00\x00\x00\x18@)"
     )
     assert (
-        dumps([1, 2], kind=Kind.SINGLE_PRECISION_BINARY_FIELD)
+        dumps(np.array([1, 2], dtype=np.float32), kind=Kind.BINARY_FIELD)
         == b"nonuniform List<scalar> 2(\x00\x00\x80?\x00\x00\x00@)"
     )
     assert (

{foamlib-0.8.0 → foamlib-0.8.1}/tests/test_files/test_files.py

@@ -98,7 +98,9 @@ def test_new_field(tmp_path: Path) -> None:
     Path(tmp_path / "testField").touch()
     f = FoamFieldFile(tmp_path / "testField")
     f.internal_field = [1, 2, 3]
-    assert f.internal_field == [1, 2, 3]
+    field = f.internal_field
+    assert isinstance(field, np.ndarray)
+    assert np.array_equal(f.internal_field, [1, 2, 3])
     assert f.class_ == "volVectorField"
 
 
@@ -166,9 +168,8 @@ def test_internal_field(cavity: FoamCase) -> None:
 
     assert cavity[0]["p"].internal_field == pytest.approx(p_arr)
     U = cavity[0]["U"].internal_field
-    assert isinstance(U, Sequence)
-    for u, u_arr in zip(U, U_arr):
-        assert u == pytest.approx(u_arr)
+    assert isinstance(U, np.ndarray)
+    assert U_arr == pytest.approx(U)
 
     p_arr = np.arange(size) * 1e-6
     U_arr = np.full((size, 3), [-1e-6, 1e-6, 0]) * np.arange(size)[:, np.newaxis]
@@ -178,9 +179,8 @@ def test_internal_field(cavity: FoamCase) -> None:
 
     assert cavity[0]["p"].internal_field == pytest.approx(p_arr)
     U = cavity[0]["U"].internal_field
-    assert isinstance(U, Sequence)
-    for u, u_arr in zip(U, U_arr):
-        assert u == pytest.approx(u_arr)
+    assert isinstance(U, np.ndarray)
+    assert U_arr == pytest.approx(U)
 
     cavity.run(parallel=False)
 
@@ -200,27 +200,23 @@ def test_binary_field(cavity: FoamCase) -> None:
     cavity.run(parallel=False)
 
     p_bin = cavity[-1]["p"].internal_field
-    assert isinstance(p_bin, Sequence)
+    assert isinstance(p_bin, np.ndarray)
     U_bin = cavity[-1]["U"].internal_field
-    assert isinstance(U_bin, Sequence)
-    assert isinstance(U_bin[0], Sequence)
-    assert len(U_bin[0]) == 3
-    size = len(p_bin)
-    assert len(U_bin) == size
+    assert isinstance(U_bin, np.ndarray)
+    assert U_bin.shape == (len(p_bin), 3)
 
     cavity.clean()
 
-    p_arr = np.arange(size) * 1e-6
-    U_arr = np.full((size, 3), [-1e-6, 1e-6, 0]) * np.arange(size)[:, np.newaxis]
+    p_arr = np.arange(len(p_bin)) * 1e-6
+    U_arr = np.full_like(U_bin, [-1e-6, 1e-6, 0]) * np.arange(len(U_bin))[:, np.newaxis]
 
     cavity[0]["p"].internal_field = p_arr
     cavity[0]["U"].internal_field = U_arr
 
     assert cavity[0]["p"].internal_field == pytest.approx(p_arr)
     U = cavity[0]["U"].internal_field
-    assert isinstance(U, Sequence)
-    for u, u_arr in zip(U, U_arr):
-        assert u == pytest.approx(u_arr)
+    assert isinstance(U, np.ndarray)
+    assert U_arr == pytest.approx(U)
 
     cavity.run(parallel=False)
 
@@ -231,26 +227,22 @@ def test_compressed_field(cavity: FoamCase) -> None:
     cavity.run(parallel=False)
 
     p_bin = cavity[-1]["p"].internal_field
-    assert isinstance(p_bin, Sequence)
+    assert isinstance(p_bin, np.ndarray)
     U_bin = cavity[-1]["U"].internal_field
-    assert isinstance(U_bin, Sequence)
-    assert isinstance(U_bin[0], Sequence)
-    assert len(U_bin[0]) == 3
-    size = len(p_bin)
-    assert len(U_bin) == size
+    assert isinstance(U_bin, np.ndarray)
+    assert U_bin.shape == (len(p_bin), 3)
 
     cavity.clean()
 
-    p_arr = np.arange(size) * 1e-6
-    U_arr = np.full((size, 3), [-1e-6, 1e-6, 0]) * np.arange(size)[:, np.newaxis]
+    p_arr = np.arange(len(p_bin)) * 1e-6
+    U_arr = np.full_like(U_bin, [-1e-6, 1e-6, 0]) * np.arange(len(U_bin))[:, np.newaxis]
 
     cavity[0]["p"].internal_field = p_arr
     cavity[0]["U"].internal_field = U_arr
 
     assert cavity[0]["p"].internal_field == pytest.approx(p_arr)
     U = cavity[0]["U"].internal_field
-    assert isinstance(U, Sequence)
-    for u, u_arr in zip(U, U_arr):
-        assert u == pytest.approx(u_arr)
+    assert isinstance(U, np.ndarray)
+    assert U_arr == pytest.approx(U)
 
     cavity.run(parallel=False)

{foamlib-0.8.0 → foamlib-0.8.1}/tests/test_files/test_parsing.py

@@ -1,3 +1,4 @@
+import numpy as np
 from foamlib import FoamFile
 from foamlib._files._parsing import Parsed
 
@@ -15,9 +16,15 @@ def test_parse_value() -> None:
     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"uniform (1 2 3)")[()] == [1, 2, 3]
-    assert Parsed(b"nonuniform List<scalar> 2(1 2)")[()] == [1, 2]
-    assert Parsed(b"nonuniform List<scalar> 2{1}")[()] == [1, 1]
+    field = Parsed(b"uniform (1 2 3)")[()]
+    assert isinstance(field, np.ndarray)
+    assert np.array_equal(field, [1, 2, 3])
+    field = Parsed(b"nonuniform List<scalar> 2(1 2)")[()]
+    assert isinstance(field, np.ndarray)
+    assert np.array_equal(field, [1, 2])
+    field = Parsed(b"nonuniform List<scalar> 2{1}")[()]
+    assert isinstance(field, np.ndarray)
+    assert np.array_equal(field, [1, 1])
     assert Parsed(b"3(1 2 3)")[()] == [1, 2, 3]
     assert Parsed(b"2((1 2 3) (4 5 6))")[()] == [
         [1, 2, 3],
@@ -27,24 +34,37 @@ def test_parse_value() -> None:
         [1, 2, 3],
         [1, 2, 3],
     ]
-    assert Parsed(b"nonuniform List<vector> 2((1 2 3) (4 5 6))")[()] == [
-        [1, 2, 3],
-        [4, 5, 6],
-    ]
-    assert Parsed(b"nonuniform List<vector> 2{(1 2 3)}")[()] == [
-        [1, 2, 3],
-        [1, 2, 3],
-    ]
-    assert Parsed(
+    field = Parsed(b"nonuniform List<vector> 2((1 2 3) (4 5 6))")[()]
+    assert isinstance(field, np.ndarray)
+    assert np.array_equal(
+        field,
+        [
+            [1, 2, 3],
+            [4, 5, 6],
+        ],
+    )
+    field = Parsed(b"nonuniform List<vector> 2{(1 2 3)}")[()]
+    assert isinstance(field, np.ndarray)
+    assert np.array_equal(
+        field,
+        [
+            [1, 2, 3],
+            [1, 2, 3],
+        ],
+    )
+    field = Parsed(
         b"nonuniform List<scalar> 2(\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00@)"
-    )[()] == [1, 2]
-    assert Parsed(
+    )[()]
+    assert isinstance(field, np.ndarray)
+    assert np.array_equal(field, [1, 2])
+    field = Parsed(
         b"nonuniform List<vector> 2(\x00\x00\x00\x00\x00\x00\xf0?\x00\x00\x00\x00\x00\x00\x00@\x00\x00\x00\x00\x00\x00\x08@\x00\x00\x00\x00\x00\x00\x10@\x00\x00\x00\x00\x00\x00\x14@\x00\x00\x00\x00\x00\x00\x18@)"
-    )[()] == [[1, 2, 3], [4, 5, 6]]
-    assert Parsed(b"nonuniform List<scalar> 2(\x00\x00\x80?\x00\x00\x00@)")[()] == [
-        1,
-        2,
-    ]
+    )[()]
+    assert isinstance(field, np.ndarray)
+    assert np.array_equal(field, [[1, 2, 3], [4, 5, 6]])
+    field = Parsed(b"nonuniform List<scalar> 2(\x00\x00\x80?\x00\x00\x00@)")[()]
+    assert isinstance(field, np.ndarray)
+    assert np.array_equal(field, [1, 2])
     assert Parsed(b"[1 1 -2 0 0 0 0]")[()] == FoamFile.DimensionSet(
         mass=1, length=1, time=-2
     )

foamlib-0.8.0/foamlib/_files/_util.py

@@ -1,23 +0,0 @@
-from __future__ import annotations
-
-import sys
-from typing import TYPE_CHECKING
-
-if sys.version_info >= (3, 9):
-    from collections.abc import Sequence
-else:
-    from typing import Sequence
-
-if sys.version_info >= (3, 10):
-    from typing import TypeGuard
-else:
-    from typing_extensions import TypeGuard
-
-if TYPE_CHECKING:
-    from ._types import Entry
-
-
-def is_sequence(
-    value: Entry,
-) -> TypeGuard[Sequence[Entry]]:
-    return isinstance(value, Sequence) and not isinstance(value, str)