foamlib 1.4.0__tar.gz → 1.4.2__tar.gz

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

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

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

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

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

@@ -16,7 +16,7 @@ import os
 from .._files import FoamFieldFile, FoamFile
 
 
-class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
+class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"], os.PathLike[str]):
     """
     Base class for OpenFOAM cases.
 
@@ -34,7 +34,7 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
     def __init__(self, path: os.PathLike[str] | str = Path()) -> None:
         self.path = Path(path).absolute()
 
-    class TimeDirectory(AbstractSet[FoamFieldFile]):
+    class TimeDirectory(AbstractSet[FoamFieldFile], os.PathLike[str]):
         """
         A time directory in an OpenFOAM case.
 
@@ -100,6 +100,7 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
             else:
                 (self.path / name).unlink()
 
+        @override
         def __fspath__(self) -> str:
             return str(self.path)
 
@@ -266,6 +267,7 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
         """The turbulenceProperties file."""
         return self.file("constant/turbulenceProperties")
 
+    @override
     def __fspath__(self) -> str:
         return str(self.path)
 

{foamlib-1.4.0 → foamlib-1.4.2}/src/foamlib/_files/_common.py

@@ -46,9 +46,9 @@ def dict_from_items(
     items: Iterable[tuple[object, _V]],
     /,
     *,
-    target: type[File] = ...,
+    target: type[SubDict] = ...,
     check_keys: bool = ...,
-) -> dict[str | None, _V] | MultiDict[str | None, _V]: ...
+) -> dict[str, _V] | MultiDict[str, _V]: ...
 
 
 @overload
@@ -56,16 +56,16 @@ def dict_from_items(
     items: Iterable[tuple[object, _V]],
     /,
     *,
-    target: type[SubDict] = ...,
+    target: type[File] = ...,
     check_keys: bool = ...,
-) -> dict[str, _V] | MultiDict[str, _V]: ...
+) -> dict[str | None, _V] | MultiDict[str | None, _V]: ...
 
 
 def dict_from_items(
     items: Iterable[tuple[object, _V]],
     /,
     *,
-    target: type[Dict] | type[File] | type[SubDict],
+    target: type[Dict] | type[SubDict] | type[File],
     check_keys: bool = False,
 ) -> (
     dict[str, _V]

{foamlib-1.4.0 → foamlib-1.4.2}/src/foamlib/_files/_parsing/_grammar.py

@@ -150,8 +150,9 @@ DATA <<= _DATA_ENTRY[1, ...].set_parse_action(
 
 _STANDALONE_DATA_ENTRY = (
     ASCIINumericList(dtype=int)
-    | ASCIIFacesLikeList()
+    | ASCIINumericList(dtype=float)
     | ASCIINumericList(dtype=float, elshape=(3,))
+    | ASCIIFacesLikeList()
     | (
         (
             binary_numeric_list(dtype=np.int32)

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

@@ -187,9 +187,9 @@ def normalized(
                 return data  # ty: ignore[invalid-return-type]
             return data.astype(float, copy=False)  # ty: ignore[possibly-missing-attribute]
 
-        # Other possible numeric standalone data (n integers)
-        case [Integral(), *rest], () if not isinstance(data, tuple) and all(
-            isinstance(r, Integral) for r in rest
+        # Other possible numeric standalone data (n integers or floats)
+        case [Real(), *rest], () if not isinstance(data, tuple) and all(
+            isinstance(r, Real) for r in rest
         ):
             return normalized(np.asarray(data), keywords=keywords, format_=format_)
 

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

@@ -1,4 +1,5 @@
 import contextlib
+import os
 import sys
 from collections.abc import Collection, Iterable, Iterator, Mapping, Sequence
 from copy import deepcopy
@@ -20,6 +21,7 @@ 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
@@ -44,6 +46,7 @@ class FoamFile(
         str | tuple[str, ...] | None,
         "Data | StandaloneData | FoamFile.SubDict | None",
     ],
+    os.PathLike[str],
     FoamFileIO,
 ):
     """
@@ -96,7 +99,7 @@ class FoamFile(
     Dimensioned = Dimensioned
     DimensionSet = DimensionSet
 
-    class KeysView(multicollections.abc.KeysView["str | None"]):
+    class KeysView(multicollections.abc.KeysView[str | None]):
         def __init__(self, file: "FoamFile", *, include_header: bool = False) -> None:
             self._file = file
             self._include_header = include_header
@@ -140,7 +143,7 @@ class FoamFile(
 
     class ItemsView(
         multicollections.abc.ItemsView[
-            "str | None", "Data | StandaloneData | FoamFile.SubDict | None"
+            str | None, "Data | StandaloneData | FoamFile.SubDict | None"
         ]
     ):
         def __init__(
@@ -288,14 +291,19 @@ class FoamFile(
         def __getitem__(self, keyword: str) -> "Data | FoamFile.SubDict | None": ...
 
         @overload
-        def __getitem__(self, keyword: slice) -> SubDict: ...
+        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 | SubDict":
+        ) -> "Data | FoamFile.SubDict | None | dict[str, Data | FoamFile.SubDict | None] | MultiDict[str, Data | FoamFile.SubDict | None]":
             if keyword == slice(None):
-                return self.as_dict()
+                return self.as_dict(deep=False)
 
             if isinstance(keyword, slice):
                 msg = "Only empty slices (:) are supported"
@@ -420,17 +428,42 @@ class FoamFile(
         def __repr__(self) -> str:
             return f"{type(self).__qualname__}('{self._file}', {self._keywords})"
 
-        def as_dict(self) -> SubDict:
-            """Return a nested dict representation of the sub-dictionary."""
-            file = self._file.as_dict(include_header=True)
+        @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)
 
-            ret = file[self._keywords[0]]
-            assert isinstance(ret, Mapping)
-            for k in self._keywords[1:]:
-                ret = ret[k]
+                ret = file[self._keywords[0]]
                 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 ret  # ty: ignore[invalid-return-type]
+
+            return dict_from_items(self.items(), target=SubDict)
 
     @property
     def version(self) -> float:
@@ -736,17 +769,20 @@ class FoamFile(
     def __getitem__(
         self,
         keywords: slice,
-    ) -> File: ...
+    ) -> (
+        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 | File":
+    ) -> "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()
+            return self.as_dict(deep=False)
 
         assert not isinstance(keywords, slice)
         parsed = self._get_parsed()
@@ -783,7 +819,7 @@ class FoamFile(
     def __setitem__(  # ty: ignore[invalid-method-override]
         self,
         keywords: str | tuple[str, ...] | None | slice,
-        data: FileLike | DataLike | StandaloneDataLike | SubDictLike | None,
+        data: DataLike | StandaloneDataLike | SubDictLike | None | FileLike,
     ) -> None:
         keywords = FoamFile._normalized_keywords(keywords, slice_ok=True)
 
@@ -980,19 +1016,44 @@ class FoamFile(
             else:
                 super().clear()
 
+    @override
     def __fspath__(self) -> str:
         return str(self.path)
 
-    def as_dict(self, *, include_header: bool = False) -> File:
+    @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"]
+    ):
         """
-        Return a nested dict representation of the file.
+        Return a 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.
         """
-        d = self._get_parsed().as_dict()
-        if not include_header:
-            d.pop("FoamFile", None)
-        return deepcopy(d)
+        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]
 
     @staticmethod
     def loads(
@@ -1230,7 +1291,7 @@ class FoamFieldFile(FoamFile):
     def getall(
         self, keywords: str | tuple[str, ...] | None
     ) -> Collection["Data | StandaloneData | FoamFieldFile.SubDict | None"]:
-        keywords = FoamFile._normalized_keywords(keywords)
+        keywords = FoamFieldFile._normalized_keywords(keywords)
 
         ret = list(super().getall(keywords))
 
@@ -1250,6 +1311,12 @@ class FoamFieldFile(FoamFile):
         keywords: str | tuple[str],
     ) -> "Data | FoamFieldFile.BoundariesSubDict | None": ...
 
+    @overload
+    def __getitem__(
+        self,
+        keywords: tuple[str, str],
+    ) -> "Data | FoamFieldFile.BoundarySubDict | None": ...
+
     @overload
     def __getitem__(
         self,
@@ -1272,11 +1339,11 @@ class FoamFieldFile(FoamFile):
     def __getitem__(  # ty: ignore[invalid-method-override]
         self,
         keywords: str | tuple[str, ...] | None | slice,
-    ) -> "Data | StandaloneData | FoamFieldFile.SubDict | None | File":
-        keywords = FoamFile._normalized_keywords(keywords, slice_ok=True)
+    ) -> "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()
+            return self.as_dict(deep=False)
 
         assert not isinstance(keywords, slice)
         ret = super().__getitem__(keywords)