foamlib 0.9.3__py3-none-any.whl → 0.9.5__py3-none-any.whl

foamlib/__init__.py

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

foamlib/_files/_files.py

@@ -22,14 +22,17 @@ from ._serialization import dumps, normalize_data, normalize_keyword
 from ._types import (
     Data,
     DataLike,
-    Dict_,
     Dimensioned,
     DimensionSet,
-    EntryLike,
     Field,
     FieldLike,
     File,
-    MutableEntry,
+    FileLike,
+    MutableSubDict,
+    StandaloneData,
+    StandaloneDataLike,
+    SubDict,
+    SubDictLike,
 )
 
 
@@ -62,7 +65,7 @@ def _tensor_kind_for_field(
 class FoamFile(
     MutableMapping[
         Optional[Union[str, Tuple[str, ...]]],
-        MutableEntry,
+        Union[Data, MutableSubDict],
     ],
     FoamFileIO,
 ):
@@ -115,7 +118,7 @@ class FoamFile(
     DimensionSet = DimensionSet
 
     class SubDict(
-        MutableMapping[str, MutableEntry],
+        MutableMapping[str, Union[Data, MutableSubDict]],
     ):
         """
         An OpenFOAM sub-dictionary within a file.
@@ -154,7 +157,7 @@ class FoamFile(
         def __setitem__(
             self,
             keyword: str,
-            data: EntryLike,
+            data: DataLike | SubDictLike,
         ) -> None:
             self._file[(*self._keywords, keyword)] = data
 
@@ -183,7 +186,7 @@ class FoamFile(
         def __repr__(self) -> str:
             return f"{type(self).__qualname__}('{self._file}', {self._keywords})"
 
-        def as_dict(self) -> Dict_:
+        def as_dict(self) -> SubDict:
             """Return a nested dict representation of the sub-dictionary."""
             ret = self._file.as_dict(include_header=True)
 
@@ -193,7 +196,7 @@ class FoamFile(
                 assert isinstance(v, dict)
                 ret = cast("File", v)
 
-            return cast("Dict_", ret)
+            return cast("SubDict", ret)
 
     @property
     def version(self) -> float:
@@ -282,7 +285,7 @@ class FoamFile(
         return deepcopy(value)
 
     def __setitem__(
-        self, keywords: str | tuple[str, ...] | None, data: EntryLike
+        self, keywords: str | tuple[str, ...] | None, data: DataLike | SubDictLike
     ) -> None:
         if not keywords:
             keywords = ()
@@ -463,7 +466,7 @@ class FoamFile(
         s: bytes | str,
         *,
         include_header: bool = False,
-    ) -> File | Data:
+    ) -> File | StandaloneData:
         """
         Standalone deserializing function.
 
@@ -486,7 +489,9 @@ class FoamFile(
         return ret
 
     @staticmethod
-    def dumps(file: File | DataLike, *, ensure_header: bool = True) -> bytes:
+    def dumps(
+        file: FileLike | StandaloneDataLike, *, ensure_header: bool = True
+    ) -> bytes:
         """
         Standalone serializing function.
 
@@ -498,21 +503,23 @@ class FoamFile(
             If `True`, a header will be included if it is not already present in the
             input object.
         """
+        header: SubDict | None
         if isinstance(file, Mapping):
-            header = file.get("FoamFile", None)
-            assert isinstance(header, FoamFile.SubDict) or header is None
+            header = file.get("FoamFile", None)  # type: ignore [assignment]
+
             entries: list[bytes] = []
             for k, v in file.items():
                 if k is not None:
                     entries.append(
-                        dumps((k, v), keywords=(), header=header, tuple_is_entry=True)
+                        dumps((k, v), keywords=(), header=header, tuple_is_entry=True)  # type: ignore [arg-type]
                     )
                 else:
+                    assert not isinstance(v, Mapping)
                     entries.append(dumps(v, keywords=(), header=header))
             ret = b" ".join(entries)
         else:
             header = None
-            ret = dumps(file)
+            ret = dumps(file, keywords=(), header=header)
 
         if header is None and ensure_header:
             class_ = "dictionary"
@@ -670,5 +677,5 @@ class FoamFieldFile(FoamFile):
         return ret
 
     @boundary_field.setter
-    def boundary_field(self, value: Mapping[str, Dict_]) -> None:
+    def boundary_field(self, value: Mapping[str, SubDict]) -> None:
         self["boundaryField"] = value

foamlib/_files/_parsing.py

@@ -363,11 +363,14 @@ _FIELD = (Keyword("uniform", _IDENTBODYCHARS).suppress() + _TENSOR) | (
 _DIRECTIVE = Word("#", _IDENTBODYCHARS)
 _TOKEN = dbl_quoted_string | _DIRECTIVE | _IDENTIFIER
 _DATA = Forward()
+_DATA_ENTRY = Forward()
 _KEYWORD_ENTRY = _keyword_entry_of(
-    _TOKEN | _list_of(_IDENTIFIER), Opt(_DATA, default="")
+    _TOKEN | _list_of(_IDENTIFIER),
+    Opt(_DATA, default=""),
+    directive=_DIRECTIVE,
+    data_entry=_DATA_ENTRY,
 )
 _DICT = _dict_of(_TOKEN, _DATA)
-_DATA_ENTRY = Forward()
 _LIST_ENTRY = _DICT | _KEYWORD_ENTRY | _DATA_ENTRY
 _LIST = _list_of(_LIST_ENTRY)
 _NUMBER = (

foamlib/_files/_serialization.py

@@ -16,8 +16,10 @@ from ._types import (
     DataLike,
     Dimensioned,
     DimensionSet,
-    Entry,
-    EntryLike,
+    StandaloneData,
+    StandaloneDataLike,
+    SubDict,
+    SubDictLike,
     is_sequence,
 )
 
@@ -30,13 +32,37 @@ def normalize_data(
 
 @overload
 def normalize_data(
-    data: EntryLike, *, keywords: tuple[str, ...] | None = None
-) -> Entry: ...
+    data: StandaloneDataLike, *, keywords: tuple[str, ...] | None = None
+) -> StandaloneData: ...
 
 
+@overload
 def normalize_data(
-    data: EntryLike, *, keywords: tuple[str, ...] | None = None
-) -> Entry:
+    data: SubDictLike, *, keywords: tuple[str, ...] | None = None
+) -> SubDict: ...
+
+
+def normalize_data(
+    data: DataLike | StandaloneDataLike | SubDictLike,
+    *,
+    keywords: tuple[str, ...] | None = None,
+) -> Data | StandaloneData | SubDict:
+    if isinstance(data, Mapping):
+        return {normalize_keyword(k): normalize_data(v) for k, v in data.items()}  # type: ignore [arg-type, misc]
+
+    if keywords == () and is_sequence(data) and not isinstance(data, tuple):
+        try:
+            arr = np.asarray(data)
+        except ValueError:
+            pass
+        else:
+            if np.issubdtype(arr.dtype, np.integer) and arr.ndim == 1:
+                return arr  # type: ignore [return-value]
+            if arr.ndim == 2 and arr.shape[1] == 3:
+                if not np.issubdtype(arr.dtype, np.floating):
+                    arr = arr.astype(float)
+                return arr  # type: ignore [return-value]
+
     if keywords is not None and (
         keywords == ("internalField",)
         or (
@@ -49,7 +75,7 @@ def normalize_data(
             )
         )
     ):
-        if is_sequence(data):
+        if is_sequence(data) and not isinstance(data, tuple):
             try:
                 arr = np.asarray(data)
             except ValueError:
@@ -61,20 +87,17 @@ def normalize_data(
                 if arr.ndim == 1 or (arr.ndim == 2 and arr.shape[1] in (3, 6, 9)):
                     return arr  # type: ignore [return-value]
 
-            return [normalize_data(d) for d in data]
+            return [normalize_data(d) for d in data]  # type: ignore [arg-type, misc]
 
         if isinstance(data, int):
             return float(data)
 
         return normalize_data(data)
 
-    if isinstance(data, Mapping):
-        return {normalize_keyword(k): normalize_data(v) for k, v in data.items()}  # type: ignore [misc]
-
     if isinstance(data, np.ndarray):
         ret = data.tolist()
         assert isinstance(ret, (int, float, list))
-        return ret
+        return ret  # type: ignore [return-value]
 
     if (
         not isinstance(data, DimensionSet)
@@ -89,17 +112,20 @@ def normalize_data(
     if keywords is None and isinstance(data, tuple) and len(data) == 2:
         k, v = data
         assert not isinstance(k, Mapping)
-        return (
-            normalize_keyword(k),
-            normalize_data(v) if not isinstance(v, Mapping) else v,
-        )  # type: ignore [return-value]
+        return (  # type: ignore [return-value]
+            normalize_keyword(k),  # type: ignore [arg-type]
+            normalize_data(v) if not isinstance(v, Mapping) else v,  # type: ignore [arg-type, misc]
+        )
 
     if (
         is_sequence(data)
         and not isinstance(data, DimensionSet)
-        and (keywords is None or not isinstance(data, tuple))
+        and not isinstance(data, tuple)
     ):
-        return [normalize_data(d) for d in data]
+        return [normalize_data(d) for d in data]  # type: ignore [arg-type, misc]
+
+    if isinstance(data, tuple) and not isinstance(data, DimensionSet):
+        return tuple(normalize_data(d) for d in data)  # type: ignore [misc]
 
     if isinstance(data, str):
         s = loads(data)
@@ -108,7 +134,7 @@ def normalize_data(
 
     if isinstance(
         data,
-        (int, float, bool, tuple, DimensionSet, Dimensioned),
+        (int, float, bool, DimensionSet, Dimensioned),
     ):
         return data
 
@@ -126,13 +152,13 @@ def normalize_keyword(data: DataLike) -> Data:
 
 
 def dumps(
-    data: EntryLike,
+    data: DataLike | StandaloneDataLike | SubDictLike,
     *,
     keywords: tuple[str, ...] | None = None,
-    header: Mapping[str, Entry] | None = None,
+    header: SubDictLike | None = None,
     tuple_is_entry: bool = False,
 ) -> bytes:
-    data = normalize_data(data, keywords=keywords)
+    data = normalize_data(data, keywords=keywords)  # type: ignore [arg-type, misc]
 
     if isinstance(data, Mapping):
         return (
@@ -148,6 +174,12 @@ def dumps(
             + b"}"
         )
 
+    if keywords == () and isinstance(data, np.ndarray):
+        if (header.get("format", "") if header else "") == "binary":
+            return dumps(len(data)) + b"(" + data.tobytes() + b")"
+
+        return dumps(data.tolist())
+
     if (
         keywords is not None
         and (
@@ -215,7 +247,8 @@ def dumps(
     if isinstance(data, tuple):
         if tuple_is_entry:
             k, v = data
-            ret = dumps(k)
+            ret = b"\n" if isinstance(k, str) and k[0] == "#" else b""
+            ret += dumps(k)
             val = dumps(
                 v,
                 keywords=(*keywords, k)
@@ -224,14 +257,16 @@ def dumps(
             )
             if val:
                 ret += b" " + val
-            if not isinstance(v, Mapping):
+            if isinstance(k, str) and k[0] == "#":
+                ret += b"\n"
+            elif not isinstance(v, Mapping):
                 ret += b";"
             return ret
 
         return b" ".join(dumps(v) for v in data)
 
     if is_sequence(data):
-        return b"(" + b" ".join(dumps(v, tuple_is_entry=True) for v in data) + b")"
+        return b"(" + b" ".join(dumps(v, tuple_is_entry=True) for v in data) + b")"  # type: ignore [arg-type]
 
     if data is True:
         return b"yes"

foamlib/_files/_types.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import sys
-from typing import Any, Dict, NamedTuple, Optional, Union
+from typing import Any, Dict, List, NamedTuple, Optional, Tuple, Union
 
 import numpy as np
 
@@ -76,9 +76,8 @@ Tensor = Union[
 ]
 
 TensorLike = Union[
-    Sequence[float],
-    "np.ndarray[tuple[()], np.dtype[np.float64]]",
     Tensor,
+    Sequence[float],
 ]
 
 
@@ -116,7 +115,7 @@ class Dimensioned:
         return Dimensioned(
             self.value + other.value,  # type: ignore [arg-type]
             self.dimensions + other.dimensions,
-            f"{self.name} + {other.name}"
+            f"{self.name}+{other.name}"
             if self.name is not None and other.name is not None
             else None,
         )
@@ -128,7 +127,7 @@ class Dimensioned:
         return Dimensioned(
             self.value - other.value,  # type: ignore [arg-type]
             self.dimensions - other.dimensions,
-            f"{self.name} - {other.name}"
+            f"{self.name}-{other.name}"
             if self.name is not None and other.name is not None
             else None,
         )
@@ -140,7 +139,7 @@ class Dimensioned:
         return Dimensioned(
             self.value * other.value,  # type: ignore [arg-type]
             self.dimensions * other.dimensions,
-            f"{self.name} * {other.name}"
+            f"{self.name}*{other.name}"
             if self.name is not None and other.name is not None
             else None,
         )
@@ -152,7 +151,7 @@ class Dimensioned:
         return Dimensioned(
             self.value / other.value,  # type: ignore [arg-type]
             self.dimensions / other.dimensions,
-            f"{self.name} / {other.name}"
+            f"{self.name}/{other.name}"
             if self.name is not None and other.name is not None
             else None,
         )
@@ -164,7 +163,7 @@ class Dimensioned:
         return Dimensioned(
             self.value**exponent,  # type: ignore [arg-type]
             self.dimensions**exponent,
-            f"{self.name} ** {exponent}" if self.name is not None else None,
+            f"pow({self.name},{exponent})" if self.name is not None else None,
         )
 
     def __float__(self) -> float:
@@ -194,48 +193,61 @@ Field = Union[
 ]
 
 FieldLike = Union[
+    Field,
     TensorLike,
     Sequence[TensorLike],
-    Sequence[Sequence[TensorLike]],
-    Field,
 ]
 
 
-Data = Union[
+DataEntry = Union[
     str,
     int,
     float,
     bool,
     Dimensioned,
     DimensionSet,
-    Sequence["Entry"],
+    List[Union["DataEntry", Tuple["DataEntry", Union["DataEntry", "SubDict"]]]],
     Field,
 ]
 
-Entry = Union[
-    Data,
-    Mapping[str, "Entry"],
+DataEntryLike = Union[
+    DataEntry,
+    Sequence[
+        Union[
+            "DataEntryLike",
+            Tuple["DataEntryLike", Union["DataEntryLike", "SubDictLike"]],
+        ]
+    ],
+    FieldLike,
+]
+
+Data = Union[
+    DataEntry,
+    Tuple[DataEntry, ...],
 ]
-"""
-A value that can be stored in an OpenFOAM file.
-"""
 
 DataLike = Union[
-    FieldLike,
-    Sequence["EntryLike"],
+    DataEntryLike,
+    Tuple["DataEntryLike", ...],
+]
+
+StandaloneData = Union[
     Data,
+    "np.ndarray[tuple[int], np.dtype[np.int64 | np.int32]]",
+    "np.ndarray[tuple[int], np.dtype[np.float64 | np.float32]]",
 ]
 
-EntryLike = Union[
+StandaloneDataLike = Union[
     DataLike,
-    Mapping[str, "EntryLike"],
+    "np.ndarray[tuple[int], np.dtype[np.int64 | np.int32]]",
+    "np.ndarray[tuple[int], np.dtype[np.float64 | np.float32]]",
 ]
 
 
 def is_sequence(
-    value: EntryLike,
+    value: DataLike | StandaloneDataLike | SubDictLike,
 ) -> TypeGuard[
-    Sequence[EntryLike]
+    Sequence[DataLike | tuple[DataLike, DataLike | SubDictLike]]
     | np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.float64 | np.float32]]
 ]:
     return (isinstance(value, Sequence) and not isinstance(value, str)) or (
@@ -243,10 +255,9 @@ def is_sequence(
     )
 
 
-MutableEntry = Union[
-    Data,
-    MutableMapping[str, "MutableEntry"],
-]
+SubDict = Dict[str, Union[Data, "SubDict"]]
+SubDictLike = Mapping[str, Union[DataLike, "SubDictLike"]]
+MutableSubDict = MutableMapping[str, Union[Data, "MutableSubDict"]]
 
-Dict_ = Dict[str, Union["Entry", "Dict_"]]
-File = Dict[Optional[str], Union["Entry", "Dict_"]]
+File = Dict[Optional[str], Union[StandaloneData, Data, "SubDict"]]
+FileLike = Mapping[Optional[str], Union[StandaloneDataLike, DataLike, "FileLike"]]

{foamlib-0.9.3.dist-info → foamlib-0.9.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: foamlib
-Version: 0.9.3
+Version: 0.9.5
 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.3.dist-info → foamlib-0.9.5.dist-info}/RECORD

@@ -1,4 +1,4 @@
-foamlib/__init__.py,sha256=sKW9pgKveQO8QUcC-4ZGxJAHmRBBUsEZzFXumN9SXpY,452
+foamlib/__init__.py,sha256=T6_0si2KRlok9sXXMi_yP97TelpSM0w0aivlsmziRxI,452
 foamlib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 foamlib/_cases/__init__.py,sha256=_A1TTHuQfS9FH2_33lSEyLtOJZGFHZBco1tWJCVOHks,358
 foamlib/_cases/_async.py,sha256=e4lGTcQBbFGwfG6SmJks5aa5LWd_0dy01kgKZWAgTGQ,11655
@@ -9,12 +9,12 @@ foamlib/_cases/_subprocess.py,sha256=VHV2SuOLqa711an6kCuvN6UlIkeh4qqFfdrpNoKzQps
 foamlib/_cases/_sync.py,sha256=yhrkwStKri7u41YImYCGBH4REcKn8Ar-32VW_WPa40c,9641
 foamlib/_cases/_util.py,sha256=QCizfbuJdOCeF9ogU2R-y-iWX5kfaOA4U2W68t6QlOM,2544
 foamlib/_files/__init__.py,sha256=q1vkjXnjnSZvo45jPAICpWeF2LZv5V6xfzAR6S8fS5A,96
-foamlib/_files/_files.py,sha256=7Si-C-2O0h27Ga4bC0W-i6_PKq7B4K2Gg1tDGh8AZFo,22416
+foamlib/_files/_files.py,sha256=nbf9SPGH4v4-H4mxiMtiD8YuBJJdGC8RFlV_KLFM6bA,22676
 foamlib/_files/_io.py,sha256=BGbbm6HKxL2ka0YMCmHqZQZ1R4PPQlkvWWb4FHMAS8k,2217
-foamlib/_files/_parsing.py,sha256=CWALQclNOXUlPylI98h2DxMNz5OE0KZf9Gioc9h3OWU,17659
-foamlib/_files/_serialization.py,sha256=R9-oXYywZubevuPkYaTIAyM0_BfF9rC819j9AXOCcg8,6451
-foamlib/_files/_types.py,sha256=BJaRzICgnl2SOI6Nc2f8F8fendqmIK8VAdeb5zroYm0,7254
-foamlib-0.9.3.dist-info/METADATA,sha256=LCtjDlLD_fJaiEUyo847EcF1jbhXVufh2iJUa_ck_Ng,12906
-foamlib-0.9.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-foamlib-0.9.3.dist-info/licenses/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
-foamlib-0.9.3.dist-info/RECORD,,
+foamlib/_files/_parsing.py,sha256=r9F7QVfGhAFOXu1q3Otzo0gfdwZ4FxRNELuauJsw5-I,17718
+foamlib/_files/_serialization.py,sha256=P7u2EUx0OwvfVYinp46CpzdjGYGXJVN0-xXXuOYogfA,8020
+foamlib/_files/_types.py,sha256=eNVxuK_NDRqh0mrTcseuAD3lqn4VEBGVUYhXn-T1zEU,7884
+foamlib-0.9.5.dist-info/METADATA,sha256=cauprjQ7VzXsUqi5HWl7B_qsVufNM0uB0Iw3h0QQgpA,12906
+foamlib-0.9.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+foamlib-0.9.5.dist-info/licenses/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
+foamlib-0.9.5.dist-info/RECORD,,