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

foamlib/__init__.py

@@ -1,10 +1,10 @@
 """A Python interface for interacting with OpenFOAM."""
 
-__version__ = "0.3.0"
+__version__ = "0.3.2"
 
 from ._cases import AsyncFoamCase, FoamCase, FoamCaseBase
 from ._files import FoamDict, FoamFieldFile, FoamFile
-from ._util import CalledProcessError
+from ._util import CalledProcessError, CalledProcessWarning
 
 __all__ = [
     "FoamCase",
@@ -14,4 +14,5 @@ __all__ = [
     "FoamFieldFile",
     "FoamDict",
     "CalledProcessError",
+    "CalledProcessWarning",
 ]

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 dumps
 
 
 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{dumps({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{dumps({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
@@ -9,148 +8,92 @@ else:
 from .._util import is_sequence
 from ._base import FoamDict
 
+try:
+    import numpy as np
 
-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)}")
+    numpy = True
+except ModuleNotFoundError:
+    numpy = False
 
 
-def _serialize_field(
+def dumps(
     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 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:
-                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 {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} {_serialize_dimensions(data.dimensions)} {_serialize_data_entry(data.value)}"
+            return f"{data.name} {dumps(data.dimensions, assume_dimensions=True)} {dumps(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)
+            return (
+                f"{dumps(data.dimensions, assume_dimensions=True)} {dumps(data.value)}"
+            )
 
-    if assume_field:
-        with suppress(TypeError):
-            return _serialize_field(data)
+    elif is_sequence(data):
+        return f"({' '.join(dumps(v) for v in 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/_util.py

@@ -2,7 +2,8 @@ import asyncio
 import subprocess
 import sys
 from pathlib import Path
-from typing import Any, Union
+from typing import Any, Optional, Union
+from warnings import warn
 
 if sys.version_info >= (3, 9):
     from collections.abc import Mapping, Sequence
@@ -14,31 +15,36 @@ if sys.version_info >= (3, 10):
 else:
     from typing_extensions import TypeGuard
 
-try:
-    import numpy as np
-except ModuleNotFoundError:
-    numpy = False
-else:
-    numpy = True
-
 
 def is_sequence(
     value: Any,
-) -> TypeGuard[Union["Sequence[Any]", "np.ndarray[Any, Any]"]]:
-    return (
-        isinstance(value, Sequence)
-        and not isinstance(value, str)
-        or numpy
-        and isinstance(value, np.ndarray)
-    )
+) -> TypeGuard[Sequence[Any]]:
+    return isinstance(value, Sequence) and not isinstance(value, str)
 
 
-CalledProcessError = subprocess.CalledProcessError
+class CalledProcessError(subprocess.CalledProcessError):
+    """Exception raised when a process fails and `check=True`."""
 
-if sys.version_info >= (3, 9):
-    CompletedProcess = subprocess.CompletedProcess[str]
-else:
-    CompletedProcess = subprocess.CompletedProcess
+    def __str__(self) -> str:
+        msg = super().__str__()
+        if self.stderr:
+            msg += f"\n{self.stderr}"
+        return msg
+
+
+class CalledProcessWarning(Warning):
+    """Warning raised when a process prints to stderr and `check=True`."""
+
+
+def _check(
+    retcode: int,
+    cmd: Union[Sequence[Union[str, Path]], str, Path],
+    stderr: Optional[str],
+) -> None:
+    if retcode != 0:
+        raise CalledProcessError(retcode, cmd, None, stderr)
+    elif stderr:
+        warn(f"Command {cmd} printed to stderr.\n{stderr}", CalledProcessWarning)
 
 
 def run_process(
@@ -47,7 +53,7 @@ def run_process(
     check: bool = True,
     cwd: Union[None, str, Path] = None,
     env: Union[None, Mapping[str, str]] = None,
-) -> CompletedProcess:
+) -> None:
     shell = not is_sequence(cmd)
 
     if sys.version_info < (3, 8):
@@ -60,14 +66,14 @@ def run_process(
         cmd,
         cwd=cwd,
         env=env,
-        stdout=asyncio.subprocess.DEVNULL,
-        stderr=asyncio.subprocess.PIPE,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.PIPE if check else subprocess.DEVNULL,
         text=True,
         shell=shell,
-        check=check,
     )
 
-    return proc
+    if check:
+        _check(proc.returncode, cmd, proc.stderr)
 
 
 async def run_process_async(
@@ -76,14 +82,14 @@ async def run_process_async(
     check: bool = True,
     cwd: Union[None, str, Path] = None,
     env: Union[None, Mapping[str, str]] = None,
-) -> CompletedProcess:
+) -> None:
     if not is_sequence(cmd):
         proc = await asyncio.create_subprocess_shell(
             str(cmd),
             cwd=cwd,
             env=env,
             stdout=asyncio.subprocess.DEVNULL,
-            stderr=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE if check else asyncio.subprocess.DEVNULL,
         )
 
     else:
@@ -94,7 +100,7 @@ async def run_process_async(
             cwd=cwd,
             env=env,
             stdout=asyncio.subprocess.DEVNULL,
-            stderr=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE if check else asyncio.subprocess.DEVNULL,
         )
 
     stdout, stderr = await proc.communicate()
@@ -102,9 +108,5 @@ async def run_process_async(
     assert stdout is None
     assert proc.returncode is not None
 
-    ret = CompletedProcess(cmd, proc.returncode, None, stderr.decode())
-
     if check:
-        ret.check_returncode()
-
-    return ret
+        _check(proc.returncode, cmd, stderr.decode())

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.3.0
+Version: 0.3.2
 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.dist-info/RECORD

@@ -0,0 +1,16 @@
+foamlib/__init__.py,sha256=RKXFmt6ZgoSEiW8H5loLPjL4VY_2oIla-Dd0C7pEUKY,431
+foamlib/_cases.py,sha256=SkUthKb98zXPMYACaGyfGC0Fo1jzD6cC4qEGesHfNfc,20554
+foamlib/_util.py,sha256=0HJ9n8QG9K7jC_xUDzOJo_NA2DBCJKJRLpmd5Yu42kU,2901
+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=aS8VDGifnDSX40HdgT512fuhQ9iGlPls3p133d64Rak,5975
+foamlib/_files/_io.py,sha256=alxMyxQh0zb6BZYqomZwOo9dQujMpRuS5yfpIKBEnaM,1976
+foamlib/_files/_parsing.py,sha256=blyt1kpYruoW5I6DMDg8jhg6f5oz7gzedmAImuJ5b4k,5966
+foamlib/_files/_serialization.py,sha256=H9STIpUxEBRwXh5WnqtjicCkGTpTYSwfWUwbVJf9x9A,2961
+foamlib-0.3.2.dist-info/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
+foamlib-0.3.2.dist-info/METADATA,sha256=DBX2JpB09uqjPowv_ShTp7BZ9ryRI_WqVmcpp7T2-DQ,4650
+foamlib-0.3.2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+foamlib-0.3.2.dist-info/top_level.txt,sha256=ZdVYtetXGwPwyfL-WhlhbTFQGAwKX5P_gXxtH9JYFPI,8
+foamlib-0.3.2.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,,