foamlib 0.2.7__tar.gz → 0.2.9__tar.gz

{foamlib-0.2.7 → foamlib-0.2.9}/PKG-INFO

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

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

{foamlib-0.2.7 → foamlib-0.2.9}/foamlib/_dictionaries/_base.py

@@ -40,7 +40,16 @@ 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.
     """
@@ -53,5 +62,3 @@ class FoamDictionaryBase:
         raise NotImplementedError
 
     _SetValue = Union[Value, "NDArray[np.generic]"]
-
-    _SetMapping = Mapping[str, Union["_SetValue", "_SetMapping"]]

{foamlib-0.2.7 → foamlib-0.2.9}/foamlib/_dictionaries/_files.py

@@ -1,4 +1,5 @@
 import sys
+from copy import deepcopy
 from pathlib import Path
 from types import TracebackType
 from typing import (
@@ -72,9 +73,12 @@ class _FoamFileBase:
         assert self.__contents is not None
 
         if self.__parsed is None:
-            self.__parsed = parse(self.__contents)
+            parsed = parse(self.__contents)
+            self.__parsed = parsed
+        else:
+            parsed = deepcopy(self.__parsed)
 
-        return self.__contents, self.__parsed
+        return self.__contents, parsed
 
     def _write(self, contents: str) -> None:
         self.__contents = contents
@@ -131,11 +135,7 @@ class FoamFile(
                 assume_dimensions=assume_dimensions,
             )
 
-        def __setitem__(
-            self,
-            keyword: str,
-            value: Union["FoamFile._SetValue", "FoamFile._SetMapping"],
-        ) -> None:
+        def __setitem__(self, keyword: str, value: "FoamFile._SetValue") -> None:
             self._setitem(keyword, value)
 
         def __delitem__(self, keyword: str) -> None:
@@ -191,7 +191,7 @@ class FoamFile(
     def _setitem(
         self,
         keywords: Union[str, Tuple[str, ...]],
-        value: Union["FoamFile._SetValue", "FoamFile._SetMapping"],
+        value: "FoamFile._SetValue",
         *,
         assume_field: bool = False,
         assume_dimensions: bool = False,
@@ -224,7 +224,7 @@ class FoamFile(
     def __setitem__(
         self,
         keywords: Union[str, Tuple[str, ...]],
-        value: Union["FoamFile._SetValue", "FoamFile._SetMapping"],
+        value: "FoamFile._SetValue",
     ) -> None:
         self._setitem(keywords, value)
 
@@ -284,7 +284,11 @@ 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."""
@@ -292,7 +296,7 @@ class FoamFieldFile(FoamFile):
         def __setitem__(
             self,
             key: str,
-            value: Union[FoamFile._SetValue, FoamFile._SetMapping],
+            value: FoamFile._SetValue,
         ) -> None:
             if key == "value":
                 self._setitem(key, value, assume_field=True)

{foamlib-0.2.7 → foamlib-0.2.9}/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.7 → foamlib-0.2.9}/foamlib/_dictionaries/_serialization.py

@@ -1,6 +1,5 @@
 import sys
 from contextlib import suppress
-from typing import Union
 
 if sys.version_info >= (3, 9):
     from collections.abc import Mapping
@@ -11,9 +10,7 @@ from .._util import is_sequence
 from ._base import FoamDictionaryBase
 
 
-def _serialize_switch(
-    value: Union[FoamDictionaryBase._SetValue, FoamDictionaryBase._SetMapping],
-) -> str:
+def _serialize_switch(value: FoamDictionaryBase._SetValue) -> str:
     if value is True:
         return "yes"
     elif value is False:
@@ -23,7 +20,7 @@ def _serialize_switch(
 
 
 def _serialize_list(
-    value: Union[FoamDictionaryBase._SetValue, FoamDictionaryBase._SetMapping],
+    value: FoamDictionaryBase._SetValue,
 ) -> str:
     if is_sequence(value):
         return f"({' '.join(_serialize_value(v) for v in value)})"
@@ -32,7 +29,7 @@ def _serialize_list(
 
 
 def _serialize_field(
-    value: Union[FoamDictionaryBase._SetValue, FoamDictionaryBase._SetMapping],
+    value: FoamDictionaryBase._SetValue,
 ) -> str:
     if is_sequence(value):
         try:
@@ -61,7 +58,7 @@ def _serialize_field(
 
 
 def _serialize_dimensions(
-    value: Union[FoamDictionaryBase._SetValue, FoamDictionaryBase._SetMapping],
+    value: FoamDictionaryBase._SetValue,
 ) -> str:
     if is_sequence(value) and len(value) == 7:
         return f"[{' '.join(str(v) for v in value)}]"
@@ -70,7 +67,7 @@ def _serialize_dimensions(
 
 
 def _serialize_dimensioned(
-    value: Union[FoamDictionaryBase._SetValue, FoamDictionaryBase._SetMapping],
+    value: FoamDictionaryBase._SetValue,
 ) -> str:
     if isinstance(value, FoamDictionaryBase.Dimensioned):
         if value.name is not None:
@@ -82,7 +79,7 @@ def _serialize_dimensioned(
 
 
 def _serialize_value(
-    value: Union[FoamDictionaryBase._SetValue, FoamDictionaryBase._SetMapping],
+    value: FoamDictionaryBase._SetValue,
     *,
     assume_field: bool = False,
     assume_dimensions: bool = False,
@@ -104,11 +101,14 @@ def _serialize_value(
     with suppress(TypeError):
         return _serialize_switch(value)
 
+    with suppress(TypeError):
+        return _serialize_dictionary(value)
+
     return str(value)
 
 
 def _serialize_dictionary(
-    value: Union[FoamDictionaryBase._SetValue, FoamDictionaryBase._SetMapping],
+    value: FoamDictionaryBase._SetValue,
 ) -> str:
     if isinstance(value, Mapping):
         return "\n".join(serialize_entry(k, v) for k, v in value.items())
@@ -118,7 +118,7 @@ def _serialize_dictionary(
 
 def serialize_entry(
     keyword: str,
-    value: Union[FoamDictionaryBase._SetValue, FoamDictionaryBase._SetMapping],
+    value: FoamDictionaryBase._SetValue,
     *,
     assume_field: bool = False,
     assume_dimensions: bool = False,

{foamlib-0.2.7 → foamlib-0.2.9}/foamlib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.2.7
+Version: 0.2.9
 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.7 → foamlib-0.2.9}/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.7/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)"
-    )