foamlib 0.3.2__tar.gz → 0.3.4__tar.gz

{foamlib-0.3.2 → foamlib-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.3.2
+Version: 0.3.4
 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.2 → foamlib-0.3.4}/foamlib/__init__.py

@@ -1,6 +1,6 @@
 """A Python interface for interacting with OpenFOAM."""
 
-__version__ = "0.3.2"
+__version__ = "0.3.4"
 
 from ._cases import AsyncFoamCase, FoamCase, FoamCaseBase
 from ._files import FoamDict, FoamFieldFile, FoamFile

{foamlib-0.3.2 → foamlib-0.3.4}/foamlib/_cases.py

@@ -32,7 +32,7 @@ from ._util import is_sequence, run_process, run_process_async
 
 
 class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
-    def __init__(self, path: Union[Path, str]):
+    def __init__(self, path: Union[Path, str] = Path()):
         self.path = Path(path).absolute()
         if not self.path.is_dir():
             raise NotADirectoryError(f"{self.path} is not a directory")
@@ -87,7 +87,7 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
             return str(self.path)
 
         def __repr__(self) -> str:
-            return f"{type(self).__name__}({self.path})"
+            return f"{type(self).__name__}('{self.path}')"
 
         def __str__(self) -> str:
             return str(self.path)
@@ -298,7 +298,7 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
         return str(self.path)
 
     def __repr__(self) -> str:
-        return f"{type(self).__name__}({self.path})"
+        return f"{type(self).__name__}('{self.path}')"
 
     def __str__(self) -> str:
         return str(self.path)

{foamlib-0.3.2 → foamlib-0.3.4}/foamlib/_files/_fields.py

@@ -65,7 +65,12 @@ class FoamFieldFile(FoamFile):
             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)
+            return cast(
+                Union[
+                    int, float, Sequence[Union[int, float, Sequence[Union[int, float]]]]
+                ],
+                ret,
+            )
 
         @value.setter
         def value(
@@ -111,7 +116,7 @@ class FoamFieldFile(FoamFile):
             self._setitem(keywords, value)
 
     @property
-    def dimensions(self) -> FoamFile.DimensionSet:
+    def dimensions(self) -> Union[FoamFile.DimensionSet, Sequence[Union[int, float]]]:
         """Alias of `self["dimensions"]`."""
         ret = self["dimensions"]
         if not isinstance(ret, FoamFile.DimensionSet):

{foamlib-0.3.2 → foamlib-0.3.4}/foamlib/_files/_files.py

@@ -12,7 +12,7 @@ else:
 
 from ._base import FoamDict
 from ._io import FoamFileIO
-from ._serialization import dumps
+from ._serialization import dumpb
 
 
 class FoamFile(
@@ -84,7 +84,7 @@ class FoamFile(
                 super().clear()
 
         def __repr__(self) -> str:
-            return f"{type(self).__qualname__}({self._file}, {self._keywords})"
+            return f"{type(self).__qualname__}('{self._file}', {self._keywords})"
 
         def as_dict(self) -> FoamDict._Dict:
             """Return a nested dict representation of the dictionary."""
@@ -113,6 +113,10 @@ class FoamFile(
         else:
             return value  # type: ignore [return-value]
 
+    @property
+    def _binary(self) -> bool:
+        return self.get(("FoamFile", "format"), None) == "binary"
+
     def _setitem(
         self,
         keywords: Union[str, Tuple[str, ...]],
@@ -134,7 +138,11 @@ class FoamFile(
                 start, end = parsed.entry_location(keywords, missing_ok=True)
 
                 self._write(
-                    f"{contents[:start]}\n{dumps({keywords[-1]: {}})}\n{contents[end:]}"
+                    contents[:start]
+                    + b"\n"
+                    + dumpb({keywords[-1]: {}})
+                    + b"\n"
+                    + contents[end:]
                 )
 
                 for k, v in data.items():
@@ -143,7 +151,16 @@ class FoamFile(
             start, end = parsed.entry_location(keywords, missing_ok=True)
 
             self._write(
-                f"{contents[:start]}\n{dumps({keywords[-1]: data}, assume_field=assume_field, assume_dimensions=assume_dimensions)}\n{contents[end:]}"
+                contents[:start]
+                + b"\n"
+                + dumpb(
+                    {keywords[-1]: data},
+                    assume_field=assume_field,
+                    assume_dimensions=assume_dimensions,
+                    binary_fields=self._binary,
+                )
+                + b"\n"
+                + contents[end:]
             )
 
     def __setitem__(
@@ -194,9 +211,6 @@ class FoamFile(
     def __fspath__(self) -> str:
         return str(self.path)
 
-    def __repr__(self) -> str:
-        return f"{type(self).__name__}({self.path})"
-
     def as_dict(self) -> FoamDict._Dict:
         """Return a nested dict representation of the file."""
         _, parsed = self._read()

{foamlib-0.3.2 → foamlib-0.3.4}/foamlib/_files/_io.py

@@ -25,7 +25,7 @@ class FoamFileIO:
         elif not self.path.is_file():
             raise FileNotFoundError(self.path)
 
-        self.__contents: Optional[str] = None
+        self.__contents: Optional[bytes] = None
         self.__parsed: Optional[Parsed] = None
         self.__defer_io = 0
         self.__dirty = False
@@ -48,9 +48,9 @@ class FoamFileIO:
             self._write(self.__contents)
         assert not self.__dirty
 
-    def _read(self) -> Tuple[str, Parsed]:
+    def _read(self) -> Tuple[bytes, Parsed]:
         if not self.__defer_io:
-            contents = self.path.read_text()
+            contents = self.path.read_bytes()
             if contents != self.__contents:
                 self.__contents = contents
                 self.__parsed = None
@@ -63,11 +63,14 @@ class FoamFileIO:
 
         return self.__contents, deepcopy(self.__parsed)
 
-    def _write(self, contents: str) -> None:
+    def _write(self, contents: bytes) -> None:
         self.__contents = contents
         self.__parsed = None
         if not self.__defer_io:
-            self.path.write_text(contents)
+            self.path.write_bytes(contents)
             self.__dirty = False
         else:
             self.__dirty = True
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}('{self.path}')"

{foamlib-0.3.2 → foamlib-0.3.4}/foamlib/_files/_parsing.py

@@ -1,3 +1,4 @@
+import array
 import sys
 from typing import Tuple, Union
 
@@ -12,6 +13,7 @@ else:
     from typing import Any as EllipsisType
 
 from pyparsing import (
+    CharsNotIn,
     Dict,
     Forward,
     Group,
@@ -27,7 +29,7 @@ from pyparsing import (
     c_style_comment,
     common,
     cpp_style_comment,
-    identbodychars,
+    identchars,
     printables,
 )
 
@@ -74,6 +76,56 @@ def _dictionary_of(
     return Dict(Group(keyword_entry)[len], asdict=not located)
 
 
+_binary_contents = Forward()
+
+
+def _binary_field_parse_action(tks: ParseResults) -> None:
+    global _binary_contents
+
+    kind, count = tks
+    if kind == "scalar":
+        elsize = 1
+    elif kind == "vector":
+        elsize = 3
+    elif kind == "symmTensor":
+        elsize = 6
+    elif kind == "tensor":
+        elsize = 9
+
+    def unpack(
+        tks: ParseResults,
+    ) -> Sequence[Union[Sequence[float], Sequence[Sequence[float]]]]:
+        bytes_ = tks[0].encode("latin-1")
+
+        arr = array.array("d", bytes_)
+
+        if elsize != 1:
+            all = [arr[i : i + elsize].tolist() for i in range(0, len(arr), elsize)]
+        else:
+            all = arr.tolist()
+
+        return [all]
+
+    _binary_contents <<= CharsNotIn(exact=count * elsize * 8).set_parse_action(unpack)
+
+    tks.clear()  # type: ignore [no-untyped-call]
+
+
+_BINARY_FIELD = (
+    (
+        Keyword("nonuniform").suppress()
+        + Literal("List").suppress()
+        + Literal("<").suppress()
+        + common.identifier
+        + Literal(">").suppress()
+        + common.integer
+        + Literal("(").suppress()
+    ).set_parse_action(_binary_field_parse_action, call_during_try=True)
+    + _binary_contents
+    + Literal(")").suppress()
+)
+
+
 _SWITCH = (
     Keyword("yes") | Keyword("true") | Keyword("on") | Keyword("y") | Keyword("t")
 ).set_parse_action(lambda: True) | (
@@ -83,12 +135,14 @@ _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(";", ""))
+_IDENTIFIER = Word(identchars + "$", printables, exclude_chars=";")
 _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)
+_FIELD = (
+    (Keyword("uniform").suppress() + _TENSOR)
+    | (Keyword("nonuniform").suppress() + _list_of(_TENSOR))
+    | _BINARY_FIELD
 )
 _TOKEN = QuotedString('"', unquote_results=False) | _IDENTIFIER
 _DATA = Forward()
@@ -109,16 +163,19 @@ _FILE = (
     .ignore(c_style_comment)
     .ignore(cpp_style_comment)
     .ignore(Literal("#include") + ... + LineEnd())  # type: ignore [no-untyped-call]
+    .parse_with_tabs()
 )
 
 
 class Parsed(Mapping[Tuple[str, ...], Union[FoamDict.Data, EllipsisType]]):
-    def __init__(self, contents: str) -> None:
+    def __init__(self, contents: bytes) -> None:
         self._parsed: MutableMapping[
             Tuple[str, ...],
             Tuple[int, Union[FoamDict.Data, EllipsisType], int],
         ] = {}
-        for parse_result in _FILE.parse_string(contents, parse_all=True):
+        for parse_result in _FILE.parse_string(
+            contents.decode("latin-1"), parse_all=True
+        ):
             self._parsed.update(self._flatten_result(parse_result))
 
     @staticmethod

foamlib-0.3.4/foamlib/_files/_serialization.py

@@ -0,0 +1,138 @@
+import array
+import itertools
+import sys
+
+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
+
+try:
+    import numpy as np
+
+    numpy = True
+except ModuleNotFoundError:
+    numpy = False
+
+
+def dumpb(
+    data: FoamDict._SetData,
+    *,
+    assume_field: bool = False,
+    assume_dimensions: bool = False,
+    assume_data_entries: bool = False,
+    binary_fields: bool = False,
+) -> bytes:
+    if numpy and isinstance(data, np.ndarray):
+        return dumpb(
+            data.tolist(),
+            assume_field=assume_field,
+            assume_dimensions=assume_dimensions,
+            assume_data_entries=assume_data_entries,
+            binary_fields=binary_fields,
+        )
+
+    elif isinstance(data, Mapping):
+        entries = []
+        for k, v in data.items():
+            b = dumpb(
+                v,
+                assume_field=assume_field,
+                assume_dimensions=assume_dimensions,
+                assume_data_entries=True,
+                binary_fields=binary_fields,
+            )
+            if isinstance(v, Mapping):
+                entries.append(dumpb(k) + b"\n" + b"{\n" + b + b"\n}")
+            elif b:
+                entries.append(dumpb(k) + b" " + b + b";")
+            else:
+                entries.append(dumpb(k) + b";")
+
+        return b"\n".join(entries)
+
+    elif isinstance(data, FoamDict.DimensionSet) or (
+        assume_dimensions and is_sequence(data) and len(data) == 7
+    ):
+        return b"[" + b" ".join(dumpb(v) for v in data) + b"]"
+
+    elif assume_field and (
+        isinstance(data, (int, float))
+        or is_sequence(data)
+        and data
+        and isinstance(data[0], (int, float))
+        and len(data) in (3, 6, 9)
+    ):
+        return b"uniform " + dumpb(data)
+
+    elif assume_field and is_sequence(data):
+        if isinstance(data[0], (int, float)):
+            kind = b"scalar"
+        elif len(data[0]) == 3:
+            kind = b"vector"
+        elif len(data[0]) == 6:
+            kind = b"symmTensor"
+        elif len(data[0]) == 9:
+            kind = b"tensor"
+        else:
+            return dumpb(
+                data,
+                assume_dimensions=assume_dimensions,
+                assume_data_entries=assume_data_entries,
+                binary_fields=binary_fields,
+            )
+
+        if binary_fields:
+            if kind == b"scalar":
+                contents = b"(" + array.array("d", data).tobytes() + b")"
+            else:
+                contents = (
+                    b"("
+                    + array.array("d", itertools.chain.from_iterable(data)).tobytes()
+                    + b")"
+                )
+        else:
+            contents = dumpb(data)
+
+        return b"nonuniform List<" + kind + b"> " + dumpb(len(data)) + contents
+
+    elif assume_data_entries and isinstance(data, tuple):
+        return b" ".join(
+            dumpb(
+                v,
+                assume_field=assume_field,
+                assume_dimensions=assume_dimensions,
+                binary_fields=binary_fields,
+            )
+            for v in data
+        )
+
+    elif isinstance(data, FoamDict.Dimensioned):
+        if data.name is not None:
+            return (
+                dumpb(data.name)
+                + b" "
+                + dumpb(data.dimensions, assume_dimensions=True)
+                + b" "
+                + dumpb(data.value)
+            )
+        else:
+            return (
+                dumpb(data.dimensions, assume_dimensions=True)
+                + b" "
+                + dumpb(data.value)
+            )
+
+    elif is_sequence(data):
+        return b"(" + b" ".join(dumpb(v) for v in data) + b")"
+
+    elif data is True:
+        return b"yes"
+    elif data is False:
+        return b"no"
+
+    else:
+        return str(data).encode("latin-1")

{foamlib-0.3.2 → foamlib-0.3.4}/foamlib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.3.2
+Version: 0.3.4
 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.2/foamlib/_files/_serialization.py

@@ -1,99 +0,0 @@
-import sys
-
-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
-
-try:
-    import numpy as np
-
-    numpy = True
-except ModuleNotFoundError:
-    numpy = False
-
-
-def dumps(
-    data: FoamDict._SetData,
-    *,
-    assume_field: bool = False,
-    assume_dimensions: bool = False,
-    assume_data_entries: bool = False,
-) -> str:
-    if numpy and isinstance(data, np.ndarray):
-        return dumps(
-            data.tolist(),
-            assume_field=assume_field,
-            assume_dimensions=assume_dimensions,
-        )
-
-    elif isinstance(data, Mapping):
-        entries = []
-        for k, v in data.items():
-            s = dumps(
-                v,
-                assume_field=assume_field,
-                assume_dimensions=assume_dimensions,
-                assume_data_entries=True,
-            )
-            if isinstance(v, Mapping):
-                entries.append(f"{k}\n{{\n{s}\n}}")
-            elif s:
-                entries.append(f"{k} {s};")
-            else:
-                entries.append(f"{k};")
-        return "\n".join(entries)
-
-    elif isinstance(data, FoamDict.DimensionSet) or (
-        assume_dimensions and is_sequence(data) and len(data) == 7
-    ):
-        return f"[{' '.join(str(v) for v in data)}]"
-
-    elif assume_field and isinstance(data, (int, float)):
-        return f"uniform {data}"
-
-    elif assume_field and is_sequence(data):
-        if isinstance(data[0], (int, float)) and len(data) in (3, 6, 9):
-            return f"uniform {dumps(data)}"
-        elif isinstance(data[0], (int, float)):
-            return f"nonuniform List<scalar> {len(data)}{dumps(data)}"
-        elif len(data[0]) == 3:
-            return f"nonuniform List<vector> {len(data)}{dumps(data)}"
-        elif len(data[0]) == 6:
-            return f"nonuniform List<symmTensor> {len(data)}{dumps(data)}"
-        elif len(data[0]) == 9:
-            return f"nonuniform List<tensor> {len(data)}{dumps(data)}"
-        else:
-            return dumps(
-                data,
-                assume_dimensions=assume_dimensions,
-                assume_data_entries=assume_data_entries,
-            )
-
-    elif assume_data_entries and isinstance(data, tuple):
-        return " ".join(
-            dumps(v, assume_field=assume_field, assume_dimensions=assume_dimensions)
-            for v in data
-        )
-
-    elif isinstance(data, FoamDict.Dimensioned):
-        if data.name is not None:
-            return f"{data.name} {dumps(data.dimensions, assume_dimensions=True)} {dumps(data.value)}"
-        else:
-            return (
-                f"{dumps(data.dimensions, assume_dimensions=True)} {dumps(data.value)}"
-            )
-
-    elif is_sequence(data):
-        return f"({' '.join(dumps(v) for v in data)})"
-
-    elif data is True:
-        return "yes"
-    elif data is False:
-        return "no"
-
-    else:
-        return str(data)