foamlib 0.2.3__tar.gz → 0.2.4__tar.gz

{foamlib-0.2.3 → foamlib-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.2.3
+Version: 0.2.4
 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
@@ -27,6 +27,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: aioshutil<2,>=1
 Requires-Dist: pyparsing<4,>=3
+Requires-Dist: typing-extensions<5,>=4
 Provides-Extra: lint
 Requires-Dist: mypy<2,>=1; extra == "lint"
 Requires-Dist: pytest<9,>=7; extra == "lint"

{foamlib-0.2.3 → foamlib-0.2.4}/foamlib/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.2.3"
+__version__ = "0.2.4"
 
 from ._cases import FoamCase, AsyncFoamCase, FoamCaseBase
 from ._dictionaries import FoamFile, FoamFieldFile, FoamDictionaryBase

{foamlib-0.2.3 → foamlib-0.2.4}/foamlib/_dictionaries/_files.py

@@ -11,9 +11,11 @@ from typing import (
     cast,
 )
 
+from typing_extensions import Self
+
 from ._base import FoamDictionaryBase
 from ._parsing import Parsed, as_dict, get_entry_locn, get_value, parse
-from ._serialization import serialize_value
+from ._serialization import serialize_entry
 
 try:
     import numpy as np
@@ -22,9 +24,62 @@ except ModuleNotFoundError:
     pass
 
 
+class _FoamFileBase:
+    def __init__(self, path: Union[str, Path]) -> None:
+        self.path = Path(path).absolute()
+        if self.path.is_dir():
+            raise IsADirectoryError(self.path)
+        elif not self.path.is_file():
+            raise FileNotFoundError(self.path)
+
+        self.__contents: Optional[str] = None
+        self.__parsed: Optional[Parsed] = None
+        self.__defer_io = 0
+        self.__dirty = False
+
+    def __enter__(self) -> Self:
+        if self.__defer_io == 0:
+            self._read()
+        self.__defer_io += 1
+        return self
+
+    def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
+        self.__defer_io -= 1
+        if self.__defer_io == 0 and self.__dirty:
+            assert self.__contents is not None
+            self._write(self.__contents)
+        assert not self.__dirty
+
+    def _read(self) -> Tuple[str, Parsed]:
+        if not self.__defer_io:
+            contents = self.path.read_text()
+            if contents != self.__contents:
+                self.__contents = contents
+                self.__parsed = None
+
+        assert self.__contents is not None
+
+        if self.__parsed is None:
+            self.__parsed = parse(self.__contents)
+
+        return self.__contents, self.__parsed
+
+    def _write(self, contents: str) -> None:
+        self.__contents = contents
+        self.__parsed = None
+        if not self.__defer_io:
+            self.path.write_text(contents)
+            self.__dirty = False
+        else:
+            self.__dirty = True
+
+
 class FoamFile(
+    _FoamFileBase,
     FoamDictionaryBase,
-    MutableMapping[str, Union["FoamFile.Value", "FoamFile.Dictionary"]],
+    MutableMapping[
+        Union[str, Tuple[str, ...]], Union["FoamFile.Value", "FoamFile.Dictionary"]
+    ],
 ):
     """
     An OpenFOAM dictionary file.
@@ -75,9 +130,20 @@ class FoamFile(
         def __iter__(self) -> Iterator[str]:
             return self._file._iter(tuple(self._keywords))
 
+        def __contains__(self, keyword: object) -> bool:
+            return (*self._keywords, keyword) in self._file
+
         def __len__(self) -> int:
             return len(list(iter(self)))
 
+        def update(self, *args: Any, **kwargs: Any) -> None:
+            with self._file:
+                super().update(*args, **kwargs)
+
+        def clear(self) -> None:
+            with self._file:
+                super().clear()
+
         def __repr__(self) -> str:
             return f"{type(self).__qualname__}({self._file}, {self._keywords})"
 
@@ -95,54 +161,6 @@ class FoamFile(
 
             return ret
 
-    def __init__(self, path: Union[str, Path]) -> None:
-        self.path = Path(path).absolute()
-        if self.path.is_dir():
-            raise IsADirectoryError(self.path)
-        elif not self.path.is_file():
-            raise FileNotFoundError(self.path)
-
-        self._contents: Optional[str] = None
-        self._parsed: Optional[Parsed] = None
-        self._defer_io = 0
-        self._dirty = False
-
-    def __enter__(self) -> "FoamFile":
-        if self._defer_io == 0:
-            self._read()
-        self._defer_io += 1
-        return self
-
-    def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
-        self._defer_io -= 1
-        if self._defer_io == 0 and self._dirty:
-            assert self._contents is not None
-            self._write(self._contents)
-        assert not self._dirty
-
-    def _read(self) -> Tuple[str, Parsed]:
-        if not self._defer_io:
-            contents = self.path.read_text()
-            if contents != self._contents:
-                self._contents = contents
-                self._parsed = None
-
-        assert self._contents is not None
-
-        if self._parsed is None:
-            self._parsed = parse(self._contents)
-
-        return self._contents, self._parsed
-
-    def _write(self, contents: str) -> None:
-        self._contents = contents
-        self._parsed = None
-        if not self._defer_io:
-            self.path.write_text(contents)
-            self._dirty = False
-        else:
-            self._dirty = True
-
     def __getitem__(
         self, keywords: Union[str, Tuple[str, ...]]
     ) -> Union["FoamFile.Value", "FoamFile.Dictionary"]:
@@ -179,7 +197,7 @@ class FoamFile(
                 start, end = get_entry_locn(parsed, keywords, missing_ok=True)
 
                 self._write(
-                    f"{contents[:start]} {keywords[-1]} {{\n}}\n {contents[end:]}"
+                    f"{contents[:start]}\n{serialize_entry(keywords[-1], {})}\n{contents[end:]}"
                 )
 
                 for k, v in value.items():
@@ -187,12 +205,8 @@ class FoamFile(
         else:
             start, end = get_entry_locn(parsed, keywords, missing_ok=True)
 
-            value = serialize_value(
-                value, assume_field=assume_field, assume_dimensions=assume_dimensions
-            )
-
             self._write(
-                f"{contents[:start]} {keywords[-1]} {value};\n {contents[end:]}"
+                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:
@@ -220,9 +234,23 @@ class FoamFile(
     def __iter__(self) -> Iterator[str]:
         return self._iter()
 
+    def __contains__(self, keywords: object) -> bool:
+        if not isinstance(keywords, tuple):
+            keywords = (keywords,)
+        _, parsed = self._read()
+        return keywords in parsed
+
     def __len__(self) -> int:
         return len(list(iter(self)))
 
+    def update(self, *args: Any, **kwargs: Any) -> None:
+        with self:
+            super().update(*args, **kwargs)
+
+    def clear(self) -> None:
+        with self:
+            super().clear()
+
     def __fspath__(self) -> str:
         return str(self.path)
 

{foamlib-0.2.3 → foamlib-0.2.4}/foamlib/_dictionaries/_serialization.py

@@ -1,5 +1,5 @@
 from contextlib import suppress
-from typing import Any, Sequence
+from typing import Any, Mapping, Sequence
 
 from ._base import FoamDictionaryBase
 
@@ -31,7 +31,7 @@ def _serialize_bool(value: Any) -> str:
 
 def _serialize_list(value: Any) -> str:
     if _is_sequence(value):
-        return f"({' '.join(serialize_value(v) for v in value)})"
+        return f"({' '.join(_serialize_value(v) for v in value)})"
     else:
         raise TypeError(f"Not a valid sequence: {type(value)}")
 
@@ -73,14 +73,14 @@ def _serialize_dimensions(value: Any) -> str:
 def _serialize_dimensioned(value: Any) -> str:
     if isinstance(value, FoamDictionaryBase.Dimensioned):
         if value.name is not None:
-            return f"{value.name} {_serialize_dimensions(value.dimensions)} {serialize_value(value.value)}"
+            return f"{value.name} {_serialize_dimensions(value.dimensions)} {_serialize_value(value.value)}"
         else:
-            return f"{_serialize_dimensions(value.dimensions)} {serialize_value(value.value)}"
+            return f"{_serialize_dimensions(value.dimensions)} {_serialize_value(value.value)}"
     else:
         raise TypeError(f"Not a valid dimensioned value: {type(value)}")
 
 
-def serialize_value(
+def _serialize_value(
     value: Any, *, assume_field: bool = False, assume_dimensions: bool = False
 ) -> str:
     if isinstance(value, FoamDictionaryBase.DimensionSet) or assume_dimensions:
@@ -101,3 +101,23 @@ def serialize_value(
         return _serialize_bool(value)
 
     return str(value)
+
+
+def _serialize_dictionary(value: Any) -> str:
+    if isinstance(value, Mapping):
+        return "\n".join(serialize_entry(k, v) for k, v in value.items())
+    else:
+        raise TypeError(f"Not a valid dictionary: {type(value)}")
+
+
+def serialize_entry(
+    keyword: str,
+    value: Any,
+    *,
+    assume_field: bool = False,
+    assume_dimensions: bool = False,
+) -> str:
+    try:
+        return f"{keyword}\n{{\n{_serialize_dictionary(value)}\n}}"
+    except TypeError:
+        return f"{keyword} {_serialize_value(value, assume_field=assume_field, assume_dimensions=assume_dimensions)};"

{foamlib-0.2.3 → foamlib-0.2.4}/foamlib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.2.3
+Version: 0.2.4
 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
@@ -27,6 +27,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: aioshutil<2,>=1
 Requires-Dist: pyparsing<4,>=3
+Requires-Dist: typing-extensions<5,>=4
 Provides-Extra: lint
 Requires-Dist: mypy<2,>=1; extra == "lint"
 Requires-Dist: pytest<9,>=7; extra == "lint"

{foamlib-0.2.3 → foamlib-0.2.4}/foamlib.egg-info/requires.txt

@@ -1,5 +1,6 @@
 aioshutil<2,>=1
 pyparsing<4,>=3
+typing-extensions<5,>=4
 
 [docs]
 sphinx<8,>=7

{foamlib-0.2.3 → foamlib-0.2.4}/pyproject.toml

@@ -30,6 +30,7 @@ classifiers = [
 dependencies = [
     "aioshutil>=1,<2",
     "pyparsing>=3,<4",
+    "typing-extensions>=4,<5",
 ]
 
 dynamic = ["version"]