foamlib 0.2.6__tar.gz → 0.2.8__tar.gz

{foamlib-0.2.6 → foamlib-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.2.6
+Version: 0.2.8
 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.2.6 → foamlib-0.2.8}/foamlib/__init__.py

@@ -1,6 +1,6 @@
 """A Python interface for interacting with OpenFOAM."""
 
-__version__ = "0.2.6"
+__version__ = "0.2.8"
 
 from ._cases import AsyncFoamCase, FoamCase, FoamCaseBase
 from ._dictionaries import FoamDictionaryBase, FoamFieldFile, FoamFile

{foamlib-0.2.6 → foamlib-0.2.8}/foamlib/_dictionaries/_base.py

@@ -4,9 +4,15 @@ from dataclasses import dataclass
 from typing import Dict, NamedTuple, Optional, Union
 
 if sys.version_info >= (3, 9):
-    from collections.abc import Sequence
+    from collections.abc import Mapping, Sequence
 else:
-    from typing import Sequence
+    from typing import Mapping, Sequence
+
+try:
+    import numpy as np
+    from numpy.typing import NDArray
+except ModuleNotFoundError:
+    pass
 
 
 class FoamDictionaryBase:
@@ -34,14 +40,25 @@ class FoamDictionaryBase:
             if not isinstance(self.dimensions, FoamDictionaryBase.DimensionSet):
                 self.dimensions = FoamDictionaryBase.DimensionSet(*self.dimensions)
 
-    Value = Union[str, int, float, bool, Dimensioned, DimensionSet, Sequence["Value"]]
+    Value = Union[
+        str,
+        int,
+        float,
+        bool,
+        Dimensioned,
+        DimensionSet,
+        Sequence["Value"],
+        Mapping[str, "Value"],
+    ]
     """
     A value that can be stored in an OpenFOAM dictionary.
     """
 
-    _Dict = Dict[str, Union["FoamDictionaryBase.Value", "_Dict"]]
+    _Dict = Dict[str, Union["Value", "_Dict"]]
 
     @abstractmethod
     def as_dict(self) -> _Dict:
         """Return a nested dict representation of the dictionary."""
         raise NotImplementedError
+
+    _SetValue = Union[Value, "NDArray[np.generic]"]

{foamlib-0.2.6 → foamlib-0.2.8}/foamlib/_dictionaries/_files.py

@@ -1,9 +1,11 @@
 import sys
 from pathlib import Path
+from types import TracebackType
 from typing import (
     Any,
     Optional,
     Tuple,
+    Type,
     Union,
     cast,
 )
@@ -48,7 +50,12 @@ class _FoamFileBase:
         self.__defer_io += 1
         return self
 
-    def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
         self.__defer_io -= 1
         if self.__defer_io == 0 and self.__dirty:
             assert self.__contents is not None
@@ -124,7 +131,7 @@ class FoamFile(
                 assume_dimensions=assume_dimensions,
             )
 
-        def __setitem__(self, keyword: str, value: Any) -> None:
+        def __setitem__(self, keyword: str, value: "FoamFile._SetValue") -> None:
             self._setitem(keyword, value)
 
         def __delitem__(self, keyword: str) -> None:
@@ -180,7 +187,7 @@ class FoamFile(
     def _setitem(
         self,
         keywords: Union[str, Tuple[str, ...]],
-        value: Any,
+        value: "FoamFile._SetValue",
         *,
         assume_field: bool = False,
         assume_dimensions: bool = False,
@@ -210,7 +217,11 @@ class FoamFile(
                 f"{contents[:start]}\n{serialize_entry(keywords[-1], value, assume_field=assume_field, assume_dimensions=assume_dimensions)}\n{contents[end:]}"
             )
 
-    def __setitem__(self, keywords: Union[str, Tuple[str, ...]], value: Any) -> None:
+    def __setitem__(
+        self,
+        keywords: Union[str, Tuple[str, ...]],
+        value: "FoamFile._SetValue",
+    ) -> None:
         self._setitem(keywords, value)
 
     def __delitem__(self, keywords: Union[str, Tuple[str, ...]]) -> None:
@@ -269,12 +280,20 @@ class FoamFieldFile(FoamFile):
 
     class BoundariesDictionary(FoamFile.Dictionary):
         def __getitem__(self, keyword: str) -> "FoamFieldFile.BoundaryDictionary":
-            return cast(FoamFieldFile.BoundaryDictionary, super().__getitem__(keyword))
+            value = super().__getitem__(keyword)
+            if not isinstance(value, FoamFieldFile.BoundaryDictionary):
+                assert not isinstance(value, FoamFile.Dictionary)
+                raise TypeError(f"boundary {keyword} is not a dictionary")
+            return value
 
     class BoundaryDictionary(FoamFile.Dictionary):
         """An OpenFOAM dictionary representing a boundary condition as a mutable mapping."""
 
-        def __setitem__(self, key: str, value: Any) -> None:
+        def __setitem__(
+            self,
+            key: str,
+            value: FoamFile._SetValue,
+        ) -> None:
             if key == "value":
                 self._setitem(key, value, assume_field=True)
             else:

{foamlib-0.2.6 → foamlib-0.2.8}/foamlib/_dictionaries/_parsing.py

@@ -1,11 +1,16 @@
 import sys
-from typing import Optional, Tuple
+from typing import Optional, Tuple, Union
 
 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 types import EllipsisType
+else:
+    from typing import Any as EllipsisType
+
 from pyparsing import (
     Dict,
     Forward,
@@ -56,6 +61,28 @@ def _list_of(elem: ParserElement) -> ParserElement:
     )
 
 
+def _dictionary_of(
+    keyword: ParserElement,
+    value: ParserElement,
+    *,
+    len: Union[int, EllipsisType] = ...,
+    located: bool = False,
+) -> ParserElement:
+    subdict = Forward()
+
+    entry = keyword + (
+        (Literal("{").suppress() + subdict + Literal("}").suppress())
+        | (value + Literal(";").suppress())
+    )
+
+    if located:
+        entry = Located(entry)
+
+    subdict <<= Dict(Group(entry)[...], asdict=not located)
+
+    return Dict(Group(entry)[len], asdict=not located)
+
+
 _TENSOR = _list_of(common.number) | common.number
 _IDENTIFIER = Word(identbodychars + "$", printables.replace(";", ""))
 _DIMENSIONED = (Opt(_IDENTIFIER) + _DIMENSIONS + _TENSOR).set_parse_action(
@@ -66,25 +93,19 @@ _FIELD = (Keyword("uniform").suppress() + _TENSOR) | (
 )
 _TOKEN = QuotedString('"', unquote_results=False) | _IDENTIFIER
 _ITEM = Forward()
-_LIST = _list_of(_ITEM)
+_ENTRY = _dictionary_of(_IDENTIFIER, _ITEM, len=1)
+_LIST = _list_of(_ENTRY | _ITEM)
 _ITEM <<= _FIELD | _LIST | _DIMENSIONED | _DIMENSIONS | common.number | _SWITCH | _TOKEN
+
 _TOKENS = (
     QuotedString('"', unquote_results=False) | Word(printables.replace(";", ""))
 )[2, ...].set_parse_action(lambda tks: " ".join(tks))
 
 _VALUE = _ITEM ^ _TOKENS
 
-_ENTRY = Forward()
-_DICTIONARY = Dict(Group(_ENTRY)[...])
-_ENTRY <<= Located(
-    _TOKEN
-    + (
-        (Literal("{").suppress() + _DICTIONARY + Literal("}").suppress())
-        | (Opt(_VALUE, default="") + Literal(";").suppress())
-    )
-)
 _FILE = (
-    _DICTIONARY.ignore(c_style_comment)
+    _dictionary_of(_TOKEN, Opt(_VALUE, default=""), located=True)
+    .ignore(c_style_comment)
     .ignore(cpp_style_comment)
     .ignore(Literal("#include") + ... + LineEnd())  # type: ignore [no-untyped-call]
 )

{foamlib-0.2.6 → foamlib-0.2.8}/foamlib/_dictionaries/_serialization.py

@@ -1,6 +1,5 @@
 import sys
 from contextlib import suppress
-from typing import Any
 
 if sys.version_info >= (3, 9):
     from collections.abc import Mapping
@@ -11,7 +10,7 @@ from .._util import is_sequence
 from ._base import FoamDictionaryBase
 
 
-def _serialize_switch(value: Any) -> str:
+def _serialize_switch(value: FoamDictionaryBase._SetValue) -> str:
     if value is True:
         return "yes"
     elif value is False:
@@ -20,14 +19,18 @@ def _serialize_switch(value: Any) -> str:
         raise TypeError(f"Not a bool: {type(value)}")
 
 
-def _serialize_list(value: Any) -> str:
+def _serialize_list(
+    value: FoamDictionaryBase._SetValue,
+) -> str:
     if is_sequence(value):
         return f"({' '.join(_serialize_value(v) for v in value)})"
     else:
         raise TypeError(f"Not a valid sequence: {type(value)}")
 
 
-def _serialize_field(value: Any) -> str:
+def _serialize_field(
+    value: FoamDictionaryBase._SetValue,
+) -> str:
     if is_sequence(value):
         try:
             s = _serialize_list(value)
@@ -54,14 +57,18 @@ def _serialize_field(value: Any) -> str:
         return f"uniform {value}"
 
 
-def _serialize_dimensions(value: Any) -> str:
+def _serialize_dimensions(
+    value: FoamDictionaryBase._SetValue,
+) -> str:
     if is_sequence(value) and len(value) == 7:
         return f"[{' '.join(str(v) for v in value)}]"
     else:
         raise TypeError(f"Not a valid dimension set: {type(value)}")
 
 
-def _serialize_dimensioned(value: Any) -> str:
+def _serialize_dimensioned(
+    value: FoamDictionaryBase._SetValue,
+) -> str:
     if isinstance(value, FoamDictionaryBase.Dimensioned):
         if value.name is not None:
             return f"{value.name} {_serialize_dimensions(value.dimensions)} {_serialize_value(value.value)}"
@@ -72,7 +79,10 @@ def _serialize_dimensioned(value: Any) -> str:
 
 
 def _serialize_value(
-    value: Any, *, assume_field: bool = False, assume_dimensions: bool = False
+    value: FoamDictionaryBase._SetValue,
+    *,
+    assume_field: bool = False,
+    assume_dimensions: bool = False,
 ) -> str:
     if isinstance(value, FoamDictionaryBase.DimensionSet) or assume_dimensions:
         with suppress(TypeError):
@@ -91,10 +101,15 @@ def _serialize_value(
     with suppress(TypeError):
         return _serialize_switch(value)
 
+    with suppress(TypeError):
+        return _serialize_dictionary(value)
+
     return str(value)
 
 
-def _serialize_dictionary(value: Any) -> str:
+def _serialize_dictionary(
+    value: FoamDictionaryBase._SetValue,
+) -> str:
     if isinstance(value, Mapping):
         return "\n".join(serialize_entry(k, v) for k, v in value.items())
     else:
@@ -103,7 +118,7 @@ def _serialize_dictionary(value: Any) -> str:
 
 def serialize_entry(
     keyword: str,
-    value: Any,
+    value: FoamDictionaryBase._SetValue,
     *,
     assume_field: bool = False,
     assume_dimensions: bool = False,

{foamlib-0.2.6 → foamlib-0.2.8}/foamlib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.2.6
+Version: 0.2.8
 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.2.6 → foamlib-0.2.8}/foamlib.egg-info/SOURCES.txt

@@ -14,5 +14,4 @@ foamlib/_dictionaries/__init__.py
 foamlib/_dictionaries/_base.py
 foamlib/_dictionaries/_files.py
 foamlib/_dictionaries/_parsing.py
-foamlib/_dictionaries/_serialization.py
-tests/test_serialization.py
+foamlib/_dictionaries/_serialization.py

foamlib-0.2.6/tests/test_serialization.py

@@ -1,52 +0,0 @@
-from foamlib import FoamFile
-from foamlib._dictionaries._serialization import _serialize_value
-
-
-def test_serialize_value() -> None:
-    assert _serialize_value(1) == "1"
-    assert _serialize_value(1.0) == "1.0"
-    assert _serialize_value(1.0e-3) == "0.001"
-    assert _serialize_value(True) == "yes"
-    assert _serialize_value(False) == "no"
-    assert _serialize_value("word") == "word"
-    assert _serialize_value("word word") == "word word"
-    assert _serialize_value('"a string"') == '"a string"'
-    assert _serialize_value(1, assume_field=True) == "uniform 1"
-    assert _serialize_value(1.0, assume_field=True) == "uniform 1.0"
-    assert _serialize_value(1.0e-3, assume_field=True) == "uniform 0.001"
-    assert _serialize_value([1.0, 2.0, 3.0]) == "(1.0 2.0 3.0)"
-    assert _serialize_value([1, 2, 3], assume_field=True) == "uniform (1 2 3)"
-    assert (
-        _serialize_value([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], assume_field=True)
-        == "nonuniform List<scalar> 10(1 2 3 4 5 6 7 8 9 10)"
-    )
-    assert (
-        _serialize_value([[1, 2, 3], [4, 5, 6]], assume_field=True)
-        == "nonuniform List<vector> 2((1 2 3) (4 5 6))"
-    )
-    assert (
-        _serialize_value(FoamFile.DimensionSet(mass=1, length=1, time=-2))
-        == "[1 1 -2 0 0 0 0]"
-    )
-    assert (
-        _serialize_value(
-            FoamFile.Dimensioned(
-                name="g",
-                dimensions=FoamFile.DimensionSet(mass=1, length=1, time=-2),
-                value=9.81,
-            )
-        )
-        == "g [1 1 -2 0 0 0 0] 9.81"
-    )
-    assert (
-        _serialize_value(
-            FoamFile.Dimensioned(
-                dimensions=FoamFile.DimensionSet(mass=1, length=1, time=-2), value=9.81
-            )
-        )
-        == "[1 1 -2 0 0 0 0] 9.81"
-    )
-    assert (
-        _serialize_value("hex (0 1 2 3 4 5 6 7) (1 1 1) simpleGrading (1 1 1)")
-        == "hex (0 1 2 3 4 5 6 7) (1 1 1) simpleGrading (1 1 1)"
-    )