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

foamlib/__init__.py

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

foamlib/_files/_files.py

@@ -17,9 +17,11 @@ else:
 import numpy as np
 
 from ._io import FoamFileIO
-from ._serialization import Kind, dumps, normalize
+from ._parsing import loads
+from ._serialization import dumps, normalize_data, normalize_keyword
 from ._types import (
     Data,
+    DataLike,
     Dict_,
     Dimensioned,
     DimensionSet,
@@ -31,6 +33,32 @@ from ._types import (
 )
 
 
+def _tensor_kind_for_field(
+    field: FieldLike,
+) -> str:
+    shape = np.shape(field)  # type: ignore [arg-type]
+    if not shape:
+        return "scalar"
+    if shape == (3,):
+        return "vector"
+    if shape == (6,):
+        return "symmTensor"
+    if shape == (9,):
+        return "tensor"
+    if len(shape) == 1:
+        return "scalar"
+    if len(shape) == 2:
+        if shape[1] == 3:
+            return "vector"
+        if shape[1] == 6:
+            return "symmTensor"
+        if shape[1] == 9:
+            return "tensor"
+
+    msg = f"Invalid field shape: {shape}"
+    raise ValueError(msg)
+
+
 class FoamFile(
     MutableMapping[
         Optional[Union[str, Tuple[str, ...]]],
@@ -261,7 +289,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_keyword(keywords[-1]), str):
             msg = f"Invalid keyword: {keywords[-1]}"
             raise ValueError(msg)
 
@@ -283,52 +311,26 @@ class FoamFile(
                     self.path.stem if self.path.suffix == ".gz" else self.path.name
                 )
 
-            kind = Kind.DEFAULT
-            if keywords == ("internalField",) or (
-                len(keywords) == 3
-                and keywords[0] == "boundaryField"
-                and (
-                    keywords[2] in ("value", "gradient")
-                    or keywords[2].endswith("Value")
-                    or keywords[2].endswith("Gradient")
-                )
-            ):
-                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.BINARY_FIELD)
+                keywords == ("internalField",)
+                or (
+                    len(keywords) == 3
+                    and keywords[0] == "boundaryField"
+                    and (
+                        keywords[2] == "value"
+                        or keywords[2] == "gradient"
+                        or keywords[2].endswith(("Value", "Gradient"))
+                    )
+                )
             ) and self.class_ == "dictionary":
                 try:
-                    shape = np.shape(data)  # type: ignore [arg-type]
+                    tensor_kind = _tensor_kind_for_field(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 shape[1] == 6:
-                            self.class_ = "volSymmTensorField"
-                        elif shape[1] == 9:
-                            self.class_ = "volTensorField"
-
-            if kind == Kind.ASCII_FIELD and self.class_.endswith("scalarField"):
-                kind = Kind.SCALAR_ASCII_FIELD
-            elif kind == Kind.BINARY_FIELD and self.class_.endswith("scalarField"):
-                kind = Kind.SCALAR_BINARY_FIELD
+                    self.class_ = (
+                        "vol" + tensor_kind[0].upper() + tensor_kind[1:] + "Field"
+                    )
 
             parsed = self._get_parsed(missing_ok=True)
 
@@ -360,7 +362,7 @@ class FoamFile(
                     ...,
                     before
                     + indentation
-                    + dumps(keywords[-1])
+                    + dumps(normalize_keyword(keywords[-1]))
                     + b"\n"
                     + indentation
                     + b"{\n"
@@ -373,23 +375,37 @@ class FoamFile(
                     self[(*keywords, k)] = v
 
             elif keywords:
-                val = dumps(data, kind=kind)
+                header = self.get("FoamFile", None)
+                assert header is None or isinstance(header, FoamFile.SubDict)
+                val = dumps(
+                    data,
+                    keywords=keywords,
+                    header=header,
+                )
                 parsed.put(
                     keywords,
-                    normalize(data, kind=kind),
+                    normalize_data(data, keywords=keywords),
                     before
                     + indentation
-                    + dumps(keywords[-1])
+                    + dumps(normalize_keyword(keywords[-1]))
                     + ((b" " + val) if val else b"")
                     + (b";" if not keywords[-1].startswith("#") else b"")
                     + after,
                 )
 
             else:
+                header = self.get("FoamFile", None)
+                assert header is None or isinstance(header, FoamFile.SubDict)
                 parsed.put(
                     (),
-                    normalize(data, kind=kind),
-                    before + dumps(data, kind=kind) + after,
+                    normalize_data(data, keywords=keywords),
+                    before
+                    + dumps(
+                        data,
+                        keywords=(),
+                        header=header,
+                    )
+                    + after,
                 )
 
     def __delitem__(self, keywords: str | tuple[str, ...] | None) -> None:
@@ -442,6 +458,85 @@ class FoamFile(
             d.pop("FoamFile", None)
         return deepcopy(d)
 
+    @staticmethod
+    def loads(
+        s: bytes | str,
+        *,
+        include_header: bool = False,
+    ) -> File | Data:
+        """
+        Standalone deserializing function.
+
+        Deserialize the OpenFOAM FoamFile format to Python objects.
+
+        :param s: The string to deserialize. This can be a dictionary, list, or any
+            other object that can be serialized to the OpenFOAM format.
+        :param include_header: Whether to include the "FoamFile" header in the output.
+            If `True`, the header will be included if it is present in the input object.
+        """
+        ret = loads(s)
+
+        if not include_header and isinstance(ret, Mapping) and "FoamFile" in ret:
+            del ret["FoamFile"]
+            if len(ret) == 1 and None in ret:
+                val = ret[None]
+                assert not isinstance(val, Mapping)
+                return val
+
+        return ret
+
+    @staticmethod
+    def dumps(file: File | DataLike, *, ensure_header: bool = True) -> bytes:
+        """
+        Standalone serializing function.
+
+        Serialize Python objects to the OpenFOAM FoamFile format.
+
+        :param file: The Python object to serialize. This can be a dictionary, list,
+            or any other object that can be serialized to the OpenFOAM format.
+        :param ensure_header: Whether to include the "FoamFile" header in the output.
+            If `True`, a header will be included if it is not already present in the
+            input object.
+        """
+        if isinstance(file, Mapping):
+            header = file.get("FoamFile", None)
+            assert isinstance(header, FoamFile.SubDict) or header is None
+            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)
+                    )
+                else:
+                    entries.append(dumps(v, keywords=(), header=header))
+            ret = b" ".join(entries)
+        else:
+            header = None
+            ret = dumps(file)
+
+        if header is None and ensure_header:
+            class_ = "dictionary"
+            if isinstance(file, Mapping) and "internalField" in file:
+                try:
+                    tensor_kind = _tensor_kind_for_field(file["internalField"])  # type: ignore [arg-type]
+                except (ValueError, TypeError):
+                    pass
+                else:
+                    class_ = "vol" + tensor_kind[0].upper() + tensor_kind[1:] + "Field"
+
+            header = {"version": 2.0, "format": "ascii", "class": class_}
+
+            ret = (
+                dumps(
+                    {"FoamFile": header},
+                    keywords=(),
+                )
+                + b" "
+                + ret
+            )
+
+        return ret
+
 
 class FoamFieldFile(FoamFile):
     """

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
@@ -380,21 +382,41 @@ _NUMBER = (
 )
 _DATA_ENTRY <<= _FIELD | _LIST | _DIMENSIONED | _DIMENSIONS | _NUMBER | _SWITCH | _TOKEN
 
-_DATA <<= (
-    _DATA_ENTRY[1, ...]
-    .set_parse_action(lambda tks: [tuple(tks)] if len(tks) > 1 else [tks[0]])
+_DATA <<= _DATA_ENTRY[1, ...].set_parse_action(
+    lambda tks: [tuple(tks)] if len(tks) > 1 else [tks[0]]
+)
+
+_STANDALONE_DATA = (
+    _ascii_numeric_list(dtype=int, ignore=_COMMENT)
+    | _binary_numeric_list(dtype=np.int64)
+    | _binary_numeric_list(dtype=np.int32)
+    | _ascii_numeric_list(dtype=float, nested=3, ignore=_COMMENT)
+    | _binary_numeric_list(dtype=np.float64, nested=3)
+    | _binary_numeric_list(dtype=np.float32, nested=3)
+    | _DATA
+).add_parse_action(lambda tks: [None, tks[0]])
+
+
+_FILE = (
+    Dict(_KEYWORD_ENTRY[...] + Opt(Group(_STANDALONE_DATA)) + _KEYWORD_ENTRY[...])
     .ignore(_COMMENT)
     .parse_with_tabs()
 )
 
 
-def parse_data(s: str) -> Data:
-    if not s.strip():
-        return ""
-    return cast("Data", _DATA.parse_string(s, parse_all=True)[0])
+def loads(s: bytes | str) -> File | Data:
+    if isinstance(s, bytes):
+        s = s.decode("latin-1")
+
+    file = _FILE.parse_string(s, parse_all=True).as_dict()
 
+    if len(file) == 1 and None in file:
+        return file[None]  # type: ignore[no-any-return]
 
-_LOCATED_DICTIONARY = Group(
+    return file
+
+
+_LOCATED_KEYWORD_ENTRIES = Group(
     _keyword_entry_of(
         _TOKEN,
         Opt(_DATA, default=""),
@@ -403,22 +425,14 @@ _LOCATED_DICTIONARY = Group(
         located=True,
     )
 )[...]
-_LOCATED_DATA = Group(
-    Located(
-        (
-            _ascii_numeric_list(dtype=int, ignore=_COMMENT)
-            | _binary_numeric_list(dtype=np.int64)
-            | _binary_numeric_list(dtype=np.int32)
-            | _ascii_numeric_list(dtype=float, nested=3, ignore=_COMMENT)
-            | _binary_numeric_list(dtype=np.float64, nested=3)
-            | _binary_numeric_list(dtype=np.float32, nested=3)
-            | _DATA
-        ).add_parse_action(lambda tks: ["", tks[0]])
-    )
-)
+_LOCATED_STANDALONE_DATA = Group(Located(_STANDALONE_DATA))
 
-_FILE = (
-    Dict(_LOCATED_DICTIONARY + Opt(_LOCATED_DATA) + _LOCATED_DICTIONARY)
+_LOCATED_FILE = (
+    Dict(
+        _LOCATED_KEYWORD_ENTRIES
+        + Opt(_LOCATED_STANDALONE_DATA)
+        + _LOCATED_KEYWORD_ENTRIES
+    )
     .ignore(_COMMENT)
     .parse_with_tabs()
 )
@@ -430,7 +444,7 @@ class Parsed(Mapping[Tuple[str, ...], Union[Data, EllipsisType]]):
             tuple[str, ...],
             tuple[int, Data | EllipsisType, int],
         ] = {}
-        for parse_result in _FILE.parse_string(
+        for parse_result in _LOCATED_FILE.parse_string(
             contents.decode("latin-1"), parse_all=True
         ):
             self._parsed.update(self._flatten_result(parse_result))
@@ -453,8 +467,7 @@ class Parsed(Mapping[Tuple[str, ...], Union[Data, EllipsisType]]):
         end = parse_result.locn_end
         assert isinstance(end, int)
         keyword, *data = item
-        assert isinstance(keyword, str)
-        if not keyword:
+        if keyword is None:
             assert not _keywords
             assert len(data) == 1
             assert not isinstance(data[0], ParseResults)

foamlib/_files/_serialization.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import sys
-from enum import Enum, auto
 from typing import overload
 
 if sys.version_info >= (3, 9):
@@ -11,7 +10,7 @@ else:
 
 import numpy as np
 
-from ._parsing import parse_data
+from ._parsing import loads
 from ._types import (
     Data,
     DataLike,
@@ -23,31 +22,32 @@ from ._types import (
 )
 
 
-class Kind(Enum):
-    DEFAULT = auto()
-    SINGLE_ENTRY = auto()
-    ASCII_FIELD = auto()
-    SCALAR_ASCII_FIELD = auto()
-    BINARY_FIELD = auto()
-    SCALAR_BINARY_FIELD = auto()
-    DIMENSIONS = auto()
-    KEYWORD = auto()
-
-
 @overload
-def normalize(data: DataLike, *, kind: Kind = Kind.DEFAULT) -> Data: ...
+def normalize_data(
+    data: DataLike, *, keywords: tuple[str, ...] | None = None
+) -> Data: ...
 
 
 @overload
-def normalize(data: EntryLike, *, kind: Kind = Kind.DEFAULT) -> Entry: ...
-
-
-def normalize(data: EntryLike, *, kind: Kind = Kind.DEFAULT) -> Entry:
-    if kind in (
-        Kind.ASCII_FIELD,
-        Kind.SCALAR_ASCII_FIELD,
-        Kind.BINARY_FIELD,
-        Kind.SCALAR_BINARY_FIELD,
+def normalize_data(
+    data: EntryLike, *, keywords: tuple[str, ...] | None = None
+) -> Entry: ...
+
+
+def normalize_data(
+    data: EntryLike, *, keywords: tuple[str, ...] | None = None
+) -> Entry:
+    if keywords is not None and (
+        keywords == ("internalField",)
+        or (
+            len(keywords) == 3
+            and keywords[0] == "boundaryField"
+            and (
+                keywords[2] == "value"
+                or keywords[2] == "gradient"
+                or keywords[2].endswith(("Value", "Gradient"))
+            )
+        )
     ):
         if is_sequence(data):
             try:
@@ -61,41 +61,50 @@ def normalize(data: EntryLike, *, kind: Kind = Kind.DEFAULT) -> Entry:
                 if arr.ndim == 1 or (arr.ndim == 2 and arr.shape[1] in (3, 6, 9)):
                     return arr  # type: ignore [return-value]
 
-            return [normalize(d, kind=Kind.SINGLE_ENTRY) for d in data]
+            return [normalize_data(d) for d in data]
 
         if isinstance(data, int):
             return float(data)
 
-        return normalize(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
 
-    if isinstance(data, Mapping):
-        return {k: normalize(v, kind=kind) for k, v in data.items()}
-
     if (
-        kind == Kind.DIMENSIONS
+        not isinstance(data, DimensionSet)
+        and keywords is not None
+        and keywords == ("dimensions",)
         and is_sequence(data)
         and len(data) <= 7
         and all(isinstance(d, (int, float)) for d in data)
     ):
         return DimensionSet(*data)
 
-    if isinstance(data, tuple) and kind == Kind.SINGLE_ENTRY and len(data) == 2:
+    if keywords is None and isinstance(data, tuple) and len(data) == 2:
         k, v = data
-        return (normalize(k), normalize(v))
+        assert not isinstance(k, Mapping)
+        return (
+            normalize_keyword(k),
+            normalize_data(v) if not isinstance(v, Mapping) else v,
+        )  # type: ignore [return-value]
 
-    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 (
+        is_sequence(data)
+        and not isinstance(data, DimensionSet)
+        and (keywords is None or not isinstance(data, tuple))
+    ):
+        return [normalize_data(d) for d in data]
 
     if isinstance(data, str):
-        parsed_data = parse_data(data)
-        if kind == Kind.KEYWORD and isinstance(parsed_data, bool):
-            return data
-        return parsed_data
+        s = loads(data)
+        if isinstance(s, (str, tuple, bool)):
+            return s
 
     if isinstance(
         data,
@@ -107,52 +116,70 @@ def normalize(data: EntryLike, *, kind: Kind = Kind.DEFAULT) -> Entry:
     raise TypeError(msg)
 
 
+def normalize_keyword(data: DataLike) -> Data:
+    ret = normalize_data(data)
+
+    if isinstance(data, str) and isinstance(ret, bool):
+        return data
+
+    return ret
+
+
 def dumps(
     data: EntryLike,
     *,
-    kind: Kind = Kind.DEFAULT,
+    keywords: tuple[str, ...] | None = None,
+    header: Mapping[str, Entry] | None = None,
+    tuple_is_entry: bool = False,
 ) -> bytes:
-    data = normalize(data, kind=kind)
+    data = normalize_data(data, keywords=keywords)
 
     if isinstance(data, Mapping):
         return (
             b"{"
-            + b" ".join(dumps((k, v), kind=Kind.SINGLE_ENTRY) for k, v in data.items())
+            + b" ".join(
+                dumps(
+                    (k, v),
+                    keywords=keywords,
+                    tuple_is_entry=True,
+                )
+                for k, v in data.items()
+            )
             + b"}"
         )
 
-    if isinstance(data, tuple) and kind == Kind.SINGLE_ENTRY and len(data) == 2:
-        k, v = data
-        ret = dumps(k)
-        val = dumps(v)
-        if val:
-            ret += b" " + val
-        if not isinstance(v, Mapping):
-            ret += b";"
-        return ret
-
-    if isinstance(data, DimensionSet):
-        return b"[" + b" ".join(dumps(v) for v in data) + b"]"
+    if (
+        keywords is not None
+        and (
+            keywords == ("internalField",)
+            or (
+                len(keywords) == 3
+                and keywords[0] == "boundaryField"
+                and (
+                    keywords[2] == "value"
+                    or keywords[2] == "gradient"
+                    or keywords[2].endswith(("Value", "Gradient"))
+                )
+            )
+        )
+        and isinstance(data, (int, float, np.ndarray))
+    ):
+        data = np.asarray(data)  # type: ignore [assignment]
+        class_ = header.get("class", "") if header else ""
+        assert isinstance(class_, str)
+        scalar = "Scalar" in class_
 
-    if kind in (
-        Kind.ASCII_FIELD,
-        Kind.SCALAR_ASCII_FIELD,
-        Kind.BINARY_FIELD,
-        Kind.SCALAR_BINARY_FIELD,
-    ) and (isinstance(data, (int, float, np.ndarray))):
         shape = np.shape(data)
-        if not shape or (
-            kind not in (Kind.SCALAR_ASCII_FIELD, Kind.SCALAR_BINARY_FIELD)
-            and shape in ((3,), (6,), (9,))
-        ):
-            return b"uniform " + dumps(data, kind=Kind.SINGLE_ENTRY)
+        if not shape or (not scalar and shape in ((3,), (6,), (9,))):
+            return b"uniform " + dumps(data)
 
         assert isinstance(data, np.ndarray)
-        ndim = len(shape)
+        ndim = np.ndim(data)
         if ndim == 1:
             tensor_kind = b"scalar"
 
         elif ndim == 2:
+            assert len(shape) == 2
             if shape[1] == 3:
                 tensor_kind = b"vector"
             elif shape[1] == 6:
@@ -165,34 +192,46 @@ def dumps(
         else:
             return dumps(data)
 
-        if kind in (Kind.BINARY_FIELD, Kind.SCALAR_BINARY_FIELD):
-            contents = b"(" + data.tobytes() + b")"
-        else:
-            assert kind in (Kind.ASCII_FIELD, Kind.SCALAR_ASCII_FIELD)
-            contents = dumps(data, kind=Kind.SINGLE_ENTRY)
+        binary = (header.get("format", "") if header else "") == "binary"
+
+        contents = b"(" + data.tobytes() + b")" if binary else dumps(data)
 
         return b"nonuniform List<" + tensor_kind + b"> " + dumps(len(data)) + contents
 
+    if isinstance(data, DimensionSet):
+        return b"[" + b" ".join(dumps(v) for v in data) + b"]"
+
     if isinstance(data, Dimensioned):
         if data.name is not None:
             return (
                 dumps(data.name)
                 + b" "
-                + dumps(data.dimensions, kind=Kind.DIMENSIONS)
+                + dumps(data.dimensions)
                 + b" "
-                + dumps(data.value, kind=Kind.SINGLE_ENTRY)
+                + dumps(data.value)
             )
-        return (
-            dumps(data.dimensions, kind=Kind.DIMENSIONS)
-            + b" "
-            + dumps(data.value, kind=Kind.SINGLE_ENTRY)
-        )
+        return dumps(data.dimensions) + b" " + dumps(data.value)
 
     if isinstance(data, tuple):
+        if tuple_is_entry:
+            k, v = data
+            ret = dumps(k)
+            val = dumps(
+                v,
+                keywords=(*keywords, k)
+                if keywords is not None and isinstance(k, str)
+                else None,
+            )
+            if val:
+                ret += b" " + val
+            if not isinstance(v, Mapping):
+                ret += b";"
+            return ret
+
         return b" ".join(dumps(v) for v in data)
 
-    if is_sequence(data) and not isinstance(data, tuple):
-        return b"(" + b" ".join(dumps(v, kind=Kind.SINGLE_ENTRY) for v in data) + b")"
+    if is_sequence(data):
+        return b"(" + b" ".join(dumps(v, tuple_is_entry=True) for v in data) + b")"
 
     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, NamedTuple, Optional, 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,
@@ -61,16 +102,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"{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,

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

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

@@ -1,4 +1,4 @@
-foamlib/__init__.py,sha256=0HqaL6QRggvb5wLBXgC3aMmHL7gltD8K2njaeYZJezI,452
+foamlib/__init__.py,sha256=sKW9pgKveQO8QUcC-4ZGxJAHmRBBUsEZzFXumN9SXpY,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=gSJQjvB1f7N2yJtCTx9kpivKqSSNjDj37qNMpned5CM,19505
+foamlib/_files/_files.py,sha256=7Si-C-2O0h27Ga4bC0W-i6_PKq7B4K2Gg1tDGh8AZFo,22416
 foamlib/_files/_io.py,sha256=BGbbm6HKxL2ka0YMCmHqZQZ1R4PPQlkvWWb4FHMAS8k,2217
-foamlib/_files/_parsing.py,sha256=Nhktc7RnF7QIydUFm1umgQKiIW0s8GoPmagWRqfvaLQ,17404
-foamlib/_files/_serialization.py,sha256=QJ-F6BKizVe0gpjnpIfPxNGTqWwalY4PQtCKdDY9D70,5502
-foamlib/_files/_types.py,sha256=q5O_x680XhGfvPHCNF_3objK1imUG2kgQYNRF2Z4qJ0,2918
-foamlib-0.9.1.dist-info/METADATA,sha256=ZSdTaK1ejV7YBHJVoQX384eudRHxTIxfjRiK7kH0Bxk,12906
-foamlib-0.9.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-foamlib-0.9.1.dist-info/licenses/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
-foamlib-0.9.1.dist-info/RECORD,,
+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,,