foamlib 0.2.9__py3-none-any.whl → 0.3.0__py3-none-any.whl

foamlib/_dictionaries/_files.py

@@ -1,422 +0,0 @@
-import sys
-from copy import deepcopy
-from pathlib import Path
-from types import TracebackType
-from typing import (
-    Any,
-    Optional,
-    Tuple,
-    Type,
-    Union,
-    cast,
-)
-
-if sys.version_info >= (3, 9):
-    from collections.abc import Iterator, Mapping, MutableMapping, Sequence
-else:
-    from typing import Iterator, Mapping, MutableMapping, Sequence
-
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
-
-try:
-    import numpy as np
-    from numpy.typing import NDArray
-except ModuleNotFoundError:
-    pass
-
-from ._base import FoamDictionaryBase
-from ._parsing import Parsed, as_dict, get_entry_locn, get_value, parse
-from ._serialization import serialize_entry
-
-
-class _FoamFileBase:
-    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) -> Self:
-        if self.__defer_io == 0:
-            self._read()
-        self.__defer_io += 1
-        return self
-
-    def __exit__(
-        self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
-    ) -> 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:
-            parsed = parse(self.__contents)
-            self.__parsed = parsed
-        else:
-            parsed = deepcopy(self.__parsed)
-
-        return self.__contents, 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
-
-
-class FoamFile(
-    _FoamFileBase,
-    FoamDictionaryBase,
-    MutableMapping[
-        Union[str, Tuple[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: "FoamFile._SetValue") -> 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 __contains__(self, keyword: object) -> bool:
-            return (*self._keywords, keyword) in self._file
-
-        def __len__(self) -> int:
-            return len(list(iter(self)))
-
-        def update(self, *args: Any, **kwargs: Any) -> None:
-            with self._file:
-                super().update(*args, **kwargs)
-
-        def clear(self) -> None:
-            with self._file:
-                super().clear()
-
-        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 __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: "FoamFile._SetValue",
-        *,
-        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]}\n{serialize_entry(keywords[-1], {})}\n{contents[end:]}"
-                )
-
-                for k, v in value.items():
-                    self[(*keywords, k)] = v
-        else:
-            start, end = get_entry_locn(parsed, keywords, missing_ok=True)
-
-            self._write(
-                f"{contents[:start]}\n{serialize_entry(keywords[-1], value, assume_field=assume_field, assume_dimensions=assume_dimensions)}\n{contents[end:]}"
-            )
-
-    def __setitem__(
-        self,
-        keywords: Union[str, Tuple[str, ...]],
-        value: "FoamFile._SetValue",
-    ) -> 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 __contains__(self, keywords: object) -> bool:
-        if not isinstance(keywords, tuple):
-            keywords = (keywords,)
-        _, parsed = self._read()
-        return keywords in parsed
-
-    def __len__(self) -> int:
-        return len(list(iter(self)))
-
-    def update(self, *args: Any, **kwargs: Any) -> None:
-        with self:
-            super().update(*args, **kwargs)
-
-    def clear(self) -> None:
-        with self:
-            super().clear()
-
-    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":
-            value = super().__getitem__(keyword)
-            if not isinstance(value, FoamFieldFile.BoundaryDictionary):
-                assert not isinstance(value, FoamFile.Dictionary)
-                raise TypeError(f"boundary {keyword} is not a dictionary")
-            return value
-
-    class BoundaryDictionary(FoamFile.Dictionary):
-        """An OpenFOAM dictionary representing a boundary condition as a mutable mapping."""
-
-        def __setitem__(
-            self,
-            key: str,
-            value: FoamFile._SetValue,
-        ) -> 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

@@ -1,198 +0,0 @@
-import sys
-from typing import Optional, Tuple, Union
-
-if sys.version_info >= (3, 9):
-    from collections.abc import Mapping, MutableMapping, Sequence
-else:
-    from typing import Mapping, MutableMapping, Sequence
-
-if sys.version_info >= (3, 10):
-    from types import EllipsisType
-else:
-    from typing import Any as EllipsisType
-
-from pyparsing import (
-    Dict,
-    Forward,
-    Group,
-    Keyword,
-    LineEnd,
-    Literal,
-    Located,
-    Opt,
-    ParserElement,
-    ParseResults,
-    QuotedString,
-    Word,
-    c_style_comment,
-    common,
-    cpp_style_comment,
-    identbodychars,
-    printables,
-)
-
-from ._base import FoamDictionaryBase
-
-_SWITCH = (
-    Keyword("yes") | Keyword("true") | Keyword("on") | Keyword("y") | Keyword("t")
-).set_parse_action(lambda: True) | (
-    Keyword("no") | Keyword("false") | Keyword("off") | Keyword("n") | Keyword("f")
-).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]])
-    )
-
-
-def _dictionary_of(
-    keyword: ParserElement,
-    value: ParserElement,
-    *,
-    len: Union[int, EllipsisType] = ...,
-    located: bool = False,
-) -> ParserElement:
-    subdict = Forward()
-
-    entry = keyword + (
-        (Literal("{").suppress() + subdict + Literal("}").suppress())
-        | (value + Literal(";").suppress())
-    )
-
-    if located:
-        entry = Located(entry)
-
-    subdict <<= Dict(Group(entry)[...], asdict=not located)
-
-    return Dict(Group(entry)[len], asdict=not located)
-
-
-_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()
-_ENTRY = _dictionary_of(_IDENTIFIER, _ITEM, len=1)
-_LIST = _list_of(_ENTRY | _ITEM)
-_ITEM <<= _FIELD | _LIST | _DIMENSIONED | _DIMENSIONS | common.number | _SWITCH | _TOKEN
-
-_TOKENS = (
-    QuotedString('"', unquote_results=False) | Word(printables.replace(";", ""))
-)[2, ...].set_parse_action(lambda tks: " ".join(tks))
-
-_VALUE = _ITEM ^ _TOKENS
-
-_FILE = (
-    _dictionary_of(_TOKEN, Opt(_VALUE, default=""), located=True)
-    .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