foamlib 0.3.0__tar.gz → 0.3.1__tar.gz

{foamlib-0.3.0 → foamlib-0.3.1}/PKG-INFO

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

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

{foamlib-0.3.0 → foamlib-0.3.1}/foamlib/_files/_base.py

@@ -1,7 +1,7 @@
 import sys
 from abc import abstractmethod
 from dataclasses import dataclass
-from typing import Dict, NamedTuple, Optional, Union
+from typing import Dict, NamedTuple, Optional, Tuple, Union
 
 if sys.version_info >= (3, 9):
     from collections.abc import Mapping, Sequence
@@ -10,7 +10,6 @@ else:
 
 try:
     import numpy as np
-    from numpy.typing import NDArray
 except ModuleNotFoundError:
     pass
 
@@ -59,4 +58,16 @@ class FoamDict:
         """Return a nested dict representation of the dictionary."""
         raise NotImplementedError
 
-    _SetData = Union[Data, "NDArray[np.generic]"]
+    _SetData = Union[
+        str,
+        int,
+        float,
+        bool,
+        Dimensioned,
+        DimensionSet,
+        Sequence["_SetData"],
+        Mapping[str, "_SetData"],
+        "np.ndarray[Tuple[()], np.dtype[np.generic]]",
+        "np.ndarray[Tuple[int], np.dtype[np.generic]]",
+        "np.ndarray[Tuple[int, int], np.dtype[np.generic]]",
+    ]

{foamlib-0.3.0 → foamlib-0.3.1}/foamlib/_files/_fields.py

@@ -10,7 +10,6 @@ from ._files import FoamFile
 
 try:
     import numpy as np
-    from numpy.typing import NDArray
 except ModuleNotFoundError:
     pass
 
@@ -58,7 +57,9 @@ class FoamFieldFile(FoamFile):
             int,
             float,
             Sequence[Union[int, float, Sequence[Union[int, float]]]],
-            "NDArray[np.generic]",
+            "np.ndarray[Tuple[()], np.dtype[np.generic]]",
+            "np.ndarray[Tuple[int], np.dtype[np.generic]]",
+            "np.ndarray[Tuple[int, int], np.dtype[np.generic]]",
         ]:
             """Alias of `self["value"]`."""
             ret = self["value"]
@@ -73,7 +74,9 @@ class FoamFieldFile(FoamFile):
                 int,
                 float,
                 Sequence[Union[int, float, Sequence[Union[int, float]]]],
-                "NDArray[np.generic]",
+                "np.ndarray[Tuple[()], np.dtype[np.generic]]",
+                "np.ndarray[Tuple[int], np.dtype[np.generic]]",
+                "np.ndarray[Tuple[int, int], np.dtype[np.generic]]",
             ],
         ) -> None:
             self["value"] = value
@@ -128,7 +131,9 @@ class FoamFieldFile(FoamFile):
         int,
         float,
         Sequence[Union[int, float, Sequence[Union[int, float]]]],
-        "NDArray[np.generic]",
+        "np.ndarray[Tuple[()], np.dtype[np.generic]]",
+        "np.ndarray[Tuple[int], np.dtype[np.generic]]",
+        "np.ndarray[Tuple[int, int], np.dtype[np.generic]]",
     ]:
         """Alias of `self["internalField"]`."""
         ret = self["internalField"]
@@ -143,7 +148,9 @@ class FoamFieldFile(FoamFile):
             int,
             float,
             Sequence[Union[int, float, Sequence[Union[int, float]]]],
-            "NDArray[np.generic]",
+            "np.ndarray[Tuple[()], np.dtype[np.generic]]",
+            "np.ndarray[Tuple[int], np.dtype[np.generic]]",
+            "np.ndarray[Tuple[int, int], np.dtype[np.generic]]",
         ],
     ) -> None:
         self["internalField"] = value

{foamlib-0.3.0 → foamlib-0.3.1}/foamlib/_files/_files.py

@@ -12,7 +12,7 @@ else:
 
 from ._base import FoamDict
 from ._io import FoamFileIO
-from ._serialization import serialize_keyword_entry
+from ._serialization import serialize
 
 
 class FoamFile(
@@ -134,7 +134,7 @@ class FoamFile(
                 start, end = parsed.entry_location(keywords, missing_ok=True)
 
                 self._write(
-                    f"{contents[:start]}\n{serialize_keyword_entry(keywords[-1], {})}\n{contents[end:]}"
+                    f"{contents[:start]}\n{serialize({keywords[-1]: {}})}\n{contents[end:]}"
                 )
 
                 for k, v in data.items():
@@ -143,7 +143,7 @@ class FoamFile(
             start, end = parsed.entry_location(keywords, missing_ok=True)
 
             self._write(
-                f"{contents[:start]}\n{serialize_keyword_entry(keywords[-1], data, assume_field=assume_field, assume_dimensions=assume_dimensions)}\n{contents[end:]}"
+                f"{contents[:start]}\n{serialize({keywords[-1]: data}, assume_field=assume_field, assume_dimensions=assume_dimensions)}\n{contents[end:]}"
             )
 
     def __setitem__(

foamlib-0.3.1/foamlib/_files/_serialization.py

@@ -0,0 +1,83 @@
+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
+
+
+def serialize(
+    data: FoamDict._SetData,
+    *,
+    assume_field: bool = False,
+    assume_dimensions: bool = False,
+    assume_data_entries: bool = False,
+) -> str:
+    if isinstance(data, Mapping):
+        entries = []
+        for k, v in data.items():
+            s = serialize(
+                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 {serialize(data)}"
+        elif isinstance(data[0], (int, float)):
+            return f"nonuniform List<scalar> {len(data)}{serialize(data)}"
+        elif len(data[0]) == 3:
+            return f"nonuniform List<vector> {len(data)}{serialize(data)}"
+        elif len(data[0]) == 6:
+            return f"nonuniform List<symmTensor> {len(data)}{serialize(data)}"
+        elif len(data[0]) == 9:
+            return f"nonuniform List<tensor> {len(data)}{serialize(data)}"
+        else:
+            return serialize(
+                data,
+                assume_dimensions=assume_dimensions,
+                assume_data_entries=assume_data_entries,
+            )
+
+    elif assume_data_entries and isinstance(data, tuple):
+        return " ".join(
+            serialize(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} {serialize(data.dimensions, assume_dimensions=True)} {serialize(data.value)}"
+        else:
+            return f"{serialize(data.dimensions, assume_dimensions=True)} {serialize(data.value)}"
+
+    elif is_sequence(data):
+        return f"({' '.join(serialize(v) for v in data)})"
+
+    elif data is True:
+        return "yes"
+    elif data is False:
+        return "no"
+
+    else:
+        return str(data)

{foamlib-0.3.0 → foamlib-0.3.1}/foamlib.egg-info/PKG-INFO

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

@@ -1,156 +0,0 @@
-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};"