foamlib 0.6.15__tar.gz → 0.7.1__tar.gz

{foamlib-0.6.15 → foamlib-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.6.15
+Version: 0.7.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
@@ -69,13 +69,19 @@ Requires-Dist: foamlib[docs]; extra == "dev"
 [![Docker](https://github.com/gerlero/foamlib/actions/workflows/docker.yml/badge.svg)](https://github.com/gerlero/foamlib/actions/workflows/docker.yml)
 [![Docker image](https://img.shields.io/badge/docker%20image-microfluidica%2Ffoamlib-0085a0)](https://hub.docker.com/r/microfluidica/foamlib/)
 
-## 👋 Basics
+**foamlib** provides a simple, modern, ergonomic and fast Python interface for interacting with [OpenFOAM](https://www.openfoam.com).
+
+<p align="center">
+    <img alt="benchmark" src="https://github.com/gerlero/foamlib/raw/main/benchmark.png" height="250">
+    <br>
+  <i>Parsing a </i>volVectorField<i> with 200k cells.</i>
+</p>
 
-**foamlib** provides a simple, modern and ergonomic Python interface for interacting with [OpenFOAM](https://www.openfoam.com).
+## 👋 Basics
 
-It offers the following Python classes:
+**foamlib** offers the following Python classes:
 
-* [`FoamFile`](https://foamlib.readthedocs.io/en/stable/files.html#foamlib.FoamFile) (and [`FoamFieldFile`](https://foamlib.readthedocs.io/en/stable/files.html#foamlib.FoamFieldFile)): read-write access to OpenFOAM configuration and field files as if they were Python `dict`s, using `foamlib`'s own parser. Supports ASCII and binary field formats (with or without compression).
+* [`FoamFile`](https://foamlib.readthedocs.io/en/stable/files.html#foamlib.FoamFile) (and [`FoamFieldFile`](https://foamlib.readthedocs.io/en/stable/files.html#foamlib.FoamFieldFile)): read-write access to OpenFOAM configuration and field files as if they were Python `dict`s, using `foamlib`'s own parser and in-place editor. Supports ASCII and binary field formats (with or without compression).
 * [`FoamCase`](https://foamlib.readthedocs.io/en/stable/cases.html#foamlib.FoamCase): a class for configuring, running, and accessing the results of OpenFOAM cases.
 * [`AsyncFoamCase`](https://foamlib.readthedocs.io/en/stable/cases.html#foamlib.AsyncFoamCase): variant of `FoamCase` with asynchronous methods for running multiple cases at once.
 * [`AsyncSlurmFoamCase`](https://foamlib.readthedocs.io/en/stable/cases.html#foamlib.AsyncSlurmFoamCase): subclass of `AsyncFoamCase` used for running cases on a Slurm cluster.
@@ -185,7 +191,7 @@ async def cost(x):
         await clone.run(fallback=True) # Run locally if Slurm is not available
         return abs(clone[-1]["U"].internal_field[0][0])
 
-result = differential_evolution(cost, bounds=[(-1, 1)], workers=AsyncFoamCase.map, polish=False)
+result = differential_evolution(cost, bounds=[(-1, 1)], workers=AsyncSlurmFoamCase.map, polish=False)
 ```
 
 ### 📄 Use it to create a `run` (or `clean`) script

{foamlib-0.6.15 → foamlib-0.7.1}/README.md

@@ -14,13 +14,19 @@
 [![Docker](https://github.com/gerlero/foamlib/actions/workflows/docker.yml/badge.svg)](https://github.com/gerlero/foamlib/actions/workflows/docker.yml)
 [![Docker image](https://img.shields.io/badge/docker%20image-microfluidica%2Ffoamlib-0085a0)](https://hub.docker.com/r/microfluidica/foamlib/)
 
-## 👋 Basics
+**foamlib** provides a simple, modern, ergonomic and fast Python interface for interacting with [OpenFOAM](https://www.openfoam.com).
+
+<p align="center">
+    <img alt="benchmark" src="https://github.com/gerlero/foamlib/raw/main/benchmark.png" height="250">
+    <br>
+  <i>Parsing a </i>volVectorField<i> with 200k cells.</i>
+</p>
 
-**foamlib** provides a simple, modern and ergonomic Python interface for interacting with [OpenFOAM](https://www.openfoam.com).
+## 👋 Basics
 
-It offers the following Python classes:
+**foamlib** offers the following Python classes:
 
-* [`FoamFile`](https://foamlib.readthedocs.io/en/stable/files.html#foamlib.FoamFile) (and [`FoamFieldFile`](https://foamlib.readthedocs.io/en/stable/files.html#foamlib.FoamFieldFile)): read-write access to OpenFOAM configuration and field files as if they were Python `dict`s, using `foamlib`'s own parser. Supports ASCII and binary field formats (with or without compression).
+* [`FoamFile`](https://foamlib.readthedocs.io/en/stable/files.html#foamlib.FoamFile) (and [`FoamFieldFile`](https://foamlib.readthedocs.io/en/stable/files.html#foamlib.FoamFieldFile)): read-write access to OpenFOAM configuration and field files as if they were Python `dict`s, using `foamlib`'s own parser and in-place editor. Supports ASCII and binary field formats (with or without compression).
 * [`FoamCase`](https://foamlib.readthedocs.io/en/stable/cases.html#foamlib.FoamCase): a class for configuring, running, and accessing the results of OpenFOAM cases.
 * [`AsyncFoamCase`](https://foamlib.readthedocs.io/en/stable/cases.html#foamlib.AsyncFoamCase): variant of `FoamCase` with asynchronous methods for running multiple cases at once.
 * [`AsyncSlurmFoamCase`](https://foamlib.readthedocs.io/en/stable/cases.html#foamlib.AsyncSlurmFoamCase): subclass of `AsyncFoamCase` used for running cases on a Slurm cluster.
@@ -130,7 +136,7 @@ async def cost(x):
         await clone.run(fallback=True) # Run locally if Slurm is not available
         return abs(clone[-1]["U"].internal_field[0][0])
 
-result = differential_evolution(cost, bounds=[(-1, 1)], workers=AsyncFoamCase.map, polish=False)
+result = differential_evolution(cost, bounds=[(-1, 1)], workers=AsyncSlurmFoamCase.map, polish=False)
 ```
 
 ### 📄 Use it to create a `run` (or `clean`) script

{foamlib-0.6.15 → foamlib-0.7.1}/foamlib/__init__.py

@@ -1,6 +1,6 @@
 """A Python interface for interacting with OpenFOAM."""
 
-__version__ = "0.6.15"
+__version__ = "0.7.1"
 
 from ._cases import (
     AsyncFoamCase,
@@ -10,7 +10,7 @@ from ._cases import (
     FoamCaseBase,
     FoamCaseRunBase,
 )
-from ._files import FoamFieldFile, FoamFile, FoamFileBase
+from ._files import FoamFieldFile, FoamFile
 
 __all__ = [
     "AsyncFoamCase",
@@ -21,5 +21,4 @@ __all__ = [
     "FoamCaseBase",
     "FoamCaseRunBase",
     "FoamFieldFile",
-    "FoamFileBase",
 ]

{foamlib-0.6.15 → foamlib-0.7.1}/foamlib/_files/__init__.py

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

{foamlib-0.6.15 → foamlib-0.7.1}/foamlib/_files/_files.py

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

{foamlib-0.6.15 → foamlib-0.7.1}/foamlib/_files/_parsing.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import array
+import re
 import sys
 from typing import Tuple, Union, cast
 
@@ -28,15 +29,15 @@ from pyparsing import (
     ParserElement,
     ParseResults,
     QuotedString,
+    Regex,
     Word,
     common,
     counted_array,
-    cpp_style_comment,
     identchars,
     printables,
 )
 
-from ._base import FoamFileBase
+from ._types import DataEntry, Dimensioned, DimensionSet, File
 
 
 def _list_of(entry: ParserElement) -> ParserElement:
@@ -56,6 +57,59 @@ def _list_of(entry: ParserElement) -> ParserElement:
     )
 
 
+def _counted_tensor_list(*, size: int, ignore: Regex) -> ParserElement:
+    float_pattern = r"[+-]?((\d+\.?\d*(e[+-]?\d+)?)|nan|inf(inity)?)"
+    ignore_pattern = rf"(?:{ignore.re.pattern}|\s)+"
+
+    if size == 1:
+        tensor_pattern = float_pattern
+        tensor = common.ieee_float
+    else:
+        tensor_pattern = rf"\((?:{ignore_pattern})?(?:{float_pattern}{ignore_pattern}){{{size - 1}}}{float_pattern}(?:{ignore_pattern})?\)"
+        tensor = (
+            Literal("(").suppress()
+            + Group(common.ieee_float[size], aslist=True)
+            + Literal(")").suppress()
+        )
+
+    list_ = Forward()
+
+    def count_parse_action(tks: ParseResults) -> None:
+        nonlocal list_
+        length = tks[0]
+        assert isinstance(length, int)
+
+        list_ <<= Regex(
+            rf"\((?:{ignore_pattern})?(?:{tensor_pattern}{ignore_pattern}){{{length - 1}}}{tensor_pattern}(?:{ignore_pattern})?\)",
+            re.IGNORECASE,
+        )
+
+    count = common.integer.add_parse_action(count_parse_action)
+
+    def list_parse_action(
+        tks: ParseResults,
+    ) -> list[list[float]] | list[list[list[float]]]:
+        values = (
+            re.sub(ignore.re, " ", tks[0]).replace("(", " ").replace(")", " ").split()
+        )
+
+        if size == 1:
+            return [[float(v) for v in values]]
+
+        return [
+            [
+                [float(v) for v in values[i : i + size]]
+                for i in range(0, len(values), size)
+            ]
+        ]
+
+    list_.add_parse_action(list_parse_action)
+
+    return (count.suppress() + list_) | (
+        common.integer + Literal("{").suppress() + tensor + Literal("}").suppress()
+    ).set_parse_action(lambda tks: [[tks[1]] * tks[0]])
+
+
 def _keyword_entry_of(
     keyword: ParserElement,
     data_entries: ParserElement,
@@ -96,6 +150,9 @@ def _unpack_binary_field(
     return [values]
 
 
+# https://github.com/pyparsing/pyparsing/pull/584
+_COMMENT = Regex(r"(?:/\*(?:[^*]|\*(?!/))*\*/)|(?://(?:\\\n|[^\n])*)")
+
 _IDENTCHARS = identchars + "$"
 _IDENTBODYCHARS = (
     printables.replace(";", "")
@@ -120,11 +177,11 @@ _SWITCH = (
 ).set_parse_action(lambda: False)
 _DIMENSIONS = (
     Literal("[").suppress() + common.number[0, 7] + Literal("]").suppress()
-).set_parse_action(lambda tks: FoamFileBase.DimensionSet(*tks))
+).set_parse_action(lambda tks: DimensionSet(*tks))
 _TENSOR = common.ieee_float | (
     Literal("(").suppress()
     + Group(
-        common.ieee_float[9] | common.ieee_float[6] | common.ieee_float[3], aslist=True
+        common.ieee_float[3] | common.ieee_float[6] | common.ieee_float[9], aslist=True
     )
     + Literal(")").suppress()
 )
@@ -133,7 +190,7 @@ _IDENTIFIER = Combine(
     + Opt(Literal("(") + Word(_IDENTBODYCHARS, exclude_chars="()") + Literal(")"))
 )
 _DIMENSIONED = (Opt(_IDENTIFIER) + _DIMENSIONS + _TENSOR).set_parse_action(
-    lambda tks: FoamFileBase.Dimensioned(*reversed(tks.as_list()))
+    lambda tks: Dimensioned(*reversed(tks.as_list()))
 )
 _FIELD = (Keyword("uniform", _IDENTBODYCHARS).suppress() + _TENSOR) | (
     Keyword("nonuniform", _IDENTBODYCHARS).suppress()
@@ -145,7 +202,7 @@ _FIELD = (Keyword("uniform", _IDENTBODYCHARS).suppress() + _TENSOR) | (
                 Literal("scalar").suppress()
                 + Literal(">").suppress()
                 + (
-                    _list_of(common.ieee_float)
+                    _counted_tensor_list(size=1, ignore=_COMMENT)
                     | (
                         (
                             (
@@ -169,11 +226,7 @@ _FIELD = (Keyword("uniform", _IDENTBODYCHARS).suppress() + _TENSOR) | (
                 Literal("vector").suppress()
                 + Literal(">").suppress()
                 + (
-                    _list_of(
-                        Literal("(").suppress()
-                        + Group(common.ieee_float[3], aslist=True)
-                        + Literal(")").suppress()
-                    )
+                    _counted_tensor_list(size=3, ignore=_COMMENT)
                     | (
                         (
                             (
@@ -194,14 +247,10 @@ _FIELD = (Keyword("uniform", _IDENTBODYCHARS).suppress() + _TENSOR) | (
                 )
             )
             | (
-                Literal("vector").suppress()
+                Literal("symmTensor").suppress()
                 + Literal(">").suppress()
                 + (
-                    _list_of(
-                        Literal("(").suppress()
-                        + Group(common.ieee_float[6], aslist=True)
-                        + Literal(")").suppress()
-                    )
+                    _counted_tensor_list(size=6, ignore=_COMMENT)
                     | (
                         (
                             (
@@ -225,11 +274,7 @@ _FIELD = (Keyword("uniform", _IDENTBODYCHARS).suppress() + _TENSOR) | (
                 Literal("tensor").suppress()
                 + Literal(">").suppress()
                 + (
-                    _list_of(
-                        Literal("(").suppress()
-                        + Group(common.ieee_float[9], aslist=True)
-                        + Literal(")").suppress()
-                    )
+                    _counted_tensor_list(size=9, ignore=_COMMENT)
                     | (
                         (
                             (
@@ -253,46 +298,45 @@ _FIELD = (Keyword("uniform", _IDENTBODYCHARS).suppress() + _TENSOR) | (
     )
 )
 _TOKEN = QuotedString('"', unquote_results=False) | _IDENTIFIER
-_DATA = Forward()
-_KEYWORD = _TOKEN | _list_of(_IDENTIFIER).set_parse_action(
-    lambda tks: "(" + " ".join(tks[0]) + ")"
+DATA = Forward()
+KEYWORD = (
+    _TOKEN
+    | _list_of(_IDENTIFIER)
+    .set_parse_action(lambda tks: "(" + " ".join(tks[0]) + ")")
+    .ignore(_COMMENT)
+    .parse_with_tabs()
 )
-_KEYWORD_ENTRY = Dict(Group(_keyword_entry_of(_KEYWORD, _DATA)), asdict=True)
+_KEYWORD_ENTRY = Dict(Group(_keyword_entry_of(KEYWORD, DATA)), asdict=True)
 _DATA_ENTRY = Forward()
 _LIST_ENTRY = _KEYWORD_ENTRY | _DATA_ENTRY
 _LIST = _list_of(_LIST_ENTRY)
 _NUMBER = common.signed_integer ^ common.ieee_float
 _DATA_ENTRY <<= _FIELD | _LIST | _DIMENSIONED | _DIMENSIONS | _NUMBER | _SWITCH | _TOKEN
 
-_DATA <<= _DATA_ENTRY[1, ...].set_parse_action(
-    lambda tks: tuple(tks) if len(tks) > 1 else [tks[0]]
+DATA <<= (
+    _DATA_ENTRY[1, ...]
+    .set_parse_action(lambda tks: tuple(tks) if len(tks) > 1 else [tks[0]])
+    .ignore(_COMMENT)
+    .parse_with_tabs()
 )
 
 _FILE = (
     Dict(
-        Group(_keyword_entry_of(_KEYWORD, Opt(_DATA, default=""), located=True))[...]
-        + Opt(
-            Group(
-                Located(
-                    _DATA_ENTRY[1, ...].set_parse_action(
-                        lambda tks: [None, tuple(tks) if len(tks) > 1 else tks[0]]
-                    )
-                )
-            )
-        )
-        + Group(_keyword_entry_of(_KEYWORD, Opt(_DATA, default=""), located=True))[...]
+        Group(_keyword_entry_of(KEYWORD, Opt(DATA, default=""), located=True))[...]
+        + Opt(Group(Located(DATA.copy().add_parse_action(lambda tks: ["", tks[0]]))))
+        + Group(_keyword_entry_of(KEYWORD, Opt(DATA, default=""), located=True))[...]
     )
-    .ignore(cpp_style_comment)
+    .ignore(_COMMENT)
     .ignore(Literal("#include") + ... + LineEnd())  # type: ignore [no-untyped-call]
     .parse_with_tabs()
 )
 
 
-class Parsed(Mapping[Tuple[str, ...], Union[FoamFileBase._DataEntry, EllipsisType]]):
+class Parsed(Mapping[Tuple[str, ...], Union[DataEntry, EllipsisType]]):
     def __init__(self, contents: bytes) -> None:
         self._parsed: MutableMapping[
             tuple[str, ...],
-            tuple[int, FoamFileBase._DataEntry | EllipsisType, int],
+            tuple[int, DataEntry | EllipsisType, int],
         ] = {}
         for parse_result in _FILE.parse_string(
             contents.decode("latin-1"), parse_all=True
@@ -305,12 +349,10 @@ class Parsed(Mapping[Tuple[str, ...], Union[FoamFileBase._DataEntry, EllipsisTyp
     @staticmethod
     def _flatten_result(
         parse_result: ParseResults, *, _keywords: tuple[str, ...] = ()
-    ) -> Mapping[
-        tuple[str, ...], tuple[int, FoamFileBase._DataEntry | EllipsisType, int]
-    ]:
+    ) -> Mapping[tuple[str, ...], tuple[int, DataEntry | EllipsisType, int]]:
         ret: MutableMapping[
             tuple[str, ...],
-            tuple[int, FoamFileBase._DataEntry | EllipsisType, int],
+            tuple[int, DataEntry | EllipsisType, int],
         ] = {}
         start = parse_result.locn_start
         assert isinstance(start, int)
@@ -319,7 +361,8 @@ class Parsed(Mapping[Tuple[str, ...], Union[FoamFileBase._DataEntry, EllipsisTyp
         end = parse_result.locn_end
         assert isinstance(end, int)
         keyword, *data = item
-        if keyword is None:
+        assert isinstance(keyword, str)
+        if not keyword:
             assert not _keywords
             assert len(data) == 1
             assert not isinstance(data[0], ParseResults)
@@ -336,16 +379,14 @@ class Parsed(Mapping[Tuple[str, ...], Union[FoamFileBase._DataEntry, EllipsisTyp
                     ret[(*_keywords, keyword)] = (start, d, end)
         return ret
 
-    def __getitem__(
-        self, keywords: tuple[str, ...]
-    ) -> FoamFileBase._DataEntry | EllipsisType:
+    def __getitem__(self, keywords: tuple[str, ...]) -> DataEntry | EllipsisType:
         _, data, _ = self._parsed[keywords]
         return data
 
     def put(
         self,
         keywords: tuple[str, ...],
-        data: FoamFileBase._DataEntry | EllipsisType,
+        data: DataEntry | EllipsisType,
         content: bytes,
     ) -> None:
         start, end = self.entry_location(keywords, missing_ok=True)
@@ -413,14 +454,14 @@ class Parsed(Mapping[Tuple[str, ...], Union[FoamFileBase._DataEntry, EllipsisTyp
 
         return start, end
 
-    def as_dict(self) -> FoamFileBase._File:
-        ret: FoamFileBase._File = {}
+    def as_dict(self) -> File:
+        ret: File = {}
         for keywords, (_, data, _) in self._parsed.items():
             r = ret
             for k in keywords[:-1]:
                 v = r[k]
                 assert isinstance(v, dict)
-                r = cast(FoamFileBase._File, v)
+                r = cast(File, v)
 
             assert isinstance(r, dict)
             if keywords:

{foamlib-0.6.15 → foamlib-0.7.1}/foamlib/_files/_serialization.py

@@ -1,9 +1,7 @@
 from __future__ import annotations
 
 import array
-import contextlib
 import itertools
-import re
 import sys
 from enum import Enum, auto
 from typing import cast, overload
@@ -13,7 +11,8 @@ if sys.version_info >= (3, 9):
 else:
     from typing import Mapping, Sequence
 
-from ._base import FoamFileBase
+from ._parsing import DATA, KEYWORD
+from ._types import Data, DataEntry, Dimensioned, DimensionSet
 from ._util import is_sequence
 
 try:
@@ -34,24 +33,15 @@ class Kind(Enum):
     DIMENSIONS = auto()
 
 
-_TOKENS = re.compile(r'(?:[^\s"]|"(?:[^"])*")+')
-
-
 @overload
-def normalize(
-    data: FoamFileBase._DataEntry, *, kind: Kind = Kind.DEFAULT
-) -> FoamFileBase._DataEntry: ...
+def normalize(data: DataEntry, *, kind: Kind = Kind.DEFAULT) -> DataEntry: ...
 
 
 @overload
-def normalize(
-    data: FoamFileBase.Data, *, kind: Kind = Kind.DEFAULT
-) -> FoamFileBase.Data: ...
+def normalize(data: Data, *, kind: Kind = Kind.DEFAULT) -> Data: ...
 
 
-def normalize(
-    data: FoamFileBase.Data, *, kind: Kind = Kind.DEFAULT
-) -> FoamFileBase.Data:
+def normalize(data: Data, *, kind: Kind = Kind.DEFAULT) -> Data:
     if numpy and isinstance(data, np.ndarray):
         ret = data.tolist()
         assert isinstance(ret, list)
@@ -67,54 +57,30 @@ def normalize(
         and all(isinstance(d, (int, float)) for d in data)
     ):
         data = cast(Sequence[float], data)
-        return FoamFileBase.DimensionSet(*data)
+        return DimensionSet(*data)
 
     if is_sequence(data) and (kind == Kind.SINGLE_ENTRY or not isinstance(data, tuple)):
-        return [normalize(d, kind=Kind.SINGLE_ENTRY) for d in data]
-
-    if isinstance(data, str):
-        data = data.strip()
-
-        if data.startswith("(") and data.endswith(")"):
-            data = data[1:-1].split()
-            if kind == Kind.KEYWORD:
-                return "(" + " ".join(data) + ")"
-            return [normalize(d, kind=Kind.SINGLE_ENTRY) for d in data]
-
-        if data.startswith("[") and data.endswith("]"):
-            data = data[1:-1].split()
-            return normalize(data, kind=Kind.DIMENSIONS)
-
-        with contextlib.suppress(ValueError):
-            return int(data)
-
-        with contextlib.suppress(ValueError):
-            return float(data)
+        if len(data) == 1 and isinstance(data[0], Mapping) and len(data[0]) > 1:
+            return [normalize({k: v}) for k, v in data[0].items()]
 
-        if kind != Kind.KEYWORD:
-            if data in ("yes", "true", "on", "y", "t"):
-                return True
-            if data in ("no", "false", "off", "n", "f"):
-                return False
-
-        tokens: list[str] = re.findall(_TOKENS, data)
+        return [normalize(d, kind=Kind.SINGLE_ENTRY) for d in data]
 
-        if len(tokens) == 1:
-            return tokens[0]
+    if isinstance(data, Dimensioned):
+        value = normalize(data.value, kind=Kind.SINGLE_ENTRY)
+        assert isinstance(value, (int, float, list))
+        return Dimensioned(value, data.dimensions, data.name)
 
+    if isinstance(data, str):
         if kind == Kind.KEYWORD:
-            return " ".join(tokens)
-
-        return tuple(tokens)
+            data = KEYWORD.parse_string(data, parse_all=True)[0]
+            assert isinstance(data, str)
+            return data
 
-    if isinstance(data, FoamFileBase.Dimensioned):
-        value = normalize(data.value, kind=Kind.SINGLE_ENTRY)
-        assert isinstance(value, (int, float, list))
-        return FoamFileBase.Dimensioned(value, data.dimensions, data.name)
+        return cast(DataEntry, DATA.parse_string(data, parse_all=True)[0])
 
     if isinstance(
         data,
-        (int, float, bool, tuple, FoamFileBase.DimensionSet),
+        (int, float, bool, tuple, DimensionSet),
     ):
         return data
 
@@ -123,7 +89,7 @@ def normalize(
 
 
 def dumps(
-    data: FoamFileBase.Data,
+    data: Data,
     *,
     kind: Kind = Kind.DEFAULT,
 ) -> bytes:
@@ -144,7 +110,7 @@ def dumps(
 
         return b" ".join(entries)
 
-    if isinstance(data, FoamFileBase.DimensionSet):
+    if isinstance(data, DimensionSet):
         return b"[" + b" ".join(dumps(v) for v in data) + b"]"
 
     if kind in (
@@ -201,7 +167,7 @@ def dumps(
 
         return b"nonuniform List<" + tensor_kind + b"> " + dumps(len(data)) + contents
 
-    if isinstance(data, FoamFileBase.Dimensioned):
+    if isinstance(data, Dimensioned):
         if data.name is not None:
             return (
                 dumps(data.name)

foamlib-0.7.1/foamlib/_files/_types.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import sys
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Dict, NamedTuple, Optional, Tuple, Union
+
+if TYPE_CHECKING:
+    import numpy as np
+
+if sys.version_info >= (3, 9):
+    from collections.abc import Mapping, MutableMapping, Sequence
+else:
+    from typing import Mapping, MutableMapping, Sequence
+
+
+class DimensionSet(NamedTuple):
+    mass: float = 0
+    length: float = 0
+    time: float = 0
+    temperature: float = 0
+    moles: float = 0
+    current: float = 0
+    luminous_intensity: float = 0
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}({', '.join(f'{n}={v}' for n, v in zip(self._fields, self) if v != 0)})"
+
+
+Tensor = Union[
+    float,
+    Sequence[float],
+    "np.ndarray[Tuple[()], np.dtype[np.generic]]",
+    "np.ndarray[Tuple[int], np.dtype[np.generic]]",
+]
+
+
+@dataclass
+class Dimensioned:
+    value: Tensor = 0
+    dimensions: DimensionSet | Sequence[float] = ()
+    name: str | None = None
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.dimensions, DimensionSet):
+            self.dimensions = DimensionSet(*self.dimensions)
+
+
+Field = Union[
+    Tensor, Sequence[Tensor], "np.ndarray[Tuple[int, int], np.dtype[np.generic]]"
+]
+
+DataEntry = Union[
+    str,
+    int,
+    float,
+    bool,
+    Dimensioned,
+    DimensionSet,
+    Sequence["Data"],
+    Tensor,
+    Field,
+]
+
+Data = Union[
+    DataEntry,
+    Mapping[str, "Data"],
+]
+"""
+A value that can be stored in an OpenFOAM file.
+"""
+
+MutableData = Union[
+    DataEntry,
+    MutableMapping[str, "MutableData"],
+]
+
+Dict_ = Dict[str, Union["Data", "Dict_"]]
+File = Dict[Optional[str], Union["Data", "Dict_"]]

{foamlib-0.6.15 → foamlib-0.7.1}/foamlib/_files/_util.py

@@ -14,10 +14,10 @@ else:
     from typing_extensions import TypeGuard
 
 if TYPE_CHECKING:
-    from ._base import FoamFileBase
+    from ._types import Data
 
 
 def is_sequence(
-    value: FoamFileBase.Data,
-) -> TypeGuard[Sequence[FoamFileBase.Data]]:
+    value: Data,
+) -> TypeGuard[Sequence[Data]]:
     return isinstance(value, Sequence) and not isinstance(value, str)

{foamlib-0.6.15 → foamlib-0.7.1}/foamlib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.6.15
+Version: 0.7.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
@@ -69,13 +69,19 @@ Requires-Dist: foamlib[docs]; extra == "dev"
 [![Docker](https://github.com/gerlero/foamlib/actions/workflows/docker.yml/badge.svg)](https://github.com/gerlero/foamlib/actions/workflows/docker.yml)
 [![Docker image](https://img.shields.io/badge/docker%20image-microfluidica%2Ffoamlib-0085a0)](https://hub.docker.com/r/microfluidica/foamlib/)
 
-## 👋 Basics
+**foamlib** provides a simple, modern, ergonomic and fast Python interface for interacting with [OpenFOAM](https://www.openfoam.com).
+
+<p align="center">
+    <img alt="benchmark" src="https://github.com/gerlero/foamlib/raw/main/benchmark.png" height="250">
+    <br>
+  <i>Parsing a </i>volVectorField<i> with 200k cells.</i>
+</p>
 
-**foamlib** provides a simple, modern and ergonomic Python interface for interacting with [OpenFOAM](https://www.openfoam.com).
+## 👋 Basics
 
-It offers the following Python classes:
+**foamlib** offers the following Python classes:
 
-* [`FoamFile`](https://foamlib.readthedocs.io/en/stable/files.html#foamlib.FoamFile) (and [`FoamFieldFile`](https://foamlib.readthedocs.io/en/stable/files.html#foamlib.FoamFieldFile)): read-write access to OpenFOAM configuration and field files as if they were Python `dict`s, using `foamlib`'s own parser. Supports ASCII and binary field formats (with or without compression).
+* [`FoamFile`](https://foamlib.readthedocs.io/en/stable/files.html#foamlib.FoamFile) (and [`FoamFieldFile`](https://foamlib.readthedocs.io/en/stable/files.html#foamlib.FoamFieldFile)): read-write access to OpenFOAM configuration and field files as if they were Python `dict`s, using `foamlib`'s own parser and in-place editor. Supports ASCII and binary field formats (with or without compression).
 * [`FoamCase`](https://foamlib.readthedocs.io/en/stable/cases.html#foamlib.FoamCase): a class for configuring, running, and accessing the results of OpenFOAM cases.
 * [`AsyncFoamCase`](https://foamlib.readthedocs.io/en/stable/cases.html#foamlib.AsyncFoamCase): variant of `FoamCase` with asynchronous methods for running multiple cases at once.
 * [`AsyncSlurmFoamCase`](https://foamlib.readthedocs.io/en/stable/cases.html#foamlib.AsyncSlurmFoamCase): subclass of `AsyncFoamCase` used for running cases on a Slurm cluster.
@@ -185,7 +191,7 @@ async def cost(x):
         await clone.run(fallback=True) # Run locally if Slurm is not available
         return abs(clone[-1]["U"].internal_field[0][0])
 
-result = differential_evolution(cost, bounds=[(-1, 1)], workers=AsyncFoamCase.map, polish=False)
+result = differential_evolution(cost, bounds=[(-1, 1)], workers=AsyncSlurmFoamCase.map, polish=False)
 ```
 
 ### 📄 Use it to create a `run` (or `clean`) script

{foamlib-0.6.15 → foamlib-0.7.1}/foamlib.egg-info/SOURCES.txt

@@ -17,9 +17,9 @@ foamlib/_cases/_subprocess.py
 foamlib/_cases/_sync.py
 foamlib/_cases/_util.py
 foamlib/_files/__init__.py
-foamlib/_files/_base.py
 foamlib/_files/_files.py
 foamlib/_files/_io.py
 foamlib/_files/_parsing.py
 foamlib/_files/_serialization.py
+foamlib/_files/_types.py
 foamlib/_files/_util.py

foamlib-0.6.15/foamlib/_files/_base.py

@@ -1,76 +0,0 @@
-from __future__ import annotations
-
-import sys
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Dict, NamedTuple, Optional, Tuple, Union
-
-if TYPE_CHECKING:
-    import numpy as np
-
-if sys.version_info >= (3, 9):
-    from collections.abc import Mapping, MutableMapping, Sequence
-else:
-    from typing import Mapping, MutableMapping, Sequence
-
-
-class FoamFileBase:
-    class DimensionSet(NamedTuple):
-        mass: float = 0
-        length: float = 0
-        time: float = 0
-        temperature: float = 0
-        moles: float = 0
-        current: float = 0
-        luminous_intensity: float = 0
-
-        def __repr__(self) -> str:
-            return f"{type(self).__qualname__}({', '.join(f'{n}={v}' for n, v in zip(self._fields, self) if v != 0)})"
-
-    _Tensor = Union[
-        float,
-        Sequence[float],
-        "np.ndarray[Tuple[()], np.dtype[np.generic]]",
-        "np.ndarray[Tuple[int], np.dtype[np.generic]]",
-    ]
-
-    @dataclass
-    class Dimensioned:
-        value: FoamFileBase._Tensor = 0
-        dimensions: FoamFileBase.DimensionSet | Sequence[float] = ()
-        name: str | None = None
-
-        def __post_init__(self) -> None:
-            if not isinstance(self.dimensions, FoamFileBase.DimensionSet):
-                self.dimensions = FoamFileBase.DimensionSet(*self.dimensions)
-
-    _Field = Union[
-        _Tensor, Sequence[_Tensor], "np.ndarray[Tuple[int, int], np.dtype[np.generic]]"
-    ]
-
-    _DataEntry = Union[
-        str,
-        int,
-        float,
-        bool,
-        Dimensioned,
-        DimensionSet,
-        Sequence["Data"],
-        _Tensor,
-        _Field,
-    ]
-
-    Data = Union[
-        _DataEntry,
-        Mapping[str, "Data"],
-    ]
-    """
-    A value that can be stored in an OpenFOAM file.
-    """
-
-    _MutableData = Union[
-        _DataEntry,
-        MutableMapping[str, "_MutableData"],
-    ]
-
-    _Dict = Dict[str, Union["Data", "_Dict"]]
-    _File = Dict[Optional[str], Union["Data", "_Dict"]]