foamlib 0.3.0__tar.gz → 0.3.2__tar.gz

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

@@ -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.0 → foamlib-0.3.2}/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-0.3.0 → foamlib-0.3.2}/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.2}/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.2}/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-0.3.2/foamlib/_files/_serialization.py

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

{foamlib-0.3.0 → foamlib-0.3.2}/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 → foamlib-0.3.2}/foamlib.egg-info/PKG-INFO

@@ -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.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};"