Remove FoamFileBase class

docs/files.rst

@@ -1,10 +1,6 @@
 File manipulation
 =================
 
-.. autoclass:: foamlib.FoamFileBase
-   :members:
-   :show-inheritance:
-
 .. autoclass:: foamlib.FoamFile
    :members:
    :show-inheritance:

foamlib/__init__.py

@@ -10,7 +10,7 @@
     FoamCaseBase,
     FoamCaseRunBase,
 )
-from ._files import FoamFieldFile, FoamFile, FoamFileBase
+from ._files import FoamFieldFile, FoamFile
 
 __all__ = [
     "AsyncFoamCase",
@@ -21,5 +21,4 @@
     "FoamCaseBase",
     "FoamCaseRunBase",
     "FoamFieldFile",
-    "FoamFileBase",
 ]

foamlib/_files/__init__.py

@@ -1,8 +1,6 @@
-from ._base import FoamFileBase
 from ._files import FoamFieldFile, FoamFile
 
 __all__ = [
     "FoamFile",
     "FoamFieldFile",
-    "FoamFileBase",
 ]

foamlib/_files/_files.py

@@ -15,17 +15,25 @@
 else:
     from typing import Iterator, Mapping, MutableMapping, Sequence
 
-from ._base import FoamFileBase
 from ._io import FoamFileIO
 from ._serialization import Kind, dumps, normalize
+from ._types import (
+    Data,
+    DataEntry,
+    Dict_,
+    Dimensioned,
+    DimensionSet,
+    Field,
+    File,
+    MutableData,
+)
 from ._util import is_sequence
 
 
 class FoamFile(
-    FoamFileBase,
     MutableMapping[
         Optional[Union[str, Tuple[str, ...]]],
-        FoamFileBase._MutableData,
+        MutableData,
     ],
     FoamFileIO,
 ):
@@ -37,24 +45,25 @@ class FoamFile(
     Use as a context manager to make multiple changes to the file while saving all changes only once at the end.
     """
 
+    Dimensioned = Dimensioned
+    DimensionSet = DimensionSet
+
     class SubDict(
-        MutableMapping[str, FoamFileBase._MutableData],
+        MutableMapping[str, MutableData],
     ):
         """An OpenFOAM dictionary within a file as a mutable mapping."""
 
         def __init__(self, _file: FoamFile, _keywords: tuple[str, ...]) -> None:
             self._file = _file
             self._keywords = _keywords
 
-        def __getitem__(
-            self, keyword: str
-        ) -> FoamFileBase._DataEntry | FoamFile.SubDict:
+        def __getitem__(self, keyword: str) -> DataEntry | FoamFile.SubDict:
             return self._file[(*self._keywords, keyword)]
 
         def __setitem__(
             self,
             keyword: str,
-            data: FoamFileBase.Data,
+            data: Data,
         ) -> None:
             self._file[(*self._keywords, keyword)] = data
 
@@ -83,17 +92,17 @@ def clear(self) -> None:
         def __repr__(self) -> str:
             return f"{type(self).__qualname__}('{self._file}', {self._keywords})"
 
-        def as_dict(self) -> FoamFileBase._Dict:
+        def as_dict(self) -> Dict_:
             """Return a nested dict representation of the dictionary."""
             ret = self._file.as_dict(include_header=True)
 
             for k in self._keywords:
                 assert isinstance(ret, dict)
                 v = ret[k]
                 assert isinstance(v, dict)
-                ret = cast(FoamFileBase._File, v)
+                ret = cast(File, v)
 
-            return cast(FoamFileBase._Dict, ret)
+            return cast(Dict_, ret)
 
     @property
     def version(self) -> float:
@@ -165,7 +174,7 @@ def object_(self, value: str) -> None:
 
     def __getitem__(
         self, keywords: str | tuple[str, ...] | None
-    ) -> FoamFileBase._DataEntry | FoamFile.SubDict:
+    ) -> DataEntry | FoamFile.SubDict:
         if not keywords:
             keywords = ()
         elif not isinstance(keywords, tuple):
@@ -181,9 +190,7 @@ def __getitem__(
             return FoamFile.SubDict(self, keywords)
         return deepcopy(value)
 
-    def __setitem__(
-        self, keywords: str | tuple[str, ...] | None, data: FoamFileBase.Data
-    ) -> None:
+    def __setitem__(self, keywords: str | tuple[str, ...] | None, data: Data) -> None:
         if not keywords:
             keywords = ()
         elif not isinstance(keywords, tuple):
@@ -368,7 +375,7 @@ def clear(self) -> None:
     def __fspath__(self) -> str:
         return str(self.path)
 
-    def as_dict(self, *, include_header: bool = False) -> FoamFileBase._File:
+    def as_dict(self, *, include_header: bool = False) -> File:
         """
         Return a nested dict representation of the file.
 
@@ -411,17 +418,17 @@ def type(self, data: str) -> None:
         @property
         def value(
             self,
-        ) -> FoamFile._Field:
+        ) -> Field:
             """Alias of `self["value"]`."""
             return cast(
-                FoamFile._Field,
+                Field,
                 self["value"],
             )
 
         @value.setter
         def value(
             self,
-            value: FoamFile._Field,
+            value: Field,
         ) -> None:
             self["value"] = value
 
@@ -431,7 +438,7 @@ def value(self) -> None:
 
     def __getitem__(
         self, keywords: str | tuple[str, ...] | None
-    ) -> FoamFileBase._DataEntry | FoamFile.SubDict:
+    ) -> DataEntry | FoamFile.SubDict:
         if not keywords:
             keywords = ()
         elif not isinstance(keywords, tuple):
@@ -446,29 +453,29 @@ def __getitem__(
         return ret
 
     @property
-    def dimensions(self) -> FoamFile.DimensionSet | Sequence[float]:
+    def dimensions(self) -> DimensionSet | Sequence[float]:
         """Alias of `self["dimensions"]`."""
         ret = self["dimensions"]
-        if not isinstance(ret, FoamFile.DimensionSet):
+        if not isinstance(ret, DimensionSet):
             msg = "dimensions is not a DimensionSet"
             raise TypeError(msg)
         return ret
 
     @dimensions.setter
-    def dimensions(self, value: FoamFile.DimensionSet | Sequence[float]) -> None:
+    def dimensions(self, value: DimensionSet | Sequence[float]) -> None:
         self["dimensions"] = value
 
     @property
     def internal_field(
         self,
-    ) -> FoamFile._Field:
+    ) -> Field:
         """Alias of `self["internalField"]`."""
-        return cast(FoamFile._Field, self["internalField"])
+        return cast(Field, self["internalField"])
 
     @internal_field.setter
     def internal_field(
         self,
-        value: FoamFile._Field,
+        value: Field,
     ) -> None:
         self["internalField"] = value
 
@@ -483,5 +490,5 @@ def boundary_field(self) -> FoamFieldFile.BoundariesSubDict:
         return ret
 
     @boundary_field.setter
-    def boundary_field(self, value: Mapping[str, FoamFile._Dict]) -> None:
+    def boundary_field(self, value: Mapping[str, Dict_]) -> None:
         self["boundaryField"] = value

foamlib/_files/_parsing.py

@@ -36,7 +36,7 @@
     printables,
 )
 
-from ._base import FoamFileBase
+from ._types import DataEntry, Dimensioned, DimensionSet, File
 
 
 def _list_of(entry: ParserElement) -> ParserElement:
@@ -120,7 +120,7 @@ def _unpack_binary_field(
 ).set_parse_action(lambda: False)
 _DIMENSIONS = (
     Literal("[").suppress() + common.number[0, 7] + Literal("]").suppress()
-).set_parse_action(lambda tks: FoamFileBase.DimensionSet(*tks))
+).set_parse_action(lambda tks: DimensionSet(*tks))
 _TENSOR = common.ieee_float | (
     Literal("(").suppress()
     + Group(
@@ -133,7 +133,7 @@ def _unpack_binary_field(
     + Opt(Literal("(") + Word(_IDENTBODYCHARS, exclude_chars="()") + Literal(")"))
 )
 _DIMENSIONED = (Opt(_IDENTIFIER) + _DIMENSIONS + _TENSOR).set_parse_action(
-    lambda tks: FoamFileBase.Dimensioned(*reversed(tks.as_list()))
+    lambda tks: Dimensioned(*reversed(tks.as_list()))
 )
 _FIELD = (Keyword("uniform", _IDENTBODYCHARS).suppress() + _TENSOR) | (
     Keyword("nonuniform", _IDENTBODYCHARS).suppress()
@@ -288,11 +288,11 @@ def _unpack_binary_field(
 )
 
 
-class Parsed(Mapping[Tuple[str, ...], Union[FoamFileBase._DataEntry, EllipsisType]]):
+class Parsed(Mapping[Tuple[str, ...], Union[DataEntry, EllipsisType]]):
     def __init__(self, contents: bytes) -> None:
         self._parsed: MutableMapping[
             tuple[str, ...],
-            tuple[int, FoamFileBase._DataEntry | EllipsisType, int],
+            tuple[int, DataEntry | EllipsisType, int],
         ] = {}
         for parse_result in _FILE.parse_string(
             contents.decode("latin-1"), parse_all=True
@@ -305,12 +305,10 @@ def __init__(self, contents: bytes) -> None:
     @staticmethod
     def _flatten_result(
         parse_result: ParseResults, *, _keywords: tuple[str, ...] = ()
-    ) -> Mapping[
-        tuple[str, ...], tuple[int, FoamFileBase._DataEntry | EllipsisType, int]
-    ]:
+    ) -> Mapping[tuple[str, ...], tuple[int, DataEntry | EllipsisType, int]]:
         ret: MutableMapping[
             tuple[str, ...],
-            tuple[int, FoamFileBase._DataEntry | EllipsisType, int],
+            tuple[int, DataEntry | EllipsisType, int],
         ] = {}
         start = parse_result.locn_start
         assert isinstance(start, int)
@@ -336,16 +334,14 @@ def _flatten_result(
                     ret[(*_keywords, keyword)] = (start, d, end)
         return ret
 
-    def __getitem__(
-        self, keywords: tuple[str, ...]
-    ) -> FoamFileBase._DataEntry | EllipsisType:
+    def __getitem__(self, keywords: tuple[str, ...]) -> DataEntry | EllipsisType:
         _, data, _ = self._parsed[keywords]
         return data
 
     def put(
         self,
         keywords: tuple[str, ...],
-        data: FoamFileBase._DataEntry | EllipsisType,
+        data: DataEntry | EllipsisType,
         content: bytes,
     ) -> None:
         start, end = self.entry_location(keywords, missing_ok=True)
@@ -413,14 +409,14 @@ def entry_location(
 
         return start, end
 
-    def as_dict(self) -> FoamFileBase._File:
-        ret: FoamFileBase._File = {}
+    def as_dict(self) -> File:
+        ret: File = {}
         for keywords, (_, data, _) in self._parsed.items():
             r = ret
             for k in keywords[:-1]:
                 v = r[k]
                 assert isinstance(v, dict)
-                r = cast(FoamFileBase._File, v)
+                r = cast(File, v)
 
             assert isinstance(r, dict)
             if keywords: