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

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/_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/_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/_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/_files/_serialization.py

@@ -1,5 +1,4 @@
 import sys
-from contextlib import suppress
 
 if sys.version_info >= (3, 9):
     from collections.abc import Mapping
@@ -10,147 +9,75 @@ 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(
+def serialize(
     data: FoamDict._SetData,
+    *,
+    assume_field: bool = False,
+    assume_dimensions: bool = False,
+    assume_data_entries: bool = False,
 ) -> 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}"
+    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:
-                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}"
-
+                entries.append(f"{k};")
+        return "\n".join(entries)
 
-def _serialize_dimensions(
-    data: FoamDict._SetData,
-) -> str:
-    if is_sequence(data) and len(data) == 7:
+    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)}]"
-    else:
-        raise TypeError(f"Not a valid dimension set: {type(data)}")
 
+    elif assume_field and isinstance(data, (int, float)):
+        return f"uniform {data}"
 
-def _serialize_dimensioned(
-    data: FoamDict._SetData,
-) -> str:
-    if isinstance(data, FoamDict.Dimensioned):
+    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_dimensions(data.dimensions)} {_serialize_data_entry(data.value)}"
+            return f"{data.name} {serialize(data.dimensions, assume_dimensions=True)} {serialize(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)}")
+            return f"{serialize(data.dimensions, assume_dimensions=True)} {serialize(data.value)}"
 
+    elif is_sequence(data):
+        return f"({' '.join(serialize(v) for v in 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
-    )
+    elif data is True:
+        return "yes"
+    elif data is False:
+        return "no"
 
-    if not data:
-        return f"{keyword};"
     else:
-        return f"{keyword} {data};"
+        return str(data)

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

@@ -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.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+foamlib/__init__.py,sha256=tO70QZaLcvSKedqwp14wd35SdnVPg57RHiaPV_q33wI,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=YA5a-i5HZuA3JslCD6r-DwZzpSA8r42dqSXef286Ako,2050
+foamlib/_files/_fields.py,sha256=jVHOHEV70i6QrWzqhF_W5CywUZyJxN5Eh5S1MrNn1G0,5632
+foamlib/_files/_files.py,sha256=EyZnvP9okZmElzL9db4FkOD82qizeJrgb_ZGIM4xoXI,5987
+foamlib/_files/_io.py,sha256=alxMyxQh0zb6BZYqomZwOo9dQujMpRuS5yfpIKBEnaM,1976
+foamlib/_files/_parsing.py,sha256=blyt1kpYruoW5I6DMDg8jhg6f5oz7gzedmAImuJ5b4k,5966
+foamlib/_files/_serialization.py,sha256=Pq45Y3_DmblAk7ccUHf6RvipC_GQqU3SV89NOtV9CEg,2695
+foamlib-0.3.1.dist-info/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
+foamlib-0.3.1.dist-info/METADATA,sha256=blCma_pulIQtuhsmJZ36RCRZxhdEnQxB6u2wfK-AVZY,4650
+foamlib-0.3.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+foamlib-0.3.1.dist-info/top_level.txt,sha256=ZdVYtetXGwPwyfL-WhlhbTFQGAwKX5P_gXxtH9JYFPI,8
+foamlib-0.3.1.dist-info/RECORD,,

foamlib-0.3.0.dist-info/RECORD

@@ -1,16 +0,0 @@
-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,,