foamlib 0.6.14__tar.gz → 0.7.0__tar.gz

{foamlib-0.6.14 → foamlib-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.6.14
+Version: 0.7.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
@@ -169,24 +169,23 @@ U = FoamFieldFile(Path(my_pitz) / "0/U")
 print(U.internal_field)
 ```
 
-### 🔁 Run an optimization loop in parallel
+### 🔁 Run an optimization loop on a Slurm-based cluster
 
 ```python
 import os
 from pathlib import Path
-from foamlib import AsyncFoamCase
+from foamlib import AsyncSlurmFoamCase
 from scipy.optimize import differential_evolution
 
-base = AsyncFoamCase(Path(os.environ["FOAM_TUTORIALS"]) / "incompressible/simpleFoam/pitzDaily")
-# Replace with `AsyncSlurmFoamCase` if on a cluster and you want cases to be run as Slurm jobs
+base = AsyncSlurmFoamCase(Path(os.environ["FOAM_TUTORIALS"]) / "incompressible/simpleFoam/pitzDaily")
 
 async def cost(x):
     async with base.clone() as clone:
         clone[0]["U"].boundary_field["inlet"].value = [x[0], 0, 0]
-        await clone.run()
+        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.14 → foamlib-0.7.0}/README.md

@@ -114,24 +114,23 @@ U = FoamFieldFile(Path(my_pitz) / "0/U")
 print(U.internal_field)
 ```
 
-### 🔁 Run an optimization loop in parallel
+### 🔁 Run an optimization loop on a Slurm-based cluster
 
 ```python
 import os
 from pathlib import Path
-from foamlib import AsyncFoamCase
+from foamlib import AsyncSlurmFoamCase
 from scipy.optimize import differential_evolution
 
-base = AsyncFoamCase(Path(os.environ["FOAM_TUTORIALS"]) / "incompressible/simpleFoam/pitzDaily")
-# Replace with `AsyncSlurmFoamCase` if on a cluster and you want cases to be run as Slurm jobs
+base = AsyncSlurmFoamCase(Path(os.environ["FOAM_TUTORIALS"]) / "incompressible/simpleFoam/pitzDaily")
 
 async def cost(x):
     async with base.clone() as clone:
         clone[0]["U"].boundary_field["inlet"].value = [x[0], 0, 0]
-        await clone.run()
+        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.14 → foamlib-0.7.0}/foamlib/__init__.py

@@ -1,6 +1,6 @@
 """A Python interface for interacting with OpenFOAM."""
 
-__version__ = "0.6.14"
+__version__ = "0.7.0"
 
 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.14 → foamlib-0.7.0}/foamlib/_files/__init__.py

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

{foamlib-0.6.14 → foamlib-0.7.0}/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,14 +190,16 @@ 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):
             keywords = (keywords,)
 
+        if keywords and not isinstance(normalize(keywords[-1], kind=Kind.KEYWORD), str):
+            msg = f"Invalid keyword: {keywords[-1]}"
+            raise ValueError(msg)
+
         with self:
             try:
                 write_header = (
@@ -293,7 +304,7 @@ class FoamFile(
                     ...,
                     before
                     + indentation
-                    + dumps(keywords[-1])
+                    + dumps(keywords[-1], kind=Kind.KEYWORD)
                     + b"\n"
                     + indentation
                     + b"{\n"
@@ -311,7 +322,7 @@ class FoamFile(
                     normalize(data, kind=kind),
                     before
                     + indentation
-                    + dumps(keywords[-1])
+                    + dumps(keywords[-1], kind=Kind.KEYWORD)
                     + b" "
                     + dumps(data, kind=kind)
                     + b";"
@@ -364,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.
 
@@ -407,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
 
@@ -427,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):
@@ -442,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
 
@@ -479,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.14 → foamlib-0.7.0}/foamlib/_files/_parsing.py

@@ -36,7 +36,7 @@ from pyparsing import (
     printables,
 )
 
-from ._base import FoamFileBase
+from ._types import DataEntry, Dimensioned, DimensionSet, File
 
 
 def _list_of(entry: ParserElement) -> ParserElement:
@@ -120,7 +120,7 @@ _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(
@@ -133,7 +133,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()
@@ -253,24 +253,24 @@ _FIELD = (Keyword("uniform", _IDENTBODYCHARS).suppress() + _TENSOR) | (
     )
 )
 _TOKEN = QuotedString('"', unquote_results=False) | _IDENTIFIER
-_DATA = Forward()
-_KEYWORD = _TOKEN | _list_of(_IDENTIFIER).set_parse_action(
+DATA = Forward()
+KEYWORD = _TOKEN | _list_of(_IDENTIFIER).set_parse_action(
     lambda tks: "(" + " ".join(tks[0]) + ")"
 )
-_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(
+DATA <<= _DATA_ENTRY[1, ...].set_parse_action(
     lambda tks: tuple(tks) if len(tks) > 1 else [tks[0]]
 )
 
 _FILE = (
     Dict(
-        Group(_keyword_entry_of(_KEYWORD, Opt(_DATA, default=""), located=True))[...]
+        Group(_keyword_entry_of(KEYWORD, Opt(DATA, default=""), located=True))[...]
         + Opt(
             Group(
                 Located(
@@ -280,7 +280,7 @@ _FILE = (
                 )
             )
         )
-        + Group(_keyword_entry_of(_KEYWORD, Opt(_DATA, default=""), located=True))[...]
+        + Group(_keyword_entry_of(KEYWORD, Opt(DATA, default=""), located=True))[...]
     )
     .ignore(cpp_style_comment)
     .ignore(Literal("#include") + ... + LineEnd())  # type: ignore [no-untyped-call]
@@ -288,11 +288,11 @@ _FILE = (
 )
 
 
-class Parsed(Mapping[Tuple[str, ...], Union[FoamFileBase._DataEntry, EllipsisType]]):
+class Parsed(Mapping[Tuple[str, ...], Union[DataEntry, EllipsisType]]):
     def __init__(self, contents: bytes) -> None:
         self._parsed: MutableMapping[
             tuple[str, ...],
-            tuple[int, FoamFileBase._DataEntry | EllipsisType, int],
+            tuple[int, DataEntry | EllipsisType, int],
         ] = {}
         for parse_result in _FILE.parse_string(
             contents.decode("latin-1"), parse_all=True
@@ -305,12 +305,10 @@ 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)
@@ -336,16 +334,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 +409,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.14 → foamlib-0.7.0}/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:
@@ -26,6 +25,7 @@ except ModuleNotFoundError:
 
 class Kind(Enum):
     DEFAULT = auto()
+    KEYWORD = auto()
     SINGLE_ENTRY = auto()
     ASCII_FIELD = auto()
     DOUBLE_PRECISION_BINARY_FIELD = auto()
@@ -33,34 +33,20 @@ 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)
         return ret
 
-    if kind == Kind.SINGLE_ENTRY and isinstance(data, tuple):
-        ret = normalize(list(data))
-        assert isinstance(ret, list)
-        return ret
-
     if isinstance(data, Mapping):
         return {k: normalize(v, kind=kind) for k, v in data.items()}
 
@@ -71,33 +57,30 @@ def normalize(
         and all(isinstance(d, (int, float)) for d in data)
     ):
         data = cast(Sequence[float], data)
-        return FoamFileBase.DimensionSet(*data)
-
-    if is_sequence(data) and not isinstance(data, tuple):
-        return [normalize(d, kind=Kind.SINGLE_ENTRY) for d in data]
-
-    if isinstance(data, str):
-        with contextlib.suppress(ValueError):
-            return int(data)
-
-        with contextlib.suppress(ValueError):
-            return float(data)
+        return DimensionSet(*data)
 
-        tokens: list[str] = re.findall(_TOKENS, data)
+    if is_sequence(data) and (kind == Kind.SINGLE_ENTRY or not isinstance(data, tuple)):
+        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 len(tokens) == 1:
-            return tokens[0]
-
-        return tuple(tokens) if kind != Kind.SINGLE_ENTRY else " ".join(tokens)
+        return [normalize(d, kind=Kind.SINGLE_ENTRY) for d in data]
 
-    if isinstance(data, FoamFileBase.Dimensioned):
+    if isinstance(data, Dimensioned):
         value = normalize(data.value, kind=Kind.SINGLE_ENTRY)
         assert isinstance(value, (int, float, list))
-        return FoamFileBase.Dimensioned(value, data.dimensions, data.name)
+        return Dimensioned(value, data.dimensions, data.name)
+
+    if isinstance(data, str):
+        if kind == Kind.KEYWORD:
+            data = KEYWORD.parse_string(data, parse_all=True)[0]
+            assert isinstance(data, str)
+            return data
+
+        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
 
@@ -106,7 +89,7 @@ def normalize(
 
 
 def dumps(
-    data: FoamFileBase.Data,
+    data: Data,
     *,
     kind: Kind = Kind.DEFAULT,
 ) -> bytes:
@@ -115,16 +98,19 @@ def dumps(
     if isinstance(data, Mapping):
         entries = []
         for k, v in data.items():
-            if isinstance(v, Mapping):
-                entries.append(dumps(k) + b" {" + dumps(v) + b"}")
-            elif not v:
-                entries.append(dumps(k) + b";")
+            value = normalize(v)
+            if isinstance(value, Mapping):
+                entries.append(
+                    dumps(k, kind=Kind.KEYWORD) + b" {" + dumps(value) + b"}"
+                )
+            elif not value:
+                entries.append(dumps(k, kind=Kind.KEYWORD) + b";")
             else:
-                entries.append(dumps(k) + b" " + dumps(v) + b";")
+                entries.append(dumps(k, kind=Kind.KEYWORD) + b" " + dumps(value) + b";")
 
         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 (
@@ -181,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.0/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.14 → foamlib-0.7.0}/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.14 → foamlib-0.7.0}/foamlib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.6.14
+Version: 0.7.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
@@ -169,24 +169,23 @@ U = FoamFieldFile(Path(my_pitz) / "0/U")
 print(U.internal_field)
 ```
 
-### 🔁 Run an optimization loop in parallel
+### 🔁 Run an optimization loop on a Slurm-based cluster
 
 ```python
 import os
 from pathlib import Path
-from foamlib import AsyncFoamCase
+from foamlib import AsyncSlurmFoamCase
 from scipy.optimize import differential_evolution
 
-base = AsyncFoamCase(Path(os.environ["FOAM_TUTORIALS"]) / "incompressible/simpleFoam/pitzDaily")
-# Replace with `AsyncSlurmFoamCase` if on a cluster and you want cases to be run as Slurm jobs
+base = AsyncSlurmFoamCase(Path(os.environ["FOAM_TUTORIALS"]) / "incompressible/simpleFoam/pitzDaily")
 
 async def cost(x):
     async with base.clone() as clone:
         clone[0]["U"].boundary_field["inlet"].value = [x[0], 0, 0]
-        await clone.run()
+        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.14 → foamlib-0.7.0}/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.14/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"]]