foamlib 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

foamlib/__init__.py

@@ -1,7 +1,7 @@
-__version__ = "0.2.1"
+__version__ = "0.2.3"
 
 from ._cases import FoamCase, AsyncFoamCase, FoamCaseBase
-from ._dictionaries import FoamFile, FoamFieldFile
+from ._dictionaries import FoamFile, FoamFieldFile, FoamDictionaryBase
 
 __all__ = [
     "FoamCase",
@@ -9,4 +9,5 @@ __all__ = [
     "FoamCaseBase",
     "FoamFile",
     "FoamFieldFile",
+    "FoamDictionaryBase",
 ]

foamlib/_cases.py

@@ -64,6 +64,14 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
             except FileNotFoundError as e:
                 raise KeyError(key) from e
 
+        def __contains__(self, obj: object) -> bool:
+            if isinstance(obj, FoamFieldFile):
+                return obj.path.parent == self.path
+            elif isinstance(obj, str):
+                return (self.path / obj).is_file()
+            else:
+                return False
+
         def __iter__(self) -> Iterator[FoamFieldFile]:
             for p in self.path.iterdir():
                 if p.is_file():

foamlib/_dictionaries/__init__.py

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

foamlib/_dictionaries/_base.py

@@ -0,0 +1,43 @@
+from abc import abstractmethod
+from dataclasses import dataclass
+from typing import Dict, NamedTuple, Optional, Sequence, Union
+
+
+class FoamDictionaryBase:
+    class DimensionSet(NamedTuple):
+        mass: Union[int, float] = 0
+        length: Union[int, float] = 0
+        time: Union[int, float] = 0
+        temperature: Union[int, float] = 0
+        moles: Union[int, float] = 0
+        current: Union[int, float] = 0
+        luminous_intensity: Union[int, 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)})"
+
+    @dataclass
+    class Dimensioned:
+        value: Union[int, float, Sequence[Union[int, float]]] = 0
+        dimensions: Union[
+            "FoamDictionaryBase.DimensionSet", Sequence[Union[int, float]]
+        ] = ()
+        name: Optional[str] = None
+
+        def __post_init__(self) -> None:
+            if not isinstance(self.dimensions, FoamDictionaryBase.DimensionSet):
+                self.dimensions = FoamDictionaryBase.DimensionSet(*self.dimensions)
+
+    Value = Union[str, int, float, bool, Dimensioned, DimensionSet, Sequence["Value"]]
+    """
+    A value that can be stored in an OpenFOAM dictionary.
+    """
+
+    _Dict = Dict[str, Union["FoamDictionaryBase.Value", "_Dict"]]
+
+    @abstractmethod
+    def as_dict(self) -> _Dict:
+        """
+        Return a nested dict representation of the dictionary.
+        """
+        raise NotImplementedError

foamlib/_dictionaries/_files.py

@@ -0,0 +1,382 @@
+from pathlib import Path
+from typing import (
+    Any,
+    Iterator,
+    Mapping,
+    MutableMapping,
+    Optional,
+    Sequence,
+    Tuple,
+    Union,
+    cast,
+)
+
+from ._base import FoamDictionaryBase
+from ._parsing import Parsed, as_dict, get_entry_locn, get_value, parse
+from ._serialization import serialize_value
+
+try:
+    import numpy as np
+    from numpy.typing import NDArray
+except ModuleNotFoundError:
+    pass
+
+
+class FoamFile(
+    FoamDictionaryBase,
+    MutableMapping[str, Union["FoamFile.Value", "FoamFile.Dictionary"]],
+):
+    """
+    An OpenFOAM dictionary file.
+
+    Use as a mutable mapping (i.e., like a dict) to access and modify entries.
+
+    Use as a context manager to make multiple changes to the file while saving all changes only once at the end.
+    """
+
+    class Dictionary(
+        FoamDictionaryBase,
+        MutableMapping[str, Union["FoamFile.Value", "FoamFile.Dictionary"]],
+    ):
+        """
+        An OpenFOAM dictionary within a file as a mutable mapping.
+        """
+
+        def __init__(self, _file: "FoamFile", _keywords: Sequence[str]) -> None:
+            self._file = _file
+            self._keywords = _keywords
+
+        def __getitem__(
+            self, keyword: str
+        ) -> Union["FoamFile.Value", "FoamFile.Dictionary"]:
+            return self._file[(*self._keywords, keyword)]
+
+        def _setitem(
+            self,
+            keyword: str,
+            value: Any,
+            *,
+            assume_field: bool = False,
+            assume_dimensions: bool = False,
+        ) -> None:
+            self._file._setitem(
+                (*self._keywords, keyword),
+                value,
+                assume_field=assume_field,
+                assume_dimensions=assume_dimensions,
+            )
+
+        def __setitem__(self, keyword: str, value: Any) -> None:
+            self._setitem(keyword, value)
+
+        def __delitem__(self, keyword: str) -> None:
+            del self._file[(*self._keywords, keyword)]
+
+        def __iter__(self) -> Iterator[str]:
+            return self._file._iter(tuple(self._keywords))
+
+        def __len__(self) -> int:
+            return len(list(iter(self)))
+
+        def __repr__(self) -> str:
+            return f"{type(self).__qualname__}({self._file}, {self._keywords})"
+
+        def as_dict(self) -> FoamDictionaryBase._Dict:
+            """
+            Return a nested dict representation of the dictionary.
+            """
+            ret = self._file.as_dict()
+
+            for k in self._keywords:
+                assert isinstance(ret, dict)
+                v = ret[k]
+                assert isinstance(v, dict)
+                ret = v
+
+            return ret
+
+    def __init__(self, path: Union[str, Path]) -> None:
+        self.path = Path(path).absolute()
+        if self.path.is_dir():
+            raise IsADirectoryError(self.path)
+        elif not self.path.is_file():
+            raise FileNotFoundError(self.path)
+
+        self._contents: Optional[str] = None
+        self._parsed: Optional[Parsed] = None
+        self._defer_io = 0
+        self._dirty = False
+
+    def __enter__(self) -> "FoamFile":
+        if self._defer_io == 0:
+            self._read()
+        self._defer_io += 1
+        return self
+
+    def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
+        self._defer_io -= 1
+        if self._defer_io == 0 and self._dirty:
+            assert self._contents is not None
+            self._write(self._contents)
+        assert not self._dirty
+
+    def _read(self) -> Tuple[str, Parsed]:
+        if not self._defer_io:
+            contents = self.path.read_text()
+            if contents != self._contents:
+                self._contents = contents
+                self._parsed = None
+
+        assert self._contents is not None
+
+        if self._parsed is None:
+            self._parsed = parse(self._contents)
+
+        return self._contents, self._parsed
+
+    def _write(self, contents: str) -> None:
+        self._contents = contents
+        self._parsed = None
+        if not self._defer_io:
+            self.path.write_text(contents)
+            self._dirty = False
+        else:
+            self._dirty = True
+
+    def __getitem__(
+        self, keywords: Union[str, Tuple[str, ...]]
+    ) -> Union["FoamFile.Value", "FoamFile.Dictionary"]:
+        if not isinstance(keywords, tuple):
+            keywords = (keywords,)
+
+        _, parsed = self._read()
+
+        value = get_value(parsed, keywords)
+
+        if value is None:
+            return FoamFile.Dictionary(self, keywords)
+        else:
+            return value
+
+    def _setitem(
+        self,
+        keywords: Union[str, Tuple[str, ...]],
+        value: Any,
+        *,
+        assume_field: bool = False,
+        assume_dimensions: bool = False,
+    ) -> None:
+        if not isinstance(keywords, tuple):
+            keywords = (keywords,)
+
+        contents, parsed = self._read()
+
+        if isinstance(value, Mapping):
+            with self:
+                if isinstance(value, FoamDictionaryBase):
+                    value = value.as_dict()
+
+                start, end = get_entry_locn(parsed, keywords, missing_ok=True)
+
+                self._write(
+                    f"{contents[:start]} {keywords[-1]} {{\n}}\n {contents[end:]}"
+                )
+
+                for k, v in value.items():
+                    self[(*keywords, k)] = v
+        else:
+            start, end = get_entry_locn(parsed, keywords, missing_ok=True)
+
+            value = serialize_value(
+                value, assume_field=assume_field, assume_dimensions=assume_dimensions
+            )
+
+            self._write(
+                f"{contents[:start]} {keywords[-1]} {value};\n {contents[end:]}"
+            )
+
+    def __setitem__(self, keywords: Union[str, Tuple[str, ...]], value: Any) -> None:
+        self._setitem(keywords, value)
+
+    def __delitem__(self, keywords: Union[str, Tuple[str, ...]]) -> None:
+        if not isinstance(keywords, tuple):
+            keywords = (keywords,)
+
+        contents, parsed = self._read()
+
+        start, end = get_entry_locn(parsed, keywords)
+
+        self._write(contents[:start] + contents[end:])
+
+    def _iter(self, keywords: Union[str, Tuple[str, ...]] = ()) -> Iterator[str]:
+        if not isinstance(keywords, tuple):
+            keywords = (keywords,)
+
+        contents = self.path.read_text()
+        parsed = parse(contents)
+
+        yield from (k[-1] for k in parsed if k[:-1] == keywords)
+
+    def __iter__(self) -> Iterator[str]:
+        return self._iter()
+
+    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 as_dict(self) -> FoamDictionaryBase._Dict:
+        """
+        Return a nested dict representation of the file.
+        """
+        _, parsed = self._read()
+        return as_dict(parsed)
+
+
+class FoamFieldFile(FoamFile):
+    """An OpenFOAM dictionary file representing a field as a mutable mapping."""
+
+    class BoundariesDictionary(FoamFile.Dictionary):
+        def __getitem__(self, keyword: str) -> "FoamFieldFile.BoundaryDictionary":
+            return cast(FoamFieldFile.BoundaryDictionary, super().__getitem__(keyword))
+
+    class BoundaryDictionary(FoamFile.Dictionary):
+        """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 __getitem__(
+        self, keywords: Union[str, Tuple[str, ...]]
+    ) -> Union[FoamFile.Value, FoamFile.Dictionary]:
+        if not isinstance(keywords, tuple):
+            keywords = (keywords,)
+
+        ret = super().__getitem__(keywords)
+        if keywords[0] == "boundaryField" and isinstance(ret, FoamFile.Dictionary):
+            if len(keywords) == 1:
+                ret = FoamFieldFile.BoundariesDictionary(self, keywords)
+            elif len(keywords) == 2:
+                ret = FoamFieldFile.BoundaryDictionary(self, keywords)
+        return ret
+
+    def __setitem__(self, keywords: Union[str, Tuple[str, ...]], value: Any) -> None:
+        if not isinstance(keywords, tuple):
+            keywords = (keywords,)
+
+        if keywords == ("internalField",):
+            self._setitem(keywords, value, assume_field=True)
+        elif keywords == ("dimensions",):
+            self._setitem(keywords, value, assume_dimensions=True)
+        else:
+            self._setitem(keywords, value)
+
+    @property
+    def dimensions(self) -> FoamFile.DimensionSet:
+        """
+        Alias of `self["dimensions"]`.
+        """
+        ret = self["dimensions"]
+        if not isinstance(ret, FoamFile.DimensionSet):
+            raise TypeError("dimensions is not a DimensionSet")
+        return ret
+
+    @dimensions.setter
+    def dimensions(
+        self, value: Union[FoamFile.DimensionSet, Sequence[Union[int, float]]]
+    ) -> None:
+        self["dimensions"] = value
+
+    @property
+    def internal_field(
+        self,
+    ) -> Union[
+        int,
+        float,
+        Sequence[Union[int, float, Sequence[Union[int, float]]]],
+        "NDArray[np.generic]",
+    ]:
+        """
+        Alias of `self["internalField"]`.
+        """
+        ret = self["internalField"]
+        if not isinstance(ret, (int, float, Sequence)):
+            raise TypeError("internalField is not a field")
+        return cast(Union[int, float, Sequence[Union[int, float]]], ret)
+
+    @internal_field.setter
+    def internal_field(
+        self,
+        value: Union[
+            int,
+            float,
+            Sequence[Union[int, float, Sequence[Union[int, float]]]],
+            "NDArray[np.generic]",
+        ],
+    ) -> None:
+        self["internalField"] = value
+
+    @property
+    def boundary_field(self) -> "FoamFieldFile.BoundariesDictionary":
+        """
+        Alias of `self["boundaryField"]`.
+        """
+        ret = self["boundaryField"]
+        if not isinstance(ret, FoamFieldFile.BoundariesDictionary):
+            assert not isinstance(ret, FoamFile.Dictionary)
+            raise TypeError("boundaryField is not a dictionary")
+        return ret

foamlib/_dictionaries/_parsing.py

@@ -0,0 +1,177 @@
+from typing import Mapping, MutableMapping, Optional, Sequence, Tuple
+
+from pyparsing import (
+    Dict,
+    Forward,
+    Group,
+    Keyword,
+    LineEnd,
+    Literal,
+    Located,
+    Opt,
+    ParseResults,
+    ParserElement,
+    QuotedString,
+    Word,
+    c_style_comment,
+    common,
+    cpp_style_comment,
+    identbodychars,
+    printables,
+)
+
+from ._base import FoamDictionaryBase
+
+_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: FoamDictionaryBase.DimensionSet(*tks))
+
+
+def _list_of(elem: ParserElement) -> ParserElement:
+    return Opt(
+        Literal("List") + Literal("<") + common.identifier + Literal(">")
+    ).suppress() + (
+        (
+            Opt(common.integer).suppress()
+            + (
+                Literal("(").suppress()
+                + Group((elem)[...], aslist=True)
+                + Literal(")").suppress()
+            )
+        )
+        | (
+            common.integer + Literal("{").suppress() + elem + Literal("}").suppress()
+        ).set_parse_action(lambda tks: [[tks[1]] * tks[0]])
+    )
+
+
+_TENSOR = _list_of(common.number) | common.number
+_IDENTIFIER = Word(identbodychars + "$", printables.replace(";", ""))
+_DIMENSIONED = (Opt(_IDENTIFIER) + _DIMENSIONS + _TENSOR).set_parse_action(
+    lambda tks: FoamDictionaryBase.Dimensioned(*reversed(tks.as_list()))
+)
+_FIELD = (Keyword("uniform").suppress() + _TENSOR) | (
+    Keyword("nonuniform").suppress() + _list_of(_TENSOR)
+)
+_TOKEN = QuotedString('"', unquote_results=False) | _IDENTIFIER
+_ITEM = Forward()
+_LIST = _list_of(_ITEM)
+_ITEM <<= (
+    _FIELD | _LIST | _DIMENSIONED | _DIMENSIONS | common.number | _YES | _NO | _TOKEN
+)
+_TOKENS = (
+    QuotedString('"', unquote_results=False) | Word(printables.replace(";", ""))
+)[2, ...].set_parse_action(lambda tks: " ".join(tks))
+
+_VALUE = _ITEM ^ _TOKENS
+
+_ENTRY = Forward()
+_DICTIONARY = Dict(Group(_ENTRY)[...])
+_ENTRY <<= Located(
+    _TOKEN
+    + (
+        (Literal("{").suppress() + _DICTIONARY + Literal("}").suppress())
+        | (Opt(_VALUE, default="") + Literal(";").suppress())
+    )
+)
+_FILE = (
+    _DICTIONARY.ignore(c_style_comment)
+    .ignore(cpp_style_comment)
+    .ignore(Literal("#include") + ... + LineEnd())  # type: ignore [no-untyped-call]
+)
+
+Parsed = Mapping[Sequence[str], Tuple[int, Optional[FoamDictionaryBase.Value], int]]
+
+
+def _flatten_result(
+    parse_result: ParseResults, *, _keywords: Sequence[str] = ()
+) -> Parsed:
+    ret: MutableMapping[
+        Sequence[str], Tuple[int, Optional[FoamDictionaryBase.Value], int]
+    ] = {}
+    start = parse_result.locn_start
+    assert isinstance(start, int)
+    item = parse_result.value
+    assert isinstance(item, Sequence)
+    end = parse_result.locn_end
+    assert isinstance(end, int)
+    key, *values = item
+    assert isinstance(key, str)
+    ret[(*_keywords, key)] = (start, None, end)
+    for value in values:
+        if isinstance(value, ParseResults):
+            ret.update(_flatten_result(value, _keywords=(*_keywords, key)))
+        else:
+            ret[(*_keywords, key)] = (start, value, end)
+    return ret
+
+
+def parse(
+    contents: str,
+) -> Parsed:
+    parse_results = _FILE.parse_string(contents, parse_all=True)
+    ret: MutableMapping[
+        Sequence[str], Tuple[int, Optional[FoamDictionaryBase.Value], int]
+    ] = {}
+    for parse_result in parse_results:
+        ret.update(_flatten_result(parse_result))
+    return ret
+
+
+def get_value(
+    parsed: Parsed,
+    keywords: Tuple[str, ...],
+) -> Optional[FoamDictionaryBase.Value]:
+    """
+    Value of an entry.
+    """
+    _, value, _ = parsed[keywords]
+    return value
+
+
+def get_entry_locn(
+    parsed: Parsed,
+    keywords: Tuple[str, ...],
+    *,
+    missing_ok: bool = False,
+) -> Tuple[int, int]:
+    """
+    Location of an entry or where it should be inserted.
+    """
+    try:
+        start, _, end = parsed[keywords]
+    except KeyError:
+        if missing_ok:
+            if len(keywords) > 1:
+                _, _, end = parsed[keywords[:-1]]
+                end -= 1
+            else:
+                end = -1
+
+            start = end
+        else:
+            raise
+
+    return start, end
+
+
+def as_dict(parsed: Parsed) -> FoamDictionaryBase._Dict:
+    """
+    Return a nested dict representation of the file.
+    """
+    ret: FoamDictionaryBase._Dict = {}
+    for keywords, (_, value, _) in parsed.items():
+
+        r = ret
+        for k in keywords[:-1]:
+            assert isinstance(r, dict)
+            v = r[k]
+            assert isinstance(v, dict)
+            r = v
+
+        assert isinstance(r, dict)
+        r[keywords[-1]] = {} if value is None else value
+
+    return ret

foamlib/_dictionaries/_serialization.py

@@ -0,0 +1,103 @@
+from contextlib import suppress
+from typing import Any, Sequence
+
+from ._base import FoamDictionaryBase
+
+try:
+    import numpy as np
+except ModuleNotFoundError:
+    numpy = False
+else:
+    numpy = True
+
+
+def _is_sequence(value: Any) -> bool:
+    return (
+        isinstance(value, Sequence)
+        and not isinstance(value, str)
+        or numpy
+        and isinstance(value, np.ndarray)
+    )
+
+
+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 _serialize_list(value: Any) -> str:
+    if _is_sequence(value):
+        return f"({' '.join(serialize_value(v) for v in value)})"
+    else:
+        raise TypeError(f"Not a valid sequence: {type(value)}")
+
+
+def _serialize_field(value: 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, FoamDictionaryBase.Dimensioned):
+        if value.name is not None:
+            return f"{value.name} {_serialize_dimensions(value.dimensions)} {serialize_value(value.value)}"
+        else:
+            return f"{_serialize_dimensions(value.dimensions)} {serialize_value(value.value)}"
+    else:
+        raise TypeError(f"Not a valid dimensioned value: {type(value)}")
+
+
+def serialize_value(
+    value: Any, *, assume_field: bool = False, assume_dimensions: bool = False
+) -> str:
+    if isinstance(value, FoamDictionaryBase.DimensionSet) or assume_dimensions:
+        with suppress(TypeError):
+            return _serialize_dimensions(value)
+
+    if assume_field:
+        with suppress(TypeError):
+            return _serialize_field(value)
+
+    with suppress(TypeError):
+        return _serialize_dimensioned(value)
+
+    with suppress(TypeError):
+        return _serialize_list(value)
+
+    with suppress(TypeError):
+        return _serialize_bool(value)
+
+    return str(value)

{foamlib-0.2.1.dist-info → foamlib-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.2.1
+Version: 0.2.3
 Summary: A Python interface for interacting with OpenFOAM
 Author-email: "Gabriel S. Gerlero" <ggerlero@cimec.unl.edu.ar>
 Project-URL: Homepage, https://github.com/gerlero/foamlib

foamlib-0.2.3.dist-info/RECORD

@@ -0,0 +1,14 @@
+foamlib/__init__.py,sha256=VYMos2oCtIAGQx88R_0tco49MZogwcC6yvwQ2oqmSmU,287
+foamlib/_cases.py,sha256=4f3c5BXnsHPhFvgXNjUcGGHyu7I0WZT6zxlvGhb9kMY,21213
+foamlib/_subprocesses.py,sha256=5vqdQvpN_2v4GgDqxi-s88NGhZ6doFxkh0XY89ZWuHA,1926
+foamlib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+foamlib/_dictionaries/__init__.py,sha256=6UWBGe1t7cq-d6WWQrVm0Xpi7Whpkr-mkTWgAM4NwcE,160
+foamlib/_dictionaries/_base.py,sha256=H8XfiaX1LD6OWwZ9m61SaKgI-_szF1udyEfiLurrCB8,1493
+foamlib/_dictionaries/_files.py,sha256=baObt7Ewf_sM-9Y5JGMFCYK1CVdNQg3vYbOfjCgQA64,11582
+foamlib/_dictionaries/_parsing.py,sha256=65kwMU6b4WmMngOR5ED8IBvMa59FQqTRmd9o0xPnWJM,4768
+foamlib/_dictionaries/_serialization.py,sha256=P_eP46c-kCXx6rIGXL7hfDuEbS9h7uANZlgXsdcNwl8,3005
+foamlib-0.2.3.dist-info/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
+foamlib-0.2.3.dist-info/METADATA,sha256=DA7Kq6YIun5m2yisx_F4DSrYP13RZKgXwq0mTTX2y9A,4600
+foamlib-0.2.3.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+foamlib-0.2.3.dist-info/top_level.txt,sha256=ZdVYtetXGwPwyfL-WhlhbTFQGAwKX5P_gXxtH9JYFPI,8
+foamlib-0.2.3.dist-info/RECORD,,

foamlib/_dictionaries.py

@@ -1,494 +0,0 @@
-from pathlib import Path
-from dataclasses import dataclass
-from collections import namedtuple
-from contextlib import suppress
-from typing import (
-    Any,
-    Union,
-    Sequence,
-    Iterator,
-    Optional,
-    Mapping,
-    MutableMapping,
-    cast,
-)
-
-from pyparsing import (
-    Dict,
-    Forward,
-    Group,
-    Keyword,
-    LineEnd,
-    Literal,
-    Located,
-    Opt,
-    QuotedString,
-    Word,
-    c_style_comment,
-    common,
-    cpp_style_comment,
-    printables,
-    identchars,
-    identbodychars,
-)
-
-try:
-    import numpy as np
-    from numpy.typing import NDArray
-except ModuleNotFoundError:
-    numpy = False
-else:
-    numpy = True
-
-from ._subprocesses import run_process, CalledProcessError
-
-
-class _FoamDictionary(MutableMapping[str, Union["FoamFile.Value", "_FoamDictionary"]]):
-
-    def __init__(self, _file: "FoamFile", _keywords: Sequence[str]) -> None:
-        self._file = _file
-        self._keywords = _keywords
-
-    def _cmd(self, args: Sequence[str], *, key: Optional[str] = None) -> str:
-        keywords = self._keywords
-
-        if key is not None:
-            keywords = [*self._keywords, key]
-
-        if keywords:
-            args = ["-entry", "/".join(keywords), *args]
-
-        try:
-            return (
-                run_process(
-                    ["foamDictionary", *args, "-precision", "15", self._file.path],
-                )
-                .stdout.decode()
-                .strip()
-            )
-        except CalledProcessError as e:
-            stderr = e.stderr.decode()
-            if "Cannot find entry" in stderr:
-                raise KeyError(key) from None
-            else:
-                raise RuntimeError(
-                    f"{e.cmd} failed with return code {e.returncode}\n{e.stderr.decode()}"
-                ) from None
-
-    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 isinstance(value, dict):
-            return _FoamDictionary(self._file, [*self._keywords, key])
-        else:
-            start, end = value
-            return _VALUE.parse_string(contents[start:end], parse_all=True).as_list()[0]
-
-    def _setitem(
-        self,
-        key: str,
-        value: Any,
-        *,
-        assume_field: bool = False,
-        assume_dimensions: bool = False,
-    ) -> None:
-        if isinstance(value, _FoamDictionary):
-            value = value._cmd(["-value"])
-        elif isinstance(value, Mapping):
-            self._cmd(["-set", "{}"], key=key)
-            subdict = self[key]
-            print(subdict)
-            assert isinstance(subdict, _FoamDictionary)
-            for k, v in value.items():
-                subdict[k] = v
-            return
-        else:
-            value = serialize(
-                value, assume_field=assume_field, assume_dimensions=assume_dimensions
-            )
-
-        if len(value) < 1000:
-            self._cmd(["-set", value], key=key)
-        else:
-            self._cmd(["-set", "_foamlib_value_"], key=key)
-            contents = self._file.path.read_text()
-            contents = contents.replace("_foamlib_value_", value, 1)
-            self._file.path.write_text(contents)
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        self._setitem(key, value)
-
-    def __delitem__(self, key: str) -> None:
-        if key not in self:
-            raise KeyError(key)
-        self._cmd(["-remove"], key=key)
-
-    def __iter__(self) -> Iterator[str]:
-        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 "FoamFile.Dictionary"
-
-
-class FoamFile(_FoamDictionary):
-    """An OpenFOAM dictionary file as a mutable mapping."""
-
-    Dictionary = _FoamDictionary
-
-    DimensionSet = namedtuple(
-        "DimensionSet",
-        [
-            "mass",
-            "length",
-            "time",
-            "temperature",
-            "moles",
-            "current",
-            "luminous_intensity",
-        ],
-        defaults=(0, 0, 0, 0, 0, 0, 0),
-    )
-
-    @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)
-
-    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, [])
-        self.path = Path(path).absolute()
-        if self.path.is_dir():
-            raise IsADirectoryError(self.path)
-        elif not self.path.is_file():
-            raise FileNotFoundError(self.path)
-
-    def __fspath__(self) -> str:
-        return str(self.path)
-
-    def __repr__(self) -> str:
-        return f"{type(self).__name__}({self.path})"
-
-
-class FoamFieldFile(FoamFile):
-    """An OpenFOAM dictionary file representing a field as a mutable mapping."""
-
-    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
-
-        def __repr__(self) -> str:
-            return "FoamFieldFile.BoundariesDictionary"
-
-    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 = FoamFieldFile.BoundariesDictionary(self, [key])
-        return ret
-
-    def __setitem__(self, key: str, value: Any) -> None:
-        if key == "internalField":
-            self._setitem(key, value, assume_field=True)
-        elif key == "dimensions":
-            self._setitem(key, value, assume_dimensions=True)
-        else:
-            self._setitem(key, value)
-
-    @property
-    def dimensions(self) -> FoamFile.DimensionSet:
-        """
-        Alias of `self["dimensions"]`.
-        """
-        ret = self["dimensions"]
-        if not isinstance(ret, FoamFile.DimensionSet):
-            raise TypeError("dimensions is not a DimensionSet")
-        return ret
-
-    @dimensions.setter
-    def dimensions(
-        self, value: Union[FoamFile.DimensionSet, Sequence[Union[int, float]]]
-    ) -> None:
-        self["dimensions"] = value
-
-    @property
-    def internal_field(
-        self,
-    ) -> Union[
-        int,
-        float,
-        Sequence[Union[int, float, Sequence[Union[int, float]]]],
-        "NDArray[np.generic]",
-    ]:
-        """
-        Alias of `self["internalField"]`.
-        """
-        ret = self["internalField"]
-        if not isinstance(ret, (int, float, Sequence)):
-            raise TypeError("internalField is not a field")
-        return cast(Union[int, float, Sequence[Union[int, float]]], ret)
-
-    @internal_field.setter
-    def internal_field(
-        self,
-        value: Union[
-            int,
-            float,
-            Sequence[Union[int, float, Sequence[Union[int, float]]]],
-            "NDArray[np.generic]",
-        ],
-    ) -> None:
-        self["internalField"] = value
-
-    @property
-    def boundary_field(self) -> "FoamFieldFile.BoundariesDictionary":
-        """
-        Alias of `self["boundaryField"]`.
-        """
-        ret = self["boundaryField"]
-        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.2.1.dist-info/RECORD

@@ -1,10 +0,0 @@
-foamlib/__init__.py,sha256=XdOd0DaoULxz-haiaIbfRNQjU3_oX2Rz7ZmKYkng1kQ,241
-foamlib/_cases.py,sha256=FL6d2_fCB9KCu9ps8Ur8ITlla3rSFsuvdvMYEXGCBM4,20923
-foamlib/_dictionaries.py,sha256=admW5ZhNvmNi6cpnOEEbESoEL5wLeiQa62o9l7ojZ8M,14828
-foamlib/_subprocesses.py,sha256=5vqdQvpN_2v4GgDqxi-s88NGhZ6doFxkh0XY89ZWuHA,1926
-foamlib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-foamlib-0.2.1.dist-info/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
-foamlib-0.2.1.dist-info/METADATA,sha256=tlM7gkY0jb3U4by5u0O59zbvSw3V8L2l5b0UrYTvMhE,4600
-foamlib-0.2.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-foamlib-0.2.1.dist-info/top_level.txt,sha256=ZdVYtetXGwPwyfL-WhlhbTFQGAwKX5P_gXxtH9JYFPI,8
-foamlib-0.2.1.dist-info/RECORD,,