foamlib 0.6.10__py3-none-any.whl → 0.6.12__py3-none-any.whl

foamlib/_files/_files.py

@@ -1,5 +1,8 @@
+from __future__ import annotations
+
 import sys
-from typing import TYPE_CHECKING, Any, Optional, Tuple, Union, cast
+from copy import deepcopy
+from typing import Any, Optional, Tuple, Union, cast
 
 if sys.version_info >= (3, 8):
     from typing import Literal
@@ -16,15 +19,12 @@ from ._io import FoamFileIO
 from ._serialization import Kind, dumps
 from ._util import is_sequence
 
-if TYPE_CHECKING:
-    import numpy as np
-
 
 class FoamFile(
     FoamFileBase,
     MutableMapping[
         Optional[Union[str, Tuple[str, ...]]],
-        Union["FoamFile.Data", "FoamFile.SubDict"],
+        FoamFileBase._MutableData,
     ],
     FoamFileIO,
 ):
@@ -37,23 +37,23 @@ class FoamFile(
     """
 
     class SubDict(
-        MutableMapping[str, Union["FoamFile.Data", "FoamFile.SubDict"]],
+        MutableMapping[str, FoamFileBase._MutableData],
     ):
         """An OpenFOAM dictionary within a file as a mutable mapping."""
 
-        def __init__(self, _file: "FoamFile", _keywords: Tuple[str, ...]) -> None:
+        def __init__(self, _file: FoamFile, _keywords: tuple[str, ...]) -> None:
             self._file = _file
             self._keywords = _keywords
 
         def __getitem__(
             self, keyword: str
-        ) -> Union["FoamFile.Data", "FoamFile.SubDict"]:
+        ) -> FoamFileBase._DataEntry | FoamFile.SubDict:
             return self._file[(*self._keywords, keyword)]
 
         def __setitem__(
             self,
             keyword: str,
-            data: "FoamFile._SetData",
+            data: FoamFileBase.Data,
         ) -> None:
             self._file[(*self._keywords, keyword)] = data
 
@@ -98,8 +98,9 @@ class FoamFile(
     def version(self) -> float:
         """Alias of `self["FoamFile", "version"]`."""
         ret = self["FoamFile", "version"]
-        if not isinstance(ret, float):
-            raise TypeError("version is not a float")
+        if not isinstance(ret, (int, float)):
+            msg = "version is not a number"
+            raise TypeError(msg)
         return ret
 
     @version.setter
@@ -111,9 +112,11 @@ class FoamFile(
         """Alias of `self["FoamFile", "format"]`."""
         ret = self["FoamFile", "format"]
         if not isinstance(ret, str):
-            raise TypeError("format is not a string")
+            msg = "format is not a string"
+            raise TypeError(msg)
         if ret not in ("ascii", "binary"):
-            raise ValueError("format is not 'ascii' or 'binary'")
+            msg = "format is not 'ascii' or 'binary'"
+            raise ValueError(msg)
         return cast(Literal["ascii", "binary"], ret)
 
     @format.setter
@@ -125,7 +128,8 @@ class FoamFile(
         """Alias of `self["FoamFile", "class"]`."""
         ret = self["FoamFile", "class"]
         if not isinstance(ret, str):
-            raise TypeError("class is not a string")
+            msg = "class is not a string"
+            raise TypeError(msg)
         return ret
 
     @class_.setter
@@ -137,7 +141,8 @@ class FoamFile(
         """Alias of `self["FoamFile", "location"]`."""
         ret = self["FoamFile", "location"]
         if not isinstance(ret, str):
-            raise TypeError("location is not a string")
+            msg = "location is not a string"
+            raise TypeError(msg)
         return ret
 
     @location.setter
@@ -149,7 +154,8 @@ class FoamFile(
         """Alias of `self["FoamFile", "object"]`."""
         ret = self["FoamFile", "object"]
         if not isinstance(ret, str):
-            raise TypeError("object is not a string")
+            msg = "object is not a string"
+            raise TypeError(msg)
         return ret
 
     @object_.setter
@@ -157,30 +163,32 @@ class FoamFile(
         self["FoamFile", "object"] = value
 
     def __getitem__(
-        self, keywords: Optional[Union[str, Tuple[str, ...]]]
-    ) -> Union["FoamFile.Data", "FoamFile.SubDict"]:
+        self, keywords: str | tuple[str, ...] | None
+    ) -> FoamFileBase._DataEntry | FoamFile.SubDict:
         if not keywords:
             keywords = ()
         elif not isinstance(keywords, tuple):
             keywords = (keywords,)
 
-        _, parsed = self._read()
+        parsed = self._get_parsed()
 
         value = parsed[keywords]
 
+        assert not isinstance(value, Mapping)
+
         if value is ...:
             return FoamFile.SubDict(self, keywords)
-        return value
+        return deepcopy(value)
 
     def __setitem__(
-        self, keywords: Optional[Union[str, Tuple[str, ...]]], data: "FoamFile._SetData"
+        self, keywords: str | tuple[str, ...] | None, data: FoamFileBase.Data
     ) -> None:
-        with self:
-            if not keywords:
-                keywords = ()
-            elif not isinstance(keywords, tuple):
-                keywords = (keywords,)
+        if not keywords:
+            keywords = ()
+        elif not isinstance(keywords, tuple):
+            keywords = (keywords,)
 
+        with self:
             try:
                 write_header = (
                     not self and "FoamFile" not in self and keywords != ("FoamFile",)
@@ -213,91 +221,104 @@ class FoamFile(
                 kind = Kind.DIMENSIONS
 
             if (
-                kind == Kind.FIELD or kind == Kind.BINARY_FIELD
+                kind in (Kind.FIELD, Kind.BINARY_FIELD)
             ) and self.class_ == "dictionary":
-                if not is_sequence(data):
-                    class_ = "volScalarField"
-                elif (len(data) == 3 and not is_sequence(data[0])) or len(data[0]) == 3:
-                    class_ = "volVectorField"
-                elif (len(data) == 6 and not is_sequence(data[0])) or len(data[0]) == 6:
-                    class_ = "volSymmTensorField"
-                elif (len(data) == 9 and not is_sequence(data[0])) or len(data[0]) == 9:
-                    class_ = "volTensorField"
+                if isinstance(data, (int, float)):
+                    self.class_ = "volScalarField"
+
+                elif is_sequence(data) and data:
+                    if isinstance(data[0], (int, float)):
+                        if len(data) == 3:
+                            self.class_ = "volVectorField"
+                        elif len(data) == 6:
+                            self.class_ = "volSymmTensorField"
+                        elif len(data) == 9:
+                            self.class_ = "volTensorField"
+                    elif (
+                        is_sequence(data[0])
+                        and data[0]
+                        and isinstance(data[0][0], (int, float))
+                    ):
+                        if len(data[0]) == 3:
+                            self.class_ = "volVectorField"
+                        elif len(data[0]) == 6:
+                            self.class_ = "volSymmTensorField"
+                        elif len(data[0]) == 9:
+                            self.class_ = "volTensorField"
+
+            parsed = self._get_parsed(missing_ok=True)
+
+            start, end = parsed.entry_location(keywords, missing_ok=True)
+
+            if start and not parsed.contents[:start].endswith(b"\n\n"):
+                if parsed.contents[:start].endswith(b"\n"):
+                    before = b"\n" if len(keywords) <= 1 else b""
                 else:
-                    class_ = "volScalarField"
-
-                self.class_ = class_
-                self[keywords] = data
+                    before = b"\n\n" if len(keywords) <= 1 else b"\n"
+            else:
+                before = b""
 
+            if not parsed.contents[end:].strip() or parsed.contents[end:].startswith(
+                b"}"
+            ):
+                after = b"\n" + b"    " * (len(keywords) - 2)
             else:
-                contents, parsed = self._read(missing_ok=True)
-
-                start, end = parsed.entry_location(keywords, missing_ok=True)
-
-                before = contents[:start].rstrip() + b"\n"
-                if len(keywords) <= 1:
-                    before += b"\n"
-
-                after = contents[end:]
-                if after.startswith(b"}"):
-                    after = b"    " * (len(keywords) - 2) + after
-                if not after or after[:1] != b"\n":
-                    after = b"\n" + after
-                if len(keywords) <= 1 and len(after) > 1 and after[:2] != b"\n\n":
-                    after = b"\n" + after
-
-                indentation = b"    " * (len(keywords) - 1)
-
-                if isinstance(data, Mapping):
-                    if isinstance(data, (FoamFile, FoamFile.SubDict)):
-                        data = data.as_dict()
-
-                    self._write(
-                        before
-                        + indentation
-                        + dumps(keywords[-1])
-                        + b"\n"
-                        + indentation
-                        + b"{\n"
-                        + indentation
-                        + b"}"
-                        + after
-                    )
-
-                    for k, v in data.items():
-                        self[(*keywords, k)] = v
-
-                elif keywords:
-                    self._write(
-                        before
-                        + indentation
-                        + dumps(keywords[-1])
-                        + b" "
-                        + dumps(data, kind=kind)
-                        + b";"
-                        + after
-                    )
+                after = b""
+
+            indentation = b"    " * (len(keywords) - 1)
+
+            if isinstance(data, Mapping):
+                if isinstance(data, (FoamFile, FoamFile.SubDict)):
+                    data = data.as_dict()
+
+                parsed.put(
+                    keywords,
+                    ...,
+                    before
+                    + indentation
+                    + dumps(keywords[-1])
+                    + b"\n"
+                    + indentation
+                    + b"{\n"
+                    + indentation
+                    + b"}"
+                    + after,
+                )
 
-                else:
-                    self._write(before + dumps(data, kind=kind) + after)
+                for k, v in data.items():
+                    self[(*keywords, k)] = v
+
+            elif keywords:
+                parsed.put(
+                    keywords,
+                    deepcopy(data),
+                    before
+                    + indentation
+                    + dumps(keywords[-1])
+                    + b" "
+                    + dumps(data, kind=kind)
+                    + b";"
+                    + after,
+                )
+
+            else:
+                parsed.put((), deepcopy(data), before + dumps(data, kind=kind) + after)
 
-    def __delitem__(self, keywords: Optional[Union[str, Tuple[str, ...]]]) -> None:
+    def __delitem__(self, keywords: str | tuple[str, ...] | None) -> None:
         if not keywords:
             keywords = ()
         elif not isinstance(keywords, tuple):
             keywords = (keywords,)
 
-        contents, parsed = self._read()
-
-        start, end = parsed.entry_location(keywords)
-
-        self._write(contents[:start] + contents[end:])
+        with self:
+            del self._get_parsed()[keywords]
 
-    def _iter(self, keywords: Tuple[str, ...] = ()) -> Iterator[Optional[str]]:
-        _, parsed = self._read()
-        yield from (k[-1] if k else None for k in parsed if k[:-1] == keywords)
+    def _iter(self, keywords: tuple[str, ...] = ()) -> Iterator[str | None]:
+        yield from (
+            k[-1] if k else None for k in self._get_parsed() if k[:-1] == keywords
+        )
 
-    def __iter__(self) -> Iterator[Optional[str]]:
+    def __iter__(self) -> Iterator[str | None]:
         yield from (k for k in self._iter() if k != "FoamFile")
 
     def __contains__(self, keywords: object) -> bool:
@@ -306,9 +327,7 @@ class FoamFile(
         elif not isinstance(keywords, tuple):
             keywords = (keywords,)
 
-        _, parsed = self._read()
-
-        return keywords in parsed
+        return keywords in self._get_parsed()
 
     def __len__(self) -> int:
         return len(list(iter(self)))
@@ -330,22 +349,22 @@ class FoamFile(
 
         :param include_header: Whether to include the "FoamFile" header in the output.
         """
-        _, parsed = self._read()
-        d = parsed.as_dict()
+        d = self._get_parsed().as_dict()
         if not include_header:
             d.pop("FoamFile", None)
-        return d
+        return deepcopy(d)
 
 
 class FoamFieldFile(FoamFile):
     """An OpenFOAM dictionary file representing a field as a mutable mapping."""
 
     class BoundariesSubDict(FoamFile.SubDict):
-        def __getitem__(self, keyword: str) -> "FoamFieldFile.BoundarySubDict":
+        def __getitem__(self, keyword: str) -> FoamFieldFile.BoundarySubDict:
             value = super().__getitem__(keyword)
             if not isinstance(value, FoamFieldFile.BoundarySubDict):
                 assert not isinstance(value, FoamFile.SubDict)
-                raise TypeError(f"boundary {keyword} is not a dictionary")
+                msg = f"boundary {keyword} is not a dictionary"
+                raise TypeError(msg)
             return value
 
     class BoundarySubDict(FoamFile.SubDict):
@@ -356,7 +375,8 @@ class FoamFieldFile(FoamFile):
             """Alias of `self["type"]`."""
             ret = self["type"]
             if not isinstance(ret, str):
-                raise TypeError("type is not a string")
+                msg = "type is not a string"
+                raise TypeError(msg)
             return ret
 
         @type.setter
@@ -366,36 +386,17 @@ class FoamFieldFile(FoamFile):
         @property
         def value(
             self,
-        ) -> Union[
-            int,
-            float,
-            Sequence[Union[int, float, Sequence[Union[int, float]]]],
-            "np.ndarray[Tuple[()], np.dtype[np.generic]]",
-            "np.ndarray[Tuple[int], np.dtype[np.generic]]",
-            "np.ndarray[Tuple[int, int], np.dtype[np.generic]]",
-        ]:
+        ) -> FoamFile._Field:
             """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, Sequence[Union[int, float]]]]
-                ],
-                ret,
+                FoamFile._Field,
+                self["value"],
             )
 
         @value.setter
         def value(
             self,
-            value: Union[
-                int,
-                float,
-                Sequence[Union[int, float, Sequence[Union[int, float]]]],
-                "np.ndarray[Tuple[()], np.dtype[np.generic]]",
-                "np.ndarray[Tuple[int], np.dtype[np.generic]]",
-                "np.ndarray[Tuple[int, int], np.dtype[np.generic]]",
-            ],
+            value: FoamFile._Field,
         ) -> None:
             self["value"] = value
 
@@ -404,8 +405,8 @@ class FoamFieldFile(FoamFile):
             del self["value"]
 
     def __getitem__(
-        self, keywords: Optional[Union[str, Tuple[str, ...]]]
-    ) -> Union[FoamFile.Data, FoamFile.SubDict]:
+        self, keywords: str | tuple[str, ...] | None
+    ) -> FoamFileBase._DataEntry | FoamFile.SubDict:
         if not keywords:
             keywords = ()
         elif not isinstance(keywords, tuple):
@@ -420,57 +421,40 @@ class FoamFieldFile(FoamFile):
         return ret
 
     @property
-    def dimensions(self) -> Union[FoamFile.DimensionSet, Sequence[Union[int, float]]]:
+    def dimensions(self) -> FoamFile.DimensionSet | Sequence[float]:
         """Alias of `self["dimensions"]`."""
         ret = self["dimensions"]
         if not isinstance(ret, FoamFile.DimensionSet):
-            raise TypeError("dimensions is not a DimensionSet")
+            msg = "dimensions is not a DimensionSet"
+            raise TypeError(msg)
         return ret
 
     @dimensions.setter
-    def dimensions(
-        self, value: Union[FoamFile.DimensionSet, Sequence[Union[int, float]]]
-    ) -> None:
+    def dimensions(self, value: FoamFile.DimensionSet | Sequence[float]) -> None:
         self["dimensions"] = value
 
     @property
     def internal_field(
         self,
-    ) -> Union[
-        int,
-        float,
-        Sequence[Union[int, float, Sequence[Union[int, float]]]],
-        "np.ndarray[Tuple[()], np.dtype[np.generic]]",
-        "np.ndarray[Tuple[int], np.dtype[np.generic]]",
-        "np.ndarray[Tuple[int, int], np.dtype[np.generic]]",
-    ]:
+    ) -> FoamFile._Field:
         """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)
+        return cast(FoamFile._Field, self["internalField"])
 
     @internal_field.setter
     def internal_field(
         self,
-        value: Union[
-            int,
-            float,
-            Sequence[Union[int, float, Sequence[Union[int, float]]]],
-            "np.ndarray[Tuple[()], np.dtype[np.generic]]",
-            "np.ndarray[Tuple[int], np.dtype[np.generic]]",
-            "np.ndarray[Tuple[int, int], np.dtype[np.generic]]",
-        ],
+        value: FoamFile._Field,
     ) -> None:
         self["internalField"] = value
 
     @property
-    def boundary_field(self) -> "FoamFieldFile.BoundariesSubDict":
+    def boundary_field(self) -> FoamFieldFile.BoundariesSubDict:
         """Alias of `self["boundaryField"]`."""
         ret = self["boundaryField"]
         if not isinstance(ret, FoamFieldFile.BoundariesSubDict):
             assert not isinstance(ret, FoamFile.SubDict)
-            raise TypeError("boundaryField is not a dictionary")
+            msg = "boundaryField is not a dictionary"
+            raise TypeError(msg)
         return ret
 
     @boundary_field.setter

foamlib/_files/_io.py

@@ -1,14 +1,10 @@
+from __future__ import annotations
+
 import gzip
 import sys
-from copy import deepcopy
 from pathlib import Path
-from types import TracebackType
 from typing import (
     TYPE_CHECKING,
-    Optional,
-    Tuple,
-    Type,
-    Union,
 )
 
 if sys.version_info >= (3, 11):
@@ -20,71 +16,64 @@ from ._parsing import Parsed
 
 if TYPE_CHECKING:
     import os
+    from types import TracebackType
 
 
 class FoamFileIO:
-    def __init__(self, path: Union["os.PathLike[str]", str]) -> None:
+    def __init__(self, path: os.PathLike[str] | str) -> None:
         self.path = Path(path).absolute()
 
-        self.__contents: Optional[bytes] = None
-        self.__parsed: Optional[Parsed] = None
+        self.__parsed: Parsed | None = None
+        self.__missing: bool | None = None
         self.__defer_io = 0
-        self.__dirty = False
 
     def __enter__(self) -> Self:
         if self.__defer_io == 0:
-            self._read(missing_ok=True)
+            self._get_parsed(missing_ok=True)
         self.__defer_io += 1
         return self
 
     def __exit__(
         self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
     ) -> None:
         self.__defer_io -= 1
-        if self.__defer_io == 0 and self.__dirty:
-            assert self.__contents is not None
-            self._write(self.__contents)
+        if self.__defer_io == 0:
+            assert self.__parsed is not None
+            if self.__parsed.modified:
+                contents = self.__parsed.contents
+
+                if self.path.suffix == ".gz":
+                    contents = gzip.compress(contents)
+
+                self.path.write_bytes(contents)
+                self.__parsed.modified = False
+                self.__missing = False
 
-    def _read(self, *, missing_ok: bool = False) -> Tuple[bytes, Parsed]:
+    def _get_parsed(self, *, missing_ok: bool = False) -> Parsed:
         if not self.__defer_io:
             try:
                 contents = self.path.read_bytes()
             except FileNotFoundError:
-                contents = None
+                self.__missing = True
+                contents = b""
             else:
-                assert isinstance(contents, bytes)
+                self.__missing = False
                 if self.path.suffix == ".gz":
                     contents = gzip.decompress(contents)
 
-            if contents != self.__contents:
-                self.__contents = contents
-                self.__parsed = None
+            if self.__parsed is None or self.__parsed.contents != contents:
+                self.__parsed = Parsed(contents)
 
-        if self.__contents is None:
-            if missing_ok:
-                return b"", Parsed(b"")
-            raise FileNotFoundError(self.path)
-
-        if self.__parsed is None:
-            parsed = Parsed(self.__contents)
-            self.__parsed = parsed
-
-        return self.__contents, deepcopy(self.__parsed)
+        assert self.__parsed is not None
+        assert self.__missing is not None
 
-    def _write(self, contents: bytes) -> None:
-        self.__contents = contents
-        self.__parsed = None
-        if not self.__defer_io:
-            if self.path.suffix == ".gz":
-                contents = gzip.compress(contents)
+        if self.__missing and not self.__parsed.modified and not missing_ok:
+            raise FileNotFoundError(self.path)
 
-            self.path.write_bytes(contents)
-            self.__dirty = False
-        else:
-            self.__dirty = True
+        return self.__parsed
 
     def __repr__(self) -> str:
         return f"{type(self).__qualname__}('{self.path}')"