foamlib 0.1.14__tar.gz → 0.2.0__tar.gz

{foamlib-0.1.14 → foamlib-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.1.14
+Version: 0.2.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
@@ -62,7 +62,7 @@ It offers the following classes (among a few others):
 
 * [`FoamCase`](https://foamlib.readthedocs.io/en/stable/#foamlib.FoamCase): a class for manipulating, executing and accessing the results of OpenFOAM cases.
 * [`AsyncFoamCase`](https://foamlib.readthedocs.io/en/stable/#foamlib.AsyncFoamCase): variant of `FoamCase` with asynchronous methods for running multiple cases at once.
-* [`FoamFile`](https://foamlib.readthedocs.io/en/stable/#foamlib.FoamFile): read-write access to OpenFOAM configuration and field files as if they were Python `dict`s (uses OpenFOAM's `foamDictionary` utility with custom parsing).
+* [`FoamFile`](https://foamlib.readthedocs.io/en/stable/#foamlib.FoamFile): read-write access to OpenFOAM configuration and field files as if they were Python `dict`s.
 
 ## Get started
 

{foamlib-0.1.14 → foamlib-0.2.0}/README.md

@@ -15,7 +15,7 @@ It offers the following classes (among a few others):
 
 * [`FoamCase`](https://foamlib.readthedocs.io/en/stable/#foamlib.FoamCase): a class for manipulating, executing and accessing the results of OpenFOAM cases.
 * [`AsyncFoamCase`](https://foamlib.readthedocs.io/en/stable/#foamlib.AsyncFoamCase): variant of `FoamCase` with asynchronous methods for running multiple cases at once.
-* [`FoamFile`](https://foamlib.readthedocs.io/en/stable/#foamlib.FoamFile): read-write access to OpenFOAM configuration and field files as if they were Python `dict`s (uses OpenFOAM's `foamDictionary` utility with custom parsing).
+* [`FoamFile`](https://foamlib.readthedocs.io/en/stable/#foamlib.FoamFile): read-write access to OpenFOAM configuration and field files as if they were Python `dict`s.
 
 ## Get started
 

foamlib-0.2.0/foamlib/__init__.py

@@ -0,0 +1,12 @@
+__version__ = "0.2.0"
+
+from ._cases import FoamCase, AsyncFoamCase, FoamCaseBase
+from ._dictionaries import FoamFile, FoamFieldFile
+
+__all__ = [
+    "FoamCase",
+    "AsyncFoamCase",
+    "FoamCaseBase",
+    "FoamFile",
+    "FoamFieldFile",
+]

{foamlib-0.1.14 → foamlib-0.2.0}/foamlib/_cases.py

@@ -24,14 +24,65 @@ from ._subprocesses import run_process, run_process_async, CalledProcessError
 from ._dictionaries import FoamFile, FoamFieldFile
 
 
-class FoamCaseBase(Sequence["FoamTimeDirectory"]):
+class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
     def __init__(self, path: Union[Path, str]):
         self.path = Path(path).absolute()
         if not self.path.is_dir():
             raise NotADirectoryError(f"{self.path} is not a directory")
 
+    class TimeDirectory(Set[FoamFieldFile]):
+        """
+        An OpenFOAM time directory in a case.
+
+        Use to access field files in the directory, e.g. `time["U"]`.
+
+        :param path: The path to the time directory.
+        """
+
+        def __init__(self, path: Union[Path, str]):
+            self.path = Path(path).absolute()
+            if not self.path.is_dir():
+                raise NotADirectoryError(f"{self.path} is not a directory")
+
+        @property
+        def time(self) -> float:
+            """
+            The time that corresponds to this directory.
+            """
+            return float(self.path.name)
+
+        @property
+        def name(self) -> str:
+            """
+            The name of this time directory.
+            """
+            return self.path.name
+
+        def __getitem__(self, key: str) -> FoamFieldFile:
+            try:
+                return FoamFieldFile(self.path / key)
+            except FileNotFoundError as e:
+                raise KeyError(key) from e
+
+        def __iter__(self) -> Iterator[FoamFieldFile]:
+            for p in self.path.iterdir():
+                if p.is_file():
+                    yield FoamFieldFile(p.name)
+
+        def __len__(self) -> int:
+            return len(list(iter(self)))
+
+        def __fspath__(self) -> str:
+            return str(self.path)
+
+        def __repr__(self) -> str:
+            return f"{type(self).__name__}({self.path})"
+
+        def __str__(self) -> str:
+            return str(self.path)
+
     @property
-    def _times(self) -> Sequence["FoamTimeDirectory"]:
+    def _times(self) -> Sequence["FoamCaseBase.TimeDirectory"]:
         times = []
         for p in self.path.iterdir():
             if p.is_dir():
@@ -40,23 +91,25 @@ class FoamCaseBase(Sequence["FoamTimeDirectory"]):
                 except ValueError:
                     pass
                 else:
-                    times.append(FoamTimeDirectory(p))
+                    times.append(FoamCaseBase.TimeDirectory(p))
 
         times.sort(key=lambda t: t.time)
 
         return times
 
     @overload
-    def __getitem__(self, index: Union[int, float, str]) -> "FoamTimeDirectory": ...
+    def __getitem__(
+        self, index: Union[int, float, str]
+    ) -> "FoamCaseBase.TimeDirectory": ...
 
     @overload
-    def __getitem__(self, index: slice) -> Sequence["FoamTimeDirectory"]: ...
+    def __getitem__(self, index: slice) -> Sequence["FoamCaseBase.TimeDirectory"]: ...
 
     def __getitem__(
         self, index: Union[int, slice, float, str]
-    ) -> Union["FoamTimeDirectory", Sequence["FoamTimeDirectory"]]:
+    ) -> Union["FoamCaseBase.TimeDirectory", Sequence["FoamCaseBase.TimeDirectory"]]:
         if isinstance(index, str):
-            return FoamTimeDirectory(self.path / str(index))
+            return FoamCaseBase.TimeDirectory(self.path / str(index))
         elif isinstance(index, float):
             for time in self._times:
                 if time.time == index:
@@ -598,55 +651,3 @@ class AsyncFoamCase(FoamCaseBase):
         )
 
         return AsyncFoamCase(dest)
-
-
-class FoamTimeDirectory(Mapping[str, FoamFieldFile]):
-    """
-    An OpenFOAM time directory in a case.
-
-    Use as a mapping to access field files in the directory, e.g. `time["U"]`.
-
-    :param path: The path to the time directory.
-    """
-
-    def __init__(self, path: Union[Path, str]):
-        self.path = Path(path).absolute()
-        if not self.path.is_dir():
-            raise NotADirectoryError(f"{self.path} is not a directory")
-
-    @property
-    def time(self) -> float:
-        """
-        The time that corresponds to this directory.
-        """
-        return float(self.path.name)
-
-    @property
-    def name(self) -> str:
-        """
-        The name of this time directory.
-        """
-        return self.path.name
-
-    def __getitem__(self, key: str) -> FoamFieldFile:
-        try:
-            return FoamFieldFile(self.path / key)
-        except FileNotFoundError as e:
-            raise KeyError(key) from e
-
-    def __iter__(self) -> Iterator[str]:
-        for p in self.path.iterdir():
-            if p.is_file():
-                yield p.name
-
-    def __len__(self) -> int:
-        return len(list(iter(self)))
-
-    def __fspath__(self) -> str:
-        return str(self.path)
-
-    def __repr__(self) -> str:
-        return f"{type(self).__name__}({self.path})"
-
-    def __str__(self) -> str:
-        return str(self.path)

{foamlib-0.1.14 → foamlib-0.2.0}/foamlib/_dictionaries.py

@@ -1,4 +1,7 @@
 from pathlib import Path
+from dataclasses import dataclass
+from collections import namedtuple
+from contextlib import suppress
 from typing import (
     Any,
     Union,
@@ -9,204 +12,38 @@ from typing import (
     MutableMapping,
     cast,
 )
-from collections import namedtuple
-from dataclasses import dataclass
-from contextlib import suppress
-
-from ._subprocesses import run_process, CalledProcessError
-
-try:
-    import numpy as np
-    from numpy.typing import NDArray
-except ModuleNotFoundError:
-    numpy = False
-else:
-    numpy = True
 
 from pyparsing import (
+    Dict,
     Forward,
     Group,
     Keyword,
+    LineEnd,
     Literal,
+    Located,
     Opt,
     QuotedString,
     Word,
+    c_style_comment,
     common,
+    cpp_style_comment,
     printables,
+    identchars,
+    identbodychars,
 )
 
-FoamDimensionSet = namedtuple(
-    "FoamDimensionSet",
-    [
-        "mass",
-        "length",
-        "time",
-        "temperature",
-        "moles",
-        "current",
-        "luminous_intensity",
-    ],
-    defaults=(0, 0, 0, 0, 0, 0, 0),
-)
-
-
-@dataclass
-class FoamDimensioned:
-    value: Union[int, float, Sequence[Union[int, float]]] = 0
-    dimensions: Union[FoamDimensionSet, Sequence[Union[int, float]]] = (
-        FoamDimensionSet()
-    )
-    name: Optional[str] = None
-
-    def __post_init__(self) -> None:
-        if not isinstance(self.dimensions, FoamDimensionSet):
-            self.dimensions = FoamDimensionSet(*self.dimensions)
-
-
-FoamValue = Union[
-    str, int, float, bool, FoamDimensioned, FoamDimensionSet, Sequence["FoamValue"]
-]
-"""
-A value that can be stored in an OpenFOAM dictionary.
-"""
-
-_YES = Keyword("yes").set_parse_action(lambda s, loc, tks: True)
-_NO = Keyword("no").set_parse_action(lambda s, loc, tks: False)
-_DIMENSIONS = (
-    Literal("[").suppress() + common.number * 7 + Literal("]").suppress()
-).set_parse_action(lambda s, loc, tks: FoamDimensionSet(*tks))
-_TOKEN = common.identifier | QuotedString('"', unquote_results=False)
-_ITEM = Forward()
-_LIST = Opt(
-    Literal("List") + Literal("<") + common.identifier + Literal(">")
-).suppress() + (
-    (
-        Opt(common.integer).suppress()
-        + Literal("(").suppress()
-        + Group(_ITEM[...])
-        + Literal(")").suppress()
-    )
-    | (
-        common.integer + Literal("{").suppress() + _ITEM + Literal("}").suppress()
-    ).set_parse_action(lambda s, loc, tks: [tks[1]] * tks[0])
-)
-_FIELD = (Keyword("uniform").suppress() + _ITEM) | (
-    Keyword("nonuniform").suppress() + _LIST
-)
-_DIMENSIONED = (Opt(common.identifier) + _DIMENSIONS + _ITEM).set_parse_action(
-    lambda s, loc, tks: FoamDimensioned(*reversed(tks.as_list()))
-)
-_ITEM <<= (
-    _FIELD | _LIST | _DIMENSIONED | _DIMENSIONS | common.number | _YES | _NO | _TOKEN
-)
-
-_TOKENS = (QuotedString('"', unquote_results=False) | Word(printables))[
-    1, ...
-].set_parse_action(lambda s, loc, tks: " ".join(tks))
-
-_VALUE = _ITEM ^ _TOKENS
-
-
-def _parse(value: str) -> FoamValue:
-    return cast(FoamValue, _VALUE.parse_string(value, parse_all=True).as_list()[0])
-
-
-def _serialize_bool(value: Any) -> str:
-    if value is True:
-        return "yes"
-    elif value is False:
-        return "no"
-    else:
-        raise TypeError(f"Not a bool: {type(value)}")
-
-
-def _is_sequence(value: Any) -> bool:
-    return (
-        isinstance(value, Sequence)
-        and not isinstance(value, str)
-        or numpy
-        and isinstance(value, np.ndarray)
-    )
-
-
-def _serialize_list(value: Any) -> str:
-    if _is_sequence(value):
-        return f"({' '.join(_serialize(v) for v in value)})"
-    else:
-        raise TypeError(f"Not a valid sequence: {type(value)}")
-
-
-def _serialize_field(value: Any) -> 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 len(value) < 10:
-                return f"uniform {s}"
-            else:
-                if isinstance(value[0], (int, float)):
-                    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: Any) -> 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: Any) -> str:
-    if isinstance(value, FoamDimensioned):
-        if value.name is not None:
-            return f"{value.name} {_serialize_dimensions(value.dimensions)} {_serialize(value.value)}"
-        else:
-            return (
-                f"{_serialize_dimensions(value.dimensions)} {_serialize(value.value)}"
-            )
-    else:
-        raise TypeError(f"Not a valid dimensioned value: {type(value)}")
-
-
-def _serialize(
-    value: Any, *, assume_field: bool = False, assume_dimensions: bool = False
-) -> str:
-    if isinstance(value, FoamDimensionSet) 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_bool(value)
+try:
+    import numpy as np
+    from numpy.typing import NDArray
+except ModuleNotFoundError:
+    numpy = False
+else:
+    numpy = True
 
-    return str(value)
+from ._subprocesses import run_process, CalledProcessError
 
 
-class FoamDictionary(MutableMapping[str, Union[FoamValue, "FoamDictionary"]]):
-    Value = FoamValue  # for backwards compatibility
+class _FoamDictionary(MutableMapping[str, Union["FoamFile.Value", "_FoamDictionary"]]):
 
     def __init__(self, _file: "FoamFile", _keywords: Sequence[str]) -> None:
         self._file = _file
@@ -238,14 +75,18 @@ class FoamDictionary(MutableMapping[str, Union[FoamValue, "FoamDictionary"]]):
                     f"{e.cmd} failed with return code {e.returncode}\n{e.stderr.decode()}"
                 ) from None
 
-    def __getitem__(self, key: str) -> Union[FoamValue, "FoamDictionary"]:
-        value = self._cmd(["-value"], key=key)
+    def __getitem__(self, key: str) -> Union["FoamFile.Value", "_FoamDictionary"]:
+        contents = self._file.path.read_text()
+        value = _DICTIONARY.parse_string(contents, parse_all=True).as_dict()
+
+        for key in [*self._keywords, key]:
+            value = value[key]
 
-        if value.startswith("{"):
-            assert value.endswith("}")
-            return FoamDictionary(self._file, [*self._keywords, key])
+        if isinstance(value, dict):
+            return _FoamDictionary(self._file, [*self._keywords, key])
         else:
-            return _parse(value)
+            start, end = value
+            return _VALUE.parse_string(contents[start:end], parse_all=True).as_list()[0]
 
     def _setitem(
         self,
@@ -255,17 +96,18 @@ class FoamDictionary(MutableMapping[str, Union[FoamValue, "FoamDictionary"]]):
         assume_field: bool = False,
         assume_dimensions: bool = False,
     ) -> None:
-        if isinstance(value, FoamDictionary):
+        if isinstance(value, _FoamDictionary):
             value = value._cmd(["-value"])
         elif isinstance(value, Mapping):
             self._cmd(["-set", "{}"], key=key)
             subdict = self[key]
-            assert isinstance(subdict, FoamDictionary)
+            print(subdict)
+            assert isinstance(subdict, _FoamDictionary)
             for k, v in value.items():
                 subdict[k] = v
             return
         else:
-            value = _serialize(
+            value = serialize(
                 value, assume_field=assume_field, assume_dimensions=assume_dimensions
             )
 
@@ -286,84 +128,53 @@ class FoamDictionary(MutableMapping[str, Union[FoamValue, "FoamDictionary"]]):
         self._cmd(["-remove"], key=key)
 
     def __iter__(self) -> Iterator[str]:
-        for key in self._cmd(["-keywords"]).splitlines():
-            if not key.startswith('"'):
-                yield key
+        value = _DICTIONARY.parse_file(self._file.path, parse_all=True).as_dict()
+
+        for key in self._keywords:
+            value = value[key]
+
+        yield from value
 
     def __len__(self) -> int:
         return len(list(iter(self)))
 
     def __repr__(self) -> str:
-        return type(self).__name__
-
-
-class FoamBoundaryDictionary(FoamDictionary):
-    """An OpenFOAM dictionary representing a boundary condition as a mutable mapping."""
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        if key == "value":
-            self._setitem(key, value, assume_field=True)
-        else:
-            self._setitem(key, value)
-
-    @property
-    def type(self) -> str:
-        """
-        Alias of `self["type"]`.
-        """
-        ret = self["type"]
-        if not isinstance(ret, str):
-            raise TypeError("type is not a string")
-        return ret
+        return "FoamFile.Dictionary"
 
-    @type.setter
-    def type(self, value: str) -> None:
-        self["type"] = value
 
-    @property
-    def value(
-        self,
-    ) -> Union[
-        int,
-        float,
-        Sequence[Union[int, float, Sequence[Union[int, float]]]],
-        "NDArray[np.generic]",
-    ]:
-        """
-        Alias of `self["value"]`.
-        """
-        ret = self["value"]
-        if not isinstance(ret, (int, float, Sequence)):
-            raise TypeError("value is not a field")
-        return cast(Union[int, float, Sequence[Union[int, float]]], ret)
+class FoamFile(_FoamDictionary):
+    """An OpenFOAM dictionary file as a mutable mapping."""
 
-    @value.setter
-    def value(
-        self,
-        value: Union[
-            int,
-            float,
-            Sequence[Union[int, float, Sequence[Union[int, float]]]],
-            "NDArray[np.generic]",
+    Dictionary = _FoamDictionary
+
+    DimensionSet = namedtuple(
+        "DimensionSet",
+        [
+            "mass",
+            "length",
+            "time",
+            "temperature",
+            "moles",
+            "current",
+            "luminous_intensity",
         ],
-    ) -> None:
-        self["value"] = value
-
-    @value.deleter
-    def value(self) -> None:
-        del self["value"]
-
+        defaults=(0, 0, 0, 0, 0, 0, 0),
+    )
 
-class FoamBoundariesDictionary(FoamDictionary):
-    def __getitem__(self, key: str) -> Union[FoamValue, FoamBoundaryDictionary]:
-        ret = super().__getitem__(key)
-        if isinstance(ret, FoamDictionary):
-            ret = FoamBoundaryDictionary(self._file, [*self._keywords, key])
-        return ret
+    @dataclass
+    class Dimensioned:
+        value: Union[int, float, Sequence[Union[int, float]]] = 0
+        dimensions: Union["FoamFile.DimensionSet", Sequence[Union[int, float]]] = ()
+        name: Optional[str] = None
 
+        def __post_init__(self) -> None:
+            if not isinstance(self.dimensions, FoamFile.DimensionSet):
+                self.dimensions = FoamFile.DimensionSet(*self.dimensions)
 
-class FoamFile(FoamDictionary):
-    """An OpenFOAM dictionary file as a mutable mapping."""
+    Value = Union[str, int, float, bool, Dimensioned, DimensionSet, Sequence["Value"]]
+    """
+    A value that can be stored in an OpenFOAM dictionary.
+    """
 
     def __init__(self, path: Union[str, Path]) -> None:
         super().__init__(self, [])
@@ -383,10 +194,80 @@ class FoamFile(FoamDictionary):
 class FoamFieldFile(FoamFile):
     """An OpenFOAM dictionary file representing a field as a mutable mapping."""
 
-    def __getitem__(self, key: str) -> Union[FoamValue, FoamDictionary]:
+    class BoundariesDictionary(_FoamDictionary):
+        def __getitem__(
+            self, key: str
+        ) -> Union["FoamFile.Value", "FoamFieldFile.BoundaryDictionary"]:
+            ret = super().__getitem__(key)
+            if isinstance(ret, _FoamDictionary):
+                ret = FoamFieldFile.BoundaryDictionary(
+                    self._file, [*self._keywords, key]
+                )
+            return ret
+
+    class BoundaryDictionary(_FoamDictionary):
+        """An OpenFOAM dictionary representing a boundary condition as a mutable mapping."""
+
+        def __setitem__(self, key: str, value: Any) -> None:
+            if key == "value":
+                self._setitem(key, value, assume_field=True)
+            else:
+                self._setitem(key, value)
+
+        @property
+        def type(self) -> str:
+            """
+            Alias of `self["type"]`.
+            """
+            ret = self["type"]
+            if not isinstance(ret, str):
+                raise TypeError("type is not a string")
+            return ret
+
+        @type.setter
+        def type(self, value: str) -> None:
+            self["type"] = value
+
+        @property
+        def value(
+            self,
+        ) -> Union[
+            int,
+            float,
+            Sequence[Union[int, float, Sequence[Union[int, float]]]],
+            "NDArray[np.generic]",
+        ]:
+            """
+            Alias of `self["value"]`.
+            """
+            ret = self["value"]
+            if not isinstance(ret, (int, float, Sequence)):
+                raise TypeError("value is not a field")
+            return cast(Union[int, float, Sequence[Union[int, float]]], ret)
+
+        @value.setter
+        def value(
+            self,
+            value: Union[
+                int,
+                float,
+                Sequence[Union[int, float, Sequence[Union[int, float]]]],
+                "NDArray[np.generic]",
+            ],
+        ) -> None:
+            self["value"] = value
+
+        @value.deleter
+        def value(self) -> None:
+            del self["value"]
+
+        def __repr__(self) -> str:
+            return "FoamFieldFile.BoundaryDictionary"
+
+    def __getitem__(self, key: str) -> Union[FoamFile.Value, _FoamDictionary]:
         ret = super().__getitem__(key)
-        if key == "boundaryField" and isinstance(ret, FoamDictionary):
-            ret = FoamBoundariesDictionary(self, [key])
+        if key == "boundaryField" and isinstance(ret, _FoamDictionary):
+            ret = FoamFieldFile.BoundariesDictionary(self, [key])
         return ret
 
     def __setitem__(self, key: str, value: Any) -> None:
@@ -397,19 +278,22 @@ class FoamFieldFile(FoamFile):
         else:
             self._setitem(key, value)
 
+    def __repr__(self) -> str:
+        return "FoamFieldFile.BoundariesDictionary"
+
     @property
-    def dimensions(self) -> FoamDimensionSet:
+    def dimensions(self) -> FoamFile.DimensionSet:
         """
         Alias of `self["dimensions"]`.
         """
         ret = self["dimensions"]
-        if not isinstance(ret, FoamDimensionSet):
+        if not isinstance(ret, FoamFile.DimensionSet):
             raise TypeError("dimensions is not a DimensionSet")
         return ret
 
     @dimensions.setter
     def dimensions(
-        self, value: Union[FoamDimensionSet, Sequence[Union[int, float]]]
+        self, value: Union[FoamFile.DimensionSet, Sequence[Union[int, float]]]
     ) -> None:
         self["dimensions"] = value
 
@@ -443,12 +327,168 @@ class FoamFieldFile(FoamFile):
         self["internalField"] = value
 
     @property
-    def boundary_field(self) -> FoamBoundariesDictionary:
+    def boundary_field(self) -> "FoamFieldFile.BoundariesDictionary":
         """
         Alias of `self["boundaryField"]`.
         """
         ret = self["boundaryField"]
-        if not isinstance(ret, FoamBoundariesDictionary):
-            assert not isinstance(ret, FoamDictionary)
+        if not isinstance(ret, FoamFieldFile.BoundariesDictionary):
+            assert not isinstance(ret, _FoamDictionary)
             raise TypeError("boundaryField is not a dictionary")
         return ret
+
+
+_YES = Keyword("yes").set_parse_action(lambda: True)
+_NO = Keyword("no").set_parse_action(lambda: False)
+_DIMENSIONS = (
+    Literal("[").suppress() + common.number * 7 + Literal("]").suppress()
+).set_parse_action(lambda tks: FoamFile.DimensionSet(*tks))
+_TOKEN = QuotedString('"', unquote_results=False) | Word(
+    identchars + "$", identbodychars
+)
+_ITEM = Forward()
+_LIST = Opt(
+    Literal("List") + Literal("<") + common.identifier + Literal(">")
+).suppress() + (
+    (
+        Opt(common.integer).suppress()
+        + Literal("(").suppress()
+        + Group(_ITEM[...])
+        + Literal(")").suppress()
+    )
+    | (
+        common.integer + Literal("{").suppress() + _ITEM + Literal("}").suppress()
+    ).set_parse_action(lambda tks: [tks[1]] * tks[0])
+)
+_FIELD = (Keyword("uniform").suppress() + _ITEM) | (
+    Keyword("nonuniform").suppress() + _LIST
+)
+_DIMENSIONED = (Opt(common.identifier) + _DIMENSIONS + _ITEM).set_parse_action(
+    lambda tks: FoamFile.Dimensioned(*reversed(tks.as_list()))
+)
+_ITEM <<= (
+    _FIELD | _LIST | _DIMENSIONED | _DIMENSIONS | common.number | _YES | _NO | _TOKEN
+)
+
+_TOKENS = (
+    QuotedString('"', unquote_results=False)
+    | Word(printables.replace(";", "").replace("{", "").replace("}", ""))
+)[2, ...].set_parse_action(lambda tks: " ".join(tks))
+
+_VALUE = (_ITEM ^ _TOKENS).ignore(c_style_comment).ignore(cpp_style_comment)
+
+
+_UNPARSED_VALUE = (
+    QuotedString('"', unquote_results=False)
+    | Word(printables.replace(";", "").replace("{", "").replace("}", ""))
+)[...]
+_KEYWORD = QuotedString('"', unquote_results=False) | Word(
+    identchars + "$(,.)", identbodychars + "$(,.)"
+)
+_DICTIONARY = Forward()
+_ENTRY = _KEYWORD + (
+    (
+        Located(_UNPARSED_VALUE).set_parse_action(lambda tks: (tks[0], tks[2]))
+        + Literal(";").suppress()
+    )
+    | (Literal("{").suppress() + _DICTIONARY + Literal("}").suppress())
+)
+_DICTIONARY <<= (
+    Dict(Group(_ENTRY)[...])
+    .set_parse_action(lambda tks: {} if not tks else tks)
+    .ignore(c_style_comment)
+    .ignore(cpp_style_comment)
+    .ignore(Literal("#include") + ... + LineEnd())  # type: ignore
+)
+
+
+def _serialize_bool(value: Any) -> str:
+    if value is True:
+        return "yes"
+    elif value is False:
+        return "no"
+    else:
+        raise TypeError(f"Not a bool: {type(value)}")
+
+
+def _is_sequence(value: Any) -> bool:
+    return (
+        isinstance(value, Sequence)
+        and not isinstance(value, str)
+        or numpy
+        and isinstance(value, np.ndarray)
+    )
+
+
+def _serialize_list(value: Any) -> str:
+    if _is_sequence(value):
+        return f"({' '.join(serialize(v) for v in value)})"
+    else:
+        raise TypeError(f"Not a valid sequence: {type(value)}")
+
+
+def _serialize_field(value: Any) -> 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 len(value) < 10:
+                return f"uniform {s}"
+            else:
+                if isinstance(value[0], (int, float)):
+                    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: Any) -> 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: Any) -> str:
+    if isinstance(value, FoamFile.Dimensioned):
+        if value.name is not None:
+            return f"{value.name} {_serialize_dimensions(value.dimensions)} {serialize(value.value)}"
+        else:
+            return f"{_serialize_dimensions(value.dimensions)} {serialize(value.value)}"
+    else:
+        raise TypeError(f"Not a valid dimensioned value: {type(value)}")
+
+
+def serialize(
+    value: Any, *, assume_field: bool = False, assume_dimensions: bool = False
+) -> str:
+    if isinstance(value, FoamFile.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_bool(value)
+
+    return str(value)

{foamlib-0.1.14 → foamlib-0.2.0}/foamlib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.1.14
+Version: 0.2.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
@@ -62,7 +62,7 @@ It offers the following classes (among a few others):
 
 * [`FoamCase`](https://foamlib.readthedocs.io/en/stable/#foamlib.FoamCase): a class for manipulating, executing and accessing the results of OpenFOAM cases.
 * [`AsyncFoamCase`](https://foamlib.readthedocs.io/en/stable/#foamlib.AsyncFoamCase): variant of `FoamCase` with asynchronous methods for running multiple cases at once.
-* [`FoamFile`](https://foamlib.readthedocs.io/en/stable/#foamlib.FoamFile): read-write access to OpenFOAM configuration and field files as if they were Python `dict`s (uses OpenFOAM's `foamDictionary` utility with custom parsing).
+* [`FoamFile`](https://foamlib.readthedocs.io/en/stable/#foamlib.FoamFile): read-write access to OpenFOAM configuration and field files as if they were Python `dict`s.
 
 ## Get started
 

{foamlib-0.1.14 → foamlib-0.2.0}/pyproject.toml

@@ -61,9 +61,6 @@ Homepage = "https://github.com/gerlero/foamlib"
 Repository = "https://github.com/gerlero/foamlib"
 Documentation = "https://foamlib.readthedocs.io"
 
-[tool.setuptools]
-packages = ["foamlib"]
-
 [tool.setuptools.dynamic]
 version = {attr = "foamlib.__version__"}
 

{foamlib-0.1.14 → foamlib-0.2.0}/tests/test_dictionaries.py

@@ -7,40 +7,54 @@ from typing import Sequence
 import numpy as np
 
 from foamlib import *
-from foamlib._dictionaries import _parse
-
-
-def test_parse() -> None:
-    assert _parse("1") == 1
-    assert _parse("1.0") == 1.0
-    assert _parse("1.0e-3") == 1.0e-3
-    assert _parse("yes") is True
-    assert _parse("no") is False
-    assert _parse("word") == "word"
-    assert _parse("word word") == "word word"
-    assert _parse('"a string"') == '"a string"'
-    assert _parse("uniform 1") == 1
-    assert _parse("uniform 1.0") == 1.0
-    assert _parse("uniform 1.0e-3") == 1.0e-3
-    assert _parse("(1.0 2.0 3.0)") == [1.0, 2.0, 3.0]
-    assert _parse("nonuniform List<scalar> 2(1 2)") == [1, 2]
-    assert _parse("3(1 2 3)") == [1, 2, 3]
-    assert _parse("2((1 2 3) (4 5 6))") == [[1, 2, 3], [4, 5, 6]]
-    assert _parse("nonuniform List<vector> 2((1 2 3) (4 5 6))") == [
+from foamlib._dictionaries import _VALUE
+
+
+def test_parse_value() -> None:
+    assert _VALUE.parse_string("1").as_list()[0] == 1
+    assert _VALUE.parse_string("1.0").as_list()[0] == 1.0
+    assert _VALUE.parse_string("1.0e-3").as_list()[0] == 1.0e-3
+    assert _VALUE.parse_string("yes").as_list()[0] is True
+    assert _VALUE.parse_string("no").as_list()[0] is False
+    assert _VALUE.parse_string("word").as_list()[0] == "word"
+    assert _VALUE.parse_string("word word").as_list()[0] == "word word"
+    assert _VALUE.parse_string('"a string"').as_list()[0] == '"a string"'
+    assert _VALUE.parse_string("uniform 1").as_list()[0] == 1
+    assert _VALUE.parse_string("uniform 1.0").as_list()[0] == 1.0
+    assert _VALUE.parse_string("uniform 1.0e-3").as_list()[0] == 1.0e-3
+    assert _VALUE.parse_string("(1.0 2.0 3.0)").as_list()[0] == [1.0, 2.0, 3.0]
+    assert _VALUE.parse_string("uniform (1 2 3)").as_list()[0] == [1, 2, 3]
+    assert _VALUE.parse_string("nonuniform List<scalar> 2(1 2)").as_list()[0] == [1, 2]
+    assert _VALUE.parse_string("3(1 2 3)").as_list()[0] == [1, 2, 3]
+    assert _VALUE.parse_string("2((1 2 3) (4 5 6))").as_list()[0] == [
         [1, 2, 3],
         [4, 5, 6],
     ]
-    assert _parse("[1 1 -2 0 0 0 0]") == FoamDimensionSet(mass=1, length=1, time=-2)
-    assert _parse("g [1 1 -2 0 0 0 0] (0 0 -9.81)") == FoamDimensioned(
+    assert _VALUE.parse_string("nonuniform List<vector> 2((1 2 3) (4 5 6))").as_list()[
+        0
+    ] == [
+        [1, 2, 3],
+        [4, 5, 6],
+    ]
+    assert _VALUE.parse_string("[1 1 -2 0 0 0 0]").as_list()[
+        0
+    ] == FoamFile.DimensionSet(mass=1, length=1, time=-2)
+    assert _VALUE.parse_string("g [1 1 -2 0 0 0 0] (0 0 -9.81)").as_list()[
+        0
+    ] == FoamFile.Dimensioned(
         name="g",
-        dimensions=FoamDimensionSet(mass=1, length=1, time=-2),
+        dimensions=FoamFile.DimensionSet(mass=1, length=1, time=-2),
         value=[0, 0, -9.81],
     )
-    assert _parse("[1 1 -2 0 0 0 0] 9.81") == FoamDimensioned(
-        dimensions=FoamDimensionSet(mass=1, length=1, time=-2), value=9.81
+    assert _VALUE.parse_string("[1 1 -2 0 0 0 0] 9.81").as_list()[
+        0
+    ] == FoamFile.Dimensioned(
+        dimensions=FoamFile.DimensionSet(mass=1, length=1, time=-2), value=9.81
     )
     assert (
-        _parse("hex (0 1 2 3 4 5 6 7) (1 1 1) simpleGrading (1 1 1)")
+        _VALUE.parse_string(
+            "hex (0 1 2 3 4 5 6 7) (1 1 1) simpleGrading (1 1 1)"
+        ).as_list()[0]
         == "hex (0 1 2 3 4 5 6 7) (1 1 1) simpleGrading (1 1 1)"
     )
 
@@ -70,21 +84,21 @@ def test_write_read(tmp_path: Path) -> None:
 
     d["subdict"] = {"key": "value"}
     sd = d["subdict"]
-    assert isinstance(sd, FoamDictionary)
+    assert isinstance(sd, FoamFile.Dictionary)
     assert sd["key"] == "value"
     assert len(sd) == 1
     assert list(sd) == ["key"]
 
     d["subdict2"] = d["subdict"]
     sd2 = d["subdict2"]
-    assert isinstance(sd2, FoamDictionary)
+    assert isinstance(sd2, FoamFile.Dictionary)
     assert sd2["key"] == "value"
     assert len(sd) == 1
     assert list(sd) == ["key"]
 
     sd["subsubdict"] = d["subdict"]
     ssd = sd["subsubdict"]
-    assert isinstance(ssd, FoamDictionary)
+    assert isinstance(ssd, FoamFile.Dictionary)
     assert ssd["key"] == "value"
 
     sd["list"] = [1, 2, 3]
@@ -93,12 +107,12 @@ def test_write_read(tmp_path: Path) -> None:
     sd["nestedList"] = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
     assert sd["nestedList"] == [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
 
-    sd["g"] = FoamDimensioned(
+    sd["g"] = FoamFile.Dimensioned(
         name="g", dimensions=[1, 1, -2, 0, 0, 0, 0], value=[0, 0, -9.81]
     )
-    assert sd["g"] == FoamDimensioned(
+    assert sd["g"] == FoamFile.Dimensioned(
         name="g",
-        dimensions=FoamDimensionSet(mass=1, length=1, time=-2),
+        dimensions=FoamFile.DimensionSet(mass=1, length=1, time=-2),
         value=[0, 0, -9.81],
     )
 
@@ -114,17 +128,17 @@ def pitz(tmp_path: Path) -> FoamCase:
 
 
 def test_dimensions(pitz: FoamCase) -> None:
-    assert pitz[0]["p"].dimensions == FoamDimensionSet(length=2, time=-2)
-    assert pitz[0]["U"].dimensions == FoamDimensionSet(length=1, time=-1)
+    assert pitz[0]["p"].dimensions == FoamFile.DimensionSet(length=2, time=-2)
+    assert pitz[0]["U"].dimensions == FoamFile.DimensionSet(length=1, time=-1)
 
-    pitz[0]["p"].dimensions = FoamDimensionSet(mass=1, length=1, time=-2)
+    pitz[0]["p"].dimensions = FoamFile.DimensionSet(mass=1, length=1, time=-2)
 
-    assert pitz[0]["p"].dimensions == FoamDimensionSet(mass=1, length=1, time=-2)
+    assert pitz[0]["p"].dimensions == FoamFile.DimensionSet(mass=1, length=1, time=-2)
 
 
 def test_boundary_field(pitz: FoamCase) -> None:
     outlet = pitz[0]["p"].boundary_field["outlet"]
-    assert isinstance(outlet, FoamBoundaryDictionary)
+    assert isinstance(outlet, FoamFieldFile.BoundaryDictionary)
     assert outlet.type == "fixedValue"
     assert outlet.value == 0
 
@@ -182,7 +196,7 @@ def test_internal_field(pitz: FoamCase) -> None:
 
 def test_fv_schemes(pitz: FoamCase) -> None:
     div_schemes = pitz.fv_schemes["divSchemes"]
-    assert isinstance(div_schemes, FoamDictionary)
+    assert isinstance(div_schemes, FoamFile.Dictionary)
     scheme = div_schemes["div(phi,U)"]
     assert isinstance(scheme, str)
     assert scheme == "bounded Gauss linearUpwind grad(U)"

foamlib-0.1.14/foamlib/__init__.py

@@ -1,26 +0,0 @@
-__version__ = "0.1.14"
-
-from ._cases import FoamCase, AsyncFoamCase, FoamTimeDirectory, FoamCaseBase
-from ._dictionaries import (
-    FoamFile,
-    FoamFieldFile,
-    FoamDictionary,
-    FoamBoundariesDictionary,
-    FoamBoundaryDictionary,
-    FoamDimensioned,
-    FoamDimensionSet,
-)
-
-__all__ = [
-    "FoamCase",
-    "AsyncFoamCase",
-    "FoamTimeDirectory",
-    "FoamCaseBase",
-    "FoamFile",
-    "FoamFieldFile",
-    "FoamDictionary",
-    "FoamBoundariesDictionary",
-    "FoamBoundaryDictionary",
-    "FoamDimensioned",
-    "FoamDimensionSet",
-]