foamlib 0.9.2__py3-none-any.whl → 0.9.4__py3-none-any.whl

foamlib/__init__.py

@@ -1,6 +1,6 @@
 """A Python interface for interacting with OpenFOAM."""
 
-__version__ = "0.9.2"
+__version__ = "0.9.4"
 
 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,7 +363,9 @@ _FIELD = (Keyword("uniform", _IDENTBODYCHARS).suppress() + _TENSOR) | (
 _DIRECTIVE = Word("#", _IDENTBODYCHARS)
 _TOKEN = dbl_quoted_string | _DIRECTIVE | _IDENTIFIER
 _DATA = Forward()
-_KEYWORD_ENTRY = _keyword_entry_of(_TOKEN | _list_of(_IDENTIFIER), _DATA)
+_KEYWORD_ENTRY = _keyword_entry_of(
+    _TOKEN | _list_of(_IDENTIFIER), Opt(_DATA, default="")
+)
 _DICT = _dict_of(_TOKEN, _DATA)
 _DATA_ENTRY = Forward()
 _LIST_ENTRY = _DICT | _KEYWORD_ENTRY | _DATA_ENTRY

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]
 
         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)
@@ -90,16 +113,19 @@ def normalize_data(
         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]
+            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]
+
+    if isinstance(data, tuple) and not isinstance(data, DimensionSet):
+        return tuple(normalize_data(d) for d in data)
 
     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 (
@@ -231,7 +263,7 @@ def dumps(
         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 Dict, NamedTuple, Optional, Union
+from typing import Any, Dict, List, NamedTuple, Optional, Tuple, Union
 
 import numpy as np
 
@@ -28,6 +28,47 @@ class DimensionSet(NamedTuple):
     def __repr__(self) -> str:
         return f"{type(self).__name__}({', '.join(f'{n}={v}' for n, v in zip(self._fields, self) if v != 0)})"
 
+    def __add__(self, other: DimensionSet) -> DimensionSet:  # type: ignore[override]
+        if not isinstance(other, DimensionSet):
+            return NotImplemented
+
+        if self != other:
+            msg = f"Cannot add DimensionSet with different dimensions: {self} + {other}"
+            raise ValueError(msg)
+
+        return self
+
+    def __sub__(self, other: DimensionSet) -> DimensionSet:
+        if not isinstance(other, DimensionSet):
+            return NotImplemented
+
+        if self != other:
+            msg = f"Cannot subtract DimensionSet with different dimensions: {self} - {other}"
+            raise ValueError(msg)
+
+        return self
+
+    def __mul__(self, other: DimensionSet) -> DimensionSet:  # type: ignore[override]
+        if not isinstance(other, DimensionSet):
+            return NotImplemented
+
+        return DimensionSet(*(a + b for a, b in zip(self, other)))
+
+    def __truediv__(self, other: DimensionSet) -> DimensionSet:
+        if not isinstance(other, DimensionSet):
+            return NotImplemented
+
+        return DimensionSet(*(a - b for a, b in zip(self, other)))
+
+    def __pow__(self, exponent: float) -> DimensionSet:
+        if not isinstance(exponent, (int, float)):
+            return NotImplemented
+
+        return DimensionSet(*(a * exponent for a in self))
+
+    def __bool__(self) -> bool:
+        return any(v != 0 for v in self)
+
 
 Tensor = Union[
     float,
@@ -35,9 +76,8 @@ Tensor = Union[
 ]
 
 TensorLike = Union[
-    Sequence[float],
-    "np.ndarray[tuple[()], np.dtype[np.float64]]",
     Tensor,
+    Sequence[float],
 ]
 
 
@@ -61,16 +101,91 @@ class Dimensioned:
 
         self.name = name
 
-    def __eq__(self, other: object) -> bool:
+    def __repr__(self) -> str:
+        if self.name is not None:
+            return (
+                f"{type(self).__name__}({self.value}, {self.dimensions}, {self.name})"
+            )
+        return f"{type(self).__name__}({self.value}, {self.dimensions})"
+
+    def __add__(self, other: Dimensioned | Tensor) -> Dimensioned:
         if not isinstance(other, Dimensioned):
+            other = Dimensioned(other, DimensionSet())
+
+        return Dimensioned(
+            self.value + other.value,  # type: ignore [arg-type]
+            self.dimensions + other.dimensions,
+            f"{self.name}+{other.name}"
+            if self.name is not None and other.name is not None
+            else None,
+        )
+
+    def __sub__(self, other: Dimensioned | Tensor) -> Dimensioned:
+        if not isinstance(other, Dimensioned):
+            other = Dimensioned(other, DimensionSet())
+
+        return Dimensioned(
+            self.value - other.value,  # type: ignore [arg-type]
+            self.dimensions - other.dimensions,
+            f"{self.name}-{other.name}"
+            if self.name is not None and other.name is not None
+            else None,
+        )
+
+    def __mul__(self, other: Dimensioned | Tensor) -> Dimensioned:
+        if not isinstance(other, Dimensioned):
+            other = Dimensioned(other, DimensionSet())
+
+        return Dimensioned(
+            self.value * other.value,  # type: ignore [arg-type]
+            self.dimensions * other.dimensions,
+            f"{self.name}*{other.name}"
+            if self.name is not None and other.name is not None
+            else None,
+        )
+
+    def __truediv__(self, other: Dimensioned | Tensor) -> Dimensioned:
+        if not isinstance(other, Dimensioned):
+            other = Dimensioned(other, DimensionSet())
+
+        return Dimensioned(
+            self.value / other.value,  # type: ignore [arg-type]
+            self.dimensions / other.dimensions,
+            f"{self.name}/{other.name}"
+            if self.name is not None and other.name is not None
+            else None,
+        )
+
+    def __pow__(self, exponent: float) -> Dimensioned:
+        if not isinstance(exponent, (int, float)):
             return NotImplemented
 
-        return (
-            self.dimensions == other.dimensions
-            and np.array_equal(self.value, other.value)
-            and self.name == other.name
+        return Dimensioned(
+            self.value**exponent,  # type: ignore [arg-type]
+            self.dimensions**exponent,
+            f"pow({self.name},{exponent})" if self.name is not None else None,
         )
 
+    def __float__(self) -> float:
+        if self.dimensions:
+            msg = f"Cannot convert non-dimensionless Dimensioned object to float: {self.dimensions}"
+            raise ValueError(msg)
+        return float(self.value)
+
+    def __int__(self) -> int:
+        if self.dimensions:
+            msg = f"Cannot convert non-dimensionless Dimensioned object to int: {self.dimensions}"
+            raise ValueError(msg)
+        return int(self.value)
+
+    def __array__(
+        self, dtype: Any = None, *, copy: Any = None
+    ) -> np.ndarray[tuple[()] | tuple[int], np.dtype[np.float64]]:
+        if self.dimensions:
+            msg = f"Cannot convert non-dimensionless Dimensioned object to array: {self.dimensions}"
+            raise ValueError(msg)
+        return np.array(self.value, dtype=dtype, copy=copy)
+
 
 Field = Union[
     float,
@@ -78,10 +193,9 @@ Field = Union[
 ]
 
 FieldLike = Union[
+    Field,
     TensorLike,
     Sequence[TensorLike],
-    Sequence[Sequence[TensorLike]],
-    Field,
 ]
 
 
@@ -92,34 +206,35 @@ Data = Union[
     bool,
     Dimensioned,
     DimensionSet,
-    Sequence["Entry"],
+    Tuple["Data", ...],
+    List[Union["Data", Tuple["Data", Union["Data", "SubDict"]]]],
     Field,
 ]
 
-Entry = Union[
+DataLike = Union[
     Data,
-    Mapping[str, "Entry"],
+    Tuple["DataLike", ...],
+    Sequence[Union["DataLike", Tuple["DataLike", Union["DataLike", "SubDictLike"]]]],
+    FieldLike,
 ]
-"""
-A value that can be stored in an OpenFOAM file.
-"""
 
-DataLike = Union[
-    FieldLike,
-    Sequence["EntryLike"],
+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 (
@@ -127,10 +242,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.2.dist-info → foamlib-0.9.4.dist-info}/METADATA

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

@@ -1,4 +1,4 @@
-foamlib/__init__.py,sha256=75bXvyciN5IbxNdsJ4XEBETcI5ojrnjWQhQco2Xmqy4,452
+foamlib/__init__.py,sha256=LQALCtihE20dGUDWlQdYlr_X7vLFUhOExPzWqPtDDAY,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=ftaAh8WJ816Y6ej9ntoUzBOn6hC22qHLgN00568Hc2w,17636
-foamlib/_files/_serialization.py,sha256=R9-oXYywZubevuPkYaTIAyM0_BfF9rC819j9AXOCcg8,6451
-foamlib/_files/_types.py,sha256=q5O_x680XhGfvPHCNF_3objK1imUG2kgQYNRF2Z4qJ0,2918
-foamlib-0.9.2.dist-info/METADATA,sha256=c1itaOTpgA5-3jV5ADxqg02_th-qPhry2mA4M7fR9rk,12906
-foamlib-0.9.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-foamlib-0.9.2.dist-info/licenses/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
-foamlib-0.9.2.dist-info/RECORD,,
+foamlib/_files/_parsing.py,sha256=CWALQclNOXUlPylI98h2DxMNz5OE0KZf9Gioc9h3OWU,17659
+foamlib/_files/_serialization.py,sha256=R7hnUNWH1McOnu4k7grfbJKvNGhADSSTIOIXrDDtw74,7800
+foamlib/_files/_types.py,sha256=SmKA6I1l6Q7JHOlhLFV1s2cU3tkeBQmj13lW3ETlKU0,7710
+foamlib-0.9.4.dist-info/METADATA,sha256=jRLgmp_A9dsqH2P_RzhESlkSBLlGB3XeC4xFljDzhRM,12906
+foamlib-0.9.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+foamlib-0.9.4.dist-info/licenses/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
+foamlib-0.9.4.dist-info/RECORD,,