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

foamlib/_files/_parsing.py

@@ -0,0 +1,195 @@
+import sys
+from typing import Tuple, Union
+
+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, 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 FoamDict
+
+
+def _list_of(entry: ParserElement) -> ParserElement:
+    return Opt(
+        Literal("List") + Literal("<") + common.identifier + Literal(">")
+    ).suppress() + (
+        (
+            Opt(common.integer).suppress()
+            + (
+                Literal("(").suppress()
+                + Group((entry)[...], aslist=True)
+                + Literal(")").suppress()
+            )
+        )
+        | (
+            common.integer + Literal("{").suppress() + entry + Literal("}").suppress()
+        ).set_parse_action(lambda tks: [[tks[1]] * tks[0]])
+    )
+
+
+def _dictionary_of(
+    keyword: ParserElement,
+    data_entries: ParserElement,
+    *,
+    len: Union[int, EllipsisType] = ...,
+    located: bool = False,
+) -> ParserElement:
+    subdict = Forward()
+
+    keyword_entry = keyword + (
+        (Literal("{").suppress() + subdict + Literal("}").suppress())
+        | (data_entries + Literal(";").suppress())
+    )
+
+    if located:
+        keyword_entry = Located(keyword_entry)
+
+    subdict <<= Dict(Group(keyword_entry)[...], asdict=not located)
+
+    return Dict(Group(keyword_entry)[len], asdict=not located)
+
+
+_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: FoamDict.DimensionSet(*tks))
+_TENSOR = _list_of(common.number) | common.number
+_IDENTIFIER = Word(identbodychars + "$", printables.replace(";", ""))
+_DIMENSIONED = (Opt(_IDENTIFIER) + _DIMENSIONS + _TENSOR).set_parse_action(
+    lambda tks: FoamDict.Dimensioned(*reversed(tks.as_list()))
+)
+_FIELD = (Keyword("uniform").suppress() + _TENSOR) | (
+    Keyword("nonuniform").suppress() + _list_of(_TENSOR)
+)
+_TOKEN = QuotedString('"', unquote_results=False) | _IDENTIFIER
+_DATA = Forward()
+_KEYWORD_ENTRY = _dictionary_of(_TOKEN, _DATA, len=1)
+_DATA_ENTRY = Forward()
+_LIST_ENTRY = _KEYWORD_ENTRY | _DATA_ENTRY
+_LIST = _list_of(_LIST_ENTRY)
+_DATA_ENTRY <<= (
+    _FIELD | _LIST | _DIMENSIONED | _DIMENSIONS | common.number | _SWITCH | _TOKEN
+)
+
+_DATA <<= _DATA_ENTRY[1, ...].set_parse_action(
+    lambda tks: tuple(tks) if len(tks) > 1 else [tks[0]]
+)
+
+_FILE = (
+    _dictionary_of(_TOKEN, Opt(_DATA, default=""), located=True)
+    .ignore(c_style_comment)
+    .ignore(cpp_style_comment)
+    .ignore(Literal("#include") + ... + LineEnd())  # type: ignore [no-untyped-call]
+)
+
+
+class Parsed(Mapping[Tuple[str, ...], Union[FoamDict.Data, EllipsisType]]):
+    def __init__(self, contents: str) -> None:
+        self._parsed: MutableMapping[
+            Tuple[str, ...],
+            Tuple[int, Union[FoamDict.Data, EllipsisType], int],
+        ] = {}
+        for parse_result in _FILE.parse_string(contents, parse_all=True):
+            self._parsed.update(self._flatten_result(parse_result))
+
+    @staticmethod
+    def _flatten_result(
+        parse_result: ParseResults, *, _keywords: Tuple[str, ...] = ()
+    ) -> Mapping[Tuple[str, ...], Tuple[int, Union[FoamDict.Data, EllipsisType], int]]:
+        ret: MutableMapping[
+            Tuple[str, ...],
+            Tuple[int, Union[FoamDict.Data, EllipsisType], 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)
+        keyword, *data = item
+        assert isinstance(keyword, str)
+        ret[(*_keywords, keyword)] = (start, ..., end)
+        for d in data:
+            if isinstance(d, ParseResults):
+                ret.update(Parsed._flatten_result(d, _keywords=(*_keywords, keyword)))
+            else:
+                ret[(*_keywords, keyword)] = (start, d, end)
+        return ret
+
+    def __getitem__(
+        self, keywords: Tuple[str, ...]
+    ) -> Union[FoamDict.Data, EllipsisType]:
+        _, data, _ = self._parsed[keywords]
+        return data
+
+    def __contains__(self, keywords: object) -> bool:
+        return keywords in self._parsed
+
+    def __iter__(self) -> Iterator[Tuple[str, ...]]:
+        return iter(self._parsed)
+
+    def __len__(self) -> int:
+        return len(self._parsed)
+
+    def entry_location(
+        self, keywords: Tuple[str, ...], *, missing_ok: bool = False
+    ) -> Tuple[int, int]:
+        try:
+            start, _, end = self._parsed[keywords]
+        except KeyError:
+            if missing_ok:
+                if len(keywords) > 1:
+                    _, _, end = self._parsed[keywords[:-1]]
+                    end -= 1
+                else:
+                    end = -1
+
+                start = end
+            else:
+                raise
+
+        return start, end
+
+    def as_dict(self) -> FoamDict._Dict:
+        ret: FoamDict._Dict = {}
+        for keywords, (_, data, _) in self._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 data is ... else data  # type: ignore [assignment]
+
+        return ret

foamlib/_files/_serialization.py

@@ -0,0 +1,156 @@
+import sys
+from contextlib import suppress
+
+if sys.version_info >= (3, 9):
+    from collections.abc import Mapping
+else:
+    from typing import Mapping
+
+from .._util import is_sequence
+from ._base import FoamDict
+
+
+def _serialize_switch(data: FoamDict._SetData) -> str:
+    if data is True:
+        return "yes"
+    elif data is False:
+        return "no"
+    else:
+        raise TypeError(f"Not a bool: {type(data)}")
+
+
+def _serialize_list(
+    data: FoamDict._SetData,
+) -> str:
+    if is_sequence(data):
+        return f"({' '.join(_serialize_data_entry(v) for v in data)})"
+    else:
+        raise TypeError(f"Not a valid sequence: {type(data)}")
+
+
+def _serialize_field(
+    data: FoamDict._SetData,
+) -> str:
+    if is_sequence(data):
+        try:
+            s = _serialize_list(data)
+        except TypeError:
+            raise TypeError(f"Not a valid field: {type(data)}") from None
+        else:
+            if not is_sequence(data[0]) and len(data) < 10:
+                return f"uniform {s}"
+            else:
+                if not is_sequence(data[0]):
+                    kind = "scalar"
+                elif len(data[0]) == 3:
+                    kind = "vector"
+                elif len(data[0]) == 6:
+                    kind = "symmTensor"
+                elif len(data[0]) == 9:
+                    kind = "tensor"
+                else:
+                    raise TypeError(
+                        f"Unsupported sequence length for field: {len(data[0])}"
+                    )
+                return f"nonuniform List<{kind}> {len(data)}{s}"
+    else:
+        return f"uniform {data}"
+
+
+def _serialize_dimensions(
+    data: FoamDict._SetData,
+) -> str:
+    if is_sequence(data) and len(data) == 7:
+        return f"[{' '.join(str(v) for v in data)}]"
+    else:
+        raise TypeError(f"Not a valid dimension set: {type(data)}")
+
+
+def _serialize_dimensioned(
+    data: FoamDict._SetData,
+) -> str:
+    if isinstance(data, FoamDict.Dimensioned):
+        if data.name is not None:
+            return f"{data.name} {_serialize_dimensions(data.dimensions)} {_serialize_data_entry(data.value)}"
+        else:
+            return f"{_serialize_dimensions(data.dimensions)} {_serialize_data_entry(data.value)}"
+    else:
+        raise TypeError(f"Not a valid dimensioned value: {type(data)}")
+
+
+def _serialize_data_entry(
+    data: FoamDict._SetData,
+    *,
+    assume_field: bool = False,
+    assume_dimensions: bool = False,
+) -> str:
+    if isinstance(data, FoamDict.DimensionSet) or assume_dimensions:
+        with suppress(TypeError):
+            return _serialize_dimensions(data)
+
+    if assume_field:
+        with suppress(TypeError):
+            return _serialize_field(data)
+
+    with suppress(TypeError):
+        return _serialize_dimensioned(data)
+
+    with suppress(TypeError):
+        return _serialize_list(data)
+
+    with suppress(TypeError):
+        return _serialize_switch(data)
+
+    with suppress(TypeError):
+        return _serialize_dictionary(data)
+
+    return str(data)
+
+
+def _serialize_data_entries(
+    data: FoamDict._SetData,
+    *,
+    assume_field: bool = False,
+    assume_dimensions: bool = False,
+) -> str:
+    if isinstance(data, FoamDict.DimensionSet) or assume_dimensions:
+        with suppress(TypeError):
+            return _serialize_dimensions(data)
+
+    if assume_field:
+        with suppress(TypeError):
+            return _serialize_field(data)
+
+    if isinstance(data, tuple):
+        return " ".join(_serialize_data_entry(v) for v in data)
+
+    return _serialize_data_entry(data)
+
+
+def _serialize_dictionary(
+    data: FoamDict._SetData,
+) -> str:
+    if isinstance(data, Mapping):
+        return "\n".join(serialize_keyword_entry(k, v) for k, v in data.items())
+    else:
+        raise TypeError(f"Not a valid dictionary: {type(data)}")
+
+
+def serialize_keyword_entry(
+    keyword: str,
+    data: FoamDict._SetData,
+    *,
+    assume_field: bool = False,
+    assume_dimensions: bool = False,
+) -> str:
+    with suppress(TypeError):
+        return f"{keyword}\n{{\n{_serialize_dictionary(data)}\n}}"
+
+    data = _serialize_data_entries(
+        data, assume_field=assume_field, assume_dimensions=assume_dimensions
+    )
+
+    if not data:
+        return f"{keyword};"
+    else:
+        return f"{keyword} {data};"

{foamlib-0.2.9.dist-info → foamlib-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.2.9
+Version: 0.3.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

foamlib-0.3.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+foamlib/__init__.py,sha256=erRnbigN4XBPDC0ykv-Lw7LVsw_xtuJ7h0tgkBTNQZ8,381
+foamlib/_cases.py,sha256=SkUthKb98zXPMYACaGyfGC0Fo1jzD6cC4qEGesHfNfc,20554
+foamlib/_util.py,sha256=PBTpBwt_j1GXASncSDZUR8pH2u_h8UyJXm8GeFKebTY,2552
+foamlib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+foamlib/_files/__init__.py,sha256=m4y_7wFV2Voly1aJrTYALjT3S1Aq7EbaijxdGFbJrmU,160
+foamlib/_files/_base.py,sha256=vONemjJA-NxRuIjuxwz8PynjtF1UImrfBQm1EbgZEec,1768
+foamlib/_files/_fields.py,sha256=jZZiMoBn0tixGnUGpITpRxcauqhPvYk65PIktBFvEHk,5073
+foamlib/_files/_files.py,sha256=1fV1TUwtNsxzt1R1YKMbB_AGpjMl-W-7YQXl7Ynoyzc,6025
+foamlib/_files/_io.py,sha256=alxMyxQh0zb6BZYqomZwOo9dQujMpRuS5yfpIKBEnaM,1976
+foamlib/_files/_parsing.py,sha256=blyt1kpYruoW5I6DMDg8jhg6f5oz7gzedmAImuJ5b4k,5966
+foamlib/_files/_serialization.py,sha256=kbl1OTvWqHwcDwS2k5CuqjDRmiv3NpA9hIXyv4boWBA,4268
+foamlib-0.3.0.dist-info/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
+foamlib-0.3.0.dist-info/METADATA,sha256=hl5EKAs6_mbW-1qcuIFst4I6tDQqCkG4LyZlx3DMhZY,4650
+foamlib-0.3.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+foamlib-0.3.0.dist-info/top_level.txt,sha256=ZdVYtetXGwPwyfL-WhlhbTFQGAwKX5P_gXxtH9JYFPI,8
+foamlib-0.3.0.dist-info/RECORD,,

foamlib/_dictionaries/__init__.py

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