foamlib 0.2.3__py3-none-any.whl → 0.2.4__py3-none-any.whl

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/_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/_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.dist-info → foamlib-0.2.4.dist-info}/METADATA

@@ -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: docs
 Requires-Dist: sphinx <8,>=7 ; extra == 'docs'
 Requires-Dist: sphinx-rtd-theme ; extra == 'docs'

foamlib-0.2.4.dist-info/RECORD

@@ -0,0 +1,14 @@
+foamlib/__init__.py,sha256=BPC3la1UvhtGOS7utfBE5tccqz8mxqzd7Fn0zFC5yz0,287
+foamlib/_cases.py,sha256=4f3c5BXnsHPhFvgXNjUcGGHyu7I0WZT6zxlvGhb9kMY,21213
+foamlib/_subprocesses.py,sha256=5vqdQvpN_2v4GgDqxi-s88NGhZ6doFxkh0XY89ZWuHA,1926
+foamlib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+foamlib/_dictionaries/__init__.py,sha256=6UWBGe1t7cq-d6WWQrVm0Xpi7Whpkr-mkTWgAM4NwcE,160
+foamlib/_dictionaries/_base.py,sha256=H8XfiaX1LD6OWwZ9m61SaKgI-_szF1udyEfiLurrCB8,1493
+foamlib/_dictionaries/_files.py,sha256=1Ve1FG2VVKLyj6yZGe4Vy8EhEOtyORQtJMUK-cbPNt4,12424
+foamlib/_dictionaries/_parsing.py,sha256=65kwMU6b4WmMngOR5ED8IBvMa59FQqTRmd9o0xPnWJM,4768
+foamlib/_dictionaries/_serialization.py,sha256=viHpQKggSBfxq9V6veVcCCLNq7wdJ-2g5maecaN2beU,3612
+foamlib-0.2.4.dist-info/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
+foamlib-0.2.4.dist-info/METADATA,sha256=Z5aFcGYwPssHy9DTrQqZ4Lsw6cJ1QjW9UFiqe0Uuf58,4640
+foamlib-0.2.4.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+foamlib-0.2.4.dist-info/top_level.txt,sha256=ZdVYtetXGwPwyfL-WhlhbTFQGAwKX5P_gXxtH9JYFPI,8
+foamlib-0.2.4.dist-info/RECORD,,

foamlib-0.2.3.dist-info/RECORD

@@ -1,14 +0,0 @@
-foamlib/__init__.py,sha256=VYMos2oCtIAGQx88R_0tco49MZogwcC6yvwQ2oqmSmU,287
-foamlib/_cases.py,sha256=4f3c5BXnsHPhFvgXNjUcGGHyu7I0WZT6zxlvGhb9kMY,21213
-foamlib/_subprocesses.py,sha256=5vqdQvpN_2v4GgDqxi-s88NGhZ6doFxkh0XY89ZWuHA,1926
-foamlib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-foamlib/_dictionaries/__init__.py,sha256=6UWBGe1t7cq-d6WWQrVm0Xpi7Whpkr-mkTWgAM4NwcE,160
-foamlib/_dictionaries/_base.py,sha256=H8XfiaX1LD6OWwZ9m61SaKgI-_szF1udyEfiLurrCB8,1493
-foamlib/_dictionaries/_files.py,sha256=baObt7Ewf_sM-9Y5JGMFCYK1CVdNQg3vYbOfjCgQA64,11582
-foamlib/_dictionaries/_parsing.py,sha256=65kwMU6b4WmMngOR5ED8IBvMa59FQqTRmd9o0xPnWJM,4768
-foamlib/_dictionaries/_serialization.py,sha256=P_eP46c-kCXx6rIGXL7hfDuEbS9h7uANZlgXsdcNwl8,3005
-foamlib-0.2.3.dist-info/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
-foamlib-0.2.3.dist-info/METADATA,sha256=DA7Kq6YIun5m2yisx_F4DSrYP13RZKgXwq0mTTX2y9A,4600
-foamlib-0.2.3.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-foamlib-0.2.3.dist-info/top_level.txt,sha256=ZdVYtetXGwPwyfL-WhlhbTFQGAwKX5P_gXxtH9JYFPI,8
-foamlib-0.2.3.dist-info/RECORD,,