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

foamlib/__init__.py

@@ -1,6 +1,6 @@
 """A Python interface for interacting with OpenFOAM."""
 
-__version__ = "0.6.10"
+__version__ = "0.6.11"
 
 from ._cases import (
     AsyncFoamCase,

foamlib/_files/_base.py

@@ -6,35 +6,46 @@ if TYPE_CHECKING:
     import numpy as np
 
 if sys.version_info >= (3, 9):
-    from collections.abc import Mapping, Sequence
+    from collections.abc import Mapping, MutableMapping, Sequence
 else:
-    from typing import Mapping, Sequence
+    from typing import Mapping, MutableMapping, Sequence
 
 
 class FoamFileBase:
     class DimensionSet(NamedTuple):
-        mass: Union[int, float] = 0
-        length: Union[int, float] = 0
-        time: Union[int, float] = 0
-        temperature: Union[int, float] = 0
-        moles: Union[int, float] = 0
-        current: Union[int, float] = 0
-        luminous_intensity: Union[int, float] = 0
+        mass: float = 0
+        length: float = 0
+        time: float = 0
+        temperature: float = 0
+        moles: float = 0
+        current: float = 0
+        luminous_intensity: float = 0
 
         def __repr__(self) -> str:
             return f"{type(self).__qualname__}({', '.join(f'{n}={v}' for n, v in zip(self._fields, self) if v != 0)})"
 
+    _Tensor = Union[
+        float,
+        Sequence[float],
+        "np.ndarray[Tuple[()], np.dtype[np.generic]]",
+        "np.ndarray[Tuple[int], np.dtype[np.generic]]",
+    ]
+
     @dataclass
     class Dimensioned:
-        value: Union[int, float, Sequence[Union[int, float]]] = 0
-        dimensions: Union["FoamFileBase.DimensionSet", Sequence[Union[int, float]]] = ()
+        value: "FoamFileBase._Tensor" = 0
+        dimensions: Union["FoamFileBase.DimensionSet", Sequence[float]] = ()
         name: Optional[str] = None
 
         def __post_init__(self) -> None:
             if not isinstance(self.dimensions, FoamFileBase.DimensionSet):
                 self.dimensions = FoamFileBase.DimensionSet(*self.dimensions)
 
-    Data = Union[
+    _Field = Union[
+        _Tensor, Sequence[_Tensor], "np.ndarray[Tuple[int, int], np.dtype[np.generic]]"
+    ]
+
+    _DataEntry = Union[
         str,
         int,
         float,
@@ -42,25 +53,22 @@ class FoamFileBase:
         Dimensioned,
         DimensionSet,
         Sequence["Data"],
+        _Tensor,
+        _Field,
+    ]
+
+    Data = Union[
+        _DataEntry,
         Mapping[str, "Data"],
     ]
     """
     A value that can be stored in an OpenFOAM file.
     """
 
+    _MutableData = Union[
+        _DataEntry,
+        MutableMapping[str, "_MutableData"],
+    ]
+
     _Dict = Dict[str, Union["Data", "_Dict"]]
     _File = Dict[Optional[str], Union["Data", "_Dict"]]
-
-    _SetData = Union[
-        str,
-        int,
-        float,
-        bool,
-        Dimensioned,
-        DimensionSet,
-        Sequence["_SetData"],
-        Mapping[str, "_SetData"],
-        "np.ndarray[Tuple[()], np.dtype[np.generic]]",
-        "np.ndarray[Tuple[int], np.dtype[np.generic]]",
-        "np.ndarray[Tuple[int, int], np.dtype[np.generic]]",
-    ]

foamlib/_files/_files.py

@@ -1,5 +1,6 @@
 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 +17,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,7 +35,7 @@ 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."""
 
@@ -47,13 +45,13 @@ class FoamFile(
 
         def __getitem__(
             self, keyword: str
-        ) -> Union["FoamFile.Data", "FoamFile.SubDict"]:
+        ) -> Union[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 +96,8 @@ 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)):
+            raise TypeError("version is not a number")
         return ret
 
     @version.setter
@@ -158,22 +156,24 @@ class FoamFile(
 
     def __getitem__(
         self, keywords: Optional[Union[str, Tuple[str, ...]]]
-    ) -> Union["FoamFile.Data", "FoamFile.SubDict"]:
+    ) -> Union[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: Optional[Union[str, Tuple[str, ...]]], data: FoamFileBase.Data
     ) -> None:
         with self:
             if not keywords:
@@ -230,20 +230,28 @@ class FoamFile(
                 self[keywords] = data
 
             else:
-                contents, parsed = self._read(missing_ok=True)
+                parsed = self._get_parsed(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":
+                before = b""
+                if parsed.contents[:start] and not parsed.contents[:start].endswith(
+                    b"\n"
+                ):
+                    before = b"\n"
+                if (
+                    parsed.contents[:start]
+                    and len(keywords) <= 1
+                    and not parsed.contents[:start].endswith(b"\n\n")
+                ):
+                    before = b"\n\n"
+
+                after = b""
+                if parsed.contents[end:].startswith(b"}"):
+                    after = b"    " * (len(keywords) - 2)
+                if not parsed.contents[end:] or not parsed.contents[end:].startswith(
+                    b"\n"
+                ):
                     after = b"\n" + after
 
                 indentation = b"    " * (len(keywords) - 1)
@@ -252,7 +260,9 @@ class FoamFile(
                     if isinstance(data, (FoamFile, FoamFile.SubDict)):
                         data = data.as_dict()
 
-                    self._write(
+                    parsed.put(
+                        keywords,
+                        ...,
                         before
                         + indentation
                         + dumps(keywords[-1])
@@ -261,25 +271,27 @@ class FoamFile(
                         + b"{\n"
                         + indentation
                         + b"}"
-                        + after
+                        + after,
                     )
 
                     for k, v in data.items():
                         self[(*keywords, k)] = v
 
                 elif keywords:
-                    self._write(
+                    parsed.put(
+                        keywords,
+                        data,
                         before
                         + indentation
                         + dumps(keywords[-1])
                         + b" "
                         + dumps(data, kind=kind)
                         + b";"
-                        + after
+                        + after,
                     )
 
                 else:
-                    self._write(before + dumps(data, kind=kind) + after)
+                    parsed.put(keywords, data, before + dumps(data, kind=kind) + after)
 
     def __delitem__(self, keywords: Optional[Union[str, Tuple[str, ...]]]) -> None:
         if not keywords:
@@ -287,15 +299,13 @@ class FoamFile(
         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)
+        yield from (
+            k[-1] if k else None for k in self._get_parsed() if k[:-1] == keywords
+        )
 
     def __iter__(self) -> Iterator[Optional[str]]:
         yield from (k for k in self._iter() if k != "FoamFile")
@@ -306,9 +316,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,11 +338,10 @@ 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):
@@ -366,36 +373,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
 
@@ -405,7 +393,7 @@ class FoamFieldFile(FoamFile):
 
     def __getitem__(
         self, keywords: Optional[Union[str, Tuple[str, ...]]]
-    ) -> Union[FoamFile.Data, FoamFile.SubDict]:
+    ) -> Union[FoamFileBase._DataEntry, FoamFile.SubDict]:
         if not keywords:
             keywords = ()
         elif not isinstance(keywords, tuple):
@@ -420,7 +408,7 @@ class FoamFieldFile(FoamFile):
         return ret
 
     @property
-    def dimensions(self) -> Union[FoamFile.DimensionSet, Sequence[Union[int, float]]]:
+    def dimensions(self) -> Union[FoamFile.DimensionSet, Sequence[float]]:
         """Alias of `self["dimensions"]`."""
         ret = self["dimensions"]
         if not isinstance(ret, FoamFile.DimensionSet):
@@ -428,39 +416,20 @@ class FoamFieldFile(FoamFile):
         return ret
 
     @dimensions.setter
-    def dimensions(
-        self, value: Union[FoamFile.DimensionSet, Sequence[Union[int, float]]]
-    ) -> None:
+    def dimensions(self, value: Union[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
 

foamlib/_files/_io.py

@@ -1,12 +1,10 @@
 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,
 )
@@ -26,14 +24,13 @@ class FoamFileIO:
     def __init__(self, path: Union["os.PathLike[str]", str]) -> None:
         self.path = Path(path).absolute()
 
-        self.__contents: Optional[bytes] = None
         self.__parsed: Optional[Parsed] = None
+        self.__missing: Optional[bool] = 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
 
@@ -44,47 +41,40 @@ class FoamFileIO:
         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)
+        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)
 
-    def _read(self, *, missing_ok: bool = False) -> Tuple[bytes, Parsed]:
+                self.path.write_bytes(contents)
+                self.__parsed.modified = False
+                self.__missing = False
+
+    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)
+        assert self.__parsed is not None
+        assert self.__missing 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: 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}')"

foamlib/_files/_parsing.py

@@ -207,28 +207,29 @@ _FILE = (
 )
 
 
-class Parsed(Mapping[Tuple[str, ...], Union[FoamFileBase.Data, EllipsisType]]):
+class Parsed(Mapping[Tuple[str, ...], Union[FoamFileBase._DataEntry, EllipsisType]]):
     def __init__(self, contents: bytes) -> None:
         self._parsed: MutableMapping[
             Tuple[str, ...],
-            Tuple[int, Union[FoamFileBase.Data, EllipsisType], int],
+            Tuple[int, Union[FoamFileBase._DataEntry, EllipsisType], int],
         ] = {}
-        self._end = len(contents)
-
         for parse_result in _FILE.parse_string(
             contents.decode("latin-1"), parse_all=True
         ):
             self._parsed.update(self._flatten_result(parse_result))
 
+        self.contents = contents
+        self.modified = False
+
     @staticmethod
     def _flatten_result(
         parse_result: ParseResults, *, _keywords: Tuple[str, ...] = ()
     ) -> Mapping[
-        Tuple[str, ...], Tuple[int, Union[FoamFileBase.Data, EllipsisType], int]
+        Tuple[str, ...], Tuple[int, Union[FoamFileBase._DataEntry, EllipsisType], int]
     ]:
         ret: MutableMapping[
             Tuple[str, ...],
-            Tuple[int, Union[FoamFileBase.Data, EllipsisType], int],
+            Tuple[int, Union[FoamFileBase._DataEntry, EllipsisType], int],
         ] = {}
         start = parse_result.locn_start
         assert isinstance(start, int)
@@ -256,13 +257,58 @@ class Parsed(Mapping[Tuple[str, ...], Union[FoamFileBase.Data, EllipsisType]]):
 
     def __getitem__(
         self, keywords: Union[str, Tuple[str, ...]]
-    ) -> Union[FoamFileBase.Data, EllipsisType]:
+    ) -> Union[FoamFileBase._DataEntry, EllipsisType]:
         if isinstance(keywords, str):
             keywords = (keywords,)
 
         _, data, _ = self._parsed[keywords]
         return data
 
+    def put(
+        self,
+        keywords: Tuple[str, ...],
+        data: Union[FoamFileBase._DataEntry, EllipsisType],
+        content: bytes,
+    ) -> None:
+        start, end = self.entry_location(keywords, missing_ok=True)
+
+        diff = len(content) - (end - start)
+        for k, (s, d, e) in self._parsed.items():
+            if s > end:
+                self._parsed[k] = (s + diff, d, e + diff)
+            elif e > start:
+                self._parsed[k] = (s, d, e + diff)
+
+        self._parsed[keywords] = (start, data, end + diff)
+
+        self.contents = self.contents[:start] + content + self.contents[end:]
+        self.modified = True
+
+        for k in list(self._parsed):
+            if keywords != k and keywords == k[: len(keywords)]:
+                del self._parsed[k]
+
+    def __delitem__(self, keywords: Union[str, Tuple[str, ...]]) -> None:
+        if isinstance(keywords, str):
+            keywords = (keywords,)
+
+        start, end = self.entry_location(keywords)
+        del self._parsed[keywords]
+
+        for k in list(self._parsed):
+            if keywords == k[: len(keywords)]:
+                del self._parsed[k]
+
+        diff = end - start
+        for k, (s, d, e) in self._parsed.items():
+            if s > end:
+                self._parsed[k] = (s - diff, d, e - diff)
+            elif e > start:
+                self._parsed[k] = (s, d, e - diff)
+
+        self.contents = self.contents[:start] + self.contents[end:]
+        self.modified = True
+
     def __contains__(self, keywords: object) -> bool:
         return keywords in self._parsed
 
@@ -280,10 +326,11 @@ class Parsed(Mapping[Tuple[str, ...], Union[FoamFileBase.Data, EllipsisType]]):
         except KeyError:
             if missing_ok:
                 if len(keywords) > 1:
-                    _, _, end = self._parsed[keywords[:-1]]
-                    end -= 1
+                    assert self[keywords[:-1]] is ...
+                    start, end = self.entry_location(keywords[:-1])
+                    end = self.contents.rindex(b"}", start, end)
                 else:
-                    end = self._end
+                    end = len(self.contents)
 
                 start = end
             else:

foamlib/_files/_serialization.py

@@ -28,7 +28,7 @@ class Kind(Enum):
 
 
 def dumps(
-    data: FoamFileBase._SetData,
+    data: FoamFileBase.Data,
     *,
     kind: Kind = Kind.DEFAULT,
 ) -> bytes:

{foamlib-0.6.10.dist-info → foamlib-0.6.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.6.10
+Version: 0.6.11
 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.6.10.dist-info → foamlib-0.6.11.dist-info}/RECORD

@@ -1,4 +1,4 @@
-foamlib/__init__.py,sha256=7AIRMyiByWRuEUEkR_MGE1zy0GuXaEzOlzXnUkCvdtw,487
+foamlib/__init__.py,sha256=tS4b8eyl8WWPCCt7EmgXM2lcx8V1Zead47kwB3zJlNY,487
 foamlib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 foamlib/_cases/__init__.py,sha256=wTUHcUgU1CBgpu0cUMtksQ5VKG6B8CFu9xc3dWwsQuo,358
 foamlib/_cases/_async.py,sha256=oQ2XnD9sansJLJDuUl3_vHaUM4L9hq2G97IcRjQAOPY,7920
@@ -9,14 +9,14 @@ foamlib/_cases/_subprocess.py,sha256=tzsBGe44EnQw3GWqRW1ktEZ4sNQ1sSHdJ_89zIfF5L0
 foamlib/_cases/_sync.py,sha256=ENvn8zseRh6YOjAgqXHzmKhKFYXdzGIW5NoMHS_NKPY,6049
 foamlib/_cases/_util.py,sha256=GNndpqw3Jg_S-Hxzl5vwRgD0czcTNb9NYHMhcfBoMBg,1493
 foamlib/_files/__init__.py,sha256=-UqB9YTH6mrJfXCX00kPTAAY20XG64u1MGPw_1ewLVs,148
-foamlib/_files/_base.py,sha256=mrZuk90sdIrSGiOeEtCcEHoz6RK4qUc6GFoDSuo7U3w,1920
-foamlib/_files/_files.py,sha256=6ZbUxb2VF225ceEHBg4L23oxHvD7M18QC9zqMPm0ZS4,16025
-foamlib/_files/_io.py,sha256=ArD9lgMw-Kjj-wl_5qU6eRdW4lZWyGBIEMWLCNV4a0Y,2467
-foamlib/_files/_parsing.py,sha256=SvPAbNb_xJwOBRGii4oLOUvhj9OdJ8auMIzdx77AYwI,9394
-foamlib/_files/_serialization.py,sha256=iIiPUbgoQzg6xeYeeTsRPWKWqrYFtAQPgglBbylPkms,3341
+foamlib/_files/_base.py,sha256=A8084rU92w9Hh2BZAEIdE31qvm15fto1qOyQJhrP5DI,1945
+foamlib/_files/_files.py,sha256=rvhb9mZFg1z6JSpb02E_8B2YD7Zmt5hh2v7rq19qC_c,14712
+foamlib/_files/_io.py,sha256=07gaGhoJuXDB9i4AxvnIT_Np71RAU2ut2G5Lcyx8TaU,2244
+foamlib/_files/_parsing.py,sha256=pqwWzlZwCTe7PxncYywO3OWd9Ppl9Oq8JYVpofxKJsY,11046
+foamlib/_files/_serialization.py,sha256=Gy9v3iZGD-RF3pS7rauft7fpT33UIzRuOm0XH4rFHvA,3337
 foamlib/_files/_util.py,sha256=UMzXmTFgvbp46w6k3oEZJoYC98pFgEK6LN5uLOwrlCg,397
-foamlib-0.6.10.dist-info/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
-foamlib-0.6.10.dist-info/METADATA,sha256=0IYRom9JRsqS6OE6x3rlRDdL6zYUubtpYl5hafW_2Bg,7742
-foamlib-0.6.10.dist-info/WHEEL,sha256=OVMc5UfuAQiSplgO0_WdW7vXVGAt9Hdd6qtN4HotdyA,91
-foamlib-0.6.10.dist-info/top_level.txt,sha256=ZdVYtetXGwPwyfL-WhlhbTFQGAwKX5P_gXxtH9JYFPI,8
-foamlib-0.6.10.dist-info/RECORD,,
+foamlib-0.6.11.dist-info/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
+foamlib-0.6.11.dist-info/METADATA,sha256=VGwnlinUiBszBq9RzNnRWvWx0hkO9ziOY4jaKNmoJwc,7742
+foamlib-0.6.11.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+foamlib-0.6.11.dist-info/top_level.txt,sha256=ZdVYtetXGwPwyfL-WhlhbTFQGAwKX5P_gXxtH9JYFPI,8
+foamlib-0.6.11.dist-info/RECORD,,

{foamlib-0.6.10.dist-info → foamlib-0.6.11.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.2.0)
+Generator: setuptools (75.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any