foamlib 0.5.0__tar.gz → 0.6.0__tar.gz

{foamlib-0.5.0 → foamlib-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.5.0
+Version: 0.6.0
 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
@@ -155,6 +155,25 @@ U = FoamFieldFile(Path(my_pitz) / "0/U")
 print(U.internal_field)
 ```
 
+### Run an optimization loop in parallel
+
+```python
+import os
+from pathlib import Path
+from foamlib import AsyncFoamCase
+from scipy.optimize import differential_evolution
+
+base = AsyncFoamCase(Path(os.environ["FOAM_TUTORIALS"]) / "incompressible/simpleFoam/pitzDaily")
+
+async def cost(x):
+    async with base.clone() as clone:
+        clone[0]["U"].boundary_field["inlet"].value = [x[0], 0, 0]
+        await clone.run()
+        return abs(clone[-1]["U"].internal_field[0][0])
+
+result = differential_evolution(cost, bounds=[(-1, 1)], workers=AsyncFoamCase.map, polish=False)
+```
+
 ## Documentation
 
 For more information, check out the [documentation](https://foamlib.readthedocs.io/).

{foamlib-0.5.0 → foamlib-0.6.0}/README.md

@@ -101,6 +101,25 @@ U = FoamFieldFile(Path(my_pitz) / "0/U")
 print(U.internal_field)
 ```
 
+### Run an optimization loop in parallel
+
+```python
+import os
+from pathlib import Path
+from foamlib import AsyncFoamCase
+from scipy.optimize import differential_evolution
+
+base = AsyncFoamCase(Path(os.environ["FOAM_TUTORIALS"]) / "incompressible/simpleFoam/pitzDaily")
+
+async def cost(x):
+    async with base.clone() as clone:
+        clone[0]["U"].boundary_field["inlet"].value = [x[0], 0, 0]
+        await clone.run()
+        return abs(clone[-1]["U"].internal_field[0][0])
+
+result = differential_evolution(cost, bounds=[(-1, 1)], workers=AsyncFoamCase.map, polish=False)
+```
+
 ## Documentation
 
 For more information, check out the [documentation](https://foamlib.readthedocs.io/).

{foamlib-0.5.0 → foamlib-0.6.0}/foamlib/__init__.py

@@ -1,6 +1,6 @@
 """A Python interface for interacting with OpenFOAM."""
 
-__version__ = "0.5.0"
+__version__ = "0.6.0"
 
 from ._cases import (
     AsyncFoamCase,

{foamlib-0.5.0 → foamlib-0.6.0}/foamlib/_cases/_async.py

@@ -2,19 +2,19 @@ import asyncio
 import multiprocessing
 import os
 import sys
-import tempfile
 from contextlib import asynccontextmanager
-from pathlib import Path
-from typing import (
-    Callable,
-    Optional,
-    Union,
-)
+from typing import Any, Callable, Optional, TypeVar, Union
 
 if sys.version_info >= (3, 9):
-    from collections.abc import AsyncGenerator, Collection, Sequence
+    from collections.abc import (
+        AsyncGenerator,
+        Awaitable,
+        Collection,
+        Iterable,
+        Sequence,
+    )
 else:
-    from typing import AsyncGenerator, Collection, Sequence
+    from typing import AsyncGenerator, Awaitable, Collection, Iterable, Sequence
 
 if sys.version_info >= (3, 11):
     from typing import Self
@@ -23,12 +23,15 @@ else:
 
 import aioshutil
 
-from ._recipes import _FoamCaseRecipes
+from ._run import FoamCaseRunBase
 from ._subprocess import run_async
-from ._util import awaitableasynccontextmanager
+from ._util import ValuedGenerator, awaitableasynccontextmanager
 
+X = TypeVar("X")
+Y = TypeVar("Y")
 
-class AsyncFoamCase(_FoamCaseRecipes):
+
+class AsyncFoamCase(FoamCaseRunBase):
     """
     An OpenFOAM case with asynchronous support.
 
@@ -45,14 +48,11 @@ class AsyncFoamCase(_FoamCaseRecipes):
     """
 
     _reserved_cpus = 0
-    _cpus_cond = None  # Cannot be initialized here yet
+    _cpus_cond = asyncio.Condition()
 
     @staticmethod
     @asynccontextmanager
     async def _cpus(cpus: int) -> AsyncGenerator[None, None]:
-        if AsyncFoamCase._cpus_cond is None:
-            AsyncFoamCase._cpus_cond = asyncio.Condition()
-
         cpus = min(cpus, AsyncFoamCase.max_cpus)
         if cpus > 0:
             async with AsyncFoamCase._cpus_cond:
@@ -69,6 +69,16 @@ class AsyncFoamCase(_FoamCaseRecipes):
                     AsyncFoamCase._reserved_cpus -= cpus
                     AsyncFoamCase._cpus_cond.notify(cpus)
 
+    @staticmethod
+    async def _run(
+        cmd: Union[Sequence[Union[str, "os.PathLike[str]"]], str],
+        *,
+        cpus: int,
+        **kwargs: Any,
+    ) -> None:
+        async with AsyncFoamCase._cpus(cpus):
+            await run_async(cmd, **kwargs)
+
     @staticmethod
     async def _rmtree(
         path: Union["os.PathLike[str]", str], ignore_errors: bool = False
@@ -87,75 +97,37 @@ class AsyncFoamCase(_FoamCaseRecipes):
     ) -> None:
         await aioshutil.copytree(src, dest, symlinks=symlinks, ignore=ignore)
 
-    async def clean(
-        self,
-        *,
-        script: bool = True,
-        check: bool = False,
-    ) -> None:
+    async def clean(self, *, check: bool = False) -> None:
         """
         Clean this case.
 
-        :param script: If True, use an (All)clean script if it exists. If False, ignore any clean scripts.
         :param check: If True, raise a CalledProcessError if the clean script returns a non-zero exit code.
         """
-        for name, args, kwargs in self._clean_cmds(script=script, check=check):
-            await getattr(self, name)(*args, **kwargs)
-
-    async def _run(
-        self,
-        cmd: Union[Sequence[Union[str, "os.PathLike[str]"]], str],
-        *,
-        parallel: bool = False,
-        cpus: int = 1,
-        check: bool = True,
-        log: bool = True,
-    ) -> None:
-        with self._output(cmd, log=log) as (stdout, stderr):
-            if parallel:
-                if isinstance(cmd, str):
-                    cmd = [
-                        "mpiexec",
-                        "-n",
-                        str(cpus),
-                        "/bin/sh",
-                        "-c",
-                        f"{cmd} -parallel",
-                    ]
-                else:
-                    cmd = ["mpiexec", "-n", str(cpus), *cmd, "-parallel"]
-
-            async with self._cpus(cpus):
-                await run_async(
-                    cmd,
-                    check=check,
-                    cwd=self.path,
-                    env=self._env(shell=isinstance(cmd, str)),
-                    stdout=stdout,
-                    stderr=stderr,
-                )
+        for coro in self._clean_calls(check=check):
+            await coro
 
     async def run(
         self,
         cmd: Optional[Union[Sequence[Union[str, "os.PathLike[str]"]], str]] = None,
         *,
-        script: bool = True,
         parallel: Optional[bool] = None,
         cpus: Optional[int] = None,
         check: bool = True,
+        log: bool = True,
     ) -> 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 script: If True and `cmd` is None, use an (All)run(-parallel) script if it exists for running the case. If False or no run script is found, autodetermine the command(s) needed to run the case.
         :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.
         :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.
         """
-        for name, args, kwargs in self._run_cmds(
-            cmd=cmd, script=script, parallel=parallel, cpus=cpus, check=check
+        for coro in self._run_calls(
+            cmd=cmd, parallel=parallel, cpus=cpus, check=check, log=log
         ):
-            await getattr(self, name)(*args, **kwargs)
+            await coro
 
     async def block_mesh(self, *, check: bool = True) -> None:
         """Run blockMesh on this case."""
@@ -171,8 +143,8 @@ class AsyncFoamCase(_FoamCaseRecipes):
 
     async def restore_0_dir(self) -> None:
         """Restore the 0 directory from the 0.orig directory."""
-        for name, args, kwargs in self._restore_0_dir_cmds():
-            await getattr(self, name)(*args, **kwargs)
+        for coro in self._restore_0_dir_calls():
+            await coro
 
     @awaitableasynccontextmanager
     @asynccontextmanager
@@ -184,24 +156,16 @@ class AsyncFoamCase(_FoamCaseRecipes):
 
         Use as an async context manager to automatically delete the copy when done.
 
-        :param dst: The destination path. If None, copy to a temporary directory.
+        :param dst: The destination path. If None, clone to `$FOAM_RUN/foamlib`.
         """
-        if dst is None:
-            dst = Path(tempfile.mkdtemp(), self.name)
-            tmp = True
-        else:
-            tmp = False
+        calls = ValuedGenerator(self._copy_calls(dst))
 
-        for name, args, kwargs in self._copy_cmds(dst):
-            await getattr(self, name)(*args, **kwargs)
+        for coro in calls:
+            await coro
 
-        yield type(self)(dst)
+        yield calls.value
 
-        if tmp:
-            assert isinstance(dst, Path)
-            await self._rmtree(dst.parent)
-        else:
-            await self._rmtree(dst)
+        await self._rmtree(calls.value.path)
 
     @awaitableasynccontextmanager
     @asynccontextmanager
@@ -213,21 +177,20 @@ class AsyncFoamCase(_FoamCaseRecipes):
 
         Use as an async context manager to automatically delete the clone when done.
 
-        :param dst: The destination path. If None, clone to a temporary directory.
+        :param dst: The destination path. If None, clone to `$FOAM_RUN/foamlib`.
         """
-        if dst is None:
-            dst = Path(tempfile.mkdtemp(), self.name)
-            tmp = True
-        else:
-            tmp = False
-
-        for name, args, kwargs in self._clone_cmds(dst):
-            await getattr(self, name)(*args, **kwargs)
-
-        yield type(self)(dst)
-
-        if tmp:
-            assert isinstance(dst, Path)
-            await self._rmtree(dst.parent)
-        else:
-            await self._rmtree(dst)
+        calls = ValuedGenerator(self._clone_calls(dst))
+
+        for coro in calls:
+            await coro
+
+        yield calls.value
+
+        await self._rmtree(calls.value.path)
+
+    @staticmethod
+    def map(coro: Callable[[X], Awaitable[Y]], iterable: Iterable[X]) -> Iterable[Y]:
+        """Run an async function on each element of an iterable concurrently."""
+        return asyncio.get_event_loop().run_until_complete(
+            asyncio.gather(*(coro(arg) for arg in iterable))
+        )

foamlib-0.5.0/foamlib/_cases/_recipes.py → foamlib-0.6.0/foamlib/_cases/_run.py

@@ -2,6 +2,8 @@ import os
 import shlex
 import shutil
 import sys
+import tempfile
+from abc import abstractmethod
 from contextlib import contextmanager
 from pathlib import Path
 from typing import (
@@ -16,6 +18,7 @@ if sys.version_info >= (3, 9):
     from collections.abc import (
         Callable,
         Collection,
+        Coroutine,
         Generator,
         Mapping,
         Sequence,
@@ -26,17 +29,96 @@ else:
     from typing import (
         Callable,
         Collection,
+        Coroutine,
         Generator,
         Mapping,
         Sequence,
     )
 
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
 from ._base import FoamCaseBase
 from ._subprocess import DEVNULL, STDOUT
 
 
-class _FoamCaseRecipes(FoamCaseBase):
-    def _clean_paths(self) -> Set[Path]:
+class FoamCaseRunBase(FoamCaseBase):
+    def __delitem__(self, key: Union[int, float, str]) -> None:
+        shutil.rmtree(self[key].path)
+
+    @staticmethod
+    @abstractmethod
+    def _run(
+        cmd: Union[Sequence[Union[str, "os.PathLike[str]"]], str],
+        *,
+        cpus: int,
+        **kwargs: Any,
+    ) -> Union[None, Coroutine[None, None, None]]:
+        raise NotImplementedError
+
+    @staticmethod
+    @abstractmethod
+    def _rmtree(
+        path: Union["os.PathLike[str]", str], *, ignore_errors: bool = False
+    ) -> Union[None, Coroutine[None, None, None]]:
+        raise NotImplementedError
+
+    @staticmethod
+    @abstractmethod
+    def _copytree(
+        src: Union["os.PathLike[str]", str],
+        dest: Union["os.PathLike[str]", str],
+        *,
+        symlinks: bool = False,
+        ignore: Optional[
+            Callable[[Union["os.PathLike[str]", str], Collection[str]], Collection[str]]
+        ] = None,
+    ) -> Union[None, Coroutine[None, None, None]]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def clean(self, *, check: bool = False) -> Union[None, Coroutine[None, None, None]]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def copy(self, dst: Optional[Union["os.PathLike[str]", str]] = None) -> Any:
+        raise NotImplementedError
+
+    @abstractmethod
+    def clone(self, dst: Optional[Union["os.PathLike[str]", str]] = None) -> Any:
+        raise NotImplementedError
+
+    @abstractmethod
+    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,
+    ) -> Union[None, Coroutine[None, None, None]]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def block_mesh(
+        self, *, check: bool = True
+    ) -> Union[None, Coroutine[None, None, None]]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def decompose_par(
+        self, *, check: bool = True
+    ) -> Union[None, Coroutine[None, None, None]]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def restore_0_dir(self) -> Union[None, Coroutine[None, None, None]]:
+        raise NotImplementedError
+
+    def __clean_paths(self) -> Set[Path]:
         has_decompose_par_dict = (self.path / "system" / "decomposeParDict").is_file()
         has_block_mesh_dict = (self.path / "system" / "blockMeshDict").is_file()
 
@@ -61,18 +143,14 @@ class _FoamCaseRecipes(FoamCaseBase):
         if has_block_mesh_dict and (self.path / "constant" / "polyMesh").exists():
             paths.add(self.path / "constant" / "polyMesh")
 
-        if self._run_script() is not None:
-            paths.update(self.path.glob("log.*"))
+        paths.update(self.path.glob("log.*"))
 
         return paths
 
-    def __delitem__(self, key: Union[int, float, str]) -> None:
-        shutil.rmtree(self[key].path)
-
-    def _clone_ignore(
+    def __clone_ignore(
         self,
     ) -> Callable[[Union["os.PathLike[str]", str], Collection[str]], Collection[str]]:
-        clean_paths = self._clean_paths()
+        clean_paths = self.__clean_paths()
 
         def ignore(
             path: Union["os.PathLike[str]", str], names: Collection[str]
@@ -82,7 +160,7 @@ class _FoamCaseRecipes(FoamCaseBase):
 
         return ignore
 
-    def _clean_script(self) -> Optional[Path]:
+    def __clean_script(self) -> Optional[Path]:
         """Return the path to the (All)clean script, or None if no clean script is found."""
         clean = self.path / "clean"
         all_clean = self.path / "Allclean"
@@ -97,9 +175,9 @@ class _FoamCaseRecipes(FoamCaseBase):
         if sys.argv and Path(sys.argv[0]).absolute() == script.absolute():
             return None
 
-        return script if Path(sys.argv[0]).absolute() != script.absolute() else None
+        return script
 
-    def _run_script(self, *, parallel: Optional[bool] = None) -> Optional[Path]:
+    def __run_script(self, *, parallel: Optional[bool] = None) -> Optional[Path]:
         """Return the path to the (All)run script, or None if no run script is found."""
         run = self.path / "run"
         run_parallel = self.path / "run-parallel"
@@ -132,7 +210,7 @@ class _FoamCaseRecipes(FoamCaseBase):
 
         return script
 
-    def _env(self, *, shell: bool) -> Optional[Mapping[str, str]]:
+    def __env(self, *, shell: bool) -> Optional[Mapping[str, str]]:
         sip_workaround = os.environ.get(
             "FOAM_LD_LIBRARY_PATH", ""
         ) and not os.environ.get("DYLD_LIBRARY_PATH", "")
@@ -151,7 +229,7 @@ class _FoamCaseRecipes(FoamCaseBase):
             return None
 
     @contextmanager
-    def _output(
+    def __output(
         self, cmd: Union[Sequence[Union[str, "os.PathLike[str]"]], str], *, log: bool
     ) -> Generator[Tuple[Union[int, IO[bytes]], Union[int, IO[bytes]]], None, None]:
         if log:
@@ -168,70 +246,64 @@ class _FoamCaseRecipes(FoamCaseBase):
         else:
             yield DEVNULL, DEVNULL
 
-    def _copy_cmds(
-        self, dest: Union["os.PathLike[str]", str]
-    ) -> Generator[Tuple[str, Sequence[Any], Mapping[str, Any]], None, None]:
-        yield (
-            "_copytree",
-            (
-                self.path,
-                dest,
-            ),
-            {"symlinks": True},
-        )
-
-    def _clean_cmds(
-        self, *, script: bool = True, check: bool = False
-    ) -> Generator[Tuple[str, Sequence[Any], Mapping[str, Any]], None, None]:
-        script_path = self._clean_script() if script else None
+    def __mkrundir(self) -> Path:
+        d = Path(os.environ["FOAM_RUN"], "foamlib")
+        d.mkdir(parents=True, exist_ok=True)
+        ret = Path(tempfile.mkdtemp(prefix=f"{self.name}-", dir=d))
+        ret.rmdir()
+        return ret
+
+    def _copy_calls(
+        self, dst: Optional[Union["os.PathLike[str]", str]]
+    ) -> Generator[Any, None, Self]:
+        if dst is None:
+            dst = self.__mkrundir()
+
+        yield self._copytree(self.path, dst, symlinks=True)
+
+        return type(self)(dst)
+
+    def _clean_calls(self, *, check: bool = False) -> Generator[Any, None, None]:
+        script_path = self.__clean_script()
 
         if script_path is not None:
-            yield ("_run", ([script_path],), {"cpus": 0, "check": check, "log": False})
+            yield self.run([script_path], cpus=0, check=check, log=False)
         else:
-            for p in self._clean_paths():
+            for p in self.__clean_paths():
                 if p.is_dir():
-                    yield ("_rmtree", (p,), {})
+                    yield self._rmtree(p)
                 else:
                     p.unlink()
 
-    def _clone_cmds(
-        self, dest: Union["os.PathLike[str]", str]
-    ) -> Generator[Tuple[str, Sequence[Any], Mapping[str, Any]], None, None]:
-        if self._clean_script() is not None:
-            yield ("copy", (dest,), {})
-            yield ("clean", (), {})
+    def _clone_calls(
+        self, dst: Optional[Union["os.PathLike[str]", str]]
+    ) -> Generator[Any, None, Self]:
+        if dst is None:
+            dst = self.__mkrundir()
+
+        if self.__clean_script() is not None:
+            yield self.copy(dst)
+            yield type(self)(dst).clean()
         else:
-            yield (
-                "_copytree",
-                (
-                    self.path,
-                    dest,
-                ),
-                {"symlinks": True, "ignore": self._clone_ignore()},
+            yield self._copytree(
+                self.path, dst, symlinks=True, ignore=self.__clone_ignore()
             )
 
-    def _restore_0_dir_cmds(
-        self,
-    ) -> Generator[Tuple[str, Sequence[Any], Mapping[str, Any]], None, None]:
-        yield ("_rmtree", (self.path / "0",), {"ignore_errors": True})
-        yield (
-            "_copytree",
-            (
-                self.path / "0.orig",
-                self.path / "0",
-            ),
-            {"symlinks": True},
-        )
-
-    def _run_cmds(
+        return type(self)(dst)
+
+    def _restore_0_dir_calls(self) -> Generator[Any, None, None]:
+        yield self._rmtree(self.path / "0", ignore_errors=True)
+        yield self._copytree(self.path / "0.orig", self.path / "0", symlinks=True)
+
+    def _run_calls(
         self,
         cmd: Optional[Union[Sequence[Union[str, "os.PathLike[str]"]], str]] = None,
         *,
-        script: bool = True,
         parallel: Optional[bool] = None,
         cpus: Optional[int] = None,
         check: bool = True,
-    ) -> Generator[Tuple[str, Sequence[Any], Mapping[str, Any]], None, None]:
+        log: bool = True,
+    ) -> Generator[Any, None, None]:
         if cmd is not None:
             if parallel:
                 if cpus is None:
@@ -241,10 +313,32 @@ class _FoamCaseRecipes(FoamCaseBase):
                 if cpus is None:
                     cpus = 1
 
-            yield ("_run", (cmd,), {"parallel": parallel, "cpus": cpus, "check": check})
+            with self.__output(cmd, log=log) as (stdout, stderr):
+                if parallel:
+                    if isinstance(cmd, str):
+                        cmd = [
+                            "mpiexec",
+                            "-n",
+                            str(cpus),
+                            "/bin/sh",
+                            "-c",
+                            f"{cmd} -parallel",
+                        ]
+                    else:
+                        cmd = ["mpiexec", "-n", str(cpus), *cmd, "-parallel"]
+
+                yield self._run(
+                    cmd,
+                    cpus=cpus,
+                    check=check,
+                    cwd=self.path,
+                    env=self.__env(shell=isinstance(cmd, str)),
+                    stdout=stdout,
+                    stderr=stderr,
+                )
 
         else:
-            script_path = self._run_script(parallel=parallel) if script else None
+            script_path = self.__run_script(parallel=parallel)
 
             if script_path is not None:
                 if parallel or parallel is None:
@@ -259,18 +353,14 @@ class _FoamCaseRecipes(FoamCaseBase):
                     if cpus is None:
                         cpus = 1
 
-                yield (
-                    "_run",
-                    ([script_path],),
-                    {"parallel": False, "cpus": cpus, "check": check},
-                )
+                yield self.run([script_path], parallel=False, cpus=cpus, check=check)
 
             else:
                 if not self and (self.path / "0.orig").is_dir():
-                    yield ("restore_0_dir", (), {})
+                    yield self.restore_0_dir()
 
                 if (self.path / "system" / "blockMeshDict").is_file():
-                    yield ("block_mesh", (), {"check": check})
+                    yield self.block_mesh(check=check)
 
                 if parallel is None:
                     parallel = (
@@ -284,7 +374,7 @@ class _FoamCaseRecipes(FoamCaseBase):
                         self._nprocessors == 0
                         and (self.path / "system" / "decomposeParDict").is_file()
                     ):
-                        yield ("decompose_par", (), {"check": check})
+                        yield self.decompose_par(check=check)
 
                     if cpus is None:
                         cpus = max(self._nprocessors, 1)
@@ -292,8 +382,6 @@ class _FoamCaseRecipes(FoamCaseBase):
                     if cpus is None:
                         cpus = 1
 
-                yield (
-                    "_run",
-                    ([self.application],),
-                    {"parallel": parallel, "cpus": cpus, "check": check},
+                yield self.run(
+                    [self.application], parallel=parallel, cpus=cpus, check=check
                 )

{foamlib-0.5.0 → foamlib-0.6.0}/foamlib/_cases/_sync.py

@@ -1,10 +1,10 @@
 import os
 import shutil
 import sys
-import tempfile
 from pathlib import Path
 from types import TracebackType
 from typing import (
+    Any,
     Callable,
     Optional,
     Type,
@@ -21,11 +21,12 @@ if sys.version_info >= (3, 11):
 else:
     from typing_extensions import Self
 
-from ._recipes import _FoamCaseRecipes
+from ._run import FoamCaseRunBase
 from ._subprocess import run_sync
+from ._util import ValuedGenerator
 
 
-class FoamCase(_FoamCaseRecipes):
+class FoamCase(FoamCaseRunBase):
     """
     An OpenFOAM case.
 
@@ -36,6 +37,18 @@ class FoamCase(_FoamCaseRecipes):
     :param path: The path to the case directory.
     """
 
+    def __init__(self, path: Union["os.PathLike[str]", str] = Path()):
+        super().__init__(path)
+
+    @staticmethod
+    def _run(
+        cmd: Union[Sequence[Union[str, "os.PathLike[str]"]], str],
+        *,
+        cpus: int,
+        **kwargs: Any,
+    ) -> None:
+        run_sync(cmd, **kwargs)
+
     @staticmethod
     def _rmtree(
         path: Union["os.PathLike[str]", str], *, ignore_errors: bool = False
@@ -65,73 +78,35 @@ class FoamCase(_FoamCaseRecipes):
     ) -> None:
         self._rmtree(self.path)
 
-    def clean(
-        self,
-        *,
-        script: bool = True,
-        check: bool = False,
-    ) -> None:
+    def clean(self, *, check: bool = False) -> None:
         """
         Clean this case.
 
-        :param script: If True, use an (All)clean script if it exists. If False, ignore any clean scripts.
         :param check: If True, raise a CalledProcessError if the clean script returns a non-zero exit code.
         """
-        for name, args, kwargs in self._clean_cmds(script=script, check=check):
-            getattr(self, name)(*args, **kwargs)
-
-    def _run(
-        self,
-        cmd: Union[Sequence[Union[str, "os.PathLike[str]"]], str],
-        *,
-        parallel: bool = False,
-        cpus: int = 1,
-        check: bool = True,
-        log: bool = True,
-    ) -> None:
-        with self._output(cmd, log=log) as (stdout, stderr):
-            if parallel:
-                if isinstance(cmd, str):
-                    cmd = [
-                        "mpiexec",
-                        "-n",
-                        str(cpus),
-                        "/bin/sh",
-                        "-c",
-                        f"{cmd} -parallel",
-                    ]
-                else:
-                    cmd = ["mpiexec", "-n", str(cpus), *cmd, "-parallel"]
-
-            run_sync(
-                cmd,
-                check=check,
-                cwd=self.path,
-                env=self._env(shell=isinstance(cmd, str)),
-                stdout=stdout,
-                stderr=stderr,
-            )
+        for _ in self._clean_calls(check=check):
+            pass
 
     def run(
         self,
         cmd: Optional[Union[Sequence[Union[str, "os.PathLike[str]"]], str]] = None,
         *,
-        script: bool = True,
         parallel: Optional[bool] = None,
+        cpus: Optional[int] = None,
         check: bool = True,
+        log: bool = True,
     ) -> 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 script: If True and `cmd` is None, use an (All)run(-parallel) script if it exists for running the case. If False or no run script is found, autodetermine the command(s) needed to run the case.
         :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.
         :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.
         """
-        for name, args, kwargs in self._run_cmds(
-            cmd=cmd, script=script, parallel=parallel, check=check
-        ):
-            getattr(self, name)(*args, **kwargs)
+        for _ in self._run_calls(cmd=cmd, parallel=parallel, check=check):
+            pass
 
     def block_mesh(self, *, check: bool = True) -> None:
         """Run blockMesh on this case."""
@@ -147,37 +122,35 @@ class FoamCase(_FoamCaseRecipes):
 
     def restore_0_dir(self) -> None:
         """Restore the 0 directory from the 0.orig directory."""
-        for name, args, kwargs in self._restore_0_dir_cmds():
-            getattr(self, name)(*args, **kwargs)
+        for _ in self._restore_0_dir_calls():
+            pass
 
-    def copy(self, dst: Optional[Union["os.PathLike[str]", str]] = None) -> "Self":
+    def copy(self, dst: Optional[Union["os.PathLike[str]", str]] = None) -> Self:
         """
         Make a copy of this case.
 
         Use as a context manager to automatically delete the copy when done.
 
-        :param dst: The destination path. If None, copy to a temporary directory.
+        :param dst: The destination path. If None, clone to `$FOAM_RUN/foamlib`.
         """
-        if dst is None:
-            dst = Path(tempfile.mkdtemp(), self.name)
+        cmds = ValuedGenerator(self._copy_calls(dst))
 
-        for name, args, kwargs in self._copy_cmds(dst):
-            getattr(self, name)(*args, **kwargs)
+        for _ in cmds:
+            pass
 
-        return type(self)(dst)
+        return cmds.value
 
-    def clone(self, dst: Optional[Union["os.PathLike[str]", str]] = None) -> "Self":
+    def clone(self, dst: Optional[Union["os.PathLike[str]", str]] = None) -> Self:
         """
         Clone this case (make a clean copy).
 
         Use as a context manager to automatically delete the clone when done.
 
-        :param dst: The destination path. If None, clone to a temporary directory.
+        :param dst: The destination path. If None, clone to `$FOAM_RUN/foamlib`.
         """
-        if dst is None:
-            dst = Path(tempfile.mkdtemp(), self.name)
+        cmds = ValuedGenerator(self._clone_calls(dst))
 
-        for name, args, kwargs in self._clone_cmds(dst):
-            getattr(self, name)(*args, **kwargs)
+        for _ in cmds:
+            pass
 
-        return type(self)(dst)
+        return cmds.value

foamlib-0.6.0/foamlib/_cases/_util.py

@@ -0,0 +1,60 @@
+import functools
+import sys
+from types import TracebackType
+from typing import (
+    Any,
+    AsyncContextManager,
+    Callable,
+    Generic,
+    Optional,
+    Type,
+    TypeVar,
+)
+
+if sys.version_info >= (3, 9):
+    from collections.abc import Generator
+else:
+    from typing import Generator
+
+
+Y = TypeVar("Y")
+S = TypeVar("S")
+R = TypeVar("R")
+
+
+class ValuedGenerator(Generic[Y, S, R]):
+    def __init__(self, generator: Generator[Y, S, R]):
+        self._generator = generator
+
+    def __iter__(self) -> Generator[Y, S, R]:
+        self.value = yield from self._generator
+        return self.value
+
+
+class _AwaitableAsyncContextManager(Generic[R]):
+    def __init__(self, cm: "AsyncContextManager[R]"):
+        self._cm = cm
+
+    def __await__(self) -> Generator[Any, Any, R]:
+        return self._cm.__aenter__().__await__()
+
+    async def __aenter__(self) -> R:
+        return await self._cm.__aenter__()
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        return await self._cm.__aexit__(exc_type, exc_val, exc_tb)
+
+
+def awaitableasynccontextmanager(
+    cm: Callable[..., "AsyncContextManager[R]"],
+) -> Callable[..., _AwaitableAsyncContextManager[R]]:
+    @functools.wraps(cm)
+    def f(*args: Any, **kwargs: Any) -> _AwaitableAsyncContextManager[R]:
+        return _AwaitableAsyncContextManager(cm(*args, **kwargs))
+
+    return f

{foamlib-0.5.0 → foamlib-0.6.0}/foamlib/_files/_files.py

@@ -11,13 +11,8 @@ if sys.version_info >= (3, 9):
 else:
     from typing import Iterator, Mapping, MutableMapping, Sequence
 
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
-
 from ._base import FoamFileBase
-from ._io import _FoamFileIO
+from ._io import FoamFileIO
 from ._serialization import Kind, dumpb
 from ._util import is_sequence
 
@@ -33,7 +28,7 @@ class FoamFile(
         Optional[Union[str, Tuple[str, ...]]],
         Union["FoamFile.Data", "FoamFile.SubDict"],
     ],
-    _FoamFileIO,
+    FoamFileIO,
 ):
     """
     An OpenFOAM data file.
@@ -101,28 +96,6 @@ class FoamFile(
 
             return cast(FoamFileBase._Dict, ret)
 
-    def create(self, *, exist_ok: bool = False, parents: bool = False) -> Self:
-        """
-        Create the file.
-
-        :param exist_ok: If False, raise a FileExistsError if the file already exists.
-
-        :param parents: If True, also create parent directories as needed.
-        """
-        if self.path.exists():
-            if not exist_ok:
-                raise FileExistsError(self.path)
-            else:
-                return self
-
-        if parents:
-            self.path.parent.mkdir(parents=True, exist_ok=True)
-
-        self.path.touch()
-        self._write_header()
-
-        return self
-
     @property
     def version(self) -> float:
         """Alias of `self["FoamFile", "version"]`."""
@@ -185,17 +158,6 @@ class FoamFile(
     def object_(self, value: str) -> None:
         self["FoamFile", "object"] = value
 
-    def _write_header(self) -> None:
-        assert "FoamFile" not in self
-        assert not self
-
-        self["FoamFile"] = {}
-        self.version = 2.0
-        self.format = "ascii"
-        self.class_ = "dictionary"
-        self.location = f'"{self.path.parent.name}"'
-        self.object_ = self.path.name
-
     def __getitem__(
         self, keywords: Optional[Union[str, Tuple[str, ...]]]
     ) -> Union["FoamFile.Data", "FoamFile.SubDict"]:
@@ -222,8 +184,24 @@ class FoamFile(
             elif not isinstance(keywords, tuple):
                 keywords = (keywords,)
 
-            if not self and "FoamFile" not in self and keywords[0] != "FoamFile":
-                self._write_header()
+            try:
+                write_header = (
+                    not self
+                    and "FoamFile" not in self
+                    and (not keywords or keywords[0] != "FoamFile")
+                )
+            except FileNotFoundError:
+                write_header = not keywords or keywords[0] != "FoamFile"
+
+            if write_header:
+                self["FoamFile"] = {}
+                self.version = 2.0
+                self.format = "ascii"
+                self.class_ = "dictionary"
+                self.location = f'"{self.path.parent.name}"'
+                self.object_ = (
+                    self.path.stem if self.path.suffix == ".gz" else self.path.name
+                )
 
             kind = Kind.DEFAULT
             if keywords == ("internalField",) or (
@@ -253,7 +231,7 @@ class FoamFile(
                 self[keywords] = data
 
             else:
-                contents, parsed = self._read()
+                contents, parsed = self._read(missing_ok=True)
 
                 start, end = parsed.entry_location(keywords, missing_ok=True)
 

{foamlib-0.5.0 → foamlib-0.6.0}/foamlib/_files/_io.py

@@ -18,7 +18,7 @@ else:
 from ._parsing import Parsed
 
 
-class _FoamFileIO:
+class FoamFileIO:
     def __init__(self, path: Union[str, Path]) -> None:
         self.path = Path(path).absolute()
 
@@ -29,7 +29,7 @@ class _FoamFileIO:
 
     def __enter__(self) -> Self:
         if self.__defer_io == 0:
-            self._read()
+            self._read(missing_ok=True)
         self.__defer_io += 1
         return self
 
@@ -44,18 +44,26 @@ class _FoamFileIO:
             assert self.__contents is not None
             self._write(self.__contents)
 
-    def _read(self) -> Tuple[bytes, Parsed]:
+    def _read(self, *, missing_ok: bool = False) -> Tuple[bytes, Parsed]:
         if not self.__defer_io:
-            contents = self.path.read_bytes()
-
-            if self.path.suffix == ".gz":
-                contents = gzip.decompress(contents)
+            try:
+                contents = self.path.read_bytes()
+            except FileNotFoundError:
+                contents = None
+            else:
+                assert isinstance(contents, bytes)
+                if self.path.suffix == ".gz":
+                    contents = gzip.decompress(contents)
 
             if contents != self.__contents:
                 self.__contents = contents
                 self.__parsed = None
 
-        assert self.__contents is not None
+        if self.__contents is None:
+            if missing_ok:
+                return b"", Parsed(b"")
+            else:
+                raise FileNotFoundError(self.path)
 
         if self.__parsed is None:
             parsed = Parsed(self.__contents)

{foamlib-0.5.0 → foamlib-0.6.0}/foamlib/_files/_parsing.py

@@ -95,68 +95,68 @@ def _unpack_binary_field(
     return [all]
 
 
-_BINARY_FIELD = (
-    Keyword("nonuniform").suppress()
-    + Literal("List").suppress()
-    + Literal("<").suppress()
-    + (
-        counted_array(
-            CharsNotIn(exact=8),
-            Literal("scalar").suppress()
-            + Literal(">").suppress()
-            + common.integer
-            + Literal("(").suppress(),
-        )
-        | counted_array(
-            CharsNotIn(exact=8 * 3),
-            Literal("vector").suppress()
-            + Literal(">").suppress()
-            + common.integer
-            + Literal("(").suppress(),
-        )
-        | counted_array(
-            CharsNotIn(exact=8 * 6),
-            Literal("symmTensor").suppress()
-            + Literal(">").suppress()
-            + common.integer
-            + Literal("(").suppress(),
-        )
-        | counted_array(
-            CharsNotIn(exact=8 * 9),
-            Literal("tensor").suppress()
-            + Literal(">").suppress()
-            + common.integer
-            + Literal("(").suppress(),
-        )
-    )
-    + Literal(")").suppress()
-).set_parse_action(_unpack_binary_field)
-
-
 _SWITCH = (
     Keyword("yes") | Keyword("true") | Keyword("on") | Keyword("y") | Keyword("t")
 ).set_parse_action(lambda: True) | (
     Keyword("no") | Keyword("false") | Keyword("off") | Keyword("n") | Keyword("f")
 ).set_parse_action(lambda: False)
 _DIMENSIONS = (
-    Literal("[").suppress() + common.number * 7 + Literal("]").suppress()
+    Literal("[").suppress() + common.number[0, 7] + Literal("]").suppress()
 ).set_parse_action(lambda tks: FoamFileBase.DimensionSet(*tks))
 _TENSOR = _list_of(common.number) | common.number
 _IDENTIFIER = Combine(
-    Word(identchars + "$", printables, exclude_chars="{(;)}")
-    + Opt(Literal("(") + Word(printables, exclude_chars="{(;)}") + Literal(")"))
+    Word(identchars + "$", printables, exclude_chars="[{(;)}]")
+    + Opt(Literal("(") + Word(printables, exclude_chars="[{(;)}]") + Literal(")"))
 )
 _DIMENSIONED = (Opt(_IDENTIFIER) + _DIMENSIONS + _TENSOR).set_parse_action(
     lambda tks: FoamFileBase.Dimensioned(*reversed(tks.as_list()))
 )
-_FIELD = (
-    (Keyword("uniform").suppress() + _TENSOR)
-    | (Keyword("nonuniform").suppress() + _list_of(_TENSOR))
-    | _BINARY_FIELD
+_FIELD = (Keyword("uniform").suppress() + _TENSOR) | (
+    Keyword("nonuniform").suppress()
+    + (
+        _list_of(_TENSOR)
+        | (
+            Literal("List").suppress()
+            + Literal("<").suppress()
+            + (
+                counted_array(
+                    CharsNotIn(exact=8),
+                    Literal("scalar").suppress()
+                    + Literal(">").suppress()
+                    + common.integer
+                    + Literal("(").suppress(),
+                )
+                | counted_array(
+                    CharsNotIn(exact=8 * 3),
+                    Literal("vector").suppress()
+                    + Literal(">").suppress()
+                    + common.integer
+                    + Literal("(").suppress(),
+                )
+                | counted_array(
+                    CharsNotIn(exact=8 * 6),
+                    Literal("symmTensor").suppress()
+                    + Literal(">").suppress()
+                    + common.integer
+                    + Literal("(").suppress(),
+                )
+                | counted_array(
+                    CharsNotIn(exact=8 * 9),
+                    Literal("tensor").suppress()
+                    + Literal(">").suppress()
+                    + common.integer
+                    + Literal("(").suppress(),
+                )
+            )
+            + Literal(")").suppress()
+        ).set_parse_action(_unpack_binary_field)
+    )
 )
 _TOKEN = QuotedString('"', unquote_results=False) | _IDENTIFIER
 _DATA = Forward()
-_KEYWORD = Combine(Literal("(") + Word(identchars + " ") + Literal(")")) | _TOKEN
+_KEYWORD = _TOKEN | _list_of(_IDENTIFIER).set_parse_action(
+    lambda tks: "(" + " ".join(tks[0]) + ")"
+)
 _KEYWORD_ENTRY = Dict(Group(_keyword_entry_of(_KEYWORD, _DATA)), asdict=True)
 _DATA_ENTRY = Forward()
 _LIST_ENTRY = _KEYWORD_ENTRY | _DATA_ENTRY

{foamlib-0.5.0 → foamlib-0.6.0}/foamlib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.5.0
+Version: 0.6.0
 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
@@ -155,6 +155,25 @@ U = FoamFieldFile(Path(my_pitz) / "0/U")
 print(U.internal_field)
 ```
 
+### Run an optimization loop in parallel
+
+```python
+import os
+from pathlib import Path
+from foamlib import AsyncFoamCase
+from scipy.optimize import differential_evolution
+
+base = AsyncFoamCase(Path(os.environ["FOAM_TUTORIALS"]) / "incompressible/simpleFoam/pitzDaily")
+
+async def cost(x):
+    async with base.clone() as clone:
+        clone[0]["U"].boundary_field["inlet"].value = [x[0], 0, 0]
+        await clone.run()
+        return abs(clone[-1]["U"].internal_field[0][0])
+
+result = differential_evolution(cost, bounds=[(-1, 1)], workers=AsyncFoamCase.map, polish=False)
+```
+
 ## Documentation
 
 For more information, check out the [documentation](https://foamlib.readthedocs.io/).

{foamlib-0.5.0 → foamlib-0.6.0}/foamlib.egg-info/SOURCES.txt

@@ -11,7 +11,7 @@ foamlib.egg-info/top_level.txt
 foamlib/_cases/__init__.py
 foamlib/_cases/_async.py
 foamlib/_cases/_base.py
-foamlib/_cases/_recipes.py
+foamlib/_cases/_run.py
 foamlib/_cases/_subprocess.py
 foamlib/_cases/_sync.py
 foamlib/_cases/_util.py

{foamlib-0.5.0 → foamlib-0.6.0}/pyproject.toml

@@ -73,6 +73,9 @@ version = {attr = "foamlib.__version__"}
 [tool.setuptools.package-data]
 "foamlib" = ["py.typed"]
 
+[tool.pytest.ini_options]
+asyncio_default_fixture_loop_scope = "function"
+
 [tool.mypy]
 packages = [
     "foamlib",

foamlib-0.5.0/foamlib/_cases/_util.py

@@ -1,27 +0,0 @@
-from types import TracebackType
-from typing import Any, AsyncContextManager, Callable, Optional, Type
-
-
-class _AwaitableAsyncContextManager:
-    def __init__(self, cm: "AsyncContextManager[Any]"):
-        self._cm = cm
-
-    def __await__(self) -> Any:
-        return self._cm.__aenter__().__await__()
-
-    async def __aenter__(self) -> Any:
-        return await self._cm.__aenter__()
-
-    async def __aexit__(
-        self,
-        exc_type: Optional[Type[BaseException]],
-        exc_val: Optional[BaseException],
-        exc_tb: Optional[TracebackType],
-    ) -> Any:
-        return await self._cm.__aexit__(exc_type, exc_val, exc_tb)
-
-
-def awaitableasynccontextmanager(
-    cm: Callable[..., "AsyncContextManager[Any]"],
-) -> Callable[..., _AwaitableAsyncContextManager]:
-    return lambda *args, **kwargs: _AwaitableAsyncContextManager(cm(*args, **kwargs))