foamlib 0.6.3__tar.gz → 0.6.4__tar.gz

{foamlib-0.6.3 → foamlib-0.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.6.3
+Version: 0.6.4
 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
@@ -69,7 +69,7 @@ Requires-Dist: foamlib[docs]; extra == "dev"
 It offers the following classes:
 
 * [`FoamFile`](https://foamlib.readthedocs.io/en/stable/files.html#foamlib.FoamFile) (and [`FoamFieldFile`](https://foamlib.readthedocs.io/en/stable/files.html#foamlib.FoamFieldFile)): read-write access to OpenFOAM configuration and field files as if they were Python `dict`s, using `foamlib`'s own parser. Supports both ASCII and binary field formats.
-* [`FoamCase`](https://foamlib.readthedocs.io/en/stable/cases.html#foamlib.FoamCase): a class for manipulating, executing and accessing the results of OpenFOAM cases.
+* [`FoamCase`](https://foamlib.readthedocs.io/en/stable/cases.html#foamlib.FoamCase): a class for configuring, running, and accessing the results of OpenFOAM cases.
 * [`AsyncFoamCase`](https://foamlib.readthedocs.io/en/stable/cases.html#foamlib.AsyncFoamCase): variant of `FoamCase` with asynchronous methods for running multiple cases at once.
 
 ## Get started
@@ -174,6 +174,18 @@ async def cost(x):
 result = differential_evolution(cost, bounds=[(-1, 1)], workers=AsyncFoamCase.map, polish=False)
 ```
 
+### Use it to create a `run` (or `clean`) script
+    
+```python
+#!/usr/bin/env python3
+from pathlib import Path
+from foamlib import FoamCase
+
+case = FoamCase(Path(__file__).parent)
+# Any additional configuration here
+case.run()
+```
+
 ## Documentation
 
 For more information, check out the [documentation](https://foamlib.readthedocs.io/).

{foamlib-0.6.3 → foamlib-0.6.4}/README.md

@@ -15,7 +15,7 @@
 It offers the following classes:
 
 * [`FoamFile`](https://foamlib.readthedocs.io/en/stable/files.html#foamlib.FoamFile) (and [`FoamFieldFile`](https://foamlib.readthedocs.io/en/stable/files.html#foamlib.FoamFieldFile)): read-write access to OpenFOAM configuration and field files as if they were Python `dict`s, using `foamlib`'s own parser. Supports both ASCII and binary field formats.
-* [`FoamCase`](https://foamlib.readthedocs.io/en/stable/cases.html#foamlib.FoamCase): a class for manipulating, executing and accessing the results of OpenFOAM cases.
+* [`FoamCase`](https://foamlib.readthedocs.io/en/stable/cases.html#foamlib.FoamCase): a class for configuring, running, and accessing the results of OpenFOAM cases.
 * [`AsyncFoamCase`](https://foamlib.readthedocs.io/en/stable/cases.html#foamlib.AsyncFoamCase): variant of `FoamCase` with asynchronous methods for running multiple cases at once.
 
 ## Get started
@@ -120,6 +120,18 @@ async def cost(x):
 result = differential_evolution(cost, bounds=[(-1, 1)], workers=AsyncFoamCase.map, polish=False)
 ```
 
+### Use it to create a `run` (or `clean`) script
+    
+```python
+#!/usr/bin/env python3
+from pathlib import Path
+from foamlib import FoamCase
+
+case = FoamCase(Path(__file__).parent)
+# Any additional configuration here
+case.run()
+```
+
 ## Documentation
 
 For more information, check out the [documentation](https://foamlib.readthedocs.io/).

{foamlib-0.6.3 → foamlib-0.6.4}/foamlib/__init__.py

@@ -1,9 +1,10 @@
 """A Python interface for interacting with OpenFOAM."""
 
-__version__ = "0.6.3"
+__version__ = "0.6.4"
 
 from ._cases import (
     AsyncFoamCase,
+    AsyncSlurmFoamCase,
     CalledProcessError,
     FoamCase,
     FoamCaseBase,
@@ -13,11 +14,12 @@ from ._files import FoamFieldFile, FoamFile, FoamFileBase
 
 __all__ = [
     "AsyncFoamCase",
+    "AsyncSlurmFoamCase",
     "CalledProcessError",
     "FoamFile",
     "FoamCase",
+    "FoamCaseBase",
     "FoamCaseRunBase",
     "FoamFieldFile",
-    "FoamCaseBase",
     "FoamFileBase",
 ]

{foamlib-0.6.3 → foamlib-0.6.4}/foamlib/_cases/__init__.py

@@ -1,6 +1,7 @@
 from ._async import AsyncFoamCase
 from ._base import FoamCaseBase
 from ._run import FoamCaseRunBase
+from ._slurm import AsyncSlurmFoamCase
 from ._subprocess import CalledProcessError
 from ._sync import FoamCase
 
@@ -8,6 +9,7 @@ __all__ = [
     "AsyncFoamCase",
     "FoamCaseBase",
     "FoamCaseRunBase",
+    "AsyncSlurmFoamCase",
     "CalledProcessError",
     "FoamCase",
 ]

{foamlib-0.6.3 → foamlib-0.6.4}/foamlib/_cases/_async.py

@@ -164,17 +164,20 @@ class AsyncFoamCase(FoamCaseRunBase):
         ):
             await coro
 
-    async def block_mesh(self, *, check: bool = True) -> None:
+    async def block_mesh(self, *, check: bool = True, log: bool = True) -> None:
         """Run blockMesh on this case."""
-        await self.run(["blockMesh"], check=check)
+        for coro in self._block_mesh_calls(check=check, log=log):
+            await coro
 
-    async def decompose_par(self, *, check: bool = True) -> None:
+    async def decompose_par(self, *, check: bool = True, log: bool = True) -> None:
         """Decompose this case for parallel running."""
-        await self.run(["decomposePar"], check=check)
+        for coro in self._decompose_par_calls(check=check, log=log):
+            await coro
 
-    async def reconstruct_par(self, *, check: bool = True) -> None:
+    async def reconstruct_par(self, *, check: bool = True, log: bool = True) -> None:
         """Reconstruct this case after parallel running."""
-        await self.run(["reconstructPar"], check=check)
+        for coro in self._reconstruct_par_calls(check=check, log=log):
+            await coro
 
     async def restore_0_dir(self) -> None:
         """Restore the 0 directory from the 0.orig directory."""

{foamlib-0.6.3 → foamlib-0.6.4}/foamlib/_cases/_run.py

@@ -63,7 +63,9 @@ class FoamCaseRunBase(FoamCaseBase):
 
             if ret not in self:
                 yield self._case.run(
-                    ["postProcess", "-func", "writeCellCentres", "-time", self.name]
+                    ["postProcess", "-func", "writeCellCentres", "-time", self.name],
+                    cpus=0,
+                    log=False,
                 )
 
             return ret
@@ -127,13 +129,19 @@ class FoamCaseRunBase(FoamCaseBase):
 
     @abstractmethod
     def block_mesh(
-        self, *, check: bool = True
+        self, *, check: bool = True, log: bool = True
     ) -> Union[None, Coroutine[None, None, None]]:
         raise NotImplementedError
 
     @abstractmethod
     def decompose_par(
-        self, *, check: bool = True
+        self, *, check: bool = True, log: bool = True
+    ) -> Union[None, Coroutine[None, None, None]]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def reconstruct_par(
+        self, *, check: bool = True, log: bool = True
     ) -> Union[None, Coroutine[None, None, None]]:
         raise NotImplementedError
 
@@ -318,6 +326,21 @@ class FoamCaseRunBase(FoamCaseBase):
         yield self._rmtree(self.path / "0", ignore_errors=True)
         yield self._copytree(self.path / "0.orig", self.path / "0", symlinks=True)
 
+    def _block_mesh_calls(
+        self, *, check: bool, log: bool
+    ) -> Generator[Any, None, None]:
+        yield self.run(["blockMesh"], cpus=0, check=check, log=log)
+
+    def _decompose_par_calls(
+        self, *, check: bool, log: bool
+    ) -> Generator[Any, None, None]:
+        yield self.run(["decomposePar"], cpus=0, check=check, log=log)
+
+    def _reconstruct_par_calls(
+        self, *, check: bool, log: bool
+    ) -> Generator[Any, None, None]:
+        yield self.run(["reconstructPar"], cpus=0, check=check, log=log)
+
     def _run_calls(
         self,
         cmd: Optional[Union[Sequence[Union[str, "os.PathLike[str]"]], str]] = None,
@@ -326,6 +349,7 @@ class FoamCaseRunBase(FoamCaseBase):
         cpus: Optional[int],
         check: bool,
         log: bool,
+        **kwargs: Any,
     ) -> Generator[Any, None, None]:
         if cmd is not None:
             if parallel:
@@ -358,6 +382,7 @@ class FoamCaseRunBase(FoamCaseBase):
                     env=self.__env(shell=isinstance(cmd, str)),
                     stdout=stdout,
                     stderr=stderr,
+                    **kwargs,
                 )
 
         else:
@@ -376,7 +401,9 @@ class FoamCaseRunBase(FoamCaseBase):
                     if cpus is None:
                         cpus = 1
 
-                yield self.run([script_path], parallel=False, cpus=cpus, check=check)
+                yield self.run(
+                    [script_path], parallel=False, cpus=cpus, check=check, **kwargs
+                )
 
             else:
                 if not self and (self.path / "0.orig").is_dir():
@@ -406,5 +433,9 @@ class FoamCaseRunBase(FoamCaseBase):
                         cpus = 1
 
                 yield self.run(
-                    [self.application], parallel=parallel, cpus=cpus, check=check
+                    [self.application],
+                    parallel=parallel,
+                    cpus=cpus,
+                    check=check,
+                    **kwargs,
                 )

foamlib-0.6.4/foamlib/_cases/_slurm.py

@@ -0,0 +1,69 @@
+import os
+import shutil
+import sys
+from typing import Any, Optional, Union
+
+if sys.version_info >= (3, 9):
+    from collections.abc import Sequence
+else:
+    from typing import Sequence
+
+from ._async import AsyncFoamCase
+from ._subprocess import run_async
+
+
+class AsyncSlurmFoamCase(AsyncFoamCase):
+    """An asynchronous OpenFOAM case that launches jobs on a Slurm cluster."""
+
+    @staticmethod
+    async def _run(
+        cmd: Union[Sequence[Union[str, "os.PathLike[str]"]], str],
+        *,
+        cpus: int,
+        fallback: bool = False,
+        **kwargs: Any,
+    ) -> None:
+        if fallback and shutil.which("salloc") is None:
+            await AsyncFoamCase._run(cmd, cpus=cpus, **kwargs)
+            return
+
+        if cpus >= 1:
+            if isinstance(cmd, str):
+                cmd = ["/bin/sh", "-c", cmd]
+
+            if cpus == 1:
+                cmd = ["srun", *cmd]
+
+            cmd = ["salloc", "-n", str(cpus), "--job-name", "foamlib", *cmd]
+
+        await run_async(cmd, **kwargs)
+
+    async def run(
+        self,
+        cmd: Optional[Union[Sequence[Union[str, "os.PathLike[str]"]], str]] = None,
+        *,
+        parallel: Optional[bool] = None,
+        cpus: Optional[int] = None,
+        check: bool = True,
+        log: bool = True,
+        fallback: bool = False,
+    ) -> None:
+        """
+        Run this case, or a specified command in the context of this case.
+
+        :param cmd: The command to run. If None, run the case. If a sequence, the first element is the command and the rest are arguments. If a string, `cmd` is executed in a shell.
+        :param parallel: If True, run in parallel using MPI. If None, autodetect whether to run in parallel.
+        :param cpus: The number of CPUs to use. If None, autodetect according to the case. If 0, run locally.
+        :param check: If True, raise a CalledProcessError if any command returns a non-zero exit code.
+        :param log: If True, log the command output to a file.
+        :param fallback: If True, fall back to running the command locally if Slurm is not available.
+        """
+        for coro in self._run_calls(
+            cmd=cmd,
+            parallel=parallel,
+            cpus=cpus,
+            check=check,
+            log=log,
+            fallback=fallback,
+        ):
+            await coro

{foamlib-0.6.3 → foamlib-0.6.4}/foamlib/_cases/_sync.py

@@ -139,17 +139,20 @@ class FoamCase(FoamCaseRunBase):
         ):
             pass
 
-    def block_mesh(self, *, check: bool = True) -> None:
+    def block_mesh(self, *, check: bool = True, log: bool = True) -> None:
         """Run blockMesh on this case."""
-        self.run(["blockMesh"], check=check)
+        for _ in self._block_mesh_calls(check=check, log=log):
+            pass
 
-    def decompose_par(self, *, check: bool = True) -> None:
+    def decompose_par(self, *, check: bool = True, log: bool = True) -> None:
         """Decompose this case for parallel running."""
-        self.run(["decomposePar"], check=check)
+        for _ in self._decompose_par_calls(check=check, log=log):
+            pass
 
-    def reconstruct_par(self, *, check: bool = True) -> None:
+    def reconstruct_par(self, *, check: bool = True, log: bool = True) -> None:
         """Reconstruct this case after parallel running."""
-        self.run(["reconstructPar"], check=check)
+        for _ in self._reconstruct_par_calls(check=check, log=log):
+            pass
 
     def restore_0_dir(self) -> None:
         """Restore the 0 directory from the 0.orig directory."""
@@ -164,12 +167,12 @@ class FoamCase(FoamCaseRunBase):
 
         :param dst: The destination path. If None, clone to `$FOAM_RUN/foamlib`.
         """
-        cmds = ValuedGenerator(self._copy_calls(dst))
+        calls = ValuedGenerator(self._copy_calls(dst))
 
-        for _ in cmds:
+        for _ in calls:
             pass
 
-        return cmds.value
+        return calls.value
 
     def clone(self, dst: Optional[Union["os.PathLike[str]", str]] = None) -> Self:
         """
@@ -179,9 +182,9 @@ class FoamCase(FoamCaseRunBase):
 
         :param dst: The destination path. If None, clone to `$FOAM_RUN/foamlib`.
         """
-        cmds = ValuedGenerator(self._clone_calls(dst))
+        calls = ValuedGenerator(self._clone_calls(dst))
 
-        for _ in cmds:
+        for _ in calls:
             pass
 
-        return cmds.value
+        return calls.value

{foamlib-0.6.3 → foamlib-0.6.4}/foamlib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.6.3
+Version: 0.6.4
 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
@@ -69,7 +69,7 @@ Requires-Dist: foamlib[docs]; extra == "dev"
 It offers the following classes:
 
 * [`FoamFile`](https://foamlib.readthedocs.io/en/stable/files.html#foamlib.FoamFile) (and [`FoamFieldFile`](https://foamlib.readthedocs.io/en/stable/files.html#foamlib.FoamFieldFile)): read-write access to OpenFOAM configuration and field files as if they were Python `dict`s, using `foamlib`'s own parser. Supports both ASCII and binary field formats.
-* [`FoamCase`](https://foamlib.readthedocs.io/en/stable/cases.html#foamlib.FoamCase): a class for manipulating, executing and accessing the results of OpenFOAM cases.
+* [`FoamCase`](https://foamlib.readthedocs.io/en/stable/cases.html#foamlib.FoamCase): a class for configuring, running, and accessing the results of OpenFOAM cases.
 * [`AsyncFoamCase`](https://foamlib.readthedocs.io/en/stable/cases.html#foamlib.AsyncFoamCase): variant of `FoamCase` with asynchronous methods for running multiple cases at once.
 
 ## Get started
@@ -174,6 +174,18 @@ async def cost(x):
 result = differential_evolution(cost, bounds=[(-1, 1)], workers=AsyncFoamCase.map, polish=False)
 ```
 
+### Use it to create a `run` (or `clean`) script
+    
+```python
+#!/usr/bin/env python3
+from pathlib import Path
+from foamlib import FoamCase
+
+case = FoamCase(Path(__file__).parent)
+# Any additional configuration here
+case.run()
+```
+
 ## Documentation
 
 For more information, check out the [documentation](https://foamlib.readthedocs.io/).

{foamlib-0.6.3 → foamlib-0.6.4}/foamlib.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ foamlib/_cases/__init__.py
 foamlib/_cases/_async.py
 foamlib/_cases/_base.py
 foamlib/_cases/_run.py
+foamlib/_cases/_slurm.py
 foamlib/_cases/_subprocess.py
 foamlib/_cases/_sync.py
 foamlib/_cases/_util.py