foamlib 1.4.2__tar.gz → 1.4.3__tar.gz

{foamlib-1.4.2 → foamlib-1.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: foamlib
-Version: 1.4.2
+Version: 1.4.3
 Summary: Pythonic interface for working with OpenFOAM
 Author: Gabriel S. Gerlero
 Author-email: Gabriel S. Gerlero <ggerlero@cimec.unl.edu.ar>

{foamlib-1.4.2 → foamlib-1.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "foamlib"
-version = "1.4.2"
+version = "1.4.3"
 license = "GPL-3.0-only"
 license-files = ["LICENSE.txt"]
 description = "Pythonic interface for working with OpenFOAM"

{foamlib-1.4.2 → foamlib-1.4.3}/src/foamlib/_files/_parsing/parsing.py

@@ -1,7 +1,12 @@
 import dataclasses
 import sys
 from collections.abc import Collection, Iterator, Sequence
-from typing import cast
+from typing import cast, overload
+
+if sys.version_info >= (3, 11):
+    from typing import Never, Unpack
+else:
+    from typing_extensions import Never, Unpack
 
 if sys.version_info >= (3, 12):
     from typing import override
@@ -116,20 +121,63 @@ class ParsedFile(
                     )
         return ret
 
+    @overload
+    @with_default
+    def getall(self, keywords: tuple[()], /) -> Collection[StandaloneData]: ...
+
+    @overload
+    @with_default
+    def getall(
+        self, keywords: tuple[str, Unpack[tuple[str, ...]]], /
+    ) -> Collection[Data | EllipsisType | None]: ...
+
     @override
     @with_default
     def getall(
         self, keywords: tuple[str, ...], /
-    ) -> Collection[Data | StandaloneData | EllipsisType]:
+    ) -> Collection[Data | StandaloneData | EllipsisType | None]:
         return [entry.data for entry in self._parsed.getall(keywords)]
 
+    @overload
+    def __getitem__(self, keywords: tuple[()]) -> StandaloneData: ...
+
+    @overload
+    def __getitem__(
+        self, keywords: tuple[str, Unpack[tuple[str, ...]]]
+    ) -> Data | EllipsisType | None: ...
+
+    @override
+    def __getitem__(
+        self, keywords: tuple[str, ...]
+    ) -> Data | StandaloneData | EllipsisType | None:  # ty: ignore[invalid-method-override]
+        entry = self._parsed[keywords]
+        return entry.data
+
     @override
-    def __setitem__(
-        self, key: tuple[str, ...], value: Data | StandaloneData | EllipsisType | None
+    def __setitem__(  # ty: ignore[invalid-method-override]
+        self, key: Never, value: Never
     ) -> None:  # pragma: no cover
         msg = "Use 'put' method instead"
         raise NotImplementedError(msg)
 
+    @overload
+    def put(
+        self,
+        keywords: tuple[()],
+        /,
+        data: StandaloneData,
+        content: bytes,
+    ) -> None: ...
+
+    @overload
+    def put(
+        self,
+        keywords: tuple[str, Unpack[tuple[str, ...]]],
+        /,
+        data: Data | EllipsisType | None,
+        content: bytes,
+    ) -> None: ...
+
     def put(
         self,
         keywords: tuple[str, ...],
@@ -143,6 +191,24 @@ class ParsedFile(
         self._parsed[keywords] = ParsedFile._Entry(data, start, start + len(content))
         self._remove_child_entries(keywords)
 
+    @overload
+    def add(
+        self,
+        keywords: tuple[()],
+        data: StandaloneData,
+        content: bytes,
+        /,
+    ) -> None: ...
+
+    @overload
+    def add(
+        self,
+        keywords: tuple[str, Unpack[tuple[str, ...]]],
+        data: Data | EllipsisType | None,
+        content: bytes,
+        /,
+    ) -> None: ...
+
     @override
     def add(  # ty: ignore[invalid-method-override]
         self,

{foamlib-1.4.2 → foamlib-1.4.3}/src/foamlib/_files/_typing.py

@@ -1,6 +1,12 @@
+import sys
 from collections.abc import Mapping, Sequence
 from typing import Literal, TypeAlias
 
+if sys.version_info >= (3, 11):
+    from typing import Unpack
+else:
+    from typing_extensions import Unpack
+
 import numpy as np
 from multicollections import MultiDict
 
@@ -38,8 +44,11 @@ DataEntryLike: TypeAlias = (
     DataEntry | Sequence["DataEntryLike | KeywordEntryLike | DictLike"] | FieldLike
 )
 
-Data: TypeAlias = DataEntry | tuple[DataEntry, ...]
-DataLike: TypeAlias = DataEntryLike | tuple[DataEntryLike, ...]
+Data: TypeAlias = DataEntry | tuple[DataEntry, DataEntry, Unpack[tuple[DataEntry, ...]]]
+DataLike: TypeAlias = (
+    DataEntryLike
+    | tuple[DataEntryLike, DataEntryLike, Unpack[tuple[DataEntryLike, ...]]]
+)
 
 StandaloneDataEntry: TypeAlias = (
     DataEntry
@@ -57,9 +66,21 @@ StandaloneDataEntryLike: TypeAlias = (
     | Sequence[Sequence[int]]
 )
 
-StandaloneData: TypeAlias = StandaloneDataEntry | tuple[StandaloneDataEntry, ...]
+StandaloneData: TypeAlias = (
+    StandaloneDataEntry
+    | tuple[
+        StandaloneDataEntry,
+        StandaloneDataEntry,
+        Unpack[tuple[StandaloneDataEntry, ...]],
+    ]
+)
 StandaloneDataLike: TypeAlias = (
-    StandaloneDataEntryLike | tuple[StandaloneDataEntryLike, ...]
+    StandaloneDataEntryLike
+    | tuple[
+        StandaloneDataEntryLike,
+        StandaloneDataEntryLike,
+        Unpack[tuple[StandaloneDataEntryLike, ...]],
+    ]
 )
 
 SubDict: TypeAlias = (

{foamlib-1.4.2 → foamlib-1.4.3}/src/foamlib/_files/files.py

@@ -6,9 +6,9 @@ from copy import deepcopy
 from typing import Literal, cast, overload
 
 if sys.version_info >= (3, 11):
-    from typing import assert_never
+    from typing import Unpack, assert_never
 else:
-    from typing_extensions import assert_never
+    from typing_extensions import Unpack, assert_never
 
 if sys.version_info >= (3, 12):
     from typing import override
@@ -21,7 +21,6 @@ from multicollections import MultiDict
 from multicollections.abc import MutableMultiMapping, with_default
 
 from .._files import _common
-from ._common import dict_from_items
 from ._io import FoamFileIO
 from ._parsing import parse
 from ._serialization import dumps, normalized
@@ -131,7 +130,12 @@ class FoamFile(
         ) -> Iterator["Data | StandaloneData | FoamFile.SubDict | None"]:
             for k, v in self._file._get_parsed().items():
                 if k != ("FoamFile",) or self._include_header:
-                    yield v if v is not ... else FoamFile.SubDict(self._file, k)
+                    if v is ...:
+                        assert k
+                        k = cast("tuple[str, Unpack[tuple[str, ...]]]", k)
+                        yield FoamFile.SubDict(self._file, k)
+                    else:
+                        yield v
 
         @override
         def __len__(self) -> int:
@@ -162,14 +166,18 @@ class FoamFile(
         def __iter__(
             self,
         ) -> Iterator[
-            tuple[str | None, "Data | StandaloneData | FoamFile.SubDict | None"]
+            tuple[str, "Data | FoamFile.SubDict | None"] | tuple[None, StandaloneData]
         ]:
             for k, v in self._file._get_parsed().items():
                 if k != ("FoamFile",) or self._include_header:
-                    yield (
-                        k[-1] if k else None,
-                        v if v is not ... else FoamFile.SubDict(self._file, k),
-                    )
+                    if not k:
+                        yield None, v
+                    else:
+                        k = cast("tuple[str, Unpack[tuple[str, ...]]]", k)
+                        yield (
+                            k[-1],
+                            v if v is not ... else FoamFile.SubDict(self._file, k),
+                        )
 
         @override
         def __len__(self) -> int:
@@ -237,6 +245,7 @@ class FoamFile(
             def __iter__(self) -> Iterator["Data | FoamFile.SubDict | None"]:
                 for k, v in self._subdict._file._get_parsed().items():
                     if k[:-1] == self._subdict._keywords:
+                        k = cast("tuple[str, Unpack[tuple[str, ...]]]", k)
                         yield (
                             v
                             if v is not ...
@@ -263,8 +272,9 @@ class FoamFile(
             ) -> Iterator[tuple[str, "Data | FoamFile.SubDict | None"]]:
                 for k, v in self._subdict._file._get_parsed().items():
                     if k[:-1] == self._subdict._keywords:
+                        k = cast("tuple[str, Unpack[tuple[str, ...]]]", k)
                         yield (
-                            k[-1] if k else None,
+                            k[-1],
                             v
                             if v is not ...
                             else FoamFile.SubDict(self._subdict._file, k),
@@ -278,39 +288,22 @@ class FoamFile(
             def __contains__(self, x: object) -> bool:  # ty: ignore[invalid-method-override]
                 return any(i == x for i in iter(self))
 
-        def __init__(self, _file: "FoamFile", _keywords: tuple[str, ...]) -> None:
+        def __init__(
+            self, _file: "FoamFile", _keywords: tuple[str, Unpack[tuple[str, ...]]]
+        ) -> None:
             self._file = _file
             self._keywords = _keywords
 
         @override
         @with_default
-        def getall(self, keyword: str) -> Collection["Data | FoamFile.SubDict | None"]:
+        def getall(
+            self, keyword: str, /
+        ) -> Collection["Data | FoamFile.SubDict | None"]:
             return self._file.getall((*self._keywords, keyword))
 
-        @overload
-        def __getitem__(self, keyword: str) -> "Data | FoamFile.SubDict | None": ...
-
-        @overload
-        def __getitem__(
-            self, keyword: slice
-        ) -> (
-            dict[str, "Data | FoamFile.SubDict | None"]
-            | MultiDict[str, "Data | FoamFile.SubDict | None"]
-        ): ...
-
         @override
-        def __getitem__(
-            self, keyword: str | slice
-        ) -> "Data | FoamFile.SubDict | None | dict[str, Data | FoamFile.SubDict | None] | MultiDict[str, Data | FoamFile.SubDict | None]":
-            if keyword == slice(None):
-                return self.as_dict(deep=False)
-
-            if isinstance(keyword, slice):
-                msg = "Only empty slices (:) are supported"
-                raise ValueError(msg)  # noqa: TRY004
-
-            ret = self._file[(*self._keywords, keyword)]
-            return cast("Data | FoamFile.SubDict | None", ret)
+        def __getitem__(self, keyword: str) -> "Data | FoamFile.SubDict | None":
+            return self._file[(*self._keywords, keyword)]  # ty: ignore[invalid-return-type]
 
         @overload
         def __setitem__(
@@ -345,7 +338,7 @@ class FoamFile(
 
         @override
         @with_default
-        def popone(self, keyword: str) -> "Data | FoamFile.SubDict | None":
+        def popone(self, keyword: str, /) -> "Data | FoamFile.SubDict | None":
             return self._file.popone((*self._keywords, keyword))
 
         @override
@@ -428,42 +421,17 @@ class FoamFile(
         def __repr__(self) -> str:
             return f"{type(self).__qualname__}('{self._file}', {self._keywords})"
 
-        @overload
-        def as_dict(self, *, deep: Literal[True] = ...) -> SubDict: ...
-
-        @overload
-        def as_dict(
-            self, *, deep: Literal[False] = ...
-        ) -> (
-            dict[str, "Data | FoamFile.SubDict | None"]
-            | MultiDict[str, "Data | FoamFile.SubDict | None"]
-        ): ...
-
-        def as_dict(
-            self, *, deep: bool = True
-        ) -> (
-            SubDict
-            | dict[str, "Data | FoamFile.SubDict | None"]
-            | MultiDict[str, "Data | FoamFile.SubDict | None"]
-        ):
-            """
-            Return a dict representation of the sub-dictionary.
+        def as_dict(self) -> SubDict:
+            """Return a nested dict representation of the sub-dictionary."""
+            file = self._file.as_dict(include_header=True)
 
-            :param deep: Whether to return a nested representation by recursing into
-                nested sub-dictionaries.
-            """
-            if deep:
-                file = self._file.as_dict(include_header=True)
-
-                ret = file[self._keywords[0]]
+            ret = file[self._keywords[0]]
+            assert isinstance(ret, Mapping)
+            for k in self._keywords[1:]:
+                ret = ret[k]
                 assert isinstance(ret, Mapping)
-                for k in self._keywords[1:]:
-                    ret = ret[k]
-                    assert isinstance(ret, Mapping)
-
-                return ret  # ty: ignore[invalid-return-type]
 
-            return dict_from_items(self.items(), target=SubDict)
+            return ret  # ty: ignore[invalid-return-type]
 
     @property
     def version(self) -> float:
@@ -663,6 +631,7 @@ class FoamFile(
                 if not keywords:
                     msg = "Cannot set a mapping at the root level of a FoamFile\nUse update(), extend(), or merge() instead."
                     raise ValueError(msg)
+                keywords = cast("tuple[str, Unpack[tuple[str, ...]]]", keywords)
 
                 if keyword.startswith("#"):
                     msg = f"Cannot set a directive as the keyword for a dictionary: {keyword}"
@@ -688,6 +657,7 @@ class FoamFile(
                     self[(*keywords, k)] = v  # ty: ignore[invalid-assignment]
 
             elif keywords:
+                keywords = cast("tuple[str, Unpack[tuple[str, ...]]]", keywords)
                 val = dumps(data, keywords=keywords, format_=format_)
 
                 content = (
@@ -718,39 +688,42 @@ class FoamFile(
     @overload
     @with_default
     def getall(
-        self, keywords: str | tuple[str]
+        self,
+        keywords: str | tuple[str, Unpack[tuple[str, ...]]],
+        /,
     ) -> Collection["Data | FoamFile.SubDict | None"]: ...
 
     @overload
     @with_default
-    def getall(self, keywords: None | tuple[()]) -> Collection[StandaloneData]: ...
-
-    @overload
-    @with_default
-    def getall(
-        self, keywords: tuple[str, ...]
-    ) -> Collection["Data | StandaloneData | FoamFile.SubDict | None"]: ...
+    def getall(self, keywords: None | tuple[()], /) -> Collection[StandaloneData]: ...
 
     @override
     @with_default
     def getall(
         self,
         keywords: str | tuple[str, ...] | None,
+        /,
     ) -> Collection["Data | StandaloneData | FoamFile.SubDict | None"]:
         keywords = FoamFile._normalized_keywords(keywords)
+        keywords = cast("tuple[str, Unpack[tuple[str, ...]]] | tuple[()]", keywords)
 
         parsed = self._get_parsed()
 
-        ret = parsed.getall(keywords)
+        values = parsed.getall(keywords)
 
-        return [
-            FoamFile.SubDict(self, keywords) if v is ... else deepcopy(v) for v in ret
-        ]
+        ret = []
+        for v in values:
+            if v is ...:
+                assert keywords
+                ret.append(FoamFile.SubDict(self, keywords))
+            else:
+                ret.append(deepcopy(v))
+        return ret
 
     @overload
     def __getitem__(
         self,
-        keywords: str | tuple[str],
+        keywords: str | tuple[str, Unpack[tuple[str, ...]]],
     ) -> "Data | FoamFile.SubDict | None": ...
 
     @overload
@@ -759,35 +732,18 @@ class FoamFile(
         keywords: None | tuple[()],
     ) -> StandaloneData: ...
 
-    @overload
-    def __getitem__(
-        self,
-        keywords: tuple[str, ...],
-    ) -> "Data | StandaloneData | FoamFile.SubDict | None": ...
-
-    @overload
-    def __getitem__(
-        self,
-        keywords: slice,
-    ) -> (
-        dict[str | None, "Data | StandaloneData | FoamFile.SubDict | None"]
-        | MultiDict[str | None, "Data | StandaloneData | FoamFile.SubDict | None"]
-    ): ...
-
     @override
     def __getitem__(  # ty: ignore[invalid-method-override]
         self,
-        keywords: str | tuple[str, ...] | None | slice,
-    ) -> "Data | StandaloneData | FoamFile.SubDict | None | dict[str | None, Data | StandaloneData | FoamFile.SubDict | None] | MultiDict[str | None, Data | StandaloneData | FoamFile.SubDict | None]":
-        keywords = FoamFile._normalized_keywords(keywords, slice_ok=True)
-
-        if keywords == slice(None):
-            return self.as_dict(deep=False)
+        keywords: str | tuple[str, ...] | None,
+    ) -> "Data | StandaloneData | FoamFile.SubDict | None":
+        keywords = FoamFile._normalized_keywords(keywords)
 
-        assert not isinstance(keywords, slice)
         parsed = self._get_parsed()
+        keywords = cast("tuple[str, Unpack[tuple[str, ...]]] | tuple[()]", keywords)
         ret = parsed[keywords]
         if ret is ...:
+            assert keywords
             return FoamFile.SubDict(self, keywords)
         return deepcopy(ret)
 
@@ -861,7 +817,9 @@ class FoamFile(
     @with_default
     @override
     def popone(
-        self, keywords: str | tuple[str, ...] | None
+        self,
+        keywords: str | tuple[str, ...] | None,
+        /,
     ) -> "Data | StandaloneData | FoamFile.SubDict | None":
         keywords = FoamFile._normalized_keywords(keywords)
 
@@ -1020,40 +978,16 @@ class FoamFile(
     def __fspath__(self) -> str:
         return str(self.path)
 
-    @overload
-    def as_dict(
-        self, *, include_header: bool = ..., deep: Literal[True] = ...
-    ) -> File: ...
-
-    @overload
-    def as_dict(
-        self, *, include_header: bool = ..., deep: Literal[False] = ...
-    ) -> (
-        dict[str | None, "Data | StandaloneData | FoamFile.SubDict | None"]
-        | MultiDict[str | None, "Data | StandaloneData | FoamFile.SubDict | None"]
-    ): ...
-
-    def as_dict(
-        self, *, include_header: bool = False, deep: bool = True
-    ) -> (
-        File
-        | dict[str | None, "Data | StandaloneData | FoamFile.SubDict | None"]
-        | MultiDict[str | None, "Data | StandaloneData | FoamFile.SubDict | None"]
-    ):
+    def as_dict(self, *, include_header: bool = False) -> File:
         """
-        Return a dict representation of the file.
+        Return a nested dict representation of the file.
 
         :param include_header: Whether to include the "FoamFile" header in the output.
-        :param deep: Whether to return a nested representation by recursing into
-            nested sub-dictionaries.
         """
-        if deep:
-            d = self._get_parsed().as_dict()
-            if not include_header:
-                d.pop("FoamFile", None)
-            return deepcopy(d)
-
-        return dict_from_items(self.items(include_header=include_header), target=File)  # ty: ignore[invalid-return-type]
+        d = self._get_parsed().as_dict()
+        if not include_header:
+            d.pop("FoamFile", None)
+        return deepcopy(d)
 
     @staticmethod
     def loads(
@@ -1135,14 +1069,14 @@ class FoamFile(
     @overload
     @staticmethod
     def _normalized_keywords(
-        keywords: None, /, *, slice_ok: bool = ...
+        keywords: None | tuple[()], /, *, slice_ok: bool = ...
     ) -> tuple[()]: ...
 
     @overload
     @staticmethod
     def _normalized_keywords(
-        keywords: tuple[str, ...], /, *, slice_ok: bool = ...
-    ) -> tuple[str, ...]: ...
+        keywords: tuple[str, Unpack[tuple[str, ...]]], /, *, slice_ok: bool = ...
+    ) -> tuple[str, Unpack[tuple[str, ...]]]: ...
 
     @overload
     @staticmethod
@@ -1225,7 +1159,7 @@ class FoamFieldFile(FoamFile):
         @override
         @with_default
         def getall(
-            self, keyword: str
+            self, keyword: str, /
         ) -> Collection["FoamFieldFile.BoundarySubDict | Data | None"]:
             ret = super().getall(keyword)
             for r in ret:
@@ -1273,23 +1207,17 @@ class FoamFieldFile(FoamFile):
     @overload
     @with_default
     def getall(
-        self, keywords: str | tuple[str]
-    ) -> Collection["Data | FoamFieldFile.BoundariesSubDict | None"]: ...
+        self, keywords: str | tuple[str, Unpack[tuple[str, ...]]], /
+    ) -> Collection["Data | FoamFieldFile.SubDict | None"]: ...
 
     @overload
     @with_default
-    def getall(self, keywords: None | tuple[()]) -> Collection[StandaloneData]: ...
-
-    @overload
-    @with_default
-    def getall(
-        self, keywords: tuple[str, ...]
-    ) -> Collection["Data | StandaloneData | FoamFieldFile.SubDict | None"]: ...
+    def getall(self, keywords: None | tuple[()], /) -> Collection[StandaloneData]: ...
 
     @override
     @with_default
     def getall(
-        self, keywords: str | tuple[str, ...] | None
+        self, keywords: str | tuple[str, ...] | None, /
     ) -> Collection["Data | StandaloneData | FoamFieldFile.SubDict | None"]:
         keywords = FoamFieldFile._normalized_keywords(keywords)
 
@@ -1299,8 +1227,10 @@ class FoamFieldFile(FoamFile):
             for i, r in enumerate(ret):
                 if isinstance(r, FoamFile.SubDict):
                     if len(keywords) == 1:
+                        keywords = cast("tuple[str]", keywords)
                         ret[i] = FoamFieldFile.BoundariesSubDict(self, keywords)
                     elif len(keywords) == 2:
+                        keywords = cast("tuple[str, str]", keywords)
                         ret[i] = FoamFieldFile.BoundarySubDict(self, keywords)
 
         return ret
@@ -1308,14 +1238,8 @@ class FoamFieldFile(FoamFile):
     @overload
     def __getitem__(
         self,
-        keywords: str | tuple[str],
-    ) -> "Data | FoamFieldFile.BoundariesSubDict | None": ...
-
-    @overload
-    def __getitem__(
-        self,
-        keywords: tuple[str, str],
-    ) -> "Data | FoamFieldFile.BoundarySubDict | None": ...
+        keywords: str | tuple[str, Unpack[tuple[str, ...]]],
+    ) -> "Data | FoamFieldFile.SubDict | None": ...
 
     @overload
     def __getitem__(
@@ -1323,35 +1247,25 @@ class FoamFieldFile(FoamFile):
         keywords: None | tuple[()],
     ) -> StandaloneData: ...
 
-    @overload
-    def __getitem__(
-        self,
-        keywords: tuple[str, ...],
-    ) -> "Data | StandaloneData | FoamFieldFile.SubDict | None": ...
-
-    @overload
-    def __getitem__(
-        self,
-        keywords: slice,
-    ) -> File: ...
-
     @override
     def __getitem__(  # ty: ignore[invalid-method-override]
         self,
-        keywords: str | tuple[str, ...] | None | slice,
-    ) -> "Data | StandaloneData | FoamFieldFile.SubDict | None | dict[str | None, Data | StandaloneData | FoamFieldFile.SubDict | None] | MultiDict[str | None, Data | StandaloneData | FoamFieldFile.SubDict | None]":
-        keywords = FoamFieldFile._normalized_keywords(keywords, slice_ok=True)
-
-        if keywords == slice(None):
-            return self.as_dict(deep=False)
+        keywords: str | tuple[str, ...] | None,
+    ) -> "Data | StandaloneData | FoamFieldFile.SubDict | None":
+        keywords = FoamFieldFile._normalized_keywords(keywords)
 
-        assert not isinstance(keywords, slice)
-        ret = super().__getitem__(keywords)
+        ret = super().__getitem__(keywords)  # ty: ignore[no-matching-overload]
 
-        if keywords[0] == "boundaryField" and isinstance(ret, FoamFile.SubDict):
+        if (
+            keywords
+            and keywords[0] == "boundaryField"
+            and isinstance(ret, FoamFile.SubDict)
+        ):
             if len(keywords) == 1:
+                keywords = cast("tuple[str]", keywords)
                 ret = FoamFieldFile.BoundariesSubDict(self, keywords)
             elif len(keywords) == 2:
+                keywords = cast("tuple[str, str]", keywords)
                 ret = FoamFieldFile.BoundarySubDict(self, keywords)
 
         return ret