foamlib 0.2.8__tar.gz → 0.2.10__tar.gz

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

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

@@ -1,9 +1,9 @@
 """A Python interface for interacting with OpenFOAM."""
 
-__version__ = "0.2.8"
+__version__ = "0.2.10"
 
 from ._cases import AsyncFoamCase, FoamCase, FoamCaseBase
-from ._dictionaries import FoamDictionaryBase, FoamFieldFile, FoamFile
+from ._files import FoamDictionaryBase, FoamFieldFile, FoamFile
 
 __all__ = [
     "FoamCase",

{foamlib-0.2.8 → foamlib-0.2.10}/foamlib/_cases.py

@@ -27,7 +27,7 @@ else:
 
 import aioshutil
 
-from ._dictionaries import FoamFieldFile, FoamFile
+from ._files import FoamFieldFile, FoamFile
 from ._util import CalledProcessError, is_sequence, run_process, run_process_async
 
 
@@ -505,7 +505,7 @@ class AsyncFoamCase(FoamCaseBase):
         check: bool = True,
     ) -> None:
         """
-        Run this case.
+        Run this case, or a specified command in the context of this case.
 
         :param cmd: The command to run. If None, run the case. If a sequence, the first element is the command and the rest are arguments. If a string, `cmd` is executed in a shell.
         :param script: If True and `cmd` is None, use an (All)run(-parallel) script if it exists for running the case. If False or no run script is found, autodetermine the command(s) needed to run the case.

{foamlib-0.2.8/foamlib/_dictionaries → foamlib-0.2.10/foamlib/_files}/__init__.py

@@ -1,5 +1,6 @@
 from ._base import FoamDictionaryBase
-from ._files import FoamFieldFile, FoamFile
+from ._fields import FoamFieldFile
+from ._files import FoamFile
 
 __all__ = [
     "FoamFile",

foamlib-0.2.10/foamlib/_files/_fields.py

@@ -0,0 +1,158 @@
+import sys
+from typing import Any, Tuple, Union, cast
+
+if sys.version_info >= (3, 9):
+    from collections.abc import Sequence
+else:
+    from typing import Sequence
+
+from ._files import FoamFile
+
+try:
+    import numpy as np
+    from numpy.typing import NDArray
+except ModuleNotFoundError:
+    pass
+
+
+class FoamFieldFile(FoamFile):
+    """An OpenFOAM dictionary file representing a field as a mutable mapping."""
+
+    class BoundariesDictionary(FoamFile.Dictionary):
+        def __getitem__(self, keyword: str) -> "FoamFieldFile.BoundaryDictionary":
+            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: FoamFile._SetValue,
+        ) -> None:
+            if key == "value":
+                self._setitem(key, value, assume_field=True)
+            else:
+                self._setitem(key, value)
+
+        @property
+        def type(self) -> str:
+            """Alias of `self["type"]`."""
+            ret = self["type"]
+            if not isinstance(ret, str):
+                raise TypeError("type is not a string")
+            return ret
+
+        @type.setter
+        def type(self, value: str) -> None:
+            self["type"] = value
+
+        @property
+        def value(
+            self,
+        ) -> Union[
+            int,
+            float,
+            Sequence[Union[int, float, Sequence[Union[int, float]]]],
+            "NDArray[np.generic]",
+        ]:
+            """Alias of `self["value"]`."""
+            ret = self["value"]
+            if not isinstance(ret, (int, float, Sequence)):
+                raise TypeError("value is not a field")
+            return cast(Union[int, float, Sequence[Union[int, float]]], ret)
+
+        @value.setter
+        def value(
+            self,
+            value: Union[
+                int,
+                float,
+                Sequence[Union[int, float, Sequence[Union[int, float]]]],
+                "NDArray[np.generic]",
+            ],
+        ) -> None:
+            self["value"] = value
+
+        @value.deleter
+        def value(self) -> None:
+            del self["value"]
+
+    def __getitem__(
+        self, keywords: Union[str, Tuple[str, ...]]
+    ) -> Union[FoamFile.Value, FoamFile.Dictionary]:
+        if not isinstance(keywords, tuple):
+            keywords = (keywords,)
+
+        ret = super().__getitem__(keywords)
+        if keywords[0] == "boundaryField" and isinstance(ret, FoamFile.Dictionary):
+            if len(keywords) == 1:
+                ret = FoamFieldFile.BoundariesDictionary(self, keywords)
+            elif len(keywords) == 2:
+                ret = FoamFieldFile.BoundaryDictionary(self, keywords)
+        return ret
+
+    def __setitem__(self, keywords: Union[str, Tuple[str, ...]], value: Any) -> None:
+        if not isinstance(keywords, tuple):
+            keywords = (keywords,)
+
+        if keywords == ("internalField",):
+            self._setitem(keywords, value, assume_field=True)
+        elif keywords == ("dimensions",):
+            self._setitem(keywords, value, assume_dimensions=True)
+        else:
+            self._setitem(keywords, value)
+
+    @property
+    def dimensions(self) -> FoamFile.DimensionSet:
+        """Alias of `self["dimensions"]`."""
+        ret = self["dimensions"]
+        if not isinstance(ret, FoamFile.DimensionSet):
+            raise TypeError("dimensions is not a DimensionSet")
+        return ret
+
+    @dimensions.setter
+    def dimensions(
+        self, value: Union[FoamFile.DimensionSet, Sequence[Union[int, float]]]
+    ) -> None:
+        self["dimensions"] = value
+
+    @property
+    def internal_field(
+        self,
+    ) -> Union[
+        int,
+        float,
+        Sequence[Union[int, float, Sequence[Union[int, float]]]],
+        "NDArray[np.generic]",
+    ]:
+        """Alias of `self["internalField"]`."""
+        ret = self["internalField"]
+        if not isinstance(ret, (int, float, Sequence)):
+            raise TypeError("internalField is not a field")
+        return cast(Union[int, float, Sequence[Union[int, float]]], ret)
+
+    @internal_field.setter
+    def internal_field(
+        self,
+        value: Union[
+            int,
+            float,
+            Sequence[Union[int, float, Sequence[Union[int, float]]]],
+            "NDArray[np.generic]",
+        ],
+    ) -> None:
+        self["internalField"] = value
+
+    @property
+    def boundary_field(self) -> "FoamFieldFile.BoundariesDictionary":
+        """Alias of `self["boundaryField"]`."""
+        ret = self["boundaryField"]
+        if not isinstance(ret, FoamFieldFile.BoundariesDictionary):
+            assert not isinstance(ret, FoamFile.Dictionary)
+            raise TypeError("boundaryField is not a dictionary")
+        return ret

foamlib-0.2.10/foamlib/_files/_files.py

@@ -0,0 +1,203 @@
+import sys
+from typing import (
+    Any,
+    Tuple,
+    Union,
+)
+
+if sys.version_info >= (3, 9):
+    from collections.abc import Iterator, Mapping, MutableMapping
+else:
+    from typing import Iterator, Mapping, MutableMapping
+
+from ._base import FoamDictionaryBase
+from ._io import FoamFileIO
+from ._serialization import serialize_entry
+
+
+class FoamFile(
+    FoamDictionaryBase,
+    MutableMapping[
+        Union[str, Tuple[str, ...]], Union["FoamFile.Value", "FoamFile.Dictionary"]
+    ],
+    FoamFileIO,
+):
+    """
+    An OpenFOAM dictionary file.
+
+    Use as a mutable mapping (i.e., like a dict) to access and modify entries.
+
+    Use as a context manager to make multiple changes to the file while saving all changes only once at the end.
+    """
+
+    class Dictionary(
+        FoamDictionaryBase,
+        MutableMapping[str, Union["FoamFile.Value", "FoamFile.Dictionary"]],
+    ):
+        """An OpenFOAM dictionary within a file as a mutable mapping."""
+
+        def __init__(self, _file: "FoamFile", _keywords: Tuple[str, ...]) -> None:
+            self._file = _file
+            self._keywords = _keywords
+
+        def __getitem__(
+            self, keyword: str
+        ) -> Union["FoamFile.Value", "FoamFile.Dictionary"]:
+            return self._file[(*self._keywords, keyword)]
+
+        def _setitem(
+            self,
+            keyword: str,
+            value: Any,
+            *,
+            assume_field: bool = False,
+            assume_dimensions: bool = False,
+        ) -> None:
+            self._file._setitem(
+                (*self._keywords, keyword),
+                value,
+                assume_field=assume_field,
+                assume_dimensions=assume_dimensions,
+            )
+
+        def __setitem__(self, keyword: str, value: "FoamFile._SetValue") -> None:
+            self._setitem(keyword, value)
+
+        def __delitem__(self, keyword: str) -> None:
+            del self._file[(*self._keywords, keyword)]
+
+        def __iter__(self) -> Iterator[str]:
+            return self._file._iter(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})"
+
+        def as_dict(self) -> FoamDictionaryBase._Dict:
+            """Return a nested dict representation of the dictionary."""
+            ret = self._file.as_dict()
+
+            for k in self._keywords:
+                assert isinstance(ret, dict)
+                v = ret[k]
+                assert isinstance(v, dict)
+                ret = v
+
+            return ret
+
+    def __getitem__(
+        self, keywords: Union[str, Tuple[str, ...]]
+    ) -> Union["FoamFile.Value", "FoamFile.Dictionary"]:
+        if not isinstance(keywords, tuple):
+            keywords = (keywords,)
+
+        _, parsed = self._read()
+
+        value = parsed[keywords]
+
+        if value is ...:
+            return FoamFile.Dictionary(self, keywords)
+        else:
+            return value  # type: ignore [return-value]
+
+    def _setitem(
+        self,
+        keywords: Union[str, Tuple[str, ...]],
+        value: "FoamFile._SetValue",
+        *,
+        assume_field: bool = False,
+        assume_dimensions: bool = False,
+    ) -> None:
+        if not isinstance(keywords, tuple):
+            keywords = (keywords,)
+
+        contents, parsed = self._read()
+
+        if isinstance(value, Mapping):
+            with self:
+                if isinstance(value, FoamDictionaryBase):
+                    value = value.as_dict()
+
+                start, end = parsed.entry_location(keywords, missing_ok=True)
+
+                self._write(
+                    f"{contents[:start]}\n{serialize_entry(keywords[-1], {})}\n{contents[end:]}"
+                )
+
+                for k, v in value.items():
+                    self[(*keywords, k)] = v
+        else:
+            start, end = parsed.entry_location(keywords, missing_ok=True)
+
+            self._write(
+                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: "FoamFile._SetValue",
+    ) -> None:
+        self._setitem(keywords, value)
+
+    def __delitem__(self, keywords: Union[str, Tuple[str, ...]]) -> None:
+        if not isinstance(keywords, tuple):
+            keywords = (keywords,)
+
+        contents, parsed = self._read()
+
+        start, end = parsed.entry_location(keywords)
+
+        self._write(contents[:start] + contents[end:])
+
+    def _iter(self, keywords: Union[str, Tuple[str, ...]] = ()) -> Iterator[str]:
+        if not isinstance(keywords, tuple):
+            keywords = (keywords,)
+
+        _, parsed = self._read()
+
+        yield from (k[-1] for k in parsed if k[:-1] == keywords)
+
+    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)
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}({self.path})"
+
+    def as_dict(self) -> FoamDictionaryBase._Dict:
+        """Return a nested dict representation of the file."""
+        _, parsed = self._read()
+        return parsed.as_dict()

foamlib-0.2.10/foamlib/_files/_io.py

@@ -0,0 +1,73 @@
+import sys
+from copy import deepcopy
+from pathlib import Path
+from types import TracebackType
+from typing import (
+    Optional,
+    Tuple,
+    Type,
+    Union,
+)
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+from ._parsing import Parsed
+
+
+class FoamFileIO:
+    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: 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
+            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:
+            parsed = Parsed(self.__contents)
+            self.__parsed = parsed
+
+        return self.__contents, deepcopy(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

{foamlib-0.2.8/foamlib/_dictionaries → foamlib-0.2.10/foamlib/_files}/_parsing.py

@@ -1,10 +1,10 @@
 import sys
-from typing import Optional, Tuple, Union
+from typing import Tuple, Union
 
 if sys.version_info >= (3, 9):
-    from collections.abc import Mapping, MutableMapping, Sequence
+    from collections.abc import Iterator, Mapping, MutableMapping, Sequence
 else:
-    from typing import Mapping, MutableMapping, Sequence
+    from typing import Iterator, Mapping, MutableMapping, Sequence
 
 if sys.version_info >= (3, 10):
     from types import EllipsisType
@@ -33,15 +33,6 @@ from pyparsing import (
 
 from ._base import FoamDictionaryBase
 
-_SWITCH = (
-    Keyword("yes") | Keyword("true") | Keyword("on") | Keyword("y") | Keyword("t")
-).set_parse_action(lambda: True) | (
-    Keyword("no") | Keyword("false") | Keyword("off") | Keyword("n") | Keyword("f")
-).set_parse_action(lambda: False)
-_DIMENSIONS = (
-    Literal("[").suppress() + common.number * 7 + Literal("]").suppress()
-).set_parse_action(lambda tks: FoamDictionaryBase.DimensionSet(*tks))
-
 
 def _list_of(elem: ParserElement) -> ParserElement:
     return Opt(
@@ -83,6 +74,15 @@ def _dictionary_of(
     return Dict(Group(entry)[len], asdict=not located)
 
 
+_SWITCH = (
+    Keyword("yes") | Keyword("true") | Keyword("on") | Keyword("y") | Keyword("t")
+).set_parse_action(lambda: True) | (
+    Keyword("no") | Keyword("false") | Keyword("off") | Keyword("n") | Keyword("f")
+).set_parse_action(lambda: False)
+_DIMENSIONS = (
+    Literal("[").suppress() + common.number * 7 + Literal("]").suppress()
+).set_parse_action(lambda tks: FoamDictionaryBase.DimensionSet(*tks))
+
 _TENSOR = _list_of(common.number) | common.number
 _IDENTIFIER = Word(identbodychars + "$", printables.replace(";", ""))
 _DIMENSIONED = (Opt(_IDENTIFIER) + _DIMENSIONS + _TENSOR).set_parse_action(
@@ -110,89 +110,87 @@ _FILE = (
     .ignore(Literal("#include") + ... + LineEnd())  # type: ignore [no-untyped-call]
 )
 
-Parsed = Mapping[Sequence[str], Tuple[int, Optional[FoamDictionaryBase.Value], int]]
-
-
-def _flatten_result(
-    parse_result: ParseResults, *, _keywords: Sequence[str] = ()
-) -> Parsed:
-    ret: MutableMapping[
-        Sequence[str], Tuple[int, Optional[FoamDictionaryBase.Value], int]
-    ] = {}
-    start = parse_result.locn_start
-    assert isinstance(start, int)
-    item = parse_result.value
-    assert isinstance(item, Sequence)
-    end = parse_result.locn_end
-    assert isinstance(end, int)
-    key, *values = item
-    assert isinstance(key, str)
-    ret[(*_keywords, key)] = (start, None, end)
-    for value in values:
-        if isinstance(value, ParseResults):
-            ret.update(_flatten_result(value, _keywords=(*_keywords, key)))
-        else:
-            ret[(*_keywords, key)] = (start, value, end)
-    return ret
-
-
-def parse(
-    contents: str,
-) -> Parsed:
-    parse_results = _FILE.parse_string(contents, parse_all=True)
-    ret: MutableMapping[
-        Sequence[str], Tuple[int, Optional[FoamDictionaryBase.Value], int]
-    ] = {}
-    for parse_result in parse_results:
-        ret.update(_flatten_result(parse_result))
-    return ret
-
-
-def get_value(
-    parsed: Parsed,
-    keywords: Tuple[str, ...],
-) -> Optional[FoamDictionaryBase.Value]:
-    """Value of an entry."""
-    _, value, _ = parsed[keywords]
-    return value
-
-
-def get_entry_locn(
-    parsed: Parsed,
-    keywords: Tuple[str, ...],
-    *,
-    missing_ok: bool = False,
-) -> Tuple[int, int]:
-    """Location of an entry or where it should be inserted."""
-    try:
-        start, _, end = parsed[keywords]
-    except KeyError:
-        if missing_ok:
-            if len(keywords) > 1:
-                _, _, end = parsed[keywords[:-1]]
-                end -= 1
-            else:
-                end = -1
 
-            start = end
-        else:
-            raise
+class Parsed(Mapping[Tuple[str, ...], Union[FoamDictionaryBase.Value, EllipsisType]]):
+    def __init__(self, contents: str) -> None:
+        self._parsed: MutableMapping[
+            Tuple[str, ...],
+            Tuple[int, Union[FoamDictionaryBase.Value, EllipsisType], int],
+        ] = {}
+        for parse_result in _FILE.parse_string(contents, parse_all=True):
+            self._parsed.update(self._flatten_result(parse_result))
+
+    @staticmethod
+    def _flatten_result(
+        parse_result: ParseResults, *, _keywords: Tuple[str, ...] = ()
+    ) -> Mapping[
+        Tuple[str, ...], Tuple[int, Union[FoamDictionaryBase.Value, EllipsisType], int]
+    ]:
+        ret: MutableMapping[
+            Tuple[str, ...],
+            Tuple[int, Union[FoamDictionaryBase.Value, EllipsisType], int],
+        ] = {}
+        start = parse_result.locn_start
+        assert isinstance(start, int)
+        item = parse_result.value
+        assert isinstance(item, Sequence)
+        end = parse_result.locn_end
+        assert isinstance(end, int)
+        key, *values = item
+        assert isinstance(key, str)
+        ret[(*_keywords, key)] = (start, ..., end)
+        for value in values:
+            if isinstance(value, ParseResults):
+                ret.update(Parsed._flatten_result(value, _keywords=(*_keywords, key)))
+            else:
+                ret[(*_keywords, key)] = (start, value, end)
+        return ret
+
+    def __getitem__(
+        self, keywords: Tuple[str, ...]
+    ) -> Union[FoamDictionaryBase.Value, EllipsisType]:
+        _, value, _ = self._parsed[keywords]
+        return value
+
+    def __contains__(self, keywords: object) -> bool:
+        return keywords in self._parsed
+
+    def __iter__(self) -> Iterator[Tuple[str, ...]]:
+        return iter(self._parsed)
+
+    def __len__(self) -> int:
+        return len(self._parsed)
+
+    def entry_location(
+        self, keywords: Tuple[str, ...], *, missing_ok: bool = False
+    ) -> Tuple[int, int]:
+        try:
+            start, _, end = self._parsed[keywords]
+        except KeyError:
+            if missing_ok:
+                if len(keywords) > 1:
+                    _, _, end = self._parsed[keywords[:-1]]
+                    end -= 1
+                else:
+                    end = -1
+
+                start = end
+            else:
+                raise
 
-    return start, end
+        return start, end
 
+    def as_dict(self) -> FoamDictionaryBase._Dict:
+        ret: FoamDictionaryBase._Dict = {}
+        for keywords, (_, value, _) in self._parsed.items():
+            r = ret
+            for k in keywords[:-1]:
+                assert isinstance(r, dict)
+                v = r[k]
+                assert isinstance(v, dict)
+                r = v
 
-def as_dict(parsed: Parsed) -> FoamDictionaryBase._Dict:
-    """Return a nested dict representation of the file."""
-    ret: FoamDictionaryBase._Dict = {}
-    for keywords, (_, value, _) in parsed.items():
-        r = ret
-        for k in keywords[:-1]:
             assert isinstance(r, dict)
-            v = r[k]
-            assert isinstance(v, dict)
-            r = v
-
-        assert isinstance(r, dict)
-        r[keywords[-1]] = {} if value is None else value
+            r[keywords[-1]] = {} if value is ... else value  # type: ignore [assignment]
 
-    return ret
+        return ret

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

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

@@ -10,8 +10,10 @@ foamlib.egg-info/SOURCES.txt
 foamlib.egg-info/dependency_links.txt
 foamlib.egg-info/requires.txt
 foamlib.egg-info/top_level.txt
-foamlib/_dictionaries/__init__.py
-foamlib/_dictionaries/_base.py
-foamlib/_dictionaries/_files.py
-foamlib/_dictionaries/_parsing.py
-foamlib/_dictionaries/_serialization.py
+foamlib/_files/__init__.py
+foamlib/_files/_base.py
+foamlib/_files/_fields.py
+foamlib/_files/_files.py
+foamlib/_files/_io.py
+foamlib/_files/_parsing.py
+foamlib/_files/_serialization.py

foamlib-0.2.8/foamlib/_dictionaries/_files.py

@@ -1,418 +0,0 @@
-import sys
-from pathlib import Path
-from types import TracebackType
-from typing import (
-    Any,
-    Optional,
-    Tuple,
-    Type,
-    Union,
-    cast,
-)
-
-if sys.version_info >= (3, 9):
-    from collections.abc import Iterator, Mapping, MutableMapping, Sequence
-else:
-    from typing import Iterator, Mapping, MutableMapping, Sequence
-
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
-
-try:
-    import numpy as np
-    from numpy.typing import NDArray
-except ModuleNotFoundError:
-    pass
-
-from ._base import FoamDictionaryBase
-from ._parsing import Parsed, as_dict, get_entry_locn, get_value, parse
-from ._serialization import serialize_entry
-
-
-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: 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
-            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[
-        Union[str, Tuple[str, ...]], Union["FoamFile.Value", "FoamFile.Dictionary"]
-    ],
-):
-    """
-    An OpenFOAM dictionary file.
-
-    Use as a mutable mapping (i.e., like a dict) to access and modify entries.
-
-    Use as a context manager to make multiple changes to the file while saving all changes only once at the end.
-    """
-
-    class Dictionary(
-        FoamDictionaryBase,
-        MutableMapping[str, Union["FoamFile.Value", "FoamFile.Dictionary"]],
-    ):
-        """An OpenFOAM dictionary within a file as a mutable mapping."""
-
-        def __init__(self, _file: "FoamFile", _keywords: Sequence[str]) -> None:
-            self._file = _file
-            self._keywords = _keywords
-
-        def __getitem__(
-            self, keyword: str
-        ) -> Union["FoamFile.Value", "FoamFile.Dictionary"]:
-            return self._file[(*self._keywords, keyword)]
-
-        def _setitem(
-            self,
-            keyword: str,
-            value: Any,
-            *,
-            assume_field: bool = False,
-            assume_dimensions: bool = False,
-        ) -> None:
-            self._file._setitem(
-                (*self._keywords, keyword),
-                value,
-                assume_field=assume_field,
-                assume_dimensions=assume_dimensions,
-            )
-
-        def __setitem__(self, keyword: str, value: "FoamFile._SetValue") -> None:
-            self._setitem(keyword, value)
-
-        def __delitem__(self, keyword: str) -> None:
-            del self._file[(*self._keywords, keyword)]
-
-        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})"
-
-        def as_dict(self) -> FoamDictionaryBase._Dict:
-            """Return a nested dict representation of the dictionary."""
-            ret = self._file.as_dict()
-
-            for k in self._keywords:
-                assert isinstance(ret, dict)
-                v = ret[k]
-                assert isinstance(v, dict)
-                ret = v
-
-            return ret
-
-    def __getitem__(
-        self, keywords: Union[str, Tuple[str, ...]]
-    ) -> Union["FoamFile.Value", "FoamFile.Dictionary"]:
-        if not isinstance(keywords, tuple):
-            keywords = (keywords,)
-
-        _, parsed = self._read()
-
-        value = get_value(parsed, keywords)
-
-        if value is None:
-            return FoamFile.Dictionary(self, keywords)
-        else:
-            return value
-
-    def _setitem(
-        self,
-        keywords: Union[str, Tuple[str, ...]],
-        value: "FoamFile._SetValue",
-        *,
-        assume_field: bool = False,
-        assume_dimensions: bool = False,
-    ) -> None:
-        if not isinstance(keywords, tuple):
-            keywords = (keywords,)
-
-        contents, parsed = self._read()
-
-        if isinstance(value, Mapping):
-            with self:
-                if isinstance(value, FoamDictionaryBase):
-                    value = value.as_dict()
-
-                start, end = get_entry_locn(parsed, keywords, missing_ok=True)
-
-                self._write(
-                    f"{contents[:start]}\n{serialize_entry(keywords[-1], {})}\n{contents[end:]}"
-                )
-
-                for k, v in value.items():
-                    self[(*keywords, k)] = v
-        else:
-            start, end = get_entry_locn(parsed, keywords, missing_ok=True)
-
-            self._write(
-                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: "FoamFile._SetValue",
-    ) -> None:
-        self._setitem(keywords, value)
-
-    def __delitem__(self, keywords: Union[str, Tuple[str, ...]]) -> None:
-        if not isinstance(keywords, tuple):
-            keywords = (keywords,)
-
-        contents, parsed = self._read()
-
-        start, end = get_entry_locn(parsed, keywords)
-
-        self._write(contents[:start] + contents[end:])
-
-    def _iter(self, keywords: Union[str, Tuple[str, ...]] = ()) -> Iterator[str]:
-        if not isinstance(keywords, tuple):
-            keywords = (keywords,)
-
-        contents = self.path.read_text()
-        parsed = parse(contents)
-
-        yield from (k[-1] for k in parsed if k[:-1] == keywords)
-
-    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)
-
-    def __repr__(self) -> str:
-        return f"{type(self).__name__}({self.path})"
-
-    def as_dict(self) -> FoamDictionaryBase._Dict:
-        """Return a nested dict representation of the file."""
-        _, parsed = self._read()
-        return as_dict(parsed)
-
-
-class FoamFieldFile(FoamFile):
-    """An OpenFOAM dictionary file representing a field as a mutable mapping."""
-
-    class BoundariesDictionary(FoamFile.Dictionary):
-        def __getitem__(self, keyword: str) -> "FoamFieldFile.BoundaryDictionary":
-            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: FoamFile._SetValue,
-        ) -> None:
-            if key == "value":
-                self._setitem(key, value, assume_field=True)
-            else:
-                self._setitem(key, value)
-
-        @property
-        def type(self) -> str:
-            """Alias of `self["type"]`."""
-            ret = self["type"]
-            if not isinstance(ret, str):
-                raise TypeError("type is not a string")
-            return ret
-
-        @type.setter
-        def type(self, value: str) -> None:
-            self["type"] = value
-
-        @property
-        def value(
-            self,
-        ) -> Union[
-            int,
-            float,
-            Sequence[Union[int, float, Sequence[Union[int, float]]]],
-            "NDArray[np.generic]",
-        ]:
-            """Alias of `self["value"]`."""
-            ret = self["value"]
-            if not isinstance(ret, (int, float, Sequence)):
-                raise TypeError("value is not a field")
-            return cast(Union[int, float, Sequence[Union[int, float]]], ret)
-
-        @value.setter
-        def value(
-            self,
-            value: Union[
-                int,
-                float,
-                Sequence[Union[int, float, Sequence[Union[int, float]]]],
-                "NDArray[np.generic]",
-            ],
-        ) -> None:
-            self["value"] = value
-
-        @value.deleter
-        def value(self) -> None:
-            del self["value"]
-
-    def __getitem__(
-        self, keywords: Union[str, Tuple[str, ...]]
-    ) -> Union[FoamFile.Value, FoamFile.Dictionary]:
-        if not isinstance(keywords, tuple):
-            keywords = (keywords,)
-
-        ret = super().__getitem__(keywords)
-        if keywords[0] == "boundaryField" and isinstance(ret, FoamFile.Dictionary):
-            if len(keywords) == 1:
-                ret = FoamFieldFile.BoundariesDictionary(self, keywords)
-            elif len(keywords) == 2:
-                ret = FoamFieldFile.BoundaryDictionary(self, keywords)
-        return ret
-
-    def __setitem__(self, keywords: Union[str, Tuple[str, ...]], value: Any) -> None:
-        if not isinstance(keywords, tuple):
-            keywords = (keywords,)
-
-        if keywords == ("internalField",):
-            self._setitem(keywords, value, assume_field=True)
-        elif keywords == ("dimensions",):
-            self._setitem(keywords, value, assume_dimensions=True)
-        else:
-            self._setitem(keywords, value)
-
-    @property
-    def dimensions(self) -> FoamFile.DimensionSet:
-        """Alias of `self["dimensions"]`."""
-        ret = self["dimensions"]
-        if not isinstance(ret, FoamFile.DimensionSet):
-            raise TypeError("dimensions is not a DimensionSet")
-        return ret
-
-    @dimensions.setter
-    def dimensions(
-        self, value: Union[FoamFile.DimensionSet, Sequence[Union[int, float]]]
-    ) -> None:
-        self["dimensions"] = value
-
-    @property
-    def internal_field(
-        self,
-    ) -> Union[
-        int,
-        float,
-        Sequence[Union[int, float, Sequence[Union[int, float]]]],
-        "NDArray[np.generic]",
-    ]:
-        """Alias of `self["internalField"]`."""
-        ret = self["internalField"]
-        if not isinstance(ret, (int, float, Sequence)):
-            raise TypeError("internalField is not a field")
-        return cast(Union[int, float, Sequence[Union[int, float]]], ret)
-
-    @internal_field.setter
-    def internal_field(
-        self,
-        value: Union[
-            int,
-            float,
-            Sequence[Union[int, float, Sequence[Union[int, float]]]],
-            "NDArray[np.generic]",
-        ],
-    ) -> None:
-        self["internalField"] = value
-
-    @property
-    def boundary_field(self) -> "FoamFieldFile.BoundariesDictionary":
-        """Alias of `self["boundaryField"]`."""
-        ret = self["boundaryField"]
-        if not isinstance(ret, FoamFieldFile.BoundariesDictionary):
-            assert not isinstance(ret, FoamFile.Dictionary)
-            raise TypeError("boundaryField is not a dictionary")
-        return ret