foamlib 0.6.11__py3-none-any.whl → 0.6.13__py3-none-any.whl

foamlib/_files/_parsing.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import array
 import sys
 from typing import Tuple, Union, cast
@@ -80,19 +82,21 @@ def _keyword_entry_of(
 
 def _unpack_binary_field(
     tks: ParseResults,
-) -> Sequence[Union[Sequence[float], Sequence[Sequence[float]]]]:
-    elsize = len(tks[0]) // 8
+    *,
+    elsize: int = 1,
+) -> Sequence[Sequence[float] | Sequence[Sequence[float]]]:
+    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"))
 
-    all: Union[Sequence[float], Sequence[Sequence[float]]]
+    values: Sequence[float] | Sequence[Sequence[float]]
 
     if elsize != 1:
-        all = [arr[i : i + elsize].tolist() for i in range(0, len(arr), elsize)]
+        values = [arr[i : i + elsize].tolist() for i in range(0, len(arr), elsize)]
     else:
-        all = arr.tolist()
+        values = arr.tolist()
 
-    return [all]
+    return [values]
 
 
 _IDENTCHARS = identchars + "$"
@@ -128,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
@@ -210,8 +261,8 @@ _FILE = (
 class Parsed(Mapping[Tuple[str, ...], Union[FoamFileBase._DataEntry, EllipsisType]]):
     def __init__(self, contents: bytes) -> None:
         self._parsed: MutableMapping[
-            Tuple[str, ...],
-            Tuple[int, Union[FoamFileBase._DataEntry, EllipsisType], int],
+            tuple[str, ...],
+            tuple[int, FoamFileBase._DataEntry | EllipsisType, int],
         ] = {}
         for parse_result in _FILE.parse_string(
             contents.decode("latin-1"), parse_all=True
@@ -223,13 +274,13 @@ class Parsed(Mapping[Tuple[str, ...], Union[FoamFileBase._DataEntry, EllipsisTyp
 
     @staticmethod
     def _flatten_result(
-        parse_result: ParseResults, *, _keywords: Tuple[str, ...] = ()
+        parse_result: ParseResults, *, _keywords: tuple[str, ...] = ()
     ) -> Mapping[
-        Tuple[str, ...], Tuple[int, Union[FoamFileBase._DataEntry, EllipsisType], int]
+        tuple[str, ...], tuple[int, FoamFileBase._DataEntry | EllipsisType, int]
     ]:
         ret: MutableMapping[
-            Tuple[str, ...],
-            Tuple[int, Union[FoamFileBase._DataEntry, EllipsisType], int],
+            tuple[str, ...],
+            tuple[int, FoamFileBase._DataEntry | EllipsisType, int],
         ] = {}
         start = parse_result.locn_start
         assert isinstance(start, int)
@@ -256,18 +307,15 @@ class Parsed(Mapping[Tuple[str, ...], Union[FoamFileBase._DataEntry, EllipsisTyp
         return ret
 
     def __getitem__(
-        self, keywords: Union[str, Tuple[str, ...]]
-    ) -> Union[FoamFileBase._DataEntry, EllipsisType]:
-        if isinstance(keywords, str):
-            keywords = (keywords,)
-
+        self, keywords: tuple[str, ...]
+    ) -> FoamFileBase._DataEntry | EllipsisType:
         _, data, _ = self._parsed[keywords]
         return data
 
     def put(
         self,
-        keywords: Tuple[str, ...],
-        data: Union[FoamFileBase._DataEntry, EllipsisType],
+        keywords: tuple[str, ...],
+        data: FoamFileBase._DataEntry | EllipsisType,
         content: bytes,
     ) -> None:
         start, end = self.entry_location(keywords, missing_ok=True)
@@ -288,10 +336,7 @@ class Parsed(Mapping[Tuple[str, ...], Union[FoamFileBase._DataEntry, EllipsisTyp
             if keywords != k and keywords == k[: len(keywords)]:
                 del self._parsed[k]
 
-    def __delitem__(self, keywords: Union[str, Tuple[str, ...]]) -> None:
-        if isinstance(keywords, str):
-            keywords = (keywords,)
-
+    def __delitem__(self, keywords: tuple[str, ...]) -> None:
         start, end = self.entry_location(keywords)
         del self._parsed[keywords]
 
@@ -312,15 +357,15 @@ class Parsed(Mapping[Tuple[str, ...], Union[FoamFileBase._DataEntry, EllipsisTyp
     def __contains__(self, keywords: object) -> bool:
         return keywords in self._parsed
 
-    def __iter__(self) -> Iterator[Tuple[str, ...]]:
+    def __iter__(self) -> Iterator[tuple[str, ...]]:
         return iter(self._parsed)
 
     def __len__(self) -> int:
         return len(self._parsed)
 
     def entry_location(
-        self, keywords: Tuple[str, ...], *, missing_ok: bool = False
-    ) -> Tuple[int, int]:
+        self, keywords: tuple[str, ...], *, missing_ok: bool = False
+    ) -> tuple[int, int]:
         try:
             start, _, end = self._parsed[keywords]
         except KeyError:

foamlib/_files/_serialization.py

@@ -1,12 +1,17 @@
+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
+    from collections.abc import Mapping, Sequence
 else:
-    from typing import Mapping
+    from typing import Mapping, Sequence
 
 from ._base import FoamFileBase
 from ._util import is_sequence
@@ -22,38 +27,111 @@ except ModuleNotFoundError:
 class Kind(Enum):
     DEFAULT = auto()
     SINGLE_ENTRY = auto()
-    FIELD = auto()
-    BINARY_FIELD = 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:
-    if numpy and isinstance(data, np.ndarray):
-        return dumps(data.tolist(), kind=kind)
+    data = normalize(data, 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" {" + dumps(v) + b"}")
+            elif not v:
                 entries.append(dumps(k) + b";")
             else:
-                entries.append(dumps(k) + b" " + b + b";")
+                entries.append(dumps(k) + b" " + dumps(v) + b";")
 
         return b" ".join(entries)
 
-    if isinstance(data, FoamFileBase.DimensionSet) or (
-        kind == Kind.DIMENSIONS and is_sequence(data) and len(data) == 7
-    ):
+    if isinstance(data, FoamFileBase.DimensionSet):
         return b"[" + b" ".join(dumps(v) for v in data) + b"]"
 
-    if (kind == Kind.FIELD or kind == Kind.BINARY_FIELD) and (
+    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
@@ -62,25 +140,40 @@ def dumps(
     ):
         return b"uniform " + dumps(data, kind=Kind.SINGLE_ENTRY)
 
-    if (kind == Kind.FIELD or kind == Kind.BINARY_FIELD) and is_sequence(data):
-        if isinstance(data[0], (int, float)):
+    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 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"
+        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 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":
-                contents = b"(" + array.array("d", data).tobytes() + b")"
+                data = cast(Sequence[float], data)
+                contents = b"(" + array.array(typecode, data).tobytes() + b")"
             else:
+                data = cast(Sequence[Sequence[float]], data)
                 contents = (
                     b"("
-                    + array.array("d", itertools.chain.from_iterable(data)).tobytes()
+                    + array.array(
+                        typecode, itertools.chain.from_iterable(data)
+                    ).tobytes()
                     + b")"
                 )
         else:
@@ -88,9 +181,6 @@ def dumps(
 
         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 (
@@ -106,6 +196,9 @@ def dumps(
             + 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")"
 

foamlib/_files/_util.py

@@ -1,5 +1,7 @@
+from __future__ import annotations
+
 import sys
-from typing import Any
+from typing import TYPE_CHECKING
 
 if sys.version_info >= (3, 9):
     from collections.abc import Sequence
@@ -11,8 +13,11 @@ if sys.version_info >= (3, 10):
 else:
     from typing_extensions import TypeGuard
 
+if TYPE_CHECKING:
+    from ._base import FoamFileBase
+
 
 def is_sequence(
-    value: Any,
-) -> TypeGuard[Sequence[Any]]:
+    value: FoamFileBase.Data,
+) -> TypeGuard[Sequence[FoamFileBase.Data]]:
     return isinstance(value, Sequence) and not isinstance(value, str)

{foamlib-0.6.11.dist-info → foamlib-0.6.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.6.11
+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.13.dist-info/RECORD

@@ -0,0 +1,22 @@
+foamlib/__init__.py,sha256=QdspvCoifzrxd6lYysyhLGr4QIan-fYuWBPYDol5YgI,487
+foamlib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+foamlib/_cases/__init__.py,sha256=wTUHcUgU1CBgpu0cUMtksQ5VKG6B8CFu9xc3dWwsQuo,358
+foamlib/_cases/_async.py,sha256=i6g4EBHqvI-1PkdrxsRto2ynW7sxsOga2bSYk1XVG1U,7795
+foamlib/_cases/_base.py,sha256=FKfZxP7HspWfSswQ6yZ5bGJRdZUlupQxj2tDqngXPmc,6785
+foamlib/_cases/_run.py,sha256=lveqKZium_qK_eTxYE8jOjwx0eiIoolCBbi56-zLw1o,14420
+foamlib/_cases/_slurm.py,sha256=kj4wqgr3foMyAoUkoHOZODRBmVqH1B9KqAIEEjM8ZBg,2328
+foamlib/_cases/_subprocess.py,sha256=6BlBRxknj2-BFcGkx7oVcuL63_utSaY1Axmsc1qV9j8,3887
+foamlib/_cases/_sync.py,sha256=2BJXB7Nzldb4OgPukqupgYqdceUGkI2mYhhtGPWEBrc,5901
+foamlib/_cases/_util.py,sha256=lhVca3ERY0zwYjDam6W2QMROt0yX5vAF-9_DS5RuMbM,1547
+foamlib/_files/__init__.py,sha256=-UqB9YTH6mrJfXCX00kPTAAY20XG64u1MGPw_1ewLVs,148
+foamlib/_files/_base.py,sha256=ZY_6Zxr3LZHVzJEex6SUTi9Pgo7Oi7i3Jo-wre9G3yE,1968
+foamlib/_files/_files.py,sha256=oYRlMfCUH9oNeu-yf2HAPmLxLHteIe7gHhsWXdn7wU0,15767
+foamlib/_files/_io.py,sha256=IQLqoqnA1TpHf21NbUho2wsYWevyqC6MKo-wfpaObUU,2226
+foamlib/_files/_parsing.py,sha256=vFOKf2Rf3Z8Vr7TtDXOUq-dLxWAQzMeKVyYQcl91P2s,12991
+foamlib/_files/_serialization.py,sha256=p2yRpyyOAOKP7P6T7BLEgRVvORuzQEcv_P6dEsOZ9_8,5981
+foamlib/_files/_util.py,sha256=VXUTD0B3NbnlaE_KCqWzrFcWvBz_2JfnIWpNp3snX3Y,526
+foamlib-0.6.13.dist-info/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
+foamlib-0.6.13.dist-info/METADATA,sha256=iWdp-dZBC-MJYEufP-ouDdsp3fy8CMfbXQWXM_EsWYo,7742
+foamlib-0.6.13.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+foamlib-0.6.13.dist-info/top_level.txt,sha256=ZdVYtetXGwPwyfL-WhlhbTFQGAwKX5P_gXxtH9JYFPI,8
+foamlib-0.6.13.dist-info/RECORD,,

foamlib-0.6.11.dist-info/RECORD

@@ -1,22 +0,0 @@
-foamlib/__init__.py,sha256=tS4b8eyl8WWPCCt7EmgXM2lcx8V1Zead47kwB3zJlNY,487
-foamlib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-foamlib/_cases/__init__.py,sha256=wTUHcUgU1CBgpu0cUMtksQ5VKG6B8CFu9xc3dWwsQuo,358
-foamlib/_cases/_async.py,sha256=oQ2XnD9sansJLJDuUl3_vHaUM4L9hq2G97IcRjQAOPY,7920
-foamlib/_cases/_base.py,sha256=HV7ifv60pAhgZdC3s5IxvdrDQ2vvlhzPwyB-80QQLe8,6733
-foamlib/_cases/_run.py,sha256=XFDBr5G1hJo0402RcZClLL_rv0d5jVgq2be25FgZcyQ,14725
-foamlib/_cases/_slurm.py,sha256=pUXcFSrwOK5URsoooiUOJg61X0WLLNHyv7bhUxIb7Bs,2346
-foamlib/_cases/_subprocess.py,sha256=tzsBGe44EnQw3GWqRW1ktEZ4sNQ1sSHdJ_89zIfF5L0,3952
-foamlib/_cases/_sync.py,sha256=ENvn8zseRh6YOjAgqXHzmKhKFYXdzGIW5NoMHS_NKPY,6049
-foamlib/_cases/_util.py,sha256=GNndpqw3Jg_S-Hxzl5vwRgD0czcTNb9NYHMhcfBoMBg,1493
-foamlib/_files/__init__.py,sha256=-UqB9YTH6mrJfXCX00kPTAAY20XG64u1MGPw_1ewLVs,148
-foamlib/_files/_base.py,sha256=A8084rU92w9Hh2BZAEIdE31qvm15fto1qOyQJhrP5DI,1945
-foamlib/_files/_files.py,sha256=rvhb9mZFg1z6JSpb02E_8B2YD7Zmt5hh2v7rq19qC_c,14712
-foamlib/_files/_io.py,sha256=07gaGhoJuXDB9i4AxvnIT_Np71RAU2ut2G5Lcyx8TaU,2244
-foamlib/_files/_parsing.py,sha256=pqwWzlZwCTe7PxncYywO3OWd9Ppl9Oq8JYVpofxKJsY,11046
-foamlib/_files/_serialization.py,sha256=Gy9v3iZGD-RF3pS7rauft7fpT33UIzRuOm0XH4rFHvA,3337
-foamlib/_files/_util.py,sha256=UMzXmTFgvbp46w6k3oEZJoYC98pFgEK6LN5uLOwrlCg,397
-foamlib-0.6.11.dist-info/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
-foamlib-0.6.11.dist-info/METADATA,sha256=VGwnlinUiBszBq9RzNnRWvWx0hkO9ziOY4jaKNmoJwc,7742
-foamlib-0.6.11.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-foamlib-0.6.11.dist-info/top_level.txt,sha256=ZdVYtetXGwPwyfL-WhlhbTFQGAwKX5P_gXxtH9JYFPI,8
-foamlib-0.6.11.dist-info/RECORD,,