foamlib 0.2.10__tar.gz → 0.3.1__tar.gz

{foamlib-0.2.10 → foamlib-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.2.10
+Version: 0.3.1
 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

{foamlib-0.2.10 → foamlib-0.3.1}/foamlib/__init__.py

@@ -1,9 +1,10 @@
 """A Python interface for interacting with OpenFOAM."""
 
-__version__ = "0.2.10"
+__version__ = "0.3.1"
 
 from ._cases import AsyncFoamCase, FoamCase, FoamCaseBase
-from ._files import FoamDictionaryBase, FoamFieldFile, FoamFile
+from ._files import FoamDict, FoamFieldFile, FoamFile
+from ._util import CalledProcessError
 
 __all__ = [
     "FoamCase",
@@ -11,5 +12,6 @@ __all__ = [
     "FoamCaseBase",
     "FoamFile",
     "FoamFieldFile",
-    "FoamDictionaryBase",
+    "FoamDict",
+    "CalledProcessError",
 ]

{foamlib-0.2.10 → foamlib-0.3.1}/foamlib/_cases.py

@@ -28,7 +28,7 @@ else:
 import aioshutil
 
 from ._files import FoamFieldFile, FoamFile
-from ._util import CalledProcessError, is_sequence, run_process, run_process_async
+from ._util import is_sequence, run_process, run_process_async
 
 
 class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
@@ -325,7 +325,7 @@ class FoamCase(FoamCaseBase):
         Clean this case.
 
         :param script: If True, use an (All)clean script if it exists. If False, ignore any clean scripts.
-        :param check: If True, raise a RuntimeError if the clean script returns a non-zero exit code.
+        :param check: If True, raise a CalledProcessError if the clean script returns a non-zero exit code.
         """
         script_path = self._clean_script() if script else None
 
@@ -349,24 +349,18 @@ class FoamCase(FoamCaseBase):
         :param cmd: The command to run. If None, run the case. If a sequence, the first element is the command and the rest are arguments. If a string, `cmd` is executed in a shell.
         :param script: If True and `cmd` is None, use an (All)run(-parallel) script if it exists for running the case. If False or no run script is found, autodetermine the command(s) needed to run the case.
         :param parallel: If True, run in parallel using MPI. If None, autodetect whether to run in parallel.
-        :param check: If True, raise a RuntimeError if any command returns a non-zero exit code.
+        :param check: If True, raise a CalledProcessError if any command returns a non-zero exit code.
         """
         if cmd is not None:
             if parallel:
                 cmd = self._parallel_cmd(cmd)
 
-            try:
-                run_process(
-                    cmd,
-                    check=check,
-                    cwd=self.path,
-                    env=self._env(),
-                )
-            except CalledProcessError as e:
-                raise RuntimeError(
-                    f"{e.cmd} failed with return code {e.returncode}\n{e.stderr}"
-                ) from None
-
+            run_process(
+                cmd,
+                check=check,
+                cwd=self.path,
+                env=self._env(),
+            )
         else:
             script_path = self._run_script(parallel=parallel) if script else None
 
@@ -485,7 +479,7 @@ class AsyncFoamCase(FoamCaseBase):
         Clean this case.
 
         :param script: If True, use an (All)clean script if it exists. If False, ignore any clean scripts.
-        :param check: If True, raise a RuntimeError if the clean script returns a non-zero exit code.
+        :param check: If True, raise a CalledProcessError if the clean script returns a non-zero exit code.
         """
         script_path = self._clean_script() if script else None
 
@@ -511,7 +505,7 @@ class AsyncFoamCase(FoamCaseBase):
         :param script: If True and `cmd` is None, use an (All)run(-parallel) script if it exists for running the case. If False or no run script is found, autodetermine the command(s) needed to run the case.
         :param parallel: If True, run in parallel using MPI. If None, autodetect whether to run in parallel.
         :param cpus: The number of CPUs to reserve for the run. The run will wait until the requested number of CPUs is available. If None, autodetect the number of CPUs to reserve.
-        :param check: If True, raise a RuntimeError if a command returns a non-zero exit code.
+        :param check: If True, raise a CalledProcessError if a command returns a non-zero exit code.
         """
         if cmd is not None:
             if cpus is None:
@@ -523,19 +517,13 @@ class AsyncFoamCase(FoamCaseBase):
             if parallel:
                 cmd = self._parallel_cmd(cmd)
 
-            try:
-                async with self._cpus(cpus):
-                    await run_process_async(
-                        cmd,
-                        check=check,
-                        cwd=self.path,
-                        env=self._env(),
-                    )
-            except CalledProcessError as e:
-                raise RuntimeError(
-                    f"{e.cmd} failed with return code {e.returncode}\n{e.stderr}"
-                ) from None
-
+            async with self._cpus(cpus):
+                await run_process_async(
+                    cmd,
+                    check=check,
+                    cwd=self.path,
+                    env=self._env(),
+                )
         else:
             script_path = self._run_script(parallel=parallel) if script else None
 

{foamlib-0.2.10 → foamlib-0.3.1}/foamlib/_files/__init__.py

@@ -1,9 +1,9 @@
-from ._base import FoamDictionaryBase
+from ._base import FoamDict
 from ._fields import FoamFieldFile
 from ._files import FoamFile
 
 __all__ = [
     "FoamFile",
     "FoamFieldFile",
-    "FoamDictionaryBase",
+    "FoamDict",
 ]

{foamlib-0.2.10 → foamlib-0.3.1}/foamlib/_files/_base.py

@@ -1,7 +1,7 @@
 import sys
 from abc import abstractmethod
 from dataclasses import dataclass
-from typing import Dict, NamedTuple, Optional, Union
+from typing import Dict, NamedTuple, Optional, Tuple, Union
 
 if sys.version_info >= (3, 9):
     from collections.abc import Mapping, Sequence
@@ -10,12 +10,11 @@ else:
 
 try:
     import numpy as np
-    from numpy.typing import NDArray
 except ModuleNotFoundError:
     pass
 
 
-class FoamDictionaryBase:
+class FoamDict:
     class DimensionSet(NamedTuple):
         mass: Union[int, float] = 0
         length: Union[int, float] = 0
@@ -31,34 +30,44 @@ class FoamDictionaryBase:
     @dataclass
     class Dimensioned:
         value: Union[int, float, Sequence[Union[int, float]]] = 0
-        dimensions: Union[
-            "FoamDictionaryBase.DimensionSet", Sequence[Union[int, float]]
-        ] = ()
+        dimensions: Union["FoamDict.DimensionSet", Sequence[Union[int, float]]] = ()
         name: Optional[str] = None
 
         def __post_init__(self) -> None:
-            if not isinstance(self.dimensions, FoamDictionaryBase.DimensionSet):
-                self.dimensions = FoamDictionaryBase.DimensionSet(*self.dimensions)
+            if not isinstance(self.dimensions, FoamDict.DimensionSet):
+                self.dimensions = FoamDict.DimensionSet(*self.dimensions)
 
-    Value = Union[
+    Data = Union[
         str,
         int,
         float,
         bool,
         Dimensioned,
         DimensionSet,
-        Sequence["Value"],
-        Mapping[str, "Value"],
+        Sequence["Data"],
+        Mapping[str, "Data"],
     ]
     """
     A value that can be stored in an OpenFOAM dictionary.
     """
 
-    _Dict = Dict[str, Union["Value", "_Dict"]]
+    _Dict = Dict[str, Union["Data", "_Dict"]]
 
     @abstractmethod
     def as_dict(self) -> _Dict:
         """Return a nested dict representation of the dictionary."""
         raise NotImplementedError
 
-    _SetValue = Union[Value, "NDArray[np.generic]"]
+    _SetData = Union[
+        str,
+        int,
+        float,
+        bool,
+        Dimensioned,
+        DimensionSet,
+        Sequence["_SetData"],
+        Mapping[str, "_SetData"],
+        "np.ndarray[Tuple[()], np.dtype[np.generic]]",
+        "np.ndarray[Tuple[int], np.dtype[np.generic]]",
+        "np.ndarray[Tuple[int, int], np.dtype[np.generic]]",
+    ]

{foamlib-0.2.10 → foamlib-0.3.1}/foamlib/_files/_fields.py

@@ -10,7 +10,6 @@ from ._files import FoamFile
 
 try:
     import numpy as np
-    from numpy.typing import NDArray
 except ModuleNotFoundError:
     pass
 
@@ -18,26 +17,26 @@ except ModuleNotFoundError:
 class FoamFieldFile(FoamFile):
     """An OpenFOAM dictionary file representing a field as a mutable mapping."""
 
-    class BoundariesDictionary(FoamFile.Dictionary):
-        def __getitem__(self, keyword: str) -> "FoamFieldFile.BoundaryDictionary":
+    class BoundariesSubDict(FoamFile.SubDict):
+        def __getitem__(self, keyword: str) -> "FoamFieldFile.BoundarySubDict":
             value = super().__getitem__(keyword)
-            if not isinstance(value, FoamFieldFile.BoundaryDictionary):
-                assert not isinstance(value, FoamFile.Dictionary)
+            if not isinstance(value, FoamFieldFile.BoundarySubDict):
+                assert not isinstance(value, FoamFile.SubDict)
                 raise TypeError(f"boundary {keyword} is not a dictionary")
             return value
 
-    class BoundaryDictionary(FoamFile.Dictionary):
+    class BoundarySubDict(FoamFile.SubDict):
         """An OpenFOAM dictionary representing a boundary condition as a mutable mapping."""
 
         def __setitem__(
             self,
-            key: str,
-            value: FoamFile._SetValue,
+            keyword: str,
+            data: FoamFile._SetData,
         ) -> None:
-            if key == "value":
-                self._setitem(key, value, assume_field=True)
+            if keyword == "value":
+                self._setitem(keyword, data, assume_field=True)
             else:
-                self._setitem(key, value)
+                self._setitem(keyword, data)
 
         @property
         def type(self) -> str:
@@ -48,8 +47,8 @@ class FoamFieldFile(FoamFile):
             return ret
 
         @type.setter
-        def type(self, value: str) -> None:
-            self["type"] = value
+        def type(self, data: str) -> None:
+            self["type"] = data
 
         @property
         def value(
@@ -58,7 +57,9 @@ class FoamFieldFile(FoamFile):
             int,
             float,
             Sequence[Union[int, float, Sequence[Union[int, float]]]],
-            "NDArray[np.generic]",
+            "np.ndarray[Tuple[()], np.dtype[np.generic]]",
+            "np.ndarray[Tuple[int], np.dtype[np.generic]]",
+            "np.ndarray[Tuple[int, int], np.dtype[np.generic]]",
         ]:
             """Alias of `self["value"]`."""
             ret = self["value"]
@@ -73,7 +74,9 @@ class FoamFieldFile(FoamFile):
                 int,
                 float,
                 Sequence[Union[int, float, Sequence[Union[int, float]]]],
-                "NDArray[np.generic]",
+                "np.ndarray[Tuple[()], np.dtype[np.generic]]",
+                "np.ndarray[Tuple[int], np.dtype[np.generic]]",
+                "np.ndarray[Tuple[int, int], np.dtype[np.generic]]",
             ],
         ) -> None:
             self["value"] = value
@@ -84,16 +87,16 @@ class FoamFieldFile(FoamFile):
 
     def __getitem__(
         self, keywords: Union[str, Tuple[str, ...]]
-    ) -> Union[FoamFile.Value, FoamFile.Dictionary]:
+    ) -> Union[FoamFile.Data, FoamFile.SubDict]:
         if not isinstance(keywords, tuple):
             keywords = (keywords,)
 
         ret = super().__getitem__(keywords)
-        if keywords[0] == "boundaryField" and isinstance(ret, FoamFile.Dictionary):
+        if keywords[0] == "boundaryField" and isinstance(ret, FoamFile.SubDict):
             if len(keywords) == 1:
-                ret = FoamFieldFile.BoundariesDictionary(self, keywords)
+                ret = FoamFieldFile.BoundariesSubDict(self, keywords)
             elif len(keywords) == 2:
-                ret = FoamFieldFile.BoundaryDictionary(self, keywords)
+                ret = FoamFieldFile.BoundarySubDict(self, keywords)
         return ret
 
     def __setitem__(self, keywords: Union[str, Tuple[str, ...]], value: Any) -> None:
@@ -128,7 +131,9 @@ class FoamFieldFile(FoamFile):
         int,
         float,
         Sequence[Union[int, float, Sequence[Union[int, float]]]],
-        "NDArray[np.generic]",
+        "np.ndarray[Tuple[()], np.dtype[np.generic]]",
+        "np.ndarray[Tuple[int], np.dtype[np.generic]]",
+        "np.ndarray[Tuple[int, int], np.dtype[np.generic]]",
     ]:
         """Alias of `self["internalField"]`."""
         ret = self["internalField"]
@@ -143,16 +148,18 @@ class FoamFieldFile(FoamFile):
             int,
             float,
             Sequence[Union[int, float, Sequence[Union[int, float]]]],
-            "NDArray[np.generic]",
+            "np.ndarray[Tuple[()], np.dtype[np.generic]]",
+            "np.ndarray[Tuple[int], np.dtype[np.generic]]",
+            "np.ndarray[Tuple[int, int], np.dtype[np.generic]]",
         ],
     ) -> None:
         self["internalField"] = value
 
     @property
-    def boundary_field(self) -> "FoamFieldFile.BoundariesDictionary":
+    def boundary_field(self) -> "FoamFieldFile.BoundariesSubDict":
         """Alias of `self["boundaryField"]`."""
         ret = self["boundaryField"]
-        if not isinstance(ret, FoamFieldFile.BoundariesDictionary):
-            assert not isinstance(ret, FoamFile.Dictionary)
+        if not isinstance(ret, FoamFieldFile.BoundariesSubDict):
+            assert not isinstance(ret, FoamFile.SubDict)
             raise TypeError("boundaryField is not a dictionary")
         return ret

{foamlib-0.2.10 → foamlib-0.3.1}/foamlib/_files/_files.py

@@ -10,15 +10,15 @@ if sys.version_info >= (3, 9):
 else:
     from typing import Iterator, Mapping, MutableMapping
 
-from ._base import FoamDictionaryBase
+from ._base import FoamDict
 from ._io import FoamFileIO
-from ._serialization import serialize_entry
+from ._serialization import serialize
 
 
 class FoamFile(
-    FoamDictionaryBase,
+    FoamDict,
     MutableMapping[
-        Union[str, Tuple[str, ...]], Union["FoamFile.Value", "FoamFile.Dictionary"]
+        Union[str, Tuple[str, ...]], Union["FoamFile.Data", "FoamFile.SubDict"]
     ],
     FoamFileIO,
 ):
@@ -30,9 +30,9 @@ class FoamFile(
     Use as a context manager to make multiple changes to the file while saving all changes only once at the end.
     """
 
-    class Dictionary(
-        FoamDictionaryBase,
-        MutableMapping[str, Union["FoamFile.Value", "FoamFile.Dictionary"]],
+    class SubDict(
+        FoamDict,
+        MutableMapping[str, Union["FoamFile.Data", "FoamFile.SubDict"]],
     ):
         """An OpenFOAM dictionary within a file as a mutable mapping."""
 
@@ -42,25 +42,25 @@ class FoamFile(
 
         def __getitem__(
             self, keyword: str
-        ) -> Union["FoamFile.Value", "FoamFile.Dictionary"]:
+        ) -> Union["FoamFile.Data", "FoamFile.SubDict"]:
             return self._file[(*self._keywords, keyword)]
 
         def _setitem(
             self,
             keyword: str,
-            value: Any,
+            data: Any,
             *,
             assume_field: bool = False,
             assume_dimensions: bool = False,
         ) -> None:
             self._file._setitem(
                 (*self._keywords, keyword),
-                value,
+                data,
                 assume_field=assume_field,
                 assume_dimensions=assume_dimensions,
             )
 
-        def __setitem__(self, keyword: str, value: "FoamFile._SetValue") -> None:
+        def __setitem__(self, keyword: str, value: "FoamFile._SetData") -> None:
             self._setitem(keyword, value)
 
         def __delitem__(self, keyword: str) -> None:
@@ -86,7 +86,7 @@ class FoamFile(
         def __repr__(self) -> str:
             return f"{type(self).__qualname__}({self._file}, {self._keywords})"
 
-        def as_dict(self) -> FoamDictionaryBase._Dict:
+        def as_dict(self) -> FoamDict._Dict:
             """Return a nested dict representation of the dictionary."""
             ret = self._file.as_dict()
 
@@ -100,7 +100,7 @@ class FoamFile(
 
     def __getitem__(
         self, keywords: Union[str, Tuple[str, ...]]
-    ) -> Union["FoamFile.Value", "FoamFile.Dictionary"]:
+    ) -> Union["FoamFile.Data", "FoamFile.SubDict"]:
         if not isinstance(keywords, tuple):
             keywords = (keywords,)
 
@@ -109,14 +109,14 @@ class FoamFile(
         value = parsed[keywords]
 
         if value is ...:
-            return FoamFile.Dictionary(self, keywords)
+            return FoamFile.SubDict(self, keywords)
         else:
             return value  # type: ignore [return-value]
 
     def _setitem(
         self,
         keywords: Union[str, Tuple[str, ...]],
-        value: "FoamFile._SetValue",
+        data: "FoamFile._SetData",
         *,
         assume_field: bool = False,
         assume_dimensions: bool = False,
@@ -126,32 +126,32 @@ class FoamFile(
 
         contents, parsed = self._read()
 
-        if isinstance(value, Mapping):
+        if isinstance(data, Mapping):
             with self:
-                if isinstance(value, FoamDictionaryBase):
-                    value = value.as_dict()
+                if isinstance(data, FoamDict):
+                    data = data.as_dict()
 
                 start, end = parsed.entry_location(keywords, missing_ok=True)
 
                 self._write(
-                    f"{contents[:start]}\n{serialize_entry(keywords[-1], {})}\n{contents[end:]}"
+                    f"{contents[:start]}\n{serialize({keywords[-1]: {}})}\n{contents[end:]}"
                 )
 
-                for k, v in value.items():
+                for k, v in data.items():
                     self[(*keywords, k)] = v
         else:
             start, end = parsed.entry_location(keywords, missing_ok=True)
 
             self._write(
-                f"{contents[:start]}\n{serialize_entry(keywords[-1], value, assume_field=assume_field, assume_dimensions=assume_dimensions)}\n{contents[end:]}"
+                f"{contents[:start]}\n{serialize({keywords[-1]: data}, assume_field=assume_field, assume_dimensions=assume_dimensions)}\n{contents[end:]}"
             )
 
     def __setitem__(
         self,
         keywords: Union[str, Tuple[str, ...]],
-        value: "FoamFile._SetValue",
+        data: "FoamFile._SetData",
     ) -> None:
-        self._setitem(keywords, value)
+        self._setitem(keywords, data)
 
     def __delitem__(self, keywords: Union[str, Tuple[str, ...]]) -> None:
         if not isinstance(keywords, tuple):
@@ -197,7 +197,7 @@ class FoamFile(
     def __repr__(self) -> str:
         return f"{type(self).__name__}({self.path})"
 
-    def as_dict(self) -> FoamDictionaryBase._Dict:
+    def as_dict(self) -> FoamDict._Dict:
         """Return a nested dict representation of the file."""
         _, parsed = self._read()
         return parsed.as_dict()

{foamlib-0.2.10 → foamlib-0.3.1}/foamlib/_files/_parsing.py

@@ -31,10 +31,10 @@ from pyparsing import (
     printables,
 )
 
-from ._base import FoamDictionaryBase
+from ._base import FoamDict
 
 
-def _list_of(elem: ParserElement) -> ParserElement:
+def _list_of(entry: ParserElement) -> ParserElement:
     return Opt(
         Literal("List") + Literal("<") + common.identifier + Literal(">")
     ).suppress() + (
@@ -42,36 +42,36 @@ def _list_of(elem: ParserElement) -> ParserElement:
             Opt(common.integer).suppress()
             + (
                 Literal("(").suppress()
-                + Group((elem)[...], aslist=True)
+                + Group((entry)[...], aslist=True)
                 + Literal(")").suppress()
             )
         )
         | (
-            common.integer + Literal("{").suppress() + elem + Literal("}").suppress()
+            common.integer + Literal("{").suppress() + entry + Literal("}").suppress()
         ).set_parse_action(lambda tks: [[tks[1]] * tks[0]])
     )
 
 
 def _dictionary_of(
     keyword: ParserElement,
-    value: ParserElement,
+    data_entries: ParserElement,
     *,
     len: Union[int, EllipsisType] = ...,
     located: bool = False,
 ) -> ParserElement:
     subdict = Forward()
 
-    entry = keyword + (
+    keyword_entry = keyword + (
         (Literal("{").suppress() + subdict + Literal("}").suppress())
-        | (value + Literal(";").suppress())
+        | (data_entries + Literal(";").suppress())
     )
 
     if located:
-        entry = Located(entry)
+        keyword_entry = Located(keyword_entry)
 
-    subdict <<= Dict(Group(entry)[...], asdict=not located)
+    subdict <<= Dict(Group(keyword_entry)[...], asdict=not located)
 
-    return Dict(Group(entry)[len], asdict=not located)
+    return Dict(Group(keyword_entry)[len], asdict=not located)
 
 
 _SWITCH = (
@@ -81,41 +81,42 @@ _SWITCH = (
 ).set_parse_action(lambda: False)
 _DIMENSIONS = (
     Literal("[").suppress() + common.number * 7 + Literal("]").suppress()
-).set_parse_action(lambda tks: FoamDictionaryBase.DimensionSet(*tks))
-
+).set_parse_action(lambda tks: FoamDict.DimensionSet(*tks))
 _TENSOR = _list_of(common.number) | common.number
 _IDENTIFIER = Word(identbodychars + "$", printables.replace(";", ""))
 _DIMENSIONED = (Opt(_IDENTIFIER) + _DIMENSIONS + _TENSOR).set_parse_action(
-    lambda tks: FoamDictionaryBase.Dimensioned(*reversed(tks.as_list()))
+    lambda tks: FoamDict.Dimensioned(*reversed(tks.as_list()))
 )
 _FIELD = (Keyword("uniform").suppress() + _TENSOR) | (
     Keyword("nonuniform").suppress() + _list_of(_TENSOR)
 )
 _TOKEN = QuotedString('"', unquote_results=False) | _IDENTIFIER
-_ITEM = Forward()
-_ENTRY = _dictionary_of(_IDENTIFIER, _ITEM, len=1)
-_LIST = _list_of(_ENTRY | _ITEM)
-_ITEM <<= _FIELD | _LIST | _DIMENSIONED | _DIMENSIONS | common.number | _SWITCH | _TOKEN
-
-_TOKENS = (
-    QuotedString('"', unquote_results=False) | Word(printables.replace(";", ""))
-)[2, ...].set_parse_action(lambda tks: " ".join(tks))
+_DATA = Forward()
+_KEYWORD_ENTRY = _dictionary_of(_TOKEN, _DATA, len=1)
+_DATA_ENTRY = Forward()
+_LIST_ENTRY = _KEYWORD_ENTRY | _DATA_ENTRY
+_LIST = _list_of(_LIST_ENTRY)
+_DATA_ENTRY <<= (
+    _FIELD | _LIST | _DIMENSIONED | _DIMENSIONS | common.number | _SWITCH | _TOKEN
+)
 
-_VALUE = _ITEM ^ _TOKENS
+_DATA <<= _DATA_ENTRY[1, ...].set_parse_action(
+    lambda tks: tuple(tks) if len(tks) > 1 else [tks[0]]
+)
 
 _FILE = (
-    _dictionary_of(_TOKEN, Opt(_VALUE, default=""), located=True)
+    _dictionary_of(_TOKEN, Opt(_DATA, default=""), located=True)
     .ignore(c_style_comment)
     .ignore(cpp_style_comment)
     .ignore(Literal("#include") + ... + LineEnd())  # type: ignore [no-untyped-call]
 )
 
 
-class Parsed(Mapping[Tuple[str, ...], Union[FoamDictionaryBase.Value, EllipsisType]]):
+class Parsed(Mapping[Tuple[str, ...], Union[FoamDict.Data, EllipsisType]]):
     def __init__(self, contents: str) -> None:
         self._parsed: MutableMapping[
             Tuple[str, ...],
-            Tuple[int, Union[FoamDictionaryBase.Value, EllipsisType], int],
+            Tuple[int, Union[FoamDict.Data, EllipsisType], int],
         ] = {}
         for parse_result in _FILE.parse_string(contents, parse_all=True):
             self._parsed.update(self._flatten_result(parse_result))
@@ -123,12 +124,10 @@ class Parsed(Mapping[Tuple[str, ...], Union[FoamDictionaryBase.Value, EllipsisTy
     @staticmethod
     def _flatten_result(
         parse_result: ParseResults, *, _keywords: Tuple[str, ...] = ()
-    ) -> Mapping[
-        Tuple[str, ...], Tuple[int, Union[FoamDictionaryBase.Value, EllipsisType], int]
-    ]:
+    ) -> Mapping[Tuple[str, ...], Tuple[int, Union[FoamDict.Data, EllipsisType], int]]:
         ret: MutableMapping[
             Tuple[str, ...],
-            Tuple[int, Union[FoamDictionaryBase.Value, EllipsisType], int],
+            Tuple[int, Union[FoamDict.Data, EllipsisType], int],
         ] = {}
         start = parse_result.locn_start
         assert isinstance(start, int)
@@ -136,21 +135,21 @@ class Parsed(Mapping[Tuple[str, ...], Union[FoamDictionaryBase.Value, EllipsisTy
         assert isinstance(item, Sequence)
         end = parse_result.locn_end
         assert isinstance(end, int)
-        key, *values = item
-        assert isinstance(key, str)
-        ret[(*_keywords, key)] = (start, ..., end)
-        for value in values:
-            if isinstance(value, ParseResults):
-                ret.update(Parsed._flatten_result(value, _keywords=(*_keywords, key)))
+        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, key)] = (start, value, end)
+                ret[(*_keywords, keyword)] = (start, d, end)
         return ret
 
     def __getitem__(
         self, keywords: Tuple[str, ...]
-    ) -> Union[FoamDictionaryBase.Value, EllipsisType]:
-        _, value, _ = self._parsed[keywords]
-        return value
+    ) -> Union[FoamDict.Data, EllipsisType]:
+        _, data, _ = self._parsed[keywords]
+        return data
 
     def __contains__(self, keywords: object) -> bool:
         return keywords in self._parsed
@@ -180,9 +179,9 @@ class Parsed(Mapping[Tuple[str, ...], Union[FoamDictionaryBase.Value, EllipsisTy
 
         return start, end
 
-    def as_dict(self) -> FoamDictionaryBase._Dict:
-        ret: FoamDictionaryBase._Dict = {}
-        for keywords, (_, value, _) in self._parsed.items():
+    def as_dict(self) -> FoamDict._Dict:
+        ret: FoamDict._Dict = {}
+        for keywords, (_, data, _) in self._parsed.items():
             r = ret
             for k in keywords[:-1]:
                 assert isinstance(r, dict)
@@ -191,6 +190,6 @@ class Parsed(Mapping[Tuple[str, ...], Union[FoamDictionaryBase.Value, EllipsisTy
                 r = v
 
             assert isinstance(r, dict)
-            r[keywords[-1]] = {} if value is ... else value  # type: ignore [assignment]
+            r[keywords[-1]] = {} if data is ... else data  # type: ignore [assignment]
 
         return ret

foamlib-0.3.1/foamlib/_files/_serialization.py

@@ -0,0 +1,83 @@
+import sys
+
+if sys.version_info >= (3, 9):
+    from collections.abc import Mapping
+else:
+    from typing import Mapping
+
+from .._util import is_sequence
+from ._base import FoamDict
+
+
+def serialize(
+    data: FoamDict._SetData,
+    *,
+    assume_field: bool = False,
+    assume_dimensions: bool = False,
+    assume_data_entries: bool = False,
+) -> str:
+    if isinstance(data, Mapping):
+        entries = []
+        for k, v in data.items():
+            s = serialize(
+                v,
+                assume_field=assume_field,
+                assume_dimensions=assume_dimensions,
+                assume_data_entries=True,
+            )
+            if isinstance(v, Mapping):
+                entries.append(f"{k}\n{{\n{s}\n}}")
+            elif s:
+                entries.append(f"{k} {s};")
+            else:
+                entries.append(f"{k};")
+        return "\n".join(entries)
+
+    elif isinstance(data, FoamDict.DimensionSet) or (
+        assume_dimensions and is_sequence(data) and len(data) == 7
+    ):
+        return f"[{' '.join(str(v) for v in data)}]"
+
+    elif assume_field and isinstance(data, (int, float)):
+        return f"uniform {data}"
+
+    elif assume_field and is_sequence(data):
+        if isinstance(data[0], (int, float)) and len(data) in (3, 6, 9):
+            return f"uniform {serialize(data)}"
+        elif isinstance(data[0], (int, float)):
+            return f"nonuniform List<scalar> {len(data)}{serialize(data)}"
+        elif len(data[0]) == 3:
+            return f"nonuniform List<vector> {len(data)}{serialize(data)}"
+        elif len(data[0]) == 6:
+            return f"nonuniform List<symmTensor> {len(data)}{serialize(data)}"
+        elif len(data[0]) == 9:
+            return f"nonuniform List<tensor> {len(data)}{serialize(data)}"
+        else:
+            return serialize(
+                data,
+                assume_dimensions=assume_dimensions,
+                assume_data_entries=assume_data_entries,
+            )
+
+    elif assume_data_entries and isinstance(data, tuple):
+        return " ".join(
+            serialize(v, assume_field=assume_field, assume_dimensions=assume_dimensions)
+            for v in data
+        )
+
+    elif isinstance(data, FoamDict.Dimensioned):
+        if data.name is not None:
+            return f"{data.name} {serialize(data.dimensions, assume_dimensions=True)} {serialize(data.value)}"
+        else:
+            return f"{serialize(data.dimensions, assume_dimensions=True)} {serialize(data.value)}"
+
+    elif is_sequence(data):
+        return f"({' '.join(serialize(v) for v in data)})"
+
+    elif data is True:
+        return "yes"
+    elif data is False:
+        return "no"
+
+    else:
+        return str(data)

{foamlib-0.2.10 → foamlib-0.3.1}/foamlib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.2.10
+Version: 0.3.1
 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

foamlib-0.2.10/foamlib/_files/_serialization.py

@@ -1,129 +0,0 @@
-import sys
-from contextlib import suppress
-
-if sys.version_info >= (3, 9):
-    from collections.abc import Mapping
-else:
-    from typing import Mapping
-
-from .._util import is_sequence
-from ._base import FoamDictionaryBase
-
-
-def _serialize_switch(value: FoamDictionaryBase._SetValue) -> str:
-    if value is True:
-        return "yes"
-    elif value is False:
-        return "no"
-    else:
-        raise TypeError(f"Not a bool: {type(value)}")
-
-
-def _serialize_list(
-    value: FoamDictionaryBase._SetValue,
-) -> str:
-    if is_sequence(value):
-        return f"({' '.join(_serialize_value(v) for v in value)})"
-    else:
-        raise TypeError(f"Not a valid sequence: {type(value)}")
-
-
-def _serialize_field(
-    value: FoamDictionaryBase._SetValue,
-) -> str:
-    if is_sequence(value):
-        try:
-            s = _serialize_list(value)
-        except TypeError:
-            raise TypeError(f"Not a valid field: {type(value)}") from None
-        else:
-            if not is_sequence(value[0]) and len(value) < 10:
-                return f"uniform {s}"
-            else:
-                if not is_sequence(value[0]):
-                    kind = "scalar"
-                elif len(value[0]) == 3:
-                    kind = "vector"
-                elif len(value[0]) == 6:
-                    kind = "symmTensor"
-                elif len(value[0]) == 9:
-                    kind = "tensor"
-                else:
-                    raise TypeError(
-                        f"Unsupported sequence length for field: {len(value[0])}"
-                    )
-                return f"nonuniform List<{kind}> {len(value)}{s}"
-    else:
-        return f"uniform {value}"
-
-
-def _serialize_dimensions(
-    value: FoamDictionaryBase._SetValue,
-) -> str:
-    if is_sequence(value) and len(value) == 7:
-        return f"[{' '.join(str(v) for v in value)}]"
-    else:
-        raise TypeError(f"Not a valid dimension set: {type(value)}")
-
-
-def _serialize_dimensioned(
-    value: FoamDictionaryBase._SetValue,
-) -> str:
-    if isinstance(value, FoamDictionaryBase.Dimensioned):
-        if value.name is not None:
-            return f"{value.name} {_serialize_dimensions(value.dimensions)} {_serialize_value(value.value)}"
-        else:
-            return f"{_serialize_dimensions(value.dimensions)} {_serialize_value(value.value)}"
-    else:
-        raise TypeError(f"Not a valid dimensioned value: {type(value)}")
-
-
-def _serialize_value(
-    value: FoamDictionaryBase._SetValue,
-    *,
-    assume_field: bool = False,
-    assume_dimensions: bool = False,
-) -> str:
-    if isinstance(value, FoamDictionaryBase.DimensionSet) or assume_dimensions:
-        with suppress(TypeError):
-            return _serialize_dimensions(value)
-
-    if assume_field:
-        with suppress(TypeError):
-            return _serialize_field(value)
-
-    with suppress(TypeError):
-        return _serialize_dimensioned(value)
-
-    with suppress(TypeError):
-        return _serialize_list(value)
-
-    with suppress(TypeError):
-        return _serialize_switch(value)
-
-    with suppress(TypeError):
-        return _serialize_dictionary(value)
-
-    return str(value)
-
-
-def _serialize_dictionary(
-    value: FoamDictionaryBase._SetValue,
-) -> str:
-    if isinstance(value, Mapping):
-        return "\n".join(serialize_entry(k, v) for k, v in value.items())
-    else:
-        raise TypeError(f"Not a valid dictionary: {type(value)}")
-
-
-def serialize_entry(
-    keyword: str,
-    value: FoamDictionaryBase._SetValue,
-    *,
-    assume_field: bool = False,
-    assume_dimensions: bool = False,
-) -> str:
-    try:
-        return f"{keyword}\n{{\n{_serialize_dictionary(value)}\n}}"
-    except TypeError:
-        return f"{keyword} {_serialize_value(value, assume_field=assume_field, assume_dimensions=assume_dimensions)};"