foamlib 1.4.2__tar.gz → 1.4.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: foamlib
-Version: 1.4.2
+Version: 1.4.4
 Summary: Pythonic interface for working with OpenFOAM
 Author: Gabriel S. Gerlero
 Author-email: Gabriel S. Gerlero <ggerlero@cimec.unl.edu.ar>
@@ -330,4 +330,4 @@ If you use **foamlib** in your research, please cite our paper:
 
 ## 👟 Footnotes
 
-<a id="benchmark">[1]</a> foamlib 1.3.11 vs. PyFoam 2023.7 (Python 3.11.13) on an M3 MacBook Air. [Benchmark script](https://github.com/gerlero/foamlib/blob/main/benchmark/benchmark.py).
+<a id="benchmark">[1]</a> foamlib 1.4.4 vs. PyFoam 2023.7 (Python 3.11.13) on an M3 MacBook Air. [Benchmark script](https://github.com/gerlero/foamlib/blob/main/benchmark/benchmark.py).

{foamlib-1.4.2 → foamlib-1.4.4}/README.md

@@ -285,4 +285,4 @@ If you use **foamlib** in your research, please cite our paper:
 
 ## 👟 Footnotes
 
-<a id="benchmark">[1]</a> foamlib 1.3.11 vs. PyFoam 2023.7 (Python 3.11.13) on an M3 MacBook Air. [Benchmark script](https://github.com/gerlero/foamlib/blob/main/benchmark/benchmark.py).
+<a id="benchmark">[1]</a> foamlib 1.4.4 vs. PyFoam 2023.7 (Python 3.11.13) on an M3 MacBook Air. [Benchmark script](https://github.com/gerlero/foamlib/blob/main/benchmark/benchmark.py).

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

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

{foamlib-1.4.2 → foamlib-1.4.4}/src/foamlib/_cases/base.py

@@ -89,7 +89,7 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"], os.PathLike[str]):
         @override
         def __len__(self) -> int:
             """Return the number of field files in this time directory."""
-            return len(list(iter(self)))
+            return sum(1 for _ in iter(self))
 
         def __delitem__(self, name: str, /) -> None:
             """Delete the field file with the given name in this time directory."""

{foamlib-1.4.2 → foamlib-1.4.4}/src/foamlib/_files/_parsing/_elements.py

@@ -31,11 +31,11 @@ from numpy.typing import DTypeLike
 from .._common import dict_from_items
 from .._typing import Dict, SubDict
 
+_FLOAT_PATTERN = r"(?i:[+-]?(?:(?:\d+\.?\d*(?:e[+-]?\d+)?)|nan|inf(?:inity)?))"
+_INT_PATTERN = r"-?\d+"
 
-class ASCIINumericList(ParserElement):
-    _FLOAT_PATTERN = r"(?i:[+-]?(?:(?:\d+\.?\d*(?:e[+-]?\d+)?)|nan|inf(?:inity)?))"
-    _INT_PATTERN = r"-?\d+"
 
+class ASCIINumericList(ParserElement):
     def __init__(
         self,
         dtype: DTypeLike,
@@ -54,38 +54,41 @@ class ASCIINumericList(ParserElement):
     def _generateDefaultName(self) -> str:
         return self.name
 
-    @override
-    def parseImpl(
-        self, instring: str, loc: int, do_actions: bool = True
+    def __parse(
+        self, instring: str, loc: int, *, assume_no_ignores: bool = False
     ) -> tuple[int, ParseResults]:
         spacing_pattern = "|".join(re.escape(c) for c in self.whiteChars)
         assert spacing_pattern
 
-        assert all(
-            isinstance(ignore_expr, Suppress) and isinstance(ignore_expr.expr, Regex)
-            for ignore_expr in self.ignoreExprs
-        )
-        ignore_pattern = "|".join(
-            ignore_expr.expr.re.pattern  # ty: ignore[unresolved-attribute]
-            for ignore_expr in self.ignoreExprs
-        )
-
-        if ignore_pattern:
-            spacing_pattern = f"{spacing_pattern}|{ignore_pattern}"
+        if assume_no_ignores:
+            ignore_pattern = ""
+        else:
+            assert all(
+                isinstance(ignore_expr, Suppress)
+                and isinstance(ignore_expr.expr, Regex)
+                for ignore_expr in self.ignoreExprs
+            )
+            ignore_pattern = "|".join(
+                ignore_expr.expr.re.pattern  # ty: ignore[unresolved-attribute]
+                for ignore_expr in self.ignoreExprs
+            )
+
+            if ignore_pattern:
+                spacing_pattern = f"{spacing_pattern}|{ignore_pattern}"
 
         if np.issubdtype(self._dtype, np.floating):
-            base_pattern = self._FLOAT_PATTERN
+            number_pattern = _FLOAT_PATTERN
         elif np.issubdtype(self._dtype, np.integer):
-            base_pattern = self._INT_PATTERN
+            number_pattern = _INT_PATTERN
         else:
             msg = f"Unsupported dtype {self._dtype}"
             raise TypeError(msg)
 
         if self._elshape:
             (dim,) = self._elshape
-            element_pattern = rf"\((?:{spacing_pattern})*(?:{base_pattern}(?:{spacing_pattern})*){{{dim}}}\)"
+            element_pattern = rf"\((?:{spacing_pattern})*(?:{number_pattern}(?:{spacing_pattern})*){{{dim}}}\)"
         else:
-            element_pattern = base_pattern
+            element_pattern = number_pattern
 
         regular_pattern = re.compile(
             rf"(\d*)(?:{spacing_pattern})*\((?:{spacing_pattern})*((?:{element_pattern}(?:{spacing_pattern})*)*)\)"
@@ -158,6 +161,15 @@ class ASCIINumericList(ParserElement):
             self,
         )
 
+    @override
+    def parseImpl(
+        self, instring: str, loc: int, do_actions: bool = True
+    ) -> tuple[int, ParseResults]:
+        try:
+            return self.__parse(instring, loc, assume_no_ignores=True)
+        except ParseException:
+            return self.__parse(instring, loc)
+
 
 _EAGER_INTEGER = Word(nums).add_parse_action(
     lambda tks: int(tks[0]), call_during_try=True
@@ -210,8 +222,6 @@ def binary_numeric_list(
 
 
 class ASCIIFacesLikeList(ParserElement):
-    _INT_PATTERN = ASCIINumericList._INT_PATTERN
-
     def __init__(self) -> None:
         super().__init__()
         self.name = "ASCIIFacesLikeList"
@@ -220,27 +230,29 @@ class ASCIIFacesLikeList(ParserElement):
     def _generateDefaultName(self) -> str:
         return self.name
 
-    @override
-    def parseImpl(
-        self, instring: str, loc: int, do_actions: bool = True
+    def __parse(
+        self, instring: str, loc: int, *, assume_no_ignores: bool = False
     ) -> tuple[int, ParseResults]:
         spacing_pattern = "|".join(re.escape(c) for c in self.whiteChars)
         assert spacing_pattern
 
-        assert all(
-            isinstance(ignore_expr, Suppress) and isinstance(ignore_expr.expr, Regex)
-            for ignore_expr in self.ignoreExprs
-        )
-        ignore_pattern = "|".join(
-            ignore_expr.expr.re.pattern  # ty: ignore[unresolved-attribute]
-            for ignore_expr in self.ignoreExprs
-        )
-
-        if ignore_pattern:
-            spacing_pattern = f"{spacing_pattern}|{ignore_pattern}"
-
-        three_face_pattern = rf"3(?:{spacing_pattern})*\((?:{spacing_pattern})*(?:{self._INT_PATTERN}(?:{spacing_pattern})*){{3}}\)"
-        four_face_pattern = rf"4(?:{spacing_pattern})*\((?:{spacing_pattern})*(?:{self._INT_PATTERN}(?:{spacing_pattern})*){{4}}\)"
+        if assume_no_ignores:
+            ignore_pattern = ""
+        else:
+            assert all(
+                isinstance(ignore_expr, Suppress)
+                and isinstance(ignore_expr.expr, Regex)
+                for ignore_expr in self.ignoreExprs
+            )
+            ignore_pattern = "|".join(
+                ignore_expr.expr.re.pattern  # ty: ignore[unresolved-attribute]
+                for ignore_expr in self.ignoreExprs
+            )
+            if ignore_pattern:
+                spacing_pattern = f"{spacing_pattern}|{ignore_pattern}"
+
+        three_face_pattern = rf"3(?:{spacing_pattern})*\((?:{spacing_pattern})*(?:{_INT_PATTERN}(?:{spacing_pattern})*){{3}}\)"
+        four_face_pattern = rf"4(?:{spacing_pattern})*\((?:{spacing_pattern})*(?:{_INT_PATTERN}(?:{spacing_pattern})*){{4}}\)"
 
         face_pattern = rf"(?:{three_face_pattern})|(?:{four_face_pattern})"
 
@@ -291,6 +303,15 @@ class ASCIIFacesLikeList(ParserElement):
             self,
         )
 
+    @override
+    def parseImpl(
+        self, instring: str, loc: int, do_actions: bool = True
+    ) -> tuple[int, ParseResults]:
+        try:
+            return self.__parse(instring, loc, assume_no_ignores=True)
+        except ParseException:
+            return self.__parse(instring, loc)
+
 
 def list_of(entry: ParserElement) -> ParserElement:
     return (

{foamlib-1.4.2 → foamlib-1.4.4}/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 __setitem__(
-        self, key: tuple[str, ...], value: Data | StandaloneData | EllipsisType | None
+    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__(  # 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,
@@ -162,6 +228,16 @@ class ParsedFile(
         self._parsed.add(keywords, ParsedFile._Entry(data, start, end))
         self._update_content(start, end, content)
 
+    @overload
+    @with_default
+    def popone(self, keywords: tuple[()]) -> StandaloneData: ...
+
+    @overload
+    @with_default
+    def popone(
+        self, keywords: tuple[str, Unpack[tuple[str, ...]]]
+    ) -> Data | EllipsisType | None: ...
+
     @override
     @with_default
     def popone(

{foamlib-1.4.2 → foamlib-1.4.4}/src/foamlib/_files/_serialization.py

@@ -5,9 +5,9 @@ from typing import Literal, overload
 from warnings import warn
 
 if sys.version_info >= (3, 11):
-    from typing import Never, assert_never, assert_type
+    from typing import Never, Unpack, assert_never, assert_type
 else:
-    from typing_extensions import Never, assert_never, assert_type
+    from typing_extensions import Never, Unpack, assert_never, assert_type
 
 import numpy as np
 
@@ -44,7 +44,7 @@ def normalized(
     data: DataLike,
     /,
     *,
-    keywords: tuple[str, ...] | None = ...,
+    keywords: tuple[str, Unpack[tuple[str, ...]]] | None = ...,
     format_: Literal["ascii", "binary"] | None = ...,
 ) -> Data: ...
 
@@ -64,21 +64,11 @@ def normalized(
     data: SubDictLike,
     /,
     *,
-    keywords: tuple[str, ...] = ...,
+    keywords: tuple[str, Unpack[tuple[str, ...]]] = ...,
     format_: Literal["ascii", "binary"] | None = ...,
 ) -> SubDict: ...
 
 
-@overload
-def normalized(
-    data: DataLike,
-    /,
-    *,
-    keywords: tuple[str, ...] = ...,
-    format_: Literal["ascii", "binary"] | None = ...,
-) -> Data: ...
-
-
 @overload
 def normalized(
     data: DictLike,
@@ -94,7 +84,7 @@ def normalized(
     data: None,
     /,
     *,
-    keywords: tuple[str, ...] = ...,
+    keywords: tuple[str, Unpack[tuple[str, ...]]] = ...,
     format_: Literal["ascii", "binary"] | None = ...,
 ) -> None: ...
 

{foamlib-1.4.2 → foamlib-1.4.4}/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.4}/src/foamlib/_files/files.py

@@ -3,12 +3,12 @@ import os
 import sys
 from collections.abc import Collection, Iterable, Iterator, Mapping, Sequence
 from copy import deepcopy
-from typing import Literal, cast, overload
+from typing import Literal, TypeVar, 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
@@ -40,10 +39,12 @@ from ._typing import (
 from ._util import SupportsKeysAndGetItem
 from .types import Dimensioned, DimensionSet
 
+_D = TypeVar("_D")
+
 
 class FoamFile(
     MutableMultiMapping[
-        str | tuple[str, ...] | None,
+        str | None,
         "Data | StandaloneData | FoamFile.SubDict | None",
     ],
     os.PathLike[str],
@@ -110,7 +111,8 @@ class FoamFile(
 
         @override
         def __len__(self) -> int:
-            return len(list(iter(self)))
+            with self._file:
+                return sum(1 for _ in iter(self))
 
         @override
         def __contains__(self, x: object) -> bool:  # ty: ignore[invalid-method-override]
@@ -131,11 +133,17 @@ 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:
-            return len(list(iter(self)))
+            with self._file:
+                return sum(1 for _ in iter(self))
 
         @override
         def __contains__(self, value: object) -> bool:
@@ -151,29 +159,31 @@ class FoamFile(
             file: "FoamFile",
             *,
             include_header: bool = False,
-            keywords: tuple[str, ...] = (),
         ) -> None:
-            assert keywords or include_header
             self._file = file
             self._include_header = include_header
-            self._keywords = keywords
 
         @override
         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:
-            return len(list(iter(self)))
+            with self._file:
+                return sum(1 for _ in iter(self))
 
         @override
         def __contains__(self, x: object) -> bool:  # ty: ignore[invalid-method-override]
@@ -221,7 +231,8 @@ class FoamFile(
 
             @override
             def __len__(self) -> int:
-                return len(list(iter(self)))
+                with self._subdict._file:
+                    return sum(1 for _ in iter(self))
 
             @override
             def __contains__(self, x: object) -> bool:  # ty: ignore[invalid-method-override]
@@ -237,6 +248,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 ...
@@ -245,7 +257,8 @@ class FoamFile(
 
             @override
             def __len__(self) -> int:
-                return len(list(iter(self)))
+                with self._subdict._file:
+                    return sum(1 for _ in iter(self))
 
             @override
             def __contains__(self, value: object) -> bool:
@@ -263,8 +276,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),
@@ -272,45 +286,29 @@ class FoamFile(
 
             @override
             def __len__(self) -> int:
-                return len(list(iter(self)))
+                with self._subdict._file:
+                    return sum(1 for _ in iter(self))
 
             @override
             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 +343,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
@@ -372,7 +370,8 @@ class FoamFile(
 
         @override
         def __len__(self) -> int:
-            return len(list(iter(self)))
+            with self._file:
+                return sum(1 for _ in iter(self))
 
         @override
         def keys(self) -> "FoamFile.SubDict.KeysView":
@@ -428,42 +427,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.
-
-            :param deep: Whether to return a nested representation by recursing into
-                nested sub-dictionaries.
-            """
-            if deep:
-                file = self._file.as_dict(include_header=True)
+        def as_dict(self) -> SubDict:
+            """Return a nested dict representation of the sub-dictionary."""
+            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:
@@ -552,10 +526,21 @@ class FoamFile(
                 self.path.stem if self.path.suffix == ".gz" else self.path.name
             )
 
+    @overload
     def _update_class_for_field_if_needed(
         self,
-        keywords: tuple[str, ...],
-        data: Data | StandaloneData | SubDict,
+        keywords: tuple[str, Unpack[tuple[str, ...]]],
+        data: Data | SubDict | None,
+        /,
+    ) -> None: ...
+
+    @overload
+    def _update_class_for_field_if_needed(
+        self, keywords: tuple[()], data: StandaloneData, /
+    ) -> None: ...
+
+    def _update_class_for_field_if_needed(
+        self, keywords: tuple[str, ...], data: Data | StandaloneData | SubDict, /
     ) -> None:
         """Update class field to appropriate field type if this is a field entry."""
         try:
@@ -620,6 +605,26 @@ class FoamFile(
 
         return before, after
 
+    @overload
+    def _perform_entry_operation(
+        self,
+        keywords: str | tuple[str, Unpack[tuple[str, ...]]],
+        data: DataLike | SubDictLike | None,
+        /,
+        *,
+        add: bool,
+    ) -> None: ...
+
+    @overload
+    def _perform_entry_operation(
+        self,
+        keywords: None | tuple[()],
+        data: StandaloneDataLike,
+        /,
+        *,
+        add: bool,
+    ) -> None: ...
+
     def _perform_entry_operation(
         self,
         keywords: tuple[str, ...],
@@ -663,6 +668,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 +694,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,94 +725,121 @@ 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__(
+    @with_default
+    def getone(
         self,
-        keywords: str | tuple[str],
+        keywords: str | tuple[str, Unpack[tuple[str, ...]]],
+        /,
     ) -> "Data | FoamFile.SubDict | None": ...
 
     @overload
-    def __getitem__(
+    @with_default
+    def getone(self, keywords: None | tuple[()], /) -> StandaloneData: ...
+
+    @override
+    @with_default
+    def getone(
+        self,
+        keywords: str | tuple[str, ...] | None,
+        /,
+    ) -> "Data | StandaloneData | FoamFile.SubDict | None":
+        keywords = FoamFile._normalized_keywords(keywords)
+
+        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)
+
+    @overload
+    def get(
+        self,
+        keywords: str | tuple[str, Unpack[tuple[str, ...]]],
+        default: _D = ...,
+        /,
+    ) -> "Data | FoamFile.SubDict | None | _D": ...
+
+    @overload
+    def get(
         self,
         keywords: None | tuple[()],
-    ) -> StandaloneData: ...
+        default: _D = ...,
+        /,
+    ) -> StandaloneData | _D: ...
+
+    @override
+    def get(  # ty: ignore[invalid-method-override]
+        self,
+        keywords: str | tuple[str, ...] | None,
+        default: _D = None,  # ty: ignore[invalid-parameter-default]
+        /,
+    ) -> "Data | StandaloneData | FoamFile.SubDict | None | _D":
+        return self.getone(keywords, default=default)
 
     @overload
     def __getitem__(
         self,
-        keywords: tuple[str, ...],
-    ) -> "Data | StandaloneData | FoamFile.SubDict | None": ...
+        keywords: str | tuple[str, Unpack[tuple[str, ...]]],
+    ) -> "Data | 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"]
-    ): ...
+        keywords: None | tuple[()],
+    ) -> StandaloneData: ...
 
     @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)
-
-        assert not isinstance(keywords, slice)
-        parsed = self._get_parsed()
-        ret = parsed[keywords]
-        if ret is ...:
-            return FoamFile.SubDict(self, keywords)
-        return deepcopy(ret)
-
-    @overload
-    def __setitem__(
-        self, keywords: None | tuple[()], data: StandaloneDataLike
-    ) -> None: ...
+        keywords: str | tuple[str, ...] | None,
+    ) -> "Data | StandaloneData | FoamFile.SubDict | None":
+        return self.getone(keywords)
 
     @overload
     def __setitem__(
-        self, keywords: str, data: DataLike | SubDictLike | None
+        self,
+        keywords: str | tuple[str, Unpack[tuple[str, ...]]],
+        data: DataLike | SubDictLike | None,
     ) -> None: ...
 
     @overload
     def __setitem__(
-        self,
-        keywords: tuple[str, ...],
-        data: DataLike | StandaloneDataLike | SubDictLike | None,
+        self, keywords: None | tuple[()], data: StandaloneDataLike
     ) -> None: ...
 
     @overload
@@ -834,7 +868,7 @@ class FoamFile(
             return
 
         assert not isinstance(keywords, slice)
-        self._perform_entry_operation(keywords, data, add=False)  # ty: ignore[invalid-argument-type]
+        self._perform_entry_operation(keywords, data, add=False)  # ty: ignore[invalid-argument-type,no-matching-overload]
 
     @override
     def __delitem__(self, keywords: str | tuple[str, ...] | None | slice) -> None:
@@ -846,22 +880,52 @@ class FoamFile(
             return
 
         assert not isinstance(keywords, slice)
-        super().__delitem__(keywords)
 
-    @override
+        with self:
+            del self._get_parsed()[keywords]
+
+    @overload
+    def add(
+        self,
+        keywords: str | tuple[str, Unpack[tuple[str, ...]]],
+        data: DataLike | SubDictLike | None,
+    ) -> None: ...
+
+    @overload
     def add(
+        self,
+        keywords: None | tuple[()],
+        data: StandaloneDataLike,
+    ) -> None: ...
+
+    @override
+    def add(  # ty: ignore[invalid-method-override]
         self,
         keywords: str | tuple[str, ...] | None,
         data: DataLike | StandaloneDataLike | SubDictLike | None,
     ) -> None:
         keywords = FoamFile._normalized_keywords(keywords)
-
+        keywords = cast("tuple[str, Unpack[tuple[str, ...]]] | tuple[()]", keywords)
         self._perform_entry_operation(keywords, data, add=True)
 
+    @overload
     @with_default
+    def popone(
+        self,
+        keywords: str | tuple[str, Unpack[tuple[str, ...]]],
+        /,
+    ) -> "Data | FoamFile.SubDict | None": ...
+
+    @overload
+    @with_default
+    def popone(self, keywords: None | tuple[()], /) -> StandaloneData: ...
+
     @override
+    @with_default
     def popone(
-        self, keywords: str | tuple[str, ...] | None
+        self,
+        keywords: str | tuple[str, ...] | None,
+        /,
     ) -> "Data | StandaloneData | FoamFile.SubDict | None":
         keywords = FoamFile._normalized_keywords(keywords)
 
@@ -870,12 +934,15 @@ class FoamFile(
 
     @overload
     def _iter(
-        self, keywords: tuple[str, ...], *, include_header: bool = False
+        self,
+        keywords: tuple[str, Unpack[tuple[str, ...]]],
+        *,
+        include_header: bool = ...,
     ) -> Iterator[str]: ...
 
     @overload
     def _iter(
-        self, keywords: tuple[()] = (), *, include_header: bool = False
+        self, keywords: tuple[()] = ..., *, include_header: bool = ...
     ) -> Iterator[str | None]: ...
 
     def _iter(
@@ -905,7 +972,8 @@ class FoamFile(
     @override
     def __len__(self) -> int:
         """Return the number of top-level keywords in the FoamFile (excluding the FoamFile header if present)."""
-        return len(list(iter(self)))
+        with self:
+            return sum(1 for _ in self._iter())
 
     @override
     def keys(
@@ -950,12 +1018,12 @@ class FoamFile(
     def update(  # ty: ignore[invalid-method-override]
         self,
         other: SupportsKeysAndGetItem[
-            str | tuple[str, ...] | None,
+            str | None,
             DataLike | StandaloneDataLike | SubDictLike | None,
         ]
         | Iterable[
             tuple[
-                str | tuple[str, ...] | None,
+                str | None,
                 DataLike | StandaloneDataLike | SubDictLike | None,
             ]
         ] = (),
@@ -969,12 +1037,12 @@ class FoamFile(
     def extend(  # ty: ignore[invalid-method-override]
         self,
         other: SupportsKeysAndGetItem[
-            str | tuple[str, ...] | None,
+            str | None,
             DataLike | StandaloneDataLike | SubDictLike | None,
         ]
         | Iterable[
             tuple[
-                str | tuple[str, ...] | None,
+                str | None,
                 DataLike | StandaloneDataLike | SubDictLike | None,
             ]
         ] = (),
@@ -988,14 +1056,10 @@ class FoamFile(
     def merge(  # ty: ignore[invalid-method-override]
         self,
         other: SupportsKeysAndGetItem[
-            str | tuple[str, ...] | None,
-            DataLike | StandaloneDataLike | SubDictLike | None,
+            str | None, DataLike | StandaloneDataLike | SubDictLike | None
         ]
         | Iterable[
-            tuple[
-                str | tuple[str, ...] | None,
-                DataLike | StandaloneDataLike | SubDictLike | None,
-            ]
+            tuple[str | None, DataLike | StandaloneDataLike | SubDictLike | None]
         ] = (),
         /,
         **kwargs: DataLike | StandaloneDataLike | SubDictLike | None,
@@ -1020,40 +1084,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 +1175,14 @@ class FoamFile(
     @overload
     @staticmethod
     def _normalized_keywords(
-        keywords: None, /, *, slice_ok: bool = ...
-    ) -> tuple[()]: ...
+        keywords: tuple[str, Unpack[tuple[str, ...]]], /, *, slice_ok: bool = ...
+    ) -> tuple[str, Unpack[tuple[str, ...]]]: ...
 
     @overload
     @staticmethod
     def _normalized_keywords(
-        keywords: tuple[str, ...], /, *, slice_ok: bool = ...
-    ) -> tuple[str, ...]: ...
+        keywords: None | tuple[()], /, *, slice_ok: bool = ...
+    ) -> tuple[()]: ...
 
     @overload
     @staticmethod
@@ -1225,7 +1265,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 +1313,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 +1333,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 +1344,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 +1353,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