foamlib 0.7.2__py3-none-any.whl → 0.7.3__py3-none-any.whl

foamlib/__init__.py

@@ -1,6 +1,6 @@
 """A Python interface for interacting with OpenFOAM."""
 
-__version__ = "0.7.2"
+__version__ = "0.7.3"
 
 from ._cases import (
     AsyncFoamCase,

foamlib/_files/_files.py

@@ -19,10 +19,10 @@ from ._io import FoamFileIO
 from ._serialization import Kind, dumps, normalize
 from ._types import (
     Data,
-    DataEntry,
     Dict_,
     Dimensioned,
     DimensionSet,
+    Entry,
     Field,
     File,
     MutableData,
@@ -57,13 +57,13 @@ class FoamFile(
             self._file = _file
             self._keywords = _keywords
 
-        def __getitem__(self, keyword: str) -> DataEntry | FoamFile.SubDict:
+        def __getitem__(self, keyword: str) -> Data | FoamFile.SubDict:
             return self._file[(*self._keywords, keyword)]
 
         def __setitem__(
             self,
             keyword: str,
-            data: Data,
+            data: Entry,
         ) -> None:
             self._file[(*self._keywords, keyword)] = data
 
@@ -174,7 +174,7 @@ class FoamFile(
 
     def __getitem__(
         self, keywords: str | tuple[str, ...] | None
-    ) -> DataEntry | FoamFile.SubDict:
+    ) -> Data | FoamFile.SubDict:
         if not keywords:
             keywords = ()
         elif not isinstance(keywords, tuple):
@@ -190,7 +190,7 @@ class FoamFile(
             return FoamFile.SubDict(self, keywords)
         return deepcopy(value)
 
-    def __setitem__(self, keywords: str | tuple[str, ...] | None, data: Data) -> None:
+    def __setitem__(self, keywords: str | tuple[str, ...] | None, data: Entry) -> None:
         if not keywords:
             keywords = ()
         elif not isinstance(keywords, tuple):
@@ -438,7 +438,7 @@ class FoamFieldFile(FoamFile):
 
     def __getitem__(
         self, keywords: str | tuple[str, ...] | None
-    ) -> DataEntry | FoamFile.SubDict:
+    ) -> Data | FoamFile.SubDict:
         if not keywords:
             keywords = ()
         elif not isinstance(keywords, tuple):

foamlib/_files/_parsing.py

@@ -16,7 +16,6 @@ else:
     from typing import Any as EllipsisType
 
 from pyparsing import (
-    CharsNotIn,
     Combine,
     Dict,
     Forward,
@@ -28,16 +27,16 @@ from pyparsing import (
     Opt,
     ParserElement,
     ParseResults,
-    QuotedString,
     Regex,
     Word,
     common,
     counted_array,
+    dbl_quoted_string,
     identchars,
     printables,
 )
 
-from ._types import DataEntry, Dimensioned, DimensionSet, File
+from ._types import Data, Dimensioned, DimensionSet, File
 
 
 def _list_of(entry: ParserElement) -> ParserElement:
@@ -59,18 +58,52 @@ def _list_of(entry: ParserElement) -> ParserElement:
     )
 
 
-def _counted_tensor_list(*, size: int, ignore: Regex) -> ParserElement:
-    float_pattern = r"[+-]?((\d+\.?\d*(e[+-]?\d+)?)|nan|inf(inity)?)"
-    ignore_pattern = rf"(?:\s|{ignore.re.pattern})+"
+def _parse_ascii_field(
+    s: str, *, elsize: int, ignore: Regex | None
+) -> list[float] | list[list[float]]:
+    values = [
+        float(v)
+        for v in (re.sub(ignore.re, " ", s) if ignore is not None else s)
+        .replace("(", " ")
+        .replace(")", " ")
+        .split()
+    ]
 
-    if size == 1:
+    if elsize == 1:
+        return values
+
+    return [values[i : i + elsize] for i in range(0, len(values), elsize)]
+
+
+def _unpack_binary_field(
+    b: bytes, *, elsize: int, length: int
+) -> list[float] | list[list[float]]:
+    float_size = len(b) / elsize / length
+    assert float_size in (4, 8)
+
+    arr = array.array("f" if float_size == 4 else "d", b)
+    values = arr.tolist()
+
+    if elsize == 1:
+        return values
+
+    return [values[i : i + elsize] for i in range(0, len(values), elsize)]
+
+
+def _counted_tensor_list(
+    *, elsize: int = 1, ignore: Regex | None = None
+) -> ParserElement:
+    float_pattern = r"(?i:[+-]?(?:(?:\d+\.?\d*(?:e[+-]?\d+)?)|nan|inf(?:inity)?))"
+    ignore_pattern = rf"(?:\s|{ignore.re.pattern})+" if ignore is not None else r"\s+"
+
+    if elsize == 1:
         tensor_pattern = float_pattern
         tensor = common.ieee_float
     else:
-        tensor_pattern = rf"\((?:{ignore_pattern})?(?:{float_pattern}{ignore_pattern}){{{size - 1}}}{float_pattern}(?:{ignore_pattern})?\)"
+        tensor_pattern = rf"\((?:{ignore_pattern})?(?:{float_pattern}{ignore_pattern}){{{elsize - 1}}}{float_pattern}(?:{ignore_pattern})?\)"
         tensor = (
             Literal("(").suppress()
-            + Group(common.ieee_float[size], aslist=True)
+            + Group(common.ieee_float[elsize], aslist=True)
             + Literal(")").suppress()
         )
 
@@ -81,34 +114,29 @@ def _counted_tensor_list(*, size: int, ignore: Regex) -> ParserElement:
         length = tks[0]
         assert isinstance(length, int)
 
-        list_ <<= Regex(
-            rf"\((?:{ignore_pattern})?(?:{tensor_pattern}{ignore_pattern}){{{length - 1}}}{tensor_pattern}(?:{ignore_pattern})?\)",
-            flags=re.IGNORECASE,
+        list_ <<= (
+            Regex(
+                rf"\((?:{ignore_pattern})?(?:{tensor_pattern}{ignore_pattern}){{{length - 1}}}{tensor_pattern}(?:{ignore_pattern})?\)"
+            ).add_parse_action(
+                lambda tks: [_parse_ascii_field(tks[0], elsize=elsize, ignore=ignore)]
+            )
+            | Regex(
+                rf"\((?s:.{{{length * elsize * 8}}}|.{{{length * elsize * 4}}})\)"
+            ).set_parse_action(
+                lambda tks: [
+                    _unpack_binary_field(
+                        tks[0][1:-1].encode("latin-1"), elsize=elsize, length=length
+                    )
+                ]
+            )
+            | (
+                Literal("{").suppress() + tensor + Literal("}").suppress()
+            ).set_parse_action(lambda tks: [[tks[0]] * length])
         )
 
-    count = common.integer.add_parse_action(count_parse_action)
-
-    def list_parse_action(
-        tks: ParseResults,
-    ) -> list[list[float]] | list[list[list[float]]]:
-        values = [
-            float(v)
-            for v in re.sub(ignore.re, " ", tks[0])
-            .replace("(", " ")
-            .replace(")", " ")
-            .split()
-        ]
-
-        if size == 1:
-            return [values]
-
-        return [[values[i : i + size] for i in range(0, len(values), size)]]
+    count = common.integer.copy().add_parse_action(count_parse_action)
 
-    list_.add_parse_action(list_parse_action)
-
-    return (count.suppress() + list_) | (
-        common.integer + Literal("{").suppress() + tensor + Literal("}").suppress()
-    ).set_parse_action(lambda tks: [[tks[1]] * tks[0]])
+    return count.suppress() + list_
 
 
 def _keyword_entry_of(
@@ -132,25 +160,6 @@ def _keyword_entry_of(
     return keyword_entry
 
 
-def _unpack_binary_field(
-    tks: ParseResults,
-    *,
-    elsize: int = 1,
-) -> Sequence[Sequence[float] | Sequence[Sequence[float]]]:
-    float_size = len(tks[0]) // elsize
-
-    arr = array.array("f" if float_size == 4 else "d", "".join(tks).encode("latin-1"))
-
-    values: Sequence[float] | Sequence[Sequence[float]]
-
-    if elsize != 1:
-        values = [arr[i : i + elsize].tolist() for i in range(0, len(arr), elsize)]
-    else:
-        values = arr.tolist()
-
-    return [values]
-
-
 # https://github.com/pyparsing/pyparsing/pull/584
 _COMMENT = Regex(r"(?:/\*(?:[^*]|\*(?!/))*\*/)|(?://(?:\\\n|[^\n])*)")
 
@@ -202,103 +211,27 @@ _FIELD = (Keyword("uniform", _IDENTBODYCHARS).suppress() + _TENSOR) | (
             (
                 Literal("scalar").suppress()
                 + Literal(">").suppress()
-                + (
-                    _counted_tensor_list(size=1, ignore=_COMMENT)
-                    | (
-                        (
-                            (
-                                counted_array(
-                                    CharsNotIn(exact=8),
-                                    common.integer + Literal("(").suppress(),
-                                )
-                            )
-                            | (
-                                counted_array(
-                                    CharsNotIn(exact=4),
-                                    common.integer + Literal("(").suppress(),
-                                )
-                            )
-                        )
-                        + Literal(")").suppress()
-                    ).set_parse_action(_unpack_binary_field)
-                )
+                + _counted_tensor_list(elsize=1, ignore=_COMMENT)
             )
             | (
                 Literal("vector").suppress()
                 + Literal(">").suppress()
-                + (
-                    _counted_tensor_list(size=3, ignore=_COMMENT)
-                    | (
-                        (
-                            (
-                                counted_array(
-                                    CharsNotIn(exact=8 * 3),
-                                    common.integer + Literal("(").suppress(),
-                                )
-                            )
-                            | (
-                                counted_array(
-                                    CharsNotIn(exact=4 * 3),
-                                    common.integer + Literal("(").suppress(),
-                                )
-                            )
-                        )
-                        + Literal(")").suppress()
-                    ).set_parse_action(lambda tks: _unpack_binary_field(tks, elsize=3))
-                )
+                + _counted_tensor_list(elsize=3, ignore=_COMMENT)
             )
             | (
                 Literal("symmTensor").suppress()
                 + Literal(">").suppress()
-                + (
-                    _counted_tensor_list(size=6, ignore=_COMMENT)
-                    | (
-                        (
-                            (
-                                counted_array(
-                                    CharsNotIn(exact=8 * 6),
-                                    common.integer + Literal("(").suppress(),
-                                )
-                            )
-                            | (
-                                counted_array(
-                                    CharsNotIn(exact=4 * 6),
-                                    common.integer + Literal("(").suppress(),
-                                )
-                            )
-                        )
-                        + Literal(")").suppress()
-                    ).set_parse_action(lambda tks: _unpack_binary_field(tks, elsize=6))
-                )
+                + _counted_tensor_list(elsize=6, ignore=_COMMENT)
             )
             | (
                 Literal("tensor").suppress()
                 + Literal(">").suppress()
-                + (
-                    _counted_tensor_list(size=9, ignore=_COMMENT)
-                    | (
-                        (
-                            (
-                                counted_array(
-                                    CharsNotIn(exact=8 * 9),
-                                    common.integer + Literal("(").suppress(),
-                                )
-                            )
-                            | (
-                                counted_array(
-                                    CharsNotIn(exact=4 * 9),
-                                    common.integer + Literal("(").suppress(),
-                                )
-                            )
-                        )
-                        + Literal(")").suppress()
-                    ).set_parse_action(lambda tks: _unpack_binary_field(tks, elsize=9))
-                )
+                + _counted_tensor_list(elsize=9, ignore=_COMMENT)
             )
         )
     )
 )
-_TOKEN = QuotedString('"', unquote_results=False) | _IDENTIFIER
+_TOKEN = dbl_quoted_string | _IDENTIFIER
 DATA = Forward()
 KEYWORD = (
     _TOKEN
@@ -333,11 +266,11 @@ _FILE = (
 )
 
 
-class Parsed(Mapping[Tuple[str, ...], Union[DataEntry, EllipsisType]]):
+class Parsed(Mapping[Tuple[str, ...], Union[Data, EllipsisType]]):
     def __init__(self, contents: bytes) -> None:
         self._parsed: MutableMapping[
             tuple[str, ...],
-            tuple[int, DataEntry | EllipsisType, int],
+            tuple[int, Data | EllipsisType, int],
         ] = {}
         for parse_result in _FILE.parse_string(
             contents.decode("latin-1"), parse_all=True
@@ -350,10 +283,10 @@ class Parsed(Mapping[Tuple[str, ...], Union[DataEntry, EllipsisType]]):
     @staticmethod
     def _flatten_result(
         parse_result: ParseResults, *, _keywords: tuple[str, ...] = ()
-    ) -> Mapping[tuple[str, ...], tuple[int, DataEntry | EllipsisType, int]]:
+    ) -> Mapping[tuple[str, ...], tuple[int, Data | EllipsisType, int]]:
         ret: MutableMapping[
             tuple[str, ...],
-            tuple[int, DataEntry | EllipsisType, int],
+            tuple[int, Data | EllipsisType, int],
         ] = {}
         start = parse_result.locn_start
         assert isinstance(start, int)
@@ -380,14 +313,14 @@ class Parsed(Mapping[Tuple[str, ...], Union[DataEntry, EllipsisType]]):
                     ret[(*_keywords, keyword)] = (start, d, end)
         return ret
 
-    def __getitem__(self, keywords: tuple[str, ...]) -> DataEntry | EllipsisType:
+    def __getitem__(self, keywords: tuple[str, ...]) -> Data | EllipsisType:
         _, data, _ = self._parsed[keywords]
         return data
 
     def put(
         self,
         keywords: tuple[str, ...],
-        data: DataEntry | EllipsisType,
+        data: Data | EllipsisType,
         content: bytes,
     ) -> None:
         start, end = self.entry_location(keywords, missing_ok=True)

foamlib/_files/_serialization.py

@@ -12,7 +12,7 @@ else:
     from typing import Mapping, Sequence
 
 from ._parsing import DATA, KEYWORD
-from ._types import Data, DataEntry, Dimensioned, DimensionSet
+from ._types import Data, Dimensioned, DimensionSet, Entry
 from ._util import is_sequence
 
 try:
@@ -34,14 +34,14 @@ class Kind(Enum):
 
 
 @overload
-def normalize(data: DataEntry, *, kind: Kind = Kind.DEFAULT) -> DataEntry: ...
+def normalize(data: Data, *, kind: Kind = Kind.DEFAULT) -> Data: ...
 
 
 @overload
-def normalize(data: Data, *, kind: Kind = Kind.DEFAULT) -> Data: ...
+def normalize(data: Entry, *, kind: Kind = Kind.DEFAULT) -> Entry: ...
 
 
-def normalize(data: Data, *, kind: Kind = Kind.DEFAULT) -> Data:
+def normalize(data: Entry, *, kind: Kind = Kind.DEFAULT) -> Entry:
     if numpy and isinstance(data, np.ndarray):
         ret = data.tolist()
         assert isinstance(ret, list)
@@ -76,7 +76,7 @@ def normalize(data: Data, *, kind: Kind = Kind.DEFAULT) -> Data:
             assert isinstance(data, str)
             return data
 
-        return cast(DataEntry, DATA.parse_string(data, parse_all=True)[0])
+        return cast(Data, DATA.parse_string(data, parse_all=True)[0])
 
     if isinstance(
         data,
@@ -89,7 +89,7 @@ def normalize(data: Data, *, kind: Kind = Kind.DEFAULT) -> Data:
 
 
 def dumps(
-    data: Data,
+    data: Entry,
     *,
     kind: Kind = Kind.DEFAULT,
 ) -> bytes:

foamlib/_files/_types.py

@@ -46,33 +46,36 @@ class Dimensioned:
 
 
 Field = Union[
-    Tensor, Sequence[Tensor], "np.ndarray[Tuple[int, int], np.dtype[np.generic]]"
+    Tensor,
+    Sequence[Tensor],
+    "np.ndarray[Tuple[int], np.dtype[np.generic]]",
+    "np.ndarray[Tuple[int, int], np.dtype[np.generic]]",
 ]
 
-DataEntry = Union[
+Data = Union[
     str,
     int,
     float,
     bool,
     Dimensioned,
     DimensionSet,
-    Sequence["Data"],
+    Sequence["Entry"],
     Tensor,
     Field,
 ]
 
-Data = Union[
-    DataEntry,
-    Mapping[str, "Data"],
+Entry = Union[
+    Data,
+    Mapping[str, "Entry"],
 ]
 """
 A value that can be stored in an OpenFOAM file.
 """
 
 MutableData = Union[
-    DataEntry,
+    Data,
     MutableMapping[str, "MutableData"],
 ]
 
-Dict_ = Dict[str, Union["Data", "Dict_"]]
-File = Dict[Optional[str], Union["Data", "Dict_"]]
+Dict_ = Dict[str, Union["Entry", "Dict_"]]
+File = Dict[Optional[str], Union["Entry", "Dict_"]]

foamlib/_files/_util.py

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

{foamlib-0.7.2.dist-info → foamlib-0.7.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.7.2
+Version: 0.7.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.7.2.dist-info → foamlib-0.7.3.dist-info}/RECORD

@@ -1,4 +1,4 @@
-foamlib/__init__.py,sha256=YrFnCARXwvjW-QZzK9cS_ivto2gvTEJwdSVU5ZfCBkM,452
+foamlib/__init__.py,sha256=GdEjgMru_5M1AG0ltkVKqNek6vw5aI4j_6QNApGRqsg,452
 foamlib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 foamlib/_cases/__init__.py,sha256=wTUHcUgU1CBgpu0cUMtksQ5VKG6B8CFu9xc3dWwsQuo,358
 foamlib/_cases/_async.py,sha256=i6g4EBHqvI-1PkdrxsRto2ynW7sxsOga2bSYk1XVG1U,7795
@@ -9,14 +9,14 @@ foamlib/_cases/_subprocess.py,sha256=6BlBRxknj2-BFcGkx7oVcuL63_utSaY1Axmsc1qV9j8
 foamlib/_cases/_sync.py,sha256=2BJXB7Nzldb4OgPukqupgYqdceUGkI2mYhhtGPWEBrc,5901
 foamlib/_cases/_util.py,sha256=lhVca3ERY0zwYjDam6W2QMROt0yX5vAF-9_DS5RuMbM,1547
 foamlib/_files/__init__.py,sha256=GDkYkF3F-ADhkCRT3j9dQQHPP5LyJJYb8TaBbZTQ6fo,96
-foamlib/_files/_files.py,sha256=LVLMeP9Zt9esuVGhntnjBA4_u_NhiX5xkm09Qemcle8,15846
+foamlib/_files/_files.py,sha256=_qzXSsKRVXNrfySewonJJqL9I4OA8RTZuYyuWTGR4Ys,15829
 foamlib/_files/_io.py,sha256=IQLqoqnA1TpHf21NbUho2wsYWevyqC6MKo-wfpaObUU,2226
-foamlib/_files/_parsing.py,sha256=D1l7j_KldD6h-iJvFT6c0CiwctWvUxeGJxh-J93zDs8,15430
-foamlib/_files/_serialization.py,sha256=0vqJxltjscqp16mIvd0iKXbeRMbq3a7uLG2INWxzCBg,5861
-foamlib/_files/_types.py,sha256=eY06nox8cZe6FixUQigvZRV9Fc7gwehJxuQz_wCCnqo,1678
-foamlib/_files/_util.py,sha256=O9t2W26XDs63cVLroW8rZ35Puas20NhnKr_gLMlZixI,493
-foamlib-0.7.2.dist-info/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
-foamlib-0.7.2.dist-info/METADATA,sha256=dK_DN2ZLU49org-G_XI4kdNDg551I8b68d52Q4cAePU,7957
-foamlib-0.7.2.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
-foamlib-0.7.2.dist-info/top_level.txt,sha256=ZdVYtetXGwPwyfL-WhlhbTFQGAwKX5P_gXxtH9JYFPI,8
-foamlib-0.7.2.dist-info/RECORD,,
+foamlib/_files/_parsing.py,sha256=sY_Cyep9R7HfeTOKnKoAh9ZVXTnrJw3HGIgFFwUPGms,12541
+foamlib/_files/_serialization.py,sha256=GOhWIMHNf5MaLJUjbiRffNGQn1xVGPbyh_Mm50iz5e8,5847
+foamlib/_files/_types.py,sha256=mOOTXVrrD6MZGH64TmK1KX7WfUVBS8JLOuHTeeDerDQ,1729
+foamlib/_files/_util.py,sha256=lkoSJHXjd6MvDxx39ZF75mhPq-_QX9AjrruVcQ7I9WI,496
+foamlib-0.7.3.dist-info/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
+foamlib-0.7.3.dist-info/METADATA,sha256=4yvR9-0fYVRRfbROkoO3HcmmtZVYI4QAqIC_NPqKE0A,7957
+foamlib-0.7.3.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
+foamlib-0.7.3.dist-info/top_level.txt,sha256=ZdVYtetXGwPwyfL-WhlhbTFQGAwKX5P_gXxtH9JYFPI,8
+foamlib-0.7.3.dist-info/RECORD,,