foamlib 0.4.4__tar.gz → 0.5.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.4.4
+Version: 0.5.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
@@ -19,6 +19,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development
 Classifier: Typing :: Typed
@@ -123,6 +124,14 @@ my_pitz.clean()
 my_pitz.control_dict["writeInterval"] = 10
 ```
 
+### Make multiple file reads and writes in a single go
+
+```python
+with my_pitz.fv_schemes as f:
+    f["gradSchemes"]["default"] = f["divSchemes"]["default"]
+    f["snGradSchemes"]["default"] = "uncorrected"
+```
+
 ### Run a case asynchronously
 
 ```python

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

@@ -70,6 +70,14 @@ my_pitz.clean()
 my_pitz.control_dict["writeInterval"] = 10
 ```
 
+### Make multiple file reads and writes in a single go
+
+```python
+with my_pitz.fv_schemes as f:
+    f["gradSchemes"]["default"] = f["divSchemes"]["default"]
+    f["snGradSchemes"]["default"] = "uncorrected"
+```
+
 ### Run a case asynchronously
 
 ```python

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

@@ -1,11 +1,10 @@
 """A Python interface for interacting with OpenFOAM."""
 
-__version__ = "0.4.4"
+__version__ = "0.5.0"
 
 from ._cases import (
     AsyncFoamCase,
     CalledProcessError,
-    CalledProcessWarning,
     FoamCase,
     FoamCaseBase,
 )
@@ -19,5 +18,4 @@ __all__ = [
     "FoamFieldFile",
     "FoamFileBase",
     "CalledProcessError",
-    "CalledProcessWarning",
 ]

{foamlib-0.4.4 → foamlib-0.5.0}/foamlib/_cases/__init__.py

@@ -1,12 +1,11 @@
 from ._async import AsyncFoamCase
 from ._base import FoamCaseBase
+from ._subprocess import CalledProcessError
 from ._sync import FoamCase
-from ._util import CalledProcessError, CalledProcessWarning
 
 __all__ = [
     "FoamCaseBase",
     "FoamCase",
     "AsyncFoamCase",
     "CalledProcessError",
-    "CalledProcessWarning",
 ]

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

@@ -1,6 +1,8 @@
 import asyncio
 import multiprocessing
+import os
 import sys
+import tempfile
 from contextlib import asynccontextmanager
 from pathlib import Path
 from typing import (
@@ -14,14 +16,19 @@ if sys.version_info >= (3, 9):
 else:
     from typing import AsyncGenerator, Collection, Sequence
 
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
 import aioshutil
 
-from .._util import is_sequence
-from ._base import FoamCaseBase
-from ._util import check_returncode
+from ._recipes import _FoamCaseRecipes
+from ._subprocess import run_async
+from ._util import awaitableasynccontextmanager
 
 
-class AsyncFoamCase(FoamCaseBase):
+class AsyncFoamCase(_FoamCaseRecipes):
     """
     An OpenFOAM case with asynchronous support.
 
@@ -63,17 +70,19 @@ class AsyncFoamCase(FoamCaseBase):
                     AsyncFoamCase._cpus_cond.notify(cpus)
 
     @staticmethod
-    async def _rmtree(path: Path, ignore_errors: bool = False) -> None:
+    async def _rmtree(
+        path: Union["os.PathLike[str]", str], ignore_errors: bool = False
+    ) -> None:
         await aioshutil.rmtree(path, ignore_errors=ignore_errors)  # type: ignore [call-arg]
 
     @staticmethod
     async def _copytree(
-        src: Path,
-        dest: Path,
+        src: Union["os.PathLike[str]", str],
+        dest: Union["os.PathLike[str]", str],
         *,
         symlinks: bool = False,
         ignore: Optional[
-            Callable[[Union[Path, str], Collection[str]], Collection[str]]
+            Callable[[Union["os.PathLike[str]", str], Collection[str]], Collection[str]]
         ] = None,
     ) -> None:
         await aioshutil.copytree(src, dest, symlinks=symlinks, ignore=ignore)
@@ -95,60 +104,54 @@ class AsyncFoamCase(FoamCaseBase):
 
     async def _run(
         self,
-        cmd: Union[Sequence[Union[str, Path]], str, Path],
+        cmd: Union[Sequence[Union[str, "os.PathLike[str]"]], str],
         *,
         parallel: bool = False,
         cpus: int = 1,
         check: bool = True,
+        log: bool = True,
     ) -> None:
-        async with self._cpus(cpus):
-            if not is_sequence(cmd):
-                if parallel:
-                    cmd = f"mpiexec -np {cpus} {cmd} -parallel"
-
-                proc = await asyncio.create_subprocess_shell(
-                    str(cmd),
+        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=True),
-                    stdout=asyncio.subprocess.DEVNULL,
-                    stderr=asyncio.subprocess.PIPE
-                    if check
-                    else asyncio.subprocess.DEVNULL,
+                    env=self._env(shell=isinstance(cmd, str)),
+                    stdout=stdout,
+                    stderr=stderr,
                 )
 
-            else:
-                if parallel:
-                    cmd = ["mpiexec", "-np", str(cpus), *cmd, "-parallel"]
-
-                if sys.version_info < (3, 8):
-                    cmd = (str(arg) for arg in cmd)
-                proc = await asyncio.create_subprocess_exec(
-                    *cmd,
-                    cwd=self.path,
-                    env=self._env(shell=False),
-                    stdout=asyncio.subprocess.DEVNULL,
-                    stderr=asyncio.subprocess.PIPE
-                    if check
-                    else asyncio.subprocess.DEVNULL,
-                )
-
-            stdout, stderr = await proc.communicate()
-
-            assert stdout is None
-            assert proc.returncode is not None
-
-            if check:
-                check_returncode(proc.returncode, cmd, stderr.decode())
-
     async def run(
         self,
-        cmd: Optional[Union[Sequence[Union[str, Path]], str, Path]] = None,
+        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,
     ) -> 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 check: If True, raise a CalledProcessError if any command returns a non-zero exit code.
+        """
         for name, args, kwargs in self._run_cmds(
             cmd=cmd, script=script, parallel=parallel, cpus=cpus, check=check
         ):
@@ -171,24 +174,60 @@ class AsyncFoamCase(FoamCaseBase):
         for name, args, kwargs in self._restore_0_dir_cmds():
             await getattr(self, name)(*args, **kwargs)
 
-    async def copy(self, dest: Union[Path, str]) -> "AsyncFoamCase":
+    @awaitableasynccontextmanager
+    @asynccontextmanager
+    async def copy(
+        self, dst: Optional[Union["os.PathLike[str]", str]] = None
+    ) -> "AsyncGenerator[Self]":
         """
         Make a copy of this case.
 
-        :param dest: The destination path.
+        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.
         """
-        for name, args, kwargs in self._copy_cmds(dest):
+        if dst is None:
+            dst = Path(tempfile.mkdtemp(), self.name)
+            tmp = True
+        else:
+            tmp = False
+
+        for name, args, kwargs in self._copy_cmds(dst):
             await getattr(self, name)(*args, **kwargs)
 
-        return AsyncFoamCase(dest)
+        yield type(self)(dst)
 
-    async def clone(self, dest: Union[Path, str]) -> "AsyncFoamCase":
+        if tmp:
+            assert isinstance(dst, Path)
+            await self._rmtree(dst.parent)
+        else:
+            await self._rmtree(dst)
+
+    @awaitableasynccontextmanager
+    @asynccontextmanager
+    async def clone(
+        self, dst: Optional[Union["os.PathLike[str]", str]] = None
+    ) -> "AsyncGenerator[Self]":
         """
         Clone this case (make a clean copy).
 
-        :param dest: The destination path.
+        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.
         """
-        for name, args, kwargs in self._clone_cmds(dest):
+        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)
 
-        return AsyncFoamCase(dest)
+        yield type(self)(dst)
+
+        if tmp:
+            assert isinstance(dst, Path)
+            await self._rmtree(dst.parent)
+        else:
+            await self._rmtree(dst)

foamlib-0.5.0/foamlib/_cases/_base.py

@@ -0,0 +1,213 @@
+import os
+import shutil
+import sys
+from pathlib import Path
+from typing import (
+    Optional,
+    Union,
+    overload,
+)
+
+if sys.version_info >= (3, 9):
+    from collections.abc import (
+        Iterator,
+        Sequence,
+        Set,
+    )
+else:
+    from typing import AbstractSet as Set
+    from typing import (
+        Iterator,
+        Sequence,
+    )
+
+from .._files import FoamFieldFile, FoamFile
+
+
+class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
+    def __init__(self, path: Union["os.PathLike[str]", str] = Path()):
+        self.path = Path(path).absolute()
+
+    class TimeDirectory(Set[FoamFieldFile]):
+        """
+        An OpenFOAM time directory in a case.
+
+        Use to access field files in the directory, e.g. `time["U"]`.
+
+        :param path: The path to the time directory.
+        """
+
+        def __init__(self, path: Union["os.PathLike[str]", str]):
+            self.path = Path(path).absolute()
+
+        @property
+        def time(self) -> float:
+            """The time that corresponds to this directory."""
+            return float(self.path.name)
+
+        @property
+        def name(self) -> str:
+            """The name of this time directory."""
+            return self.path.name
+
+        def __getitem__(self, key: str) -> FoamFieldFile:
+            if (self.path / f"{key}.gz").is_file() and not (self.path / key).is_file():
+                return FoamFieldFile(self.path / f"{key}.gz")
+            else:
+                return FoamFieldFile(self.path / key)
+
+        def __contains__(self, obj: object) -> bool:
+            if isinstance(obj, FoamFieldFile):
+                return obj.path.parent == self.path
+            elif isinstance(obj, str):
+                return (self.path / obj).is_file() or (
+                    self.path / f"{obj}.gz"
+                ).is_file()
+            else:
+                return False
+
+        def __iter__(self) -> Iterator[FoamFieldFile]:
+            for p in self.path.iterdir():
+                if p.is_file() and (
+                    p.suffix != ".gz" or not p.with_suffix("").is_file()
+                ):
+                    yield FoamFieldFile(p)
+
+        def __len__(self) -> int:
+            return len(list(iter(self)))
+
+        def __delitem__(self, key: str) -> None:
+            if (self.path / f"{key}.gz").is_file() and not (self.path / key).is_file():
+                (self.path / f"{key}.gz").unlink()
+            else:
+                (self.path / key).unlink()
+
+        def __fspath__(self) -> str:
+            return str(self.path)
+
+        def __repr__(self) -> str:
+            return f"{type(self).__qualname__}('{self.path}')"
+
+        def __str__(self) -> str:
+            return str(self.path)
+
+    @property
+    def _times(self) -> Sequence["FoamCaseBase.TimeDirectory"]:
+        times = []
+        for p in self.path.iterdir():
+            if p.is_dir():
+                try:
+                    float(p.name)
+                except ValueError:
+                    pass
+                else:
+                    times.append(FoamCaseBase.TimeDirectory(p))
+
+        times.sort(key=lambda t: t.time)
+
+        return times
+
+    @overload
+    def __getitem__(
+        self, index: Union[int, float, str]
+    ) -> "FoamCaseBase.TimeDirectory": ...
+
+    @overload
+    def __getitem__(self, index: slice) -> Sequence["FoamCaseBase.TimeDirectory"]: ...
+
+    def __getitem__(
+        self, index: Union[int, slice, float, str]
+    ) -> Union["FoamCaseBase.TimeDirectory", Sequence["FoamCaseBase.TimeDirectory"]]:
+        if isinstance(index, str):
+            return FoamCaseBase.TimeDirectory(self.path / index)
+        elif isinstance(index, float):
+            for time in self._times:
+                if time.time == index:
+                    return time
+            raise IndexError(f"Time {index} not found")
+        return self._times[index]
+
+    def __len__(self) -> int:
+        return len(self._times)
+
+    def __delitem__(self, key: Union[int, float, str]) -> None:
+        shutil.rmtree(self[key].path)
+
+    @property
+    def name(self) -> str:
+        """The name of the case."""
+        return self.path.name
+
+    def file(self, path: Union["os.PathLike[str]", str]) -> FoamFile:
+        """Return a FoamFile object for the given path in the case."""
+        return FoamFile(self.path / path)
+
+    @property
+    def _nsubdomains(self) -> Optional[int]:
+        """Return the number of subdomains as set in the decomposeParDict, or None if no decomposeParDict is found."""
+        try:
+            nsubdomains = self.decompose_par_dict["numberOfSubdomains"]
+            if not isinstance(nsubdomains, int):
+                raise TypeError(
+                    f"numberOfSubdomains in {self.decompose_par_dict} is not an integer"
+                )
+            return nsubdomains
+        except FileNotFoundError:
+            return None
+
+    @property
+    def _nprocessors(self) -> int:
+        """Return the number of processor directories in the case."""
+        return len(list(self.path.glob("processor*")))
+
+    @property
+    def application(self) -> str:
+        """The application name as set in the controlDict."""
+        application = self.control_dict["application"]
+        if not isinstance(application, str):
+            raise TypeError(f"application in {self.control_dict} is not a string")
+        return application
+
+    @property
+    def control_dict(self) -> FoamFile:
+        """The controlDict file."""
+        return self.file("system/controlDict")
+
+    @property
+    def fv_schemes(self) -> FoamFile:
+        """The fvSchemes file."""
+        return self.file("system/fvSchemes")
+
+    @property
+    def fv_solution(self) -> FoamFile:
+        """The fvSolution file."""
+        return self.file("system/fvSolution")
+
+    @property
+    def decompose_par_dict(self) -> FoamFile:
+        """The decomposeParDict file."""
+        return self.file("system/decomposeParDict")
+
+    @property
+    def block_mesh_dict(self) -> FoamFile:
+        """The blockMeshDict file."""
+        return self.file("system/blockMeshDict")
+
+    @property
+    def transport_properties(self) -> FoamFile:
+        """The transportProperties file."""
+        return self.file("constant/transportProperties")
+
+    @property
+    def turbulence_properties(self) -> FoamFile:
+        """The turbulenceProperties file."""
+        return self.file("constant/turbulenceProperties")
+
+    def __fspath__(self) -> str:
+        return str(self.path)
+
+    def __repr__(self) -> str:
+        return f"{type(self).__qualname__}('{self.path}')"
+
+    def __str__(self) -> str:
+        return str(self.path)

foamlib-0.4.4/foamlib/_cases/_base.py → foamlib-0.5.0/foamlib/_cases/_recipes.py

@@ -1,13 +1,15 @@
 import os
+import shlex
 import shutil
 import sys
+from contextlib import contextmanager
 from pathlib import Path
 from typing import (
+    IO,
     Any,
     Optional,
     Tuple,
     Union,
-    overload,
 )
 
 if sys.version_info >= (3, 9):
@@ -15,7 +17,6 @@ if sys.version_info >= (3, 9):
         Callable,
         Collection,
         Generator,
-        Iterator,
         Mapping,
         Sequence,
         Set,
@@ -26,121 +27,15 @@ else:
         Callable,
         Collection,
         Generator,
-        Iterator,
         Mapping,
         Sequence,
     )
 
+from ._base import FoamCaseBase
+from ._subprocess import DEVNULL, STDOUT
 
-from .._files import FoamFieldFile, FoamFile
-
-
-class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
-    def __init__(self, path: Union[Path, str, "FoamCaseBase"] = Path()):
-        self.path = Path(path).absolute()
-
-    class TimeDirectory(Set[FoamFieldFile]):
-        """
-        An OpenFOAM time directory in a case.
-
-        Use to access field files in the directory, e.g. `time["U"]`.
-
-        :param path: The path to the time directory.
-        """
-
-        def __init__(self, path: Union[Path, str]):
-            self.path = Path(path).absolute()
-
-        @property
-        def time(self) -> float:
-            """The time that corresponds to this directory."""
-            return float(self.path.name)
-
-        @property
-        def name(self) -> str:
-            """The name of this time directory."""
-            return self.path.name
-
-        def __getitem__(self, key: str) -> FoamFieldFile:
-            if (self.path / f"{key}.gz").is_file() and not (self.path / key).is_file():
-                return FoamFieldFile(self.path / f"{key}.gz")
-            else:
-                return FoamFieldFile(self.path / key)
-
-        def __contains__(self, obj: object) -> bool:
-            if isinstance(obj, FoamFieldFile):
-                return obj.path.parent == self.path
-            elif isinstance(obj, str):
-                return (self.path / obj).is_file() or (
-                    self.path / f"{obj}.gz"
-                ).is_file()
-            else:
-                return False
-
-        def __iter__(self) -> Iterator[FoamFieldFile]:
-            for p in self.path.iterdir():
-                if p.is_file() and (
-                    p.suffix != ".gz" or not p.with_suffix("").is_file()
-                ):
-                    yield FoamFieldFile(p)
-
-        def __len__(self) -> int:
-            return len(list(iter(self)))
-
-        def __delitem__(self, key: str) -> None:
-            if (self.path / f"{key}.gz").is_file() and not (self.path / key).is_file():
-                (self.path / f"{key}.gz").unlink()
-            else:
-                (self.path / key).unlink()
-
-        def __fspath__(self) -> str:
-            return str(self.path)
-
-        def __repr__(self) -> str:
-            return f"{type(self).__qualname__}('{self.path}')"
-
-        def __str__(self) -> str:
-            return str(self.path)
-
-    @property
-    def _times(self) -> Sequence["FoamCaseBase.TimeDirectory"]:
-        times = []
-        for p in self.path.iterdir():
-            if p.is_dir():
-                try:
-                    float(p.name)
-                except ValueError:
-                    pass
-                else:
-                    times.append(FoamCaseBase.TimeDirectory(p))
-
-        times.sort(key=lambda t: t.time)
-
-        return times
-
-    @overload
-    def __getitem__(
-        self, index: Union[int, float, str]
-    ) -> "FoamCaseBase.TimeDirectory": ...
-
-    @overload
-    def __getitem__(self, index: slice) -> Sequence["FoamCaseBase.TimeDirectory"]: ...
-
-    def __getitem__(
-        self, index: Union[int, slice, float, str]
-    ) -> Union["FoamCaseBase.TimeDirectory", Sequence["FoamCaseBase.TimeDirectory"]]:
-        if isinstance(index, str):
-            return FoamCaseBase.TimeDirectory(self.path / index)
-        elif isinstance(index, float):
-            for time in self._times:
-                if time.time == index:
-                    return time
-            raise IndexError(f"Time {index} not found")
-        return self._times[index]
-
-    def __len__(self) -> int:
-        return len(self._times)
 
+class _FoamCaseRecipes(FoamCaseBase):
     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()
@@ -176,10 +71,12 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
 
     def _clone_ignore(
         self,
-    ) -> Callable[[Union[Path, str], Collection[str]], Collection[str]]:
+    ) -> Callable[[Union["os.PathLike[str]", str], Collection[str]], Collection[str]]:
         clean_paths = self._clean_paths()
 
-        def ignore(path: Union[Path, str], names: Collection[str]) -> Collection[str]:
+        def ignore(
+            path: Union["os.PathLike[str]", str], names: Collection[str]
+        ) -> Collection[str]:
             paths = {Path(path) / name for name in names}
             return {p.name for p in paths.intersection(clean_paths)}
 
@@ -253,8 +150,26 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
         else:
             return None
 
+    @contextmanager
+    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:
+            if isinstance(cmd, str):
+                name = shlex.split(cmd)[0]
+            else:
+                if isinstance(cmd[0], os.PathLike):
+                    name = Path(cmd[0]).name
+                else:
+                    name = cmd[0]
+
+            with (self.path / f"log.{name}").open("ab") as stdout:
+                yield stdout, STDOUT
+        else:
+            yield DEVNULL, DEVNULL
+
     def _copy_cmds(
-        self, dest: Union[Path, str]
+        self, dest: Union["os.PathLike[str]", str]
     ) -> Generator[Tuple[str, Sequence[Any], Mapping[str, Any]], None, None]:
         yield (
             "_copytree",
@@ -271,7 +186,7 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
         script_path = self._clean_script() if script else None
 
         if script_path is not None:
-            yield ("_run", ([script_path],), {"cpus": 0, "check": check})
+            yield ("_run", ([script_path],), {"cpus": 0, "check": check, "log": False})
         else:
             for p in self._clean_paths():
                 if p.is_dir():
@@ -280,7 +195,7 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
                     p.unlink()
 
     def _clone_cmds(
-        self, dest: Union[Path, str]
+        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,), {})
@@ -310,7 +225,7 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
 
     def _run_cmds(
         self,
-        cmd: Optional[Union[Sequence[Union[str, Path]], str, Path]] = None,
+        cmd: Optional[Union[Sequence[Union[str, "os.PathLike[str]"]], str]] = None,
         *,
         script: bool = True,
         parallel: Optional[bool] = None,
@@ -382,82 +297,3 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
                     ([self.application],),
                     {"parallel": parallel, "cpus": cpus, "check": check},
                 )
-
-    @property
-    def name(self) -> str:
-        """The name of the case."""
-        return self.path.name
-
-    def file(self, path: Union[Path, str]) -> FoamFile:
-        """Return a FoamFile object for the given path in the case."""
-        return FoamFile(self.path / path)
-
-    @property
-    def _nsubdomains(self) -> Optional[int]:
-        """Return the number of subdomains as set in the decomposeParDict, or None if no decomposeParDict is found."""
-        try:
-            nsubdomains = self.decompose_par_dict["numberOfSubdomains"]
-            if not isinstance(nsubdomains, int):
-                raise TypeError(
-                    f"numberOfSubdomains in {self.decompose_par_dict} is not an integer"
-                )
-            return nsubdomains
-        except FileNotFoundError:
-            return None
-
-    @property
-    def _nprocessors(self) -> int:
-        """Return the number of processor directories in the case."""
-        return len(list(self.path.glob("processor*")))
-
-    @property
-    def application(self) -> str:
-        """The application name as set in the controlDict."""
-        application = self.control_dict["application"]
-        if not isinstance(application, str):
-            raise TypeError(f"application in {self.control_dict} is not a string")
-        return application
-
-    @property
-    def control_dict(self) -> FoamFile:
-        """The controlDict file."""
-        return self.file("system/controlDict")
-
-    @property
-    def fv_schemes(self) -> FoamFile:
-        """The fvSchemes file."""
-        return self.file("system/fvSchemes")
-
-    @property
-    def fv_solution(self) -> FoamFile:
-        """The fvSolution file."""
-        return self.file("system/fvSolution")
-
-    @property
-    def decompose_par_dict(self) -> FoamFile:
-        """The decomposeParDict file."""
-        return self.file("system/decomposeParDict")
-
-    @property
-    def block_mesh_dict(self) -> FoamFile:
-        """The blockMeshDict file."""
-        return self.file("system/blockMeshDict")
-
-    @property
-    def transport_properties(self) -> FoamFile:
-        """The transportProperties file."""
-        return self.file("constant/transportProperties")
-
-    @property
-    def turbulence_properties(self) -> FoamFile:
-        """The turbulenceProperties file."""
-        return self.file("constant/turbulenceProperties")
-
-    def __fspath__(self) -> str:
-        return str(self.path)
-
-    def __repr__(self) -> str:
-        return f"{type(self).__qualname__}('{self.path}')"
-
-    def __str__(self) -> str:
-        return str(self.path)

foamlib-0.5.0/foamlib/_cases/_subprocess.py

@@ -0,0 +1,86 @@
+import asyncio
+import os
+import subprocess
+import sys
+from typing import IO, Optional, Union
+
+if sys.version_info >= (3, 9):
+    from collections.abc import Mapping, Sequence
+else:
+    from typing import Mapping, Sequence
+
+CalledProcessError = subprocess.CalledProcessError
+CompletedProcess = subprocess.CompletedProcess
+
+DEVNULL = subprocess.DEVNULL
+PIPE = subprocess.PIPE
+STDOUT = subprocess.STDOUT
+
+
+def run_sync(
+    cmd: Union[Sequence[Union[str, "os.PathLike[str]"]], str],
+    *,
+    check: bool = True,
+    cwd: Optional["os.PathLike[str]"] = None,
+    env: Optional[Mapping[str, str]] = None,
+    stdout: Optional[Union[int, IO[bytes]]] = None,
+    stderr: Optional[Union[int, IO[bytes]]] = None,
+) -> "CompletedProcess[bytes]":
+    if not isinstance(cmd, str) and sys.version_info < (3, 8):
+        cmd = [str(arg) for arg in cmd]
+
+    return subprocess.run(
+        cmd,
+        cwd=cwd,
+        env=env,
+        stdout=stdout,
+        stderr=stderr,
+        shell=isinstance(cmd, str),
+        check=check,
+    )
+
+
+async def run_async(
+    cmd: Union[Sequence[Union[str, "os.PathLike[str]"]], str],
+    *,
+    check: bool = True,
+    cwd: Optional["os.PathLike[str]"] = None,
+    env: Optional[Mapping[str, str]] = None,
+    stdout: Optional[Union[int, IO[bytes]]] = None,
+    stderr: Optional[Union[int, IO[bytes]]] = None,
+) -> "CompletedProcess[bytes]":
+    if isinstance(cmd, str):
+        proc = await asyncio.create_subprocess_shell(
+            cmd,
+            cwd=cwd,
+            env=env,
+            stdout=stdout,
+            stderr=stderr,
+        )
+
+    else:
+        if sys.version_info < (3, 8):
+            cmd = [str(arg) for arg in cmd]
+        proc = await asyncio.create_subprocess_exec(
+            *cmd,
+            cwd=cwd,
+            env=env,
+            stdout=stdout,
+            stderr=stderr,
+        )
+
+    output, error = await proc.communicate()
+
+    assert proc.returncode is not None
+
+    if check and proc.returncode != 0:
+        raise CalledProcessError(
+            returncode=proc.returncode,
+            cmd=cmd,
+            output=output,
+            stderr=error,
+        )
+
+    return CompletedProcess(
+        cmd, returncode=proc.returncode, stdout=output, stderr=error
+    )

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

@@ -1,10 +1,13 @@
+import os
 import shutil
-import subprocess
 import sys
+import tempfile
 from pathlib import Path
+from types import TracebackType
 from typing import (
     Callable,
     Optional,
+    Type,
     Union,
 )
 
@@ -13,12 +16,16 @@ if sys.version_info >= (3, 9):
 else:
     from typing import Collection, Sequence
 
-from .._util import is_sequence
-from ._base import FoamCaseBase
-from ._util import check_returncode
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+from ._recipes import _FoamCaseRecipes
+from ._subprocess import run_sync
 
 
-class FoamCase(FoamCaseBase):
+class FoamCase(_FoamCaseRecipes):
     """
     An OpenFOAM case.
 
@@ -30,21 +37,34 @@ class FoamCase(FoamCaseBase):
     """
 
     @staticmethod
-    def _rmtree(path: Path, *, ignore_errors: bool = False) -> None:
+    def _rmtree(
+        path: Union["os.PathLike[str]", str], *, ignore_errors: bool = False
+    ) -> None:
         shutil.rmtree(path, ignore_errors=ignore_errors)
 
     @staticmethod
     def _copytree(
-        src: Path,
-        dest: Path,
+        src: Union["os.PathLike[str]", str],
+        dest: Union["os.PathLike[str]", str],
         *,
         symlinks: bool = False,
         ignore: Optional[
-            Callable[[Union[Path, str], Collection[str]], Collection[str]]
+            Callable[[Union["os.PathLike[str]", str], Collection[str]], Collection[str]]
         ] = None,
     ) -> None:
         shutil.copytree(src, dest, symlinks=symlinks, ignore=ignore)
 
+    def __enter__(self) -> "FoamCase":
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        self._rmtree(self.path)
+
     def clean(
         self,
         *,
@@ -62,43 +82,39 @@ class FoamCase(FoamCaseBase):
 
     def _run(
         self,
-        cmd: Union[Sequence[Union[str, Path]], str, Path],
+        cmd: Union[Sequence[Union[str, "os.PathLike[str]"]], str],
         *,
         parallel: bool = False,
         cpus: int = 1,
         check: bool = True,
+        log: bool = True,
     ) -> None:
-        shell = not is_sequence(cmd)
-
-        if parallel:
-            if shell:
-                cmd = f"mpiexec -np {cpus} {cmd} -parallel"
-            else:
-                assert is_sequence(cmd)
-                cmd = ["mpiexec", "-np", str(cpus), *cmd, "-parallel"]
-
-        if sys.version_info < (3, 8):
-            if shell:
-                cmd = str(cmd)
-            else:
-                cmd = (str(arg) for arg in cmd)
-
-        proc = subprocess.run(
-            cmd,
-            cwd=self.path,
-            env=self._env(shell=shell),
-            stdout=subprocess.DEVNULL,
-            stderr=subprocess.PIPE if check else subprocess.DEVNULL,
-            text=True,
-            shell=shell,
-        )
-
-        if check:
-            check_returncode(proc.returncode, cmd, proc.stderr)
+        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,
+            )
 
     def run(
         self,
-        cmd: Optional[Union[Sequence[Union[str, Path]], str, Path]] = None,
+        cmd: Optional[Union[Sequence[Union[str, "os.PathLike[str]"]], str]] = None,
         *,
         script: bool = True,
         parallel: Optional[bool] = None,
@@ -134,24 +150,34 @@ class FoamCase(FoamCaseBase):
         for name, args, kwargs in self._restore_0_dir_cmds():
             getattr(self, name)(*args, **kwargs)
 
-    def copy(self, dest: Union[Path, str]) -> "FoamCase":
+    def copy(self, dst: Optional[Union["os.PathLike[str]", str]] = None) -> "Self":
         """
         Make a copy of this case.
 
-        :param dest: The destination path.
+        Use as a context manager to automatically delete the copy when done.
+
+        :param dst: The destination path. If None, copy to a temporary directory.
         """
-        for name, args, kwargs in self._copy_cmds(dest):
+        if dst is None:
+            dst = Path(tempfile.mkdtemp(), self.name)
+
+        for name, args, kwargs in self._copy_cmds(dst):
             getattr(self, name)(*args, **kwargs)
 
-        return FoamCase(dest)
+        return type(self)(dst)
 
-    def clone(self, dest: Union[Path, str]) -> "FoamCase":
+    def clone(self, dst: Optional[Union["os.PathLike[str]", str]] = None) -> "Self":
         """
         Clone this case (make a clean copy).
 
-        :param dest: The destination path.
+        Use as a context manager to automatically delete the clone when done.
+
+        :param dst: The destination path. If None, clone to a temporary directory.
         """
-        for name, args, kwargs in self._clone_cmds(dest):
+        if dst is None:
+            dst = Path(tempfile.mkdtemp(), self.name)
+
+        for name, args, kwargs in self._clone_cmds(dst):
             getattr(self, name)(*args, **kwargs)
 
-        return FoamCase(dest)
+        return type(self)(dst)

foamlib-0.5.0/foamlib/_cases/_util.py

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

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

@@ -16,10 +16,10 @@ if sys.version_info >= (3, 11):
 else:
     from typing_extensions import Self
 
-from .._util import is_sequence
 from ._base import FoamFileBase
 from ._io import _FoamFileIO
 from ._serialization import Kind, dumpb
+from ._util import is_sequence
 
 try:
     import numpy as np
@@ -105,13 +105,9 @@ class FoamFile(
         """
         Create the file.
 
-        Parameters
-        ----------
-        exist_ok : bool, optional
-            If False (the default), raise a FileExistsError if the file already exists.
-            If True, do nothing if the file already exists.
-        parents : bool, optional
-            If True, also create parent directories as needed.
+        :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:

{foamlib-0.4.4 → foamlib-0.5.0}/foamlib/_files/_serialization.py

@@ -8,8 +8,8 @@ if sys.version_info >= (3, 9):
 else:
     from typing import Mapping
 
-from .._util import is_sequence
 from ._base import FoamFileBase
+from ._util import is_sequence
 
 try:
     import numpy as np

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.4.4
+Version: 0.5.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
@@ -19,6 +19,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development
 Classifier: Typing :: Typed
@@ -123,6 +124,14 @@ my_pitz.clean()
 my_pitz.control_dict["writeInterval"] = 10
 ```
 
+### Make multiple file reads and writes in a single go
+
+```python
+with my_pitz.fv_schemes as f:
+    f["gradSchemes"]["default"] = f["divSchemes"]["default"]
+    f["snGradSchemes"]["default"] = "uncorrected"
+```
+
 ### Run a case asynchronously
 
 ```python

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

@@ -2,7 +2,6 @@ LICENSE.txt
 README.md
 pyproject.toml
 foamlib/__init__.py
-foamlib/_util.py
 foamlib/py.typed
 foamlib.egg-info/PKG-INFO
 foamlib.egg-info/SOURCES.txt
@@ -12,6 +11,8 @@ foamlib.egg-info/top_level.txt
 foamlib/_cases/__init__.py
 foamlib/_cases/_async.py
 foamlib/_cases/_base.py
+foamlib/_cases/_recipes.py
+foamlib/_cases/_subprocess.py
 foamlib/_cases/_sync.py
 foamlib/_cases/_util.py
 foamlib/_files/__init__.py
@@ -19,4 +20,5 @@ foamlib/_files/_base.py
 foamlib/_files/_files.py
 foamlib/_files/_io.py
 foamlib/_files/_parsing.py
-foamlib/_files/_serialization.py
+foamlib/_files/_serialization.py
+foamlib/_files/_util.py

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

@@ -22,6 +22,7 @@ classifiers = [
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Topic :: Scientific/Engineering",
     "Topic :: Software Development",
     "Typing :: Typed",

foamlib-0.4.4/foamlib/_cases/_util.py

@@ -1,35 +0,0 @@
-import subprocess
-import sys
-from pathlib import Path
-from typing import Optional, Union
-from warnings import warn
-
-if sys.version_info >= (3, 9):
-    from collections.abc import Sequence
-else:
-    from typing import Sequence
-
-
-class CalledProcessError(subprocess.CalledProcessError):
-    """Exception raised when a process fails and `check=True`."""
-
-    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_returncode(
-    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)