foamlib 0.6.12__tar.gz → 0.6.13__tar.gz

{foamlib-0.6.12 → foamlib-0.6.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.6.12
+Version: 0.6.13
 Summary: A Python interface for interacting with OpenFOAM
 Author-email: "Gabriel S. Gerlero" <ggerlero@cimec.unl.edu.ar>
 Project-URL: Homepage, https://github.com/gerlero/foamlib

{foamlib-0.6.12 → foamlib-0.6.13}/foamlib/__init__.py

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

{foamlib-0.6.12 → foamlib-0.6.13}/foamlib/_files/_files.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import os
 import sys
 from copy import deepcopy
 from typing import Any, Optional, Tuple, Union, cast
@@ -16,7 +17,7 @@ else:
 
 from ._base import FoamFileBase
 from ._io import FoamFileIO
-from ._serialization import Kind, dumps
+from ._serialization import Kind, dumps, normalize
 from ._util import is_sequence
 
 
@@ -216,12 +217,28 @@ class FoamFile(
                     or keywords[2].endswith("Gradient")
                 )
             ):
-                kind = Kind.BINARY_FIELD if self.format == "binary" else Kind.FIELD
+                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
             elif keywords == ("dimensions",):
                 kind = Kind.DIMENSIONS
 
             if (
-                kind in (Kind.FIELD, Kind.BINARY_FIELD)
+                kind
+                in (
+                    Kind.ASCII_FIELD,
+                    Kind.DOUBLE_PRECISION_BINARY_FIELD,
+                    Kind.SINGLE_PRECISION_BINARY_FIELD,
+                )
             ) and self.class_ == "dictionary":
                 if isinstance(data, (int, float)):
                     self.class_ = "volScalarField"
@@ -291,7 +308,7 @@ class FoamFile(
             elif keywords:
                 parsed.put(
                     keywords,
-                    deepcopy(data),
+                    normalize(data, kind=kind),
                     before
                     + indentation
                     + dumps(keywords[-1])
@@ -302,7 +319,11 @@ class FoamFile(
                 )
 
             else:
-                parsed.put((), deepcopy(data), before + dumps(data, kind=kind) + after)
+                parsed.put(
+                    (),
+                    normalize(data, kind=kind),
+                    before + dumps(data, kind=kind) + after,
+                )
 
     def __delitem__(self, keywords: str | tuple[str, ...] | None) -> None:
         if not keywords:

{foamlib-0.6.12 → foamlib-0.6.13}/foamlib/_files/_parsing.py

@@ -82,10 +82,12 @@ def _keyword_entry_of(
 
 def _unpack_binary_field(
     tks: ParseResults,
+    *,
+    elsize: int = 1,
 ) -> Sequence[Sequence[float] | Sequence[Sequence[float]]]:
-    elsize = len(tks[0]) // 8
+    float_size = len(tks[0]) // elsize
 
-    arr = array.array("d", "".join(tks).encode("latin-1"))
+    arr = array.array("f" if float_size == 4 else "d", "".join(tks).encode("latin-1"))
 
     values: Sequence[float] | Sequence[Sequence[float]]
 
@@ -130,45 +132,92 @@ _IDENTIFIER = Combine(
 _DIMENSIONED = (Opt(_IDENTIFIER) + _DIMENSIONS + _TENSOR).set_parse_action(
     lambda tks: FoamFileBase.Dimensioned(*reversed(tks.as_list()))
 )
-_FIELD = (Keyword("uniform").suppress() + _TENSOR) | (
-    Keyword("nonuniform").suppress()
+_FIELD = (Keyword("uniform", _IDENTBODYCHARS).suppress() + _TENSOR) | (
+    Keyword("nonuniform", _IDENTBODYCHARS).suppress()
     + (
         _list_of(_TENSOR)
         | (
             Literal("List").suppress()
             + Literal("<").suppress()
             + (
-                counted_array(
-                    CharsNotIn(exact=8),
+                (
                     Literal("scalar").suppress()
                     + Literal(">").suppress()
-                    + common.integer
-                    + Literal("(").suppress(),
-                )
-                | counted_array(
-                    CharsNotIn(exact=8 * 3),
+                    + (
+                        (
+                            counted_array(
+                                CharsNotIn(exact=8),
+                                common.integer + Literal("(").suppress(),
+                            )
+                        )
+                        | (
+                            counted_array(
+                                CharsNotIn(exact=4),
+                                common.integer + Literal("(").suppress(),
+                            )
+                        )
+                    )
+                    + Literal(")").suppress()
+                ).set_parse_action(_unpack_binary_field)
+                | (
                     Literal("vector").suppress()
                     + Literal(">").suppress()
-                    + common.integer
-                    + Literal("(").suppress(),
-                )
-                | counted_array(
-                    CharsNotIn(exact=8 * 6),
+                    + (
+                        (
+                            counted_array(
+                                CharsNotIn(exact=8 * 3),
+                                common.integer + Literal("(").suppress(),
+                            )
+                        )
+                        | (
+                            counted_array(
+                                CharsNotIn(exact=4 * 3),
+                                common.integer + Literal("(").suppress(),
+                            )
+                        )
+                    )
+                    + Literal(")").suppress()
+                ).set_parse_action(lambda tks: _unpack_binary_field(tks, elsize=3))
+                | (
                     Literal("symmTensor").suppress()
                     + Literal(">").suppress()
-                    + common.integer
-                    + Literal("(").suppress(),
-                )
-                | counted_array(
-                    CharsNotIn(exact=8 * 9),
+                    + (
+                        (
+                            counted_array(
+                                CharsNotIn(exact=8 * 6),
+                                common.integer + Literal("(").suppress(),
+                            )
+                        )
+                        | (
+                            counted_array(
+                                CharsNotIn(exact=4 * 6),
+                                common.integer + Literal("(").suppress(),
+                            )
+                        )
+                    )
+                    + Literal(")").suppress()
+                ).set_parse_action(lambda tks: _unpack_binary_field(tks, elsize=6))
+                | (
                     Literal("tensor").suppress()
                     + Literal(">").suppress()
-                    + common.integer
-                    + Literal("(").suppress(),
-                )
+                    + (
+                        (
+                            counted_array(
+                                CharsNotIn(exact=8 * 9),
+                                common.integer + Literal("(").suppress(),
+                            )
+                        )
+                        | (
+                            counted_array(
+                                CharsNotIn(exact=4 * 9),
+                                common.integer + Literal("(").suppress(),
+                            )
+                        )
+                    )
+                    + Literal(")").suppress()
+                ).set_parse_action(lambda tks: _unpack_binary_field(tks, elsize=9))
             )
-            + Literal(")").suppress()
-        ).set_parse_action(_unpack_binary_field)
+        )
     )
 )
 _TOKEN = QuotedString('"', unquote_results=False) | _IDENTIFIER

foamlib-0.6.13/foamlib/_files/_serialization.py

@@ -0,0 +1,210 @@
+from __future__ import annotations
+
+import array
+import contextlib
+import itertools
+import re
+import sys
+from enum import Enum, auto
+from typing import cast, overload
+
+if sys.version_info >= (3, 9):
+    from collections.abc import Mapping, Sequence
+else:
+    from typing import Mapping, Sequence
+
+from ._base import FoamFileBase
+from ._util import is_sequence
+
+try:
+    import numpy as np
+
+    numpy = True
+except ModuleNotFoundError:
+    numpy = False
+
+
+class Kind(Enum):
+    DEFAULT = auto()
+    SINGLE_ENTRY = auto()
+    ASCII_FIELD = auto()
+    DOUBLE_PRECISION_BINARY_FIELD = auto()
+    SINGLE_PRECISION_BINARY_FIELD = auto()
+    DIMENSIONS = auto()
+
+
+_TOKENS = re.compile(r'(?:[^\s"]|"(?:[^"])*")+')
+
+
+@overload
+def normalize(
+    data: FoamFileBase._DataEntry, *, kind: Kind = Kind.DEFAULT
+) -> FoamFileBase._DataEntry: ...
+
+
+@overload
+def normalize(
+    data: FoamFileBase.Data, *, kind: Kind = Kind.DEFAULT
+) -> FoamFileBase.Data: ...
+
+
+def normalize(
+    data: FoamFileBase.Data, *, kind: Kind = Kind.DEFAULT
+) -> FoamFileBase.Data:
+    if numpy and isinstance(data, np.ndarray):
+        ret = data.tolist()
+        assert isinstance(ret, list)
+        return ret
+
+    if kind == Kind.SINGLE_ENTRY and isinstance(data, tuple):
+        ret = normalize(list(data))
+        assert isinstance(ret, list)
+        return ret
+
+    if isinstance(data, Mapping):
+        return {k: normalize(v, kind=kind) for k, v in data.items()}
+
+    if (
+        kind == Kind.DIMENSIONS
+        and is_sequence(data)
+        and len(data) <= 7
+        and all(isinstance(d, (int, float)) for d in data)
+    ):
+        data = cast(Sequence[float], data)
+        return FoamFileBase.DimensionSet(*data)
+
+    if is_sequence(data) and not isinstance(data, tuple):
+        return [normalize(d, kind=Kind.SINGLE_ENTRY) for d in data]
+
+    if isinstance(data, str):
+        with contextlib.suppress(ValueError):
+            return int(data)
+
+        with contextlib.suppress(ValueError):
+            return float(data)
+
+        tokens: list[str] = re.findall(_TOKENS, data)
+
+        if len(tokens) == 1:
+            return tokens[0]
+
+        return tuple(tokens) if kind != Kind.SINGLE_ENTRY else " ".join(tokens)
+
+    if isinstance(data, FoamFileBase.Dimensioned):
+        value = normalize(data.value, kind=Kind.SINGLE_ENTRY)
+        assert isinstance(value, (int, float, list))
+        return FoamFileBase.Dimensioned(value, data.dimensions, data.name)
+
+    if isinstance(
+        data,
+        (int, float, bool, tuple, FoamFileBase.DimensionSet),
+    ):
+        return data
+
+    msg = f"Unsupported data type: {type(data)}"
+    raise TypeError(msg)
+
+
+def dumps(
+    data: FoamFileBase.Data,
+    *,
+    kind: Kind = Kind.DEFAULT,
+) -> bytes:
+    data = normalize(data, kind=kind)
+
+    if isinstance(data, Mapping):
+        entries = []
+        for k, v in data.items():
+            if isinstance(v, Mapping):
+                entries.append(dumps(k) + b" {" + dumps(v) + b"}")
+            elif not v:
+                entries.append(dumps(k) + b";")
+            else:
+                entries.append(dumps(k) + b" " + dumps(v) + b";")
+
+        return b" ".join(entries)
+
+    if isinstance(data, FoamFileBase.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)
+    ):
+        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)):
+            tensor_kind = b"scalar"
+        elif is_sequence(data[0]) and data[0] and isinstance(data[0][0], (int, float)):
+            if len(data[0]) == 3:
+                tensor_kind = b"vector"
+            elif len(data[0]) == 6:
+                tensor_kind = b"symmTensor"
+            elif len(data[0]) == 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")"
+                )
+        else:
+            contents = dumps(data, kind=Kind.SINGLE_ENTRY)
+
+        return b"nonuniform List<" + tensor_kind + b"> " + dumps(len(data)) + contents
+
+    if isinstance(data, FoamFileBase.Dimensioned):
+        if data.name is not None:
+            return (
+                dumps(data.name)
+                + b" "
+                + dumps(data.dimensions, kind=Kind.DIMENSIONS)
+                + b" "
+                + dumps(data.value, kind=Kind.SINGLE_ENTRY)
+            )
+        return (
+            dumps(data.dimensions, kind=Kind.DIMENSIONS)
+            + b" "
+            + dumps(data.value, kind=Kind.SINGLE_ENTRY)
+        )
+
+    if isinstance(data, tuple):
+        return b" ".join(dumps(v) for v in data)
+
+    if is_sequence(data):
+        return b"(" + b" ".join(dumps(v, kind=Kind.SINGLE_ENTRY) for v in data) + b")"
+
+    if data is True:
+        return b"yes"
+    if data is False:
+        return b"no"
+
+    return str(data).encode("latin-1")

{foamlib-0.6.12 → foamlib-0.6.13}/foamlib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.6.12
+Version: 0.6.13
 Summary: A Python interface for interacting with OpenFOAM
 Author-email: "Gabriel S. Gerlero" <ggerlero@cimec.unl.edu.ar>
 Project-URL: Homepage, https://github.com/gerlero/foamlib

foamlib-0.6.12/foamlib/_files/_serialization.py

@@ -1,125 +0,0 @@
-from __future__ import annotations
-
-import array
-import itertools
-import sys
-from enum import Enum, auto
-from typing import cast
-
-if sys.version_info >= (3, 9):
-    from collections.abc import Mapping, Sequence
-else:
-    from typing import Mapping, Sequence
-
-from ._base import FoamFileBase
-from ._util import is_sequence
-
-try:
-    import numpy as np
-
-    numpy = True
-except ModuleNotFoundError:
-    numpy = False
-
-
-class Kind(Enum):
-    DEFAULT = auto()
-    SINGLE_ENTRY = auto()
-    FIELD = auto()
-    BINARY_FIELD = auto()
-    DIMENSIONS = auto()
-
-
-def dumps(
-    data: FoamFileBase.Data,
-    *,
-    kind: Kind = Kind.DEFAULT,
-) -> bytes:
-    if numpy and isinstance(data, np.ndarray):
-        return dumps(data.tolist(), kind=kind)
-
-    if isinstance(data, Mapping):
-        entries = []
-        for k, v in data.items():
-            b = dumps(v, kind=kind)
-            if isinstance(v, Mapping):
-                entries.append(dumps(k) + b" {" + b + b"}")
-            elif not b:
-                entries.append(dumps(k) + b";")
-            else:
-                entries.append(dumps(k) + b" " + b + b";")
-
-        return b" ".join(entries)
-
-    if isinstance(data, FoamFileBase.DimensionSet) or (
-        kind == Kind.DIMENSIONS and is_sequence(data) and len(data) == 7
-    ):
-        return b"[" + b" ".join(dumps(v) for v in data) + b"]"
-
-    if kind in (Kind.FIELD, Kind.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)
-    ):
-        return b"uniform " + dumps(data, kind=Kind.SINGLE_ENTRY)
-
-    if kind in (Kind.FIELD, Kind.BINARY_FIELD) and is_sequence(data):
-        if data and isinstance(data[0], (int, float)):
-            tensor_kind = b"scalar"
-        elif is_sequence(data[0]) and data[0] and isinstance(data[0][0], (int, float)):
-            if len(data[0]) == 3:
-                tensor_kind = b"vector"
-            elif len(data[0]) == 6:
-                tensor_kind = b"symmTensor"
-            elif len(data[0]) == 9:
-                tensor_kind = b"tensor"
-            else:
-                return dumps(data)
-        else:
-            return dumps(data)
-
-        if kind == Kind.BINARY_FIELD:
-            if tensor_kind == b"scalar":
-                data = cast(Sequence[float], data)
-                contents = b"(" + array.array("d", data).tobytes() + b")"
-            else:
-                data = cast(Sequence[Sequence[float]], data)
-                contents = (
-                    b"("
-                    + array.array("d", itertools.chain.from_iterable(data)).tobytes()
-                    + b")"
-                )
-        else:
-            contents = dumps(data, kind=Kind.SINGLE_ENTRY)
-
-        return b"nonuniform List<" + tensor_kind + b"> " + dumps(len(data)) + contents
-
-    if kind != Kind.SINGLE_ENTRY and isinstance(data, tuple):
-        return b" ".join(dumps(v) for v in data)
-
-    if isinstance(data, FoamFileBase.Dimensioned):
-        if data.name is not None:
-            return (
-                dumps(data.name)
-                + b" "
-                + dumps(data.dimensions, kind=Kind.DIMENSIONS)
-                + b" "
-                + dumps(data.value, kind=Kind.SINGLE_ENTRY)
-            )
-        return (
-            dumps(data.dimensions, kind=Kind.DIMENSIONS)
-            + b" "
-            + dumps(data.value, kind=Kind.SINGLE_ENTRY)
-        )
-
-    if is_sequence(data):
-        return b"(" + b" ".join(dumps(v, kind=Kind.SINGLE_ENTRY) for v in data) + b")"
-
-    if data is True:
-        return b"yes"
-    if data is False:
-        return b"no"
-
-    return str(data).encode("latin-1")