foamlib 0.9.2__tar.gz → 0.9.3__tar.gz

{foamlib-0.9.2 → foamlib-0.9.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: foamlib
-Version: 0.9.2
+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.2 → foamlib-0.9.3}/foamlib/__init__.py

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

{foamlib-0.9.2 → foamlib-0.9.3}/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-0.9.3/foamlib/_files/_types.py

@@ -0,0 +1,252 @@
+from __future__ import annotations
+
+import sys
+from typing import Any, Dict, NamedTuple, Optional, Union
+
+import numpy as np
+
+if sys.version_info >= (3, 9):
+    from collections.abc import Mapping, MutableMapping, Sequence
+else:
+    from typing import Mapping, MutableMapping, Sequence
+
+if sys.version_info >= (3, 10):
+    from typing import TypeGuard
+else:
+    from typing_extensions import TypeGuard
+
+
+class DimensionSet(NamedTuple):
+    mass: float = 0
+    length: float = 0
+    time: float = 0
+    temperature: float = 0
+    moles: float = 0
+    current: float = 0
+    luminous_intensity: float = 0
+
+    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,
+    "np.ndarray[tuple[int], np.dtype[np.float64]]",
+]
+
+TensorLike = Union[
+    Sequence[float],
+    "np.ndarray[tuple[()], np.dtype[np.float64]]",
+    Tensor,
+]
+
+
+class Dimensioned:
+    def __init__(
+        self,
+        value: TensorLike,
+        dimensions: DimensionSet | Sequence[float],
+        name: str | None = None,
+    ) -> None:
+        if is_sequence(value):
+            self.value: Tensor = np.array(value, dtype=float)  # type: ignore [assignment]
+        else:
+            assert isinstance(value, (int, float, np.ndarray))
+            self.value = float(value)
+
+        if not isinstance(dimensions, DimensionSet):
+            self.dimensions = DimensionSet(*dimensions)
+        else:
+            self.dimensions = dimensions
+
+        self.name = name
+
+    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 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,
+    "np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.float64 | np.float32]]",
+]
+
+FieldLike = Union[
+    TensorLike,
+    Sequence[TensorLike],
+    Sequence[Sequence[TensorLike]],
+    Field,
+]
+
+
+Data = Union[
+    str,
+    int,
+    float,
+    bool,
+    Dimensioned,
+    DimensionSet,
+    Sequence["Entry"],
+    Field,
+]
+
+Entry = Union[
+    Data,
+    Mapping[str, "Entry"],
+]
+"""
+A value that can be stored in an OpenFOAM file.
+"""
+
+DataLike = Union[
+    FieldLike,
+    Sequence["EntryLike"],
+    Data,
+]
+
+EntryLike = Union[
+    DataLike,
+    Mapping[str, "EntryLike"],
+]
+
+
+def is_sequence(
+    value: EntryLike,
+) -> TypeGuard[
+    Sequence[EntryLike]
+    | np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.float64 | np.float32]]
+]:
+    return (isinstance(value, Sequence) and not isinstance(value, str)) or (
+        isinstance(value, np.ndarray) and value.ndim > 0
+    )
+
+
+MutableEntry = Union[
+    Data,
+    MutableMapping[str, "MutableEntry"],
+]
+
+Dict_ = Dict[str, Union["Entry", "Dict_"]]
+File = Dict[Optional[str], Union["Entry", "Dict_"]]

{foamlib-0.9.2 → foamlib-0.9.3}/tests/test_files/test_files.py

@@ -78,13 +78,12 @@ def test_write_read(tmp_path: Path) -> None:
     assert sd["nestedList"] == [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
 
     sd["g"] = FoamFile.Dimensioned(
-        name="g", dimensions=[1, 1, -2, 0, 0, 0, 0], value=[0, 0, -9.81]
-    )
-    assert sd["g"] == FoamFile.Dimensioned(
-        name="g",
-        dimensions=FoamFile.DimensionSet(mass=1, length=1, time=-2),
-        value=[0, 0, -9.81],
+        name="g", dimensions=[0, 1, -2, 0, 0, 0, 0], value=[0, 0, -9.81]
     )
+    assert isinstance(sd["g"], FoamFile.Dimensioned)
+    assert sd["g"].name == "g"
+    assert sd["g"].dimensions == FoamFile.DimensionSet(length=1, time=-2)
+    assert np.array_equal(sd["g"].value, [0, 0, -9.81])
 
     sd["n"] = 1
     sd["y"] = 2

{foamlib-0.9.2 → foamlib-0.9.3}/tests/test_files/test_parsing/test_basic.py

@@ -95,14 +95,16 @@ def test_parse_value() -> None:
     assert Parsed(b"[1 1 -2 0 0 0 0]")[()] == FoamFile.DimensionSet(
         mass=1, length=1, time=-2
     )
-    assert Parsed(b"g [1 1 -2 0 0 0 0] (0 0 -9.81)")[()] == FoamFile.Dimensioned(
-        name="g",
-        dimensions=FoamFile.DimensionSet(mass=1, length=1, time=-2),
-        value=[0, 0, -9.81],
-    )
-    assert Parsed(b"[1 1 -2 0 0 0 0] 9.81")[()] == FoamFile.Dimensioned(
-        dimensions=FoamFile.DimensionSet(mass=1, length=1, time=-2), value=9.81
-    )
+    dimensioned = Parsed(b"g [1 1 -2 0 0 0 0] (0 0 -9.81)")[()]
+    assert isinstance(dimensioned, FoamFile.Dimensioned)
+    assert dimensioned.dimensions == FoamFile.DimensionSet(mass=1, length=1, time=-2)
+    assert np.array_equal(dimensioned.value, [0, 0, -9.81])
+    assert dimensioned.name == "g"
+    dimensioned = Parsed(b"[1 1 -2 0 0 0 0] 9.81")[()]
+    assert isinstance(dimensioned, FoamFile.Dimensioned)
+    assert dimensioned.dimensions == FoamFile.DimensionSet(mass=1, length=1, time=-2)
+    assert dimensioned.value == 9.81
+    assert dimensioned.name is None
     tpl = Parsed(b"hex (0 1 2 3 4 5 6 7) (1 1 1) simpleGrading (1 1 1)")[()]
     assert isinstance(tpl, tuple)
     assert len(tpl) == 5

{foamlib-0.9.2 → foamlib-0.9.3}/tests/test_files/test_parsing/test_loads.py

@@ -18,6 +18,7 @@ def test_loads() -> None:
     assert FoamFile.loads("word word") == ("word", "word")
     assert FoamFile.loads('"a string"') == '"a string"'
     assert FoamFile.loads("(word word)") == ["word", "word"]
+    assert FoamFile.loads("keyword value;") == {"keyword": "value"}
     assert FoamFile.loads("uniform 1") == 1
     assert FoamFile.loads("uniform 1.0") == 1.0
     assert FoamFile.loads("uniform 1.0e-3") == 1.0e-3
@@ -57,13 +58,16 @@ def test_loads() -> None:
     assert FoamFile.loads("[1 1 -2 0 0 0 0]") == FoamFile.DimensionSet(
         mass=1, length=1, time=-2
     )
-    assert FoamFile.loads("g [1 1 -2 0 0 0 0] (0 0 -9.81)") == FoamFile.Dimensioned(
-        name="g",
-        dimensions=FoamFile.DimensionSet(mass=1, length=1, time=-2),
-        value=[0, 0, -9.81],
-    )
-    assert FoamFile.loads("[1 1 -2 0 0 0 0] 9.81") == FoamFile.Dimensioned(
-        dimensions=FoamFile.DimensionSet(mass=1, length=1, time=-2), value=9.81
-    )
+    dimensioned = FoamFile.loads("g [1 1 -2 0 0 0 0] (0 0 -9.81)")
+    assert isinstance(dimensioned, FoamFile.Dimensioned)
+    assert dimensioned.dimensions == FoamFile.DimensionSet(mass=1, length=1, time=-2)
+    assert np.array_equal(dimensioned.value, [0, 0, -9.81])
+    assert dimensioned.name == "g"
+    dimensioned = FoamFile.loads("[1 1 -2 0 0 0 0] 9.81")
+    assert isinstance(dimensioned, FoamFile.Dimensioned)
+    assert dimensioned.dimensions == FoamFile.DimensionSet(mass=1, length=1, time=-2)
+    assert dimensioned.value == 9.81
+    assert dimensioned.name is None
     assert FoamFile.loads("a {b c; d e;}") == {"a": {"b": "c", "d": "e"}}
     assert FoamFile.loads("(a b; c d;)") == [("a", "b"), ("c", "d")]
+    assert FoamFile.loads("keyword;") == {"keyword": ""}

foamlib-0.9.3/tests/test_files/test_types.py

@@ -0,0 +1,62 @@
+import numpy as np
+import pytest
+from foamlib import FoamFile
+
+
+def test_dimension_set() -> None:
+    dims = FoamFile.DimensionSet(length=1, time=-2)
+    assert dims.length == 1
+    assert dims.time == -2
+    assert dims.mass == 0
+
+    assert dims + dims == dims
+    assert dims - dims == dims
+    assert dims * dims == FoamFile.DimensionSet(length=2, time=-4)
+    assert dims / dims == FoamFile.DimensionSet()
+    assert dims**2 == FoamFile.DimensionSet(length=2, time=-4)
+
+    assert dims
+    assert not FoamFile.DimensionSet()
+
+
+def test_dimensioned() -> None:
+    dimensioned = FoamFile.Dimensioned(
+        9.81, FoamFile.DimensionSet(length=1, time=-2), "g"
+    )
+    assert dimensioned.value == 9.81
+    assert dimensioned.dimensions == FoamFile.DimensionSet(length=1, time=-2)
+    assert dimensioned.name == "g"
+
+    result = dimensioned + dimensioned
+    assert result.value == 9.81 * 2
+    assert result.dimensions == FoamFile.DimensionSet(length=1, time=-2)
+    assert result.name == "g + g"
+
+    result = dimensioned - dimensioned
+    assert result.value == 0.0
+    assert result.dimensions == FoamFile.DimensionSet(length=1, time=-2)
+    assert result.name == "g - g"
+
+    result = dimensioned * dimensioned
+    assert result.value == 9.81**2
+    assert result.dimensions == FoamFile.DimensionSet(length=2, time=-4)
+    assert result.name == "g * g"
+
+    result = dimensioned / dimensioned
+    assert result.value == 1.0
+    assert result.dimensions == FoamFile.DimensionSet()
+    assert result.name == "g / g"
+
+    result = dimensioned**2
+    assert result.value == 9.81**2
+    assert result.dimensions == FoamFile.DimensionSet(length=2, time=-4)
+    assert result.name == "g ** 2"
+
+    with pytest.raises(ValueError, match="dimension"):
+        dimensioned + 1
+
+    with pytest.raises(ValueError, match="dimension"):
+        float(dimensioned)
+
+    with pytest.raises(ValueError, match="dimension"):
+        np.array(dimensioned)

foamlib-0.9.2/foamlib/_files/_types.py

@@ -1,136 +0,0 @@
-from __future__ import annotations
-
-import sys
-from typing import Dict, NamedTuple, Optional, Union
-
-import numpy as np
-
-if sys.version_info >= (3, 9):
-    from collections.abc import Mapping, MutableMapping, Sequence
-else:
-    from typing import Mapping, MutableMapping, Sequence
-
-if sys.version_info >= (3, 10):
-    from typing import TypeGuard
-else:
-    from typing_extensions import TypeGuard
-
-
-class DimensionSet(NamedTuple):
-    mass: float = 0
-    length: float = 0
-    time: float = 0
-    temperature: float = 0
-    moles: float = 0
-    current: float = 0
-    luminous_intensity: float = 0
-
-    def __repr__(self) -> str:
-        return f"{type(self).__name__}({', '.join(f'{n}={v}' for n, v in zip(self._fields, self) if v != 0)})"
-
-
-Tensor = Union[
-    float,
-    "np.ndarray[tuple[int], np.dtype[np.float64]]",
-]
-
-TensorLike = Union[
-    Sequence[float],
-    "np.ndarray[tuple[()], np.dtype[np.float64]]",
-    Tensor,
-]
-
-
-class Dimensioned:
-    def __init__(
-        self,
-        value: TensorLike,
-        dimensions: DimensionSet | Sequence[float],
-        name: str | None = None,
-    ) -> None:
-        if is_sequence(value):
-            self.value: Tensor = np.array(value, dtype=float)  # type: ignore [assignment]
-        else:
-            assert isinstance(value, (int, float, np.ndarray))
-            self.value = float(value)
-
-        if not isinstance(dimensions, DimensionSet):
-            self.dimensions = DimensionSet(*dimensions)
-        else:
-            self.dimensions = dimensions
-
-        self.name = name
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, Dimensioned):
-            return NotImplemented
-
-        return (
-            self.dimensions == other.dimensions
-            and np.array_equal(self.value, other.value)
-            and self.name == other.name
-        )
-
-
-Field = Union[
-    float,
-    "np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.float64 | np.float32]]",
-]
-
-FieldLike = Union[
-    TensorLike,
-    Sequence[TensorLike],
-    Sequence[Sequence[TensorLike]],
-    Field,
-]
-
-
-Data = Union[
-    str,
-    int,
-    float,
-    bool,
-    Dimensioned,
-    DimensionSet,
-    Sequence["Entry"],
-    Field,
-]
-
-Entry = Union[
-    Data,
-    Mapping[str, "Entry"],
-]
-"""
-A value that can be stored in an OpenFOAM file.
-"""
-
-DataLike = Union[
-    FieldLike,
-    Sequence["EntryLike"],
-    Data,
-]
-
-EntryLike = Union[
-    DataLike,
-    Mapping[str, "EntryLike"],
-]
-
-
-def is_sequence(
-    value: EntryLike,
-) -> TypeGuard[
-    Sequence[EntryLike]
-    | np.ndarray[tuple[int] | tuple[int, int], np.dtype[np.float64 | np.float32]]
-]:
-    return (isinstance(value, Sequence) and not isinstance(value, str)) or (
-        isinstance(value, np.ndarray) and value.ndim > 0
-    )
-
-
-MutableEntry = Union[
-    Data,
-    MutableMapping[str, "MutableEntry"],
-]
-
-Dict_ = Dict[str, Union["Entry", "Dict_"]]
-File = Dict[Optional[str], Union["Entry", "Dict_"]]