foamlib 0.3.23__py3-none-any.whl → 0.4.0__py3-none-any.whl

foamlib/__init__.py

@@ -1,6 +1,6 @@
 """A Python interface for interacting with OpenFOAM."""
 
-__version__ = "0.3.23"
+__version__ = "0.4.0"
 
 from ._cases import (
     AsyncFoamCase,
@@ -9,7 +9,7 @@ from ._cases import (
     FoamCase,
     FoamCaseBase,
 )
-from ._files import FoamDict, FoamFieldFile, FoamFile
+from ._files import FoamFieldFile, FoamFile, FoamFileBase
 
 __all__ = [
     "FoamCase",
@@ -17,7 +17,7 @@ __all__ = [
     "FoamCaseBase",
     "FoamFile",
     "FoamFieldFile",
-    "FoamDict",
+    "FoamFileBase",
     "CalledProcessError",
     "CalledProcessWarning",
 ]

foamlib/_cases/_base.py

@@ -1,4 +1,5 @@
 import os
+import shutil
 import sys
 from pathlib import Path
 from typing import (
@@ -62,12 +63,10 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
             return self.path.name
 
         def __getitem__(self, key: str) -> FoamFieldFile:
-            if (self.path / key).is_file():
-                return FoamFieldFile(self.path / key)
-            elif (self.path / f"{key}.gz").is_file():
+            if (self.path / f"{key}.gz").is_file() and not (self.path / key).is_file():
                 return FoamFieldFile(self.path / f"{key}.gz")
             else:
-                raise KeyError(key)
+                return FoamFieldFile(self.path / key)
 
         def __contains__(self, obj: object) -> bool:
             if isinstance(obj, FoamFieldFile):
@@ -89,6 +88,12 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
         def __len__(self) -> int:
             return len(list(iter(self)))
 
+        def __delitem__(self, key: str) -> None:
+            if (self.path / f"{key}.gz").is_file() and not (self.path / key).is_file():
+                (self.path / f"{key}.gz").unlink()
+            else:
+                (self.path / key).unlink()
+
         def __fspath__(self) -> str:
             return str(self.path)
 
@@ -167,6 +172,9 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
 
         return paths
 
+    def __delitem__(self, key: Union[int, float, str]) -> None:
+        shutil.rmtree(self[key].path)
+
     def _clone_ignore(
         self,
     ) -> Callable[[Union[Path, str], Collection[str]], Collection[str]]:

foamlib/_files/__init__.py

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

foamlib/_files/_base.py

@@ -1,5 +1,4 @@
 import sys
-from abc import abstractmethod
 from dataclasses import dataclass
 from typing import Dict, NamedTuple, Optional, Tuple, Union
 
@@ -14,7 +13,7 @@ except ModuleNotFoundError:
     pass
 
 
-class FoamDict:
+class FoamFileBase:
     class DimensionSet(NamedTuple):
         mass: Union[int, float] = 0
         length: Union[int, float] = 0
@@ -30,12 +29,12 @@ class FoamDict:
     @dataclass
     class Dimensioned:
         value: Union[int, float, Sequence[Union[int, float]]] = 0
-        dimensions: Union["FoamDict.DimensionSet", Sequence[Union[int, float]]] = ()
+        dimensions: Union["FoamFileBase.DimensionSet", Sequence[Union[int, float]]] = ()
         name: Optional[str] = None
 
         def __post_init__(self) -> None:
-            if not isinstance(self.dimensions, FoamDict.DimensionSet):
-                self.dimensions = FoamDict.DimensionSet(*self.dimensions)
+            if not isinstance(self.dimensions, FoamFileBase.DimensionSet):
+                self.dimensions = FoamFileBase.DimensionSet(*self.dimensions)
 
     Data = Union[
         str,
@@ -48,16 +47,11 @@ class FoamDict:
         Mapping[str, "Data"],
     ]
     """
-    A value that can be stored in an OpenFOAM dictionary.
+    A value that can be stored in an OpenFOAM file.
     """
 
     _Dict = Dict[str, Union["Data", "_Dict"]]
 
-    @abstractmethod
-    def as_dict(self) -> _Dict:
-        """Return a nested dict representation of the dictionary."""
-        raise NotImplementedError
-
     _SetData = Union[
         str,
         int,

foamlib/_files/_files.py

@@ -1,14 +1,24 @@
 import sys
-from typing import Any, Tuple, Union, cast
+from typing import Any, Optional, Tuple, Union, cast
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
 
 if sys.version_info >= (3, 9):
     from collections.abc import Iterator, Mapping, MutableMapping, Sequence
 else:
     from typing import Iterator, Mapping, MutableMapping, Sequence
 
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
 from .._util import is_sequence
-from ._base import FoamDict
-from ._io import FoamFileIO
+from ._base import FoamFileBase
+from ._io import _FoamFileIO
 from ._serialization import Kind, dumpb
 
 try:
@@ -18,11 +28,12 @@ except ModuleNotFoundError:
 
 
 class FoamFile(
-    FoamDict,
+    FoamFileBase,
     MutableMapping[
-        Union[str, Tuple[str, ...]], Union["FoamFile.Data", "FoamFile.SubDict"]
+        Optional[Union[str, Tuple[str, ...]]],
+        Union["FoamFile.Data", "FoamFile.SubDict"],
     ],
-    FoamFileIO,
+    _FoamFileIO,
 ):
     """
     An OpenFOAM data file.
@@ -33,7 +44,6 @@ class FoamFile(
     """
 
     class SubDict(
-        FoamDict,
         MutableMapping[str, Union["FoamFile.Data", "FoamFile.SubDict"]],
     ):
         """An OpenFOAM dictionary within a file as a mutable mapping."""
@@ -58,7 +68,9 @@ class FoamFile(
             del self._file[(*self._keywords, keyword)]
 
         def __iter__(self) -> Iterator[str]:
-            return self._file._iter(self._keywords)
+            for k in self._file._iter(self._keywords):
+                assert k is not None
+                yield k
 
         def __contains__(self, keyword: object) -> bool:
             return (*self._keywords, keyword) in self._file
@@ -77,7 +89,7 @@ class FoamFile(
         def __repr__(self) -> str:
             return f"{type(self).__qualname__}('{self._file}', {self._keywords})"
 
-        def as_dict(self) -> FoamDict._Dict:
+        def as_dict(self) -> FoamFileBase._Dict:
             """Return a nested dict representation of the dictionary."""
             ret = self._file.as_dict()
 
@@ -89,85 +101,111 @@ class FoamFile(
 
             return ret
 
-    class Header(SubDict):
-        """The header of an OpenFOAM file."""
+    def create(self, *, exist_ok: bool = False, parents: bool = False) -> Self:
+        """
+        Create the file.
+
+        Parameters
+        ----------
+        exist_ok : bool, optional
+            If False (the default), raise a FileExistsError if the file already exists.
+            If True, do nothing if the file already exists.
+        parents : bool, optional
+            If True, also create parent directories as needed.
+        """
+        if self.path.exists():
+            if not exist_ok:
+                raise FileExistsError(self.path)
+            else:
+                return self
 
-        def __init__(self, _file: "FoamFile") -> None:
-            super().__init__(_file, ("FoamFile",))
+        if parents:
+            self.path.parent.mkdir(parents=True, exist_ok=True)
 
-        @property
-        def version(self) -> float:
-            """Alias of `self["version"]`."""
-            ret = self["version"]
-            if not isinstance(ret, float):
-                raise TypeError("version is not a float")
-            return ret
+        self.path.touch()
+        self._write_header()
 
-        @version.setter
-        def version(self, data: float) -> None:
-            self["version"] = data
+        return self
 
-        @property
-        def format(self) -> str:
-            """Alias of `self["format"]`."""
-            ret = self["format"]
-            if not isinstance(ret, str):
-                raise TypeError("format is not a string")
-            return ret
+    @property
+    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")
+        return ret
 
-        @format.setter
-        def format(self, data: str) -> None:
-            self["format"] = data
+    @version.setter
+    def version(self, value: float) -> None:
+        self["FoamFile", "version"] = value
 
-        @property
-        def class_(self) -> str:
-            """Alias of `self["class"]`."""
-            ret = self["class"]
-            if not isinstance(ret, str):
-                raise TypeError("class is not a string")
-            return ret
+    @property
+    def format(self) -> Literal["ascii", "binary"]:
+        """Alias of `self["FoamFile", "format"]`."""
+        ret = self["FoamFile", "format"]
+        if not isinstance(ret, str):
+            raise TypeError("format is not a string")
+        if ret not in ("ascii", "binary"):
+            raise ValueError("format is not 'ascii' or 'binary'")
+        return cast(Literal["ascii", "binary"], ret)
+
+    @format.setter
+    def format(self, value: Literal["ascii", "binary"]) -> None:
+        self["FoamFile", "format"] = value
 
-        @class_.setter
-        def class_(self, data: str) -> None:
-            self["class"] = data
+    @property
+    def class_(self) -> str:
+        """Alias of `self["FoamFile", "class"]`."""
+        ret = self["FoamFile", "class"]
+        if not isinstance(ret, str):
+            raise TypeError("class is not a string")
+        return ret
 
-        @property
-        def location(self) -> str:
-            """Alias of `self["location"]`."""
-            ret = self["location"]
-            if not isinstance(ret, str):
-                raise TypeError("location is not a string")
-            return ret
+    @class_.setter
+    def class_(self, value: str) -> None:
+        self["FoamFile", "class"] = value
 
-        @location.setter
-        def location(self, data: str) -> None:
-            self["location"] = data
+    @property
+    def location(self) -> str:
+        """Alias of `self["FoamFile", "location"]`."""
+        ret = self["FoamFile", "location"]
+        if not isinstance(ret, str):
+            raise TypeError("location is not a string")
+        return ret
 
-        @property
-        def object(self) -> str:
-            """Alias of `self["object"]`."""
-            ret = self["object"]
-            if not isinstance(ret, str):
-                raise TypeError("object is not a string")
-            return ret
+    @location.setter
+    def location(self, value: str) -> None:
+        self["FoamFile", "location"] = value
 
     @property
-    def header(self) -> Header:
-        """Alias of `self["FoamFile"]`."""
-        ret = self["FoamFile"]
-        if not isinstance(ret, FoamFile.Header):
-            assert not isinstance(ret, FoamFile.SubDict)
-            raise TypeError("FoamFile is not a dictionary")
+    def object_(self) -> str:
+        """Alias of `self["FoamFile", "object"]`."""
+        ret = self["FoamFile", "object"]
+        if not isinstance(ret, str):
+            raise TypeError("object is not a string")
         return ret
 
-    @header.setter
-    def header(self, data: FoamDict._Dict) -> None:
-        self["FoamFile"] = data
+    @object_.setter
+    def object_(self, value: str) -> None:
+        self["FoamFile", "object"] = value
+
+    def _write_header(self) -> None:
+        assert "FoamFile" not in self
+        assert not self
+
+        self["FoamFile"] = {}
+        self.version = 2.0
+        self.format = "ascii"
+        self.class_ = "dictionary"
+        self.location = f'"{self.path.parent.name}"'
+        self.object_ = self.path.name
 
     def __getitem__(
-        self, keywords: Union[str, Tuple[str, ...]]
+        self, keywords: Optional[Union[str, Tuple[str, ...]]]
     ) -> Union["FoamFile.Data", "FoamFile.SubDict"]:
-        if not isinstance(keywords, tuple):
+        if not keywords:
+            keywords = ()
+        elif not isinstance(keywords, tuple):
             keywords = (keywords,)
 
         _, parsed = self._read()
@@ -175,28 +213,21 @@ class FoamFile(
         value = parsed[keywords]
 
         if value is ...:
-            if keywords == ("FoamFile",):
-                return FoamFile.Header(self)
-            else:
-                return FoamFile.SubDict(self, keywords)
+            return FoamFile.SubDict(self, keywords)
         else:
             return value
 
     def __setitem__(
-        self, keywords: Union[str, Tuple[str, ...]], data: "FoamFile._SetData"
+        self, keywords: Optional[Union[str, Tuple[str, ...]]], data: "FoamFile._SetData"
     ) -> None:
         with self:
-            if not isinstance(keywords, tuple):
+            if not keywords:
+                keywords = ()
+            elif not isinstance(keywords, tuple):
                 keywords = (keywords,)
 
-            if not self and keywords[0] != "FoamFile":
-                self.header = {
-                    "version": 2.0,
-                    "format": "ascii",
-                    "class": "dictionary",
-                    "location": f'"{self.path.parent.name}"',
-                    "object": self.path.name,
-                }  # type: ignore [assignment]
+            if not self and "FoamFile" not in self and keywords[0] != "FoamFile":
+                self._write_header()
 
             kind = Kind.DEFAULT
             if keywords == ("internalField",) or (
@@ -204,35 +235,13 @@ class FoamFile(
                 and keywords[0] == "boundaryField"
                 and keywords[2] == "value"
             ):
-                kind = (
-                    Kind.BINARY_FIELD if self.header.format == "binary" else Kind.FIELD
-                )
+                kind = Kind.BINARY_FIELD if self.format == "binary" else Kind.FIELD
             elif keywords == ("dimensions",):
                 kind = Kind.DIMENSIONS
 
-            contents, parsed = self._read()
-
-            if isinstance(data, Mapping):
-                if isinstance(data, FoamDict):
-                    data = data.as_dict()
-
-                start, end = parsed.entry_location(keywords, missing_ok=True)
-
-                self._write(
-                    contents[:start]
-                    + (b"\n" if contents[start - 1 : start] != b"\n" else b"")
-                    + (b"  " * (len(keywords) - 1) if keywords else b"")
-                    + dumpb({keywords[-1]: {}})
-                    + b"\n"
-                    + contents[end:]
-                )
-
-                for k, v in data.items():
-                    self[(*keywords, k)] = v
-
-            elif (
+            if (
                 kind == Kind.FIELD or kind == Kind.BINARY_FIELD
-            ) and self.header.class_ == "dictionary":
+            ) and self.class_ == "dictionary":
                 if not is_sequence(data):
                     class_ = "volScalarField"
                 elif (len(data) == 3 and not is_sequence(data[0])) or len(data[0]) == 3:
@@ -244,27 +253,65 @@ class FoamFile(
                 else:
                     class_ = "volScalarField"
 
-                self.header.class_ = class_
+                self.class_ = class_
                 self[keywords] = data
 
             else:
+                contents, parsed = self._read()
+
                 start, end = parsed.entry_location(keywords, missing_ok=True)
 
-                self._write(
-                    contents[:start]
-                    + (
-                        b"\n"
-                        if start > 0 and contents[start - 1 : start] != b"\n"
-                        else b""
+                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":
+                    after = b"\n" + after
+
+                indentation = b"    " * (len(keywords) - 1)
+
+                if isinstance(data, Mapping):
+                    if isinstance(data, (FoamFile, FoamFile.SubDict)):
+                        data = data.as_dict()
+
+                    self._write(
+                        before
+                        + indentation
+                        + dumpb(keywords[-1])
+                        + b"\n"
+                        + indentation
+                        + b"{\n"
+                        + indentation
+                        + b"}"
+                        + after
+                    )
+
+                    for k, v in data.items():
+                        self[(*keywords, k)] = v
+
+                elif keywords:
+                    self._write(
+                        before
+                        + indentation
+                        + dumpb(keywords[-1])
+                        + b" "
+                        + dumpb(data, kind=kind)
+                        + b";"
+                        + after
                     )
-                    + (b"    " * (len(keywords) - 1) if keywords else b"")
-                    + dumpb({keywords[-1]: data}, kind=kind)
-                    + b"\n"
-                    + contents[end:]
-                )
-
-    def __delitem__(self, keywords: Union[str, Tuple[str, ...]]) -> None:
-        if not isinstance(keywords, tuple):
+
+                else:
+                    self._write(before + dumpb(data, kind=kind) + after)
+
+    def __delitem__(self, keywords: Optional[Union[str, Tuple[str, ...]]]) -> None:
+        if not keywords:
+            keywords = ()
+        elif not isinstance(keywords, tuple):
             keywords = (keywords,)
 
         contents, parsed = self._read()
@@ -273,21 +320,26 @@ class FoamFile(
 
         self._write(contents[:start] + contents[end:])
 
-    def _iter(self, keywords: Union[str, Tuple[str, ...]] = ()) -> Iterator[str]:
-        if not isinstance(keywords, tuple):
-            keywords = (keywords,)
-
+    def _iter(self, keywords: Tuple[str, ...] = ()) -> Iterator[Optional[str]]:
         _, parsed = self._read()
 
-        yield from (k[-1] for k in parsed if k[:-1] == keywords)
+        yield from (
+            k[-1] if k else None
+            for k in parsed
+            if k != ("FoamFile",) and k[:-1] == keywords
+        )
 
-    def __iter__(self) -> Iterator[str]:
+    def __iter__(self) -> Iterator[Optional[str]]:
         return self._iter()
 
     def __contains__(self, keywords: object) -> bool:
-        if not isinstance(keywords, tuple):
+        if not keywords:
+            keywords = ()
+        elif not isinstance(keywords, tuple):
             keywords = (keywords,)
+
         _, parsed = self._read()
+
         return keywords in parsed
 
     def __len__(self) -> int:
@@ -304,10 +356,12 @@ class FoamFile(
     def __fspath__(self) -> str:
         return str(self.path)
 
-    def as_dict(self) -> FoamDict._Dict:
+    def as_dict(self) -> FoamFileBase._Dict:
         """Return a nested dict representation of the file."""
         _, parsed = self._read()
-        return parsed.as_dict()
+        d = parsed.as_dict()
+        del d["FoamFile"]
+        return d
 
 
 class FoamFieldFile(FoamFile):
@@ -377,9 +431,11 @@ class FoamFieldFile(FoamFile):
             del self["value"]
 
     def __getitem__(
-        self, keywords: Union[str, Tuple[str, ...]]
+        self, keywords: Optional[Union[str, Tuple[str, ...]]]
     ) -> Union[FoamFile.Data, FoamFile.SubDict]:
-        if not isinstance(keywords, tuple):
+        if not keywords:
+            keywords = ()
+        elif not isinstance(keywords, tuple):
             keywords = (keywords,)
 
         ret = super().__getitem__(keywords)

foamlib/_files/_io.py

@@ -18,7 +18,7 @@ else:
 from ._parsing import Parsed
 
 
-class FoamFileIO:
+class _FoamFileIO:
     def __init__(self, path: Union[str, Path]) -> None:
         self.path = Path(path).absolute()
 

foamlib/_files/_parsing.py

@@ -33,7 +33,7 @@ from pyparsing import (
     printables,
 )
 
-from ._base import FoamDict
+from ._base import FoamFileBase
 
 
 def _list_of(entry: ParserElement) -> ParserElement:
@@ -132,11 +132,11 @@ _SWITCH = (
 ).set_parse_action(lambda: False)
 _DIMENSIONS = (
     Literal("[").suppress() + common.number * 7 + Literal("]").suppress()
-).set_parse_action(lambda tks: FoamDict.DimensionSet(*tks))
+).set_parse_action(lambda tks: FoamFileBase.DimensionSet(*tks))
 _TENSOR = _list_of(common.number) | common.number
 _IDENTIFIER = Word(identchars + "$", printables, exclude_chars="{;}")
 _DIMENSIONED = (Opt(_IDENTIFIER) + _DIMENSIONS + _TENSOR).set_parse_action(
-    lambda tks: FoamDict.Dimensioned(*reversed(tks.as_list()))
+    lambda tks: FoamFileBase.Dimensioned(*reversed(tks.as_list()))
 )
 _FIELD = (
     (Keyword("uniform").suppress() + _TENSOR)
@@ -164,7 +164,7 @@ _FILE = (
             Group(
                 Located(
                     _DATA_ENTRY[1, ...].set_parse_action(
-                        lambda tks: ["", tuple(tks) if len(tks) > 1 else tks[0]]
+                        lambda tks: [None, tuple(tks) if len(tks) > 1 else tks[0]]
                     )
                 )
             )
@@ -178,11 +178,11 @@ _FILE = (
 )
 
 
-class Parsed(Mapping[Tuple[str, ...], Union[FoamDict.Data, EllipsisType]]):
+class Parsed(Mapping[Tuple[str, ...], Union[FoamFileBase.Data, EllipsisType]]):
     def __init__(self, contents: bytes) -> None:
         self._parsed: MutableMapping[
             Tuple[str, ...],
-            Tuple[int, Union[FoamDict.Data, EllipsisType], int],
+            Tuple[int, Union[FoamFileBase.Data, EllipsisType], int],
         ] = {}
         self._end = len(contents)
 
@@ -194,10 +194,12 @@ class Parsed(Mapping[Tuple[str, ...], Union[FoamDict.Data, EllipsisType]]):
     @staticmethod
     def _flatten_result(
         parse_result: ParseResults, *, _keywords: Tuple[str, ...] = ()
-    ) -> Mapping[Tuple[str, ...], Tuple[int, Union[FoamDict.Data, EllipsisType], int]]:
+    ) -> Mapping[
+        Tuple[str, ...], Tuple[int, Union[FoamFileBase.Data, EllipsisType], int]
+    ]:
         ret: MutableMapping[
             Tuple[str, ...],
-            Tuple[int, Union[FoamDict.Data, EllipsisType], int],
+            Tuple[int, Union[FoamFileBase.Data, EllipsisType], int],
         ] = {}
         start = parse_result.locn_start
         assert isinstance(start, int)
@@ -206,18 +208,26 @@ class Parsed(Mapping[Tuple[str, ...], Union[FoamDict.Data, EllipsisType]]):
         end = parse_result.locn_end
         assert isinstance(end, int)
         keyword, *data = item
-        assert isinstance(keyword, str)
-        ret[(*_keywords, keyword)] = (start, ..., end)
-        for d in data:
-            if isinstance(d, ParseResults):
-                ret.update(Parsed._flatten_result(d, _keywords=(*_keywords, keyword)))
-            else:
-                ret[(*_keywords, keyword)] = (start, d, end)
+        if keyword is None:
+            assert not _keywords
+            assert len(data) == 1
+            assert not isinstance(data[0], ParseResults)
+            ret[()] = (start, data[0], end)
+        else:
+            assert isinstance(keyword, str)
+            ret[(*_keywords, keyword)] = (start, ..., end)
+            for d in data:
+                if isinstance(d, ParseResults):
+                    ret.update(
+                        Parsed._flatten_result(d, _keywords=(*_keywords, keyword))
+                    )
+                else:
+                    ret[(*_keywords, keyword)] = (start, d, end)
         return ret
 
     def __getitem__(
         self, keywords: Union[str, Tuple[str, ...]]
-    ) -> Union[FoamDict.Data, EllipsisType]:
+    ) -> Union[FoamFileBase.Data, EllipsisType]:
         if isinstance(keywords, str):
             keywords = (keywords,)
 
@@ -252,8 +262,8 @@ class Parsed(Mapping[Tuple[str, ...], Union[FoamDict.Data, EllipsisType]]):
 
         return start, end
 
-    def as_dict(self) -> FoamDict._Dict:
-        ret: FoamDict._Dict = {}
+    def as_dict(self) -> FoamFileBase._Dict:
+        ret: FoamFileBase._Dict = {}
         for keywords, (_, data, _) in self._parsed.items():
             r = ret
             for k in keywords[:-1]:

foamlib/_files/_serialization.py

@@ -9,7 +9,7 @@ else:
     from typing import Mapping
 
 from .._util import is_sequence
-from ._base import FoamDict
+from ._base import FoamFileBase
 
 try:
     import numpy as np
@@ -28,7 +28,7 @@ class Kind(Enum):
 
 
 def dumpb(
-    data: FoamDict._SetData,
+    data: FoamFileBase._SetData,
     *,
     kind: Kind = Kind.DEFAULT,
 ) -> bytes:
@@ -39,18 +39,16 @@ def dumpb(
         entries = []
         for k, v in data.items():
             b = dumpb(v, kind=kind)
-            if not k:
-                entries.append(b)
-            elif isinstance(v, Mapping):
-                entries.append(dumpb(k) + b"\n" + b"{\n" + b + b"\n}")
+            if isinstance(v, Mapping):
+                entries.append(dumpb(k) + b" {" + b + b"}")
             elif not b:
                 entries.append(dumpb(k) + b";")
             else:
                 entries.append(dumpb(k) + b" " + b + b";")
 
-        return b"\n".join(entries)
+        return b" ".join(entries)
 
-    elif isinstance(data, FoamDict.DimensionSet) or (
+    elif isinstance(data, FoamFileBase.DimensionSet) or (
         kind == Kind.DIMENSIONS and is_sequence(data) and len(data) == 7
     ):
         return b"[" + b" ".join(dumpb(v) for v in data) + b"]"
@@ -93,7 +91,7 @@ def dumpb(
     elif kind != Kind.SINGLE_ENTRY and isinstance(data, tuple):
         return b" ".join(dumpb(v) for v in data)
 
-    elif isinstance(data, FoamDict.Dimensioned):
+    elif isinstance(data, FoamFileBase.Dimensioned):
         if data.name is not None:
             return (
                 dumpb(data.name)

{foamlib-0.3.23.dist-info → foamlib-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.3.23
+Version: 0.4.0
 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
@@ -45,7 +45,7 @@ Requires-Dist: numpy <3,>=1 ; extra == 'numpy'
 Provides-Extra: test
 Requires-Dist: foamlib[numpy] ; extra == 'test'
 Requires-Dist: pytest <9,>=7 ; extra == 'test'
-Requires-Dist: pytest-asyncio <0.24,>=0.21 ; extra == 'test'
+Requires-Dist: pytest-asyncio <0.25,>=0.21 ; extra == 'test'
 Requires-Dist: pytest-cov ; extra == 'test'
 Provides-Extra: typing
 Requires-Dist: foamlib[test] ; extra == 'typing'

foamlib-0.4.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+foamlib/__init__.py,sha256=ZL6X6uzZgGj8D5Thi9ZuZyr1Mpo6f78yT_Rf4sBU12I,446
+foamlib/_util.py,sha256=UMzXmTFgvbp46w6k3oEZJoYC98pFgEK6LN5uLOwrlCg,397
+foamlib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+foamlib/_cases/__init__.py,sha256=xnQpR64EvFtCh07qnSz7kjQ1IhJXjRDwaZWwQGZhGv4,280
+foamlib/_cases/_async.py,sha256=ehmAedDepDXaRdf8f0IznxDMYAQxoUWSIxbhxG_17Rw,6035
+foamlib/_cases/_base.py,sha256=JrYJplmXV84qwgerdVSCHz2rCI-KWB4IvTBPMkYpecw,12657
+foamlib/_cases/_sync.py,sha256=CloQgd-93jxfSXIt7J5NxcAu3N_iF3eXMKO-NfNOgi4,4522
+foamlib/_cases/_util.py,sha256=v6sHxHCEgagsVuup0S1xJW-x9py5xj3bUye8PiFfb3o,925
+foamlib/_files/__init__.py,sha256=-UqB9YTH6mrJfXCX00kPTAAY20XG64u1MGPw_1ewLVs,148
+foamlib/_files/_base.py,sha256=sy1RP08pdv079KD_UBy7xUYEnXyNK35AiKVcCalYmPU,1873
+foamlib/_files/_files.py,sha256=2bvl2YZ0bqHpbQV35vzYO7wWNOo_2WDF9LbyLagIvBE,16193
+foamlib/_files/_io.py,sha256=f_tYI7AqaFsQ8mtK__fEoIUqpYb3YmrI8X5D8updmNM,2084
+foamlib/_files/_parsing.py,sha256=bOJkqNUMUiXZJQXXEnIAb0bcdj_AgDmDhrr19oyY_Sw,8078
+foamlib/_files/_serialization.py,sha256=3yb9fgjCpDoRfZoLsbZaIFrkZ3vGBzleFRw6IbaZuuY,3408
+foamlib-0.4.0.dist-info/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
+foamlib-0.4.0.dist-info/METADATA,sha256=3DObrf-prhkIgLQ2crezzAVkKW4ZIuNrXEsbqT3ilUc,5457
+foamlib-0.4.0.dist-info/WHEEL,sha256=uCRv0ZEik_232NlR4YDw4Pv3Ajt5bKvMH13NUU7hFuI,91
+foamlib-0.4.0.dist-info/top_level.txt,sha256=ZdVYtetXGwPwyfL-WhlhbTFQGAwKX5P_gXxtH9JYFPI,8
+foamlib-0.4.0.dist-info/RECORD,,

foamlib-0.3.23.dist-info/RECORD

@@ -1,19 +0,0 @@
-foamlib/__init__.py,sha256=pFmZVC3Cy4orJQeNLbr2JbQw3fVdOgShmuvNNIU0e9U,439
-foamlib/_util.py,sha256=UMzXmTFgvbp46w6k3oEZJoYC98pFgEK6LN5uLOwrlCg,397
-foamlib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-foamlib/_cases/__init__.py,sha256=xnQpR64EvFtCh07qnSz7kjQ1IhJXjRDwaZWwQGZhGv4,280
-foamlib/_cases/_async.py,sha256=ehmAedDepDXaRdf8f0IznxDMYAQxoUWSIxbhxG_17Rw,6035
-foamlib/_cases/_base.py,sha256=jfKevsV5CtxsyORvp-sYrdnW4pUxs6Or0I6nGXZVjII,12336
-foamlib/_cases/_sync.py,sha256=CloQgd-93jxfSXIt7J5NxcAu3N_iF3eXMKO-NfNOgi4,4522
-foamlib/_cases/_util.py,sha256=v6sHxHCEgagsVuup0S1xJW-x9py5xj3bUye8PiFfb3o,925
-foamlib/_files/__init__.py,sha256=vDkPj8u8bX_I_m2YfeKvXBgwg8D1ufyFCfHGHKN3JPQ,140
-foamlib/_files/_base.py,sha256=YA5a-i5HZuA3JslCD6r-DwZzpSA8r42dqSXef286Ako,2050
-foamlib/_files/_files.py,sha256=BPRbZLclOmxemuBTXpEeNoiUMx3VL_FUCGsX1YlidcA,14635
-foamlib/_files/_io.py,sha256=hlcqQqU-1cdIbDc3YqxnMfxALo4SFAEcRIoZM2vMtnE,2083
-foamlib/_files/_parsing.py,sha256=3Hp4pdVgrneCtVJl4G65cQYwOA9CwUOcH5jtIfNY014,7738
-foamlib/_files/_serialization.py,sha256=LCeaLWtNvkcs0dfowL7nViiByxw7U_fvgueVjFliipU,3462
-foamlib-0.3.23.dist-info/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
-foamlib-0.3.23.dist-info/METADATA,sha256=0i-sNTwsELdUk54SvL0Dz70CarcmkqU2_HYsLftSwps,5458
-foamlib-0.3.23.dist-info/WHEEL,sha256=uCRv0ZEik_232NlR4YDw4Pv3Ajt5bKvMH13NUU7hFuI,91
-foamlib-0.3.23.dist-info/top_level.txt,sha256=ZdVYtetXGwPwyfL-WhlhbTFQGAwKX5P_gXxtH9JYFPI,8
-foamlib-0.3.23.dist-info/RECORD,,