foamlib 0.3.1__tar.gz → 0.3.2__tar.gz

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

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

@@ -1,10 +1,10 @@
 """A Python interface for interacting with OpenFOAM."""
 
-__version__ = "0.3.1"
+__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.1 → 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
+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({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({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.1 → foamlib-0.3.2}/foamlib/_files/_serialization.py

@@ -8,18 +8,32 @@ else:
 from .._util import is_sequence
 from ._base import FoamDict
 
+try:
+    import numpy as np
 
-def serialize(
+    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 isinstance(data, Mapping):
+    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 = serialize(
+            s = dumps(
                 v,
                 assume_field=assume_field,
                 assume_dimensions=assume_dimensions,
@@ -43,17 +57,17 @@ def serialize(
 
     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)}"
+            return f"uniform {dumps(data)}"
         elif isinstance(data[0], (int, float)):
-            return f"nonuniform List<scalar> {len(data)}{serialize(data)}"
+            return f"nonuniform List<scalar> {len(data)}{dumps(data)}"
         elif len(data[0]) == 3:
-            return f"nonuniform List<vector> {len(data)}{serialize(data)}"
+            return f"nonuniform List<vector> {len(data)}{dumps(data)}"
         elif len(data[0]) == 6:
-            return f"nonuniform List<symmTensor> {len(data)}{serialize(data)}"
+            return f"nonuniform List<symmTensor> {len(data)}{dumps(data)}"
         elif len(data[0]) == 9:
-            return f"nonuniform List<tensor> {len(data)}{serialize(data)}"
+            return f"nonuniform List<tensor> {len(data)}{dumps(data)}"
         else:
-            return serialize(
+            return dumps(
                 data,
                 assume_dimensions=assume_dimensions,
                 assume_data_entries=assume_data_entries,
@@ -61,18 +75,20 @@ def serialize(
 
     elif assume_data_entries and isinstance(data, tuple):
         return " ".join(
-            serialize(v, assume_field=assume_field, assume_dimensions=assume_dimensions)
+            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(data.dimensions, assume_dimensions=True)} {serialize(data.value)}"
+            return f"{data.name} {dumps(data.dimensions, assume_dimensions=True)} {dumps(data.value)}"
         else:
-            return f"{serialize(data.dimensions, assume_dimensions=True)} {serialize(data.value)}"
+            return (
+                f"{dumps(data.dimensions, assume_dimensions=True)} {dumps(data.value)}"
+            )
 
     elif is_sequence(data):
-        return f"({' '.join(serialize(v) for v in data)})"
+        return f"({' '.join(dumps(v) for v in data)})"
 
     elif data is True:
         return "yes"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.3.1
+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