foamlib 0.3.11__py3-none-any.whl → 0.3.12__py3-none-any.whl

foamlib/__init__.py

@@ -1,6 +1,6 @@
 """A Python interface for interacting with OpenFOAM."""
 
-__version__ = "0.3.11"
+__version__ = "0.3.12"
 
 from ._cases import AsyncFoamCase, FoamCase, FoamCaseBase
 from ._files import FoamDict, FoamFieldFile, FoamFile

foamlib/_cases/__init__.py

@@ -0,0 +1,9 @@
+from ._async import AsyncFoamCase
+from ._base import FoamCaseBase
+from ._sync import FoamCase
+
+__all__ = [
+    "FoamCaseBase",
+    "FoamCase",
+    "AsyncFoamCase",
+]

foamlib/_cases/_async.py

@@ -0,0 +1,157 @@
+import asyncio
+import multiprocessing
+import sys
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import (
+    Optional,
+    Union,
+)
+
+if sys.version_info >= (3, 9):
+    from collections.abc import AsyncGenerator, Sequence
+else:
+    from typing import AsyncGenerator, Sequence
+
+import aioshutil
+
+from .._util import run_process_async
+from ._base import FoamCaseBase
+
+
+class AsyncFoamCase(FoamCaseBase):
+    """
+    An OpenFOAM case with asynchronous support.
+
+    Provides methods for running and cleaning cases, as well as accessing files.
+
+    Access the time directories of the case as a sequence, e.g. `case[0]` or `case[-1]`.
+
+    :param path: The path to the case directory.
+    """
+
+    max_cpus = multiprocessing.cpu_count()
+    """
+    Maximum number of CPUs to use for running `AsyncFoamCase`s concurrently. Defaults to the number of CPUs on the system.
+    """
+
+    _reserved_cpus = 0
+    _cpus_cond = None  # Cannot be initialized here yet
+
+    @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:
+                await AsyncFoamCase._cpus_cond.wait_for(
+                    lambda: AsyncFoamCase.max_cpus - AsyncFoamCase._reserved_cpus
+                    >= cpus
+                )
+                AsyncFoamCase._reserved_cpus += cpus
+        try:
+            yield
+        finally:
+            if cpus > 0:
+                async with AsyncFoamCase._cpus_cond:
+                    AsyncFoamCase._reserved_cpus -= cpus
+                    AsyncFoamCase._cpus_cond.notify(cpus)
+
+    async def clean(
+        self,
+        *,
+        script: bool = True,
+        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.
+        """
+        script_path = self._clean_script() if script else None
+
+        if script_path is not None:
+            await self.run([script_path], check=check)
+        else:
+            for p in self._clean_paths():
+                if p.is_dir():
+                    await aioshutil.rmtree(p)  # type: ignore [call-arg]
+                else:
+                    p.unlink()
+
+    async def _run(
+        self,
+        cmd: Union[Sequence[Union[str, Path]], str, Path],
+        *,
+        check: bool = True,
+    ) -> None:
+        await run_process_async(cmd, cwd=self.path, check=check)
+
+    async def run(
+        self,
+        cmd: Optional[Union[Sequence[Union[str, Path]], str, Path]] = None,
+        *,
+        script: bool = True,
+        parallel: Optional[bool] = None,
+        cpus: Optional[int] = None,
+        check: bool = True,
+    ) -> None:
+        for name, args, kwargs in self._run_cmds(
+            cmd=cmd, script=script, parallel=parallel, check=check
+        ):
+            if cpus is None:
+                cpus = 1
+
+                if name == "run" and kwargs.get("parallel", False):
+                    cpus = min(self._nprocessors, cpus)
+
+            async with self._cpus(cpus):
+                await getattr(self, name)(*args, **kwargs)
+
+    async def block_mesh(self, *, check: bool = True) -> None:
+        """Run blockMesh on this case."""
+        await self.run(["blockMesh"], check=check)
+
+    async def decompose_par(self, *, check: bool = True) -> None:
+        """Decompose this case for parallel running."""
+        await self.run(["decomposePar"], check=check)
+
+    async def reconstruct_par(self, *, check: bool = True) -> None:
+        """Reconstruct this case after parallel running."""
+        await self.run(["reconstructPar"], check=check)
+
+    async def restore_0_dir(self) -> None:
+        """Restore the 0 directory from the 0.orig directory."""
+        await aioshutil.rmtree(self.path / "0", ignore_errors=True)  # type: ignore [call-arg]
+        await aioshutil.copytree(self.path / "0.orig", self.path / "0")
+
+    async def copy(self, dest: Union[Path, str]) -> "AsyncFoamCase":
+        """
+        Make a copy of this case.
+
+        :param dest: The destination path.
+        """
+        return AsyncFoamCase(await aioshutil.copytree(self.path, dest, symlinks=True))
+
+    async def clone(self, dest: Union[Path, str]) -> "AsyncFoamCase":
+        """
+        Clone this case (make a clean copy).
+
+        :param dest: The destination path.
+        """
+        if self._clean_script() is not None:
+            copy = await self.copy(dest)
+            await copy.clean()
+            return copy
+
+        dest = Path(dest)
+
+        await aioshutil.copytree(
+            self.path, dest, symlinks=True, ignore=self._clone_ignore()
+        )
+
+        return AsyncFoamCase(dest)

foamlib/_cases/_base.py

@@ -0,0 +1,354 @@
+import sys
+from pathlib import Path
+from typing import (
+    Any,
+    Optional,
+    Tuple,
+    Union,
+    overload,
+)
+
+if sys.version_info >= (3, 9):
+    from collections.abc import (
+        Callable,
+        Collection,
+        Generator,
+        Iterator,
+        Mapping,
+        Sequence,
+        Set,
+    )
+else:
+    from typing import AbstractSet as Set
+    from typing import (
+        Callable,
+        Collection,
+        Generator,
+        Iterator,
+        Mapping,
+        Sequence,
+    )
+
+
+from .._files import FoamFieldFile, FoamFile
+from .._util import is_sequence
+
+
+class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
+    def __init__(self, path: Union[Path, 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[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 / key).is_file():
+                return FoamFieldFile(self.path / key)
+            elif (self.path / f"{key}.gz").is_file():
+                return FoamFieldFile(self.path / f"{key}.gz")
+            else:
+                raise KeyError(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 __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 _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()
+
+        paths = set()
+
+        for p in self.path.iterdir():
+            if p.is_dir():
+                try:
+                    t = float(p.name)
+                except ValueError:
+                    pass
+                else:
+                    if t != 0:
+                        paths.add(p)
+
+                if has_decompose_par_dict and p.name.startswith("processor"):
+                    paths.add(p)
+
+        if (self.path / "0.orig").is_dir() and (self.path / "0").is_dir():
+            paths.add(self.path / "0")
+
+        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.*"))
+
+        return paths
+
+    def _clone_ignore(
+        self,
+    ) -> Callable[[Union[Path, str], Collection[str]], Collection[str]]:
+        clean_paths = self._clean_paths()
+
+        def ignore(path: Union[Path, str], names: Collection[str]) -> Collection[str]:
+            paths = {Path(path) / name for name in names}
+            return {p.name for p in paths.intersection(clean_paths)}
+
+        return ignore
+
+    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"
+
+        if clean.is_file():
+            return clean
+        elif all_clean.is_file():
+            return all_clean
+        else:
+            return None
+
+    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"
+        all_run = self.path / "Allrun"
+        all_run_parallel = self.path / "Allrun-parallel"
+
+        if run.is_file() or all_run.is_file():
+            if run_parallel.is_file() or all_run_parallel.is_file():
+                if parallel:
+                    return run_parallel if run_parallel.is_file() else all_run_parallel
+                elif parallel is False:
+                    return run if run.is_file() else all_run
+                else:
+                    raise ValueError(
+                        "Both (All)run and (All)run-parallel scripts are present. Please specify parallel argument."
+                    )
+            return run if run.is_file() else all_run
+        elif parallel is not False and (
+            run_parallel.is_file() or all_run_parallel.is_file()
+        ):
+            return run_parallel if run_parallel.is_file() else all_run_parallel
+        else:
+            return None
+
+    def _run_cmds(
+        self,
+        cmd: Optional[Union[Sequence[Union[str, Path]], str, Path]] = None,
+        *,
+        script: bool = True,
+        parallel: Optional[bool] = None,
+        check: bool = True,
+    ) -> Generator[Tuple[str, Sequence[Any], Mapping[str, Any]], None, None]:
+        if cmd is not None:
+            if parallel:
+                cmd = self._parallel_cmd(cmd)
+
+            yield ("_run", (cmd,), {"check": check})
+        else:
+            script_path = self._run_script(parallel=parallel) if script else None
+
+            if script_path is not None:
+                yield ("_run", ([script_path],), {"check": check})
+
+            else:
+                if not self and (self.path / "0.orig").is_dir():
+                    yield ("restore_0_dir", (), {})
+
+                if (self.path / "system" / "blockMeshDict").is_file():
+                    yield ("block_mesh", (), {"check": check})
+
+                if parallel is None:
+                    parallel = (
+                        self._nprocessors > 0
+                        or (self.path / "system" / "decomposeParDict").is_file()
+                    )
+
+                if parallel:
+                    if (
+                        self._nprocessors == 0
+                        and (self.path / "system" / "decomposeParDict").is_file()
+                    ):
+                        yield ("decompose_par", (), {"check": check})
+
+                yield (
+                    "run",
+                    ([self.application],),
+                    {"parallel": parallel, "check": check},
+                )
+
+    def _parallel_cmd(
+        self, cmd: Union[Sequence[Union[str, Path]], str, Path]
+    ) -> Union[Sequence[Union[str, Path]], str]:
+        if not is_sequence(cmd):
+            return f"mpiexec -np {self._nprocessors} {cmd} -parallel"
+        else:
+            return [
+                "mpiexec",
+                "-np",
+                str(self._nprocessors),
+                cmd[0],
+                "-parallel",
+                *cmd[1:],
+            ]
+
+    @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/_cases/_sync.py

@@ -0,0 +1,121 @@
+import shutil
+import sys
+from pathlib import Path
+from typing import (
+    Optional,
+    Union,
+)
+
+if sys.version_info >= (3, 9):
+    from collections.abc import Sequence
+else:
+    from typing import Sequence
+
+from .._util import run_process
+from ._base import FoamCaseBase
+
+
+class FoamCase(FoamCaseBase):
+    """
+    An OpenFOAM case.
+
+    Provides methods for running and cleaning cases, as well as accessing files.
+
+    Access the time directories of the case as a sequence, e.g. `case[0]` or `case[-1]`.
+
+    :param path: The path to the case directory.
+    """
+
+    def clean(
+        self,
+        *,
+        script: bool = True,
+        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.
+        """
+        script_path = self._clean_script() if script else None
+
+        if script_path is not None:
+            self.run([script_path], check=check)
+        else:
+            for p in self._clean_paths():
+                if p.is_dir():
+                    shutil.rmtree(p)
+                else:
+                    p.unlink()
+
+    def _run(
+        self,
+        cmd: Union[Sequence[Union[str, Path]], str, Path],
+        *,
+        check: bool = True,
+    ) -> None:
+        run_process(cmd, cwd=self.path, check=check)
+
+    def run(
+        self,
+        cmd: Optional[Union[Sequence[Union[str, Path]], str, Path]] = None,
+        *,
+        script: bool = True,
+        parallel: Optional[bool] = 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, check=check
+        ):
+            getattr(self, name)(*args, **kwargs)
+
+    def block_mesh(self, *, check: bool = True) -> None:
+        """Run blockMesh on this case."""
+        self.run(["blockMesh"], check=check)
+
+    def decompose_par(self, *, check: bool = True) -> None:
+        """Decompose this case for parallel running."""
+        self.run(["decomposePar"], check=check)
+
+    def reconstruct_par(self, *, check: bool = True) -> None:
+        """Reconstruct this case after parallel running."""
+        self.run(["reconstructPar"], check=check)
+
+    def restore_0_dir(self) -> None:
+        """Restore the 0 directory from the 0.orig directory."""
+        shutil.rmtree(self.path / "0", ignore_errors=True)
+        shutil.copytree(self.path / "0.orig", self.path / "0")
+
+    def copy(self, dest: Union[Path, str]) -> "FoamCase":
+        """
+        Make a copy of this case.
+
+        :param dest: The destination path.
+        """
+        return FoamCase(shutil.copytree(self.path, dest, symlinks=True))
+
+    def clone(self, dest: Union[Path, str]) -> "FoamCase":
+        """
+        Clone this case (make a clean copy).
+
+        :param dest: The destination path.
+        """
+        if self._clean_script() is not None:
+            copy = self.copy(dest)
+            copy.clean()
+            return copy
+
+        dest = Path(dest)
+
+        shutil.copytree(self.path, dest, symlinks=True, ignore=self._clone_ignore())
+
+        return FoamCase(dest)

{foamlib-0.3.11.dist-info → foamlib-0.3.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.3.11
+Version: 0.3.12
 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
@@ -36,7 +36,7 @@ Requires-Dist: foamlib[typing] ; extra == 'dev'
 Requires-Dist: foamlib[docs] ; extra == 'dev'
 Provides-Extra: docs
 Requires-Dist: foamlib[numpy] ; extra == 'docs'
-Requires-Dist: sphinx <8,>=7 ; extra == 'docs'
+Requires-Dist: sphinx <9,>=7 ; extra == 'docs'
 Requires-Dist: sphinx-rtd-theme ; extra == 'docs'
 Provides-Extra: lint
 Requires-Dist: ruff ; extra == 'lint'

foamlib-0.3.12.dist-info/RECORD

@@ -0,0 +1,18 @@
+foamlib/__init__.py,sha256=vhhhADNxwAVfkJ0_bm28V9p2b-Mo5Mgua44ZIo2hl88,432
+foamlib/_util.py,sha256=vL03aAzpWdZyYIhe2WTxHiz9b4lnttVnRuzqUmZvXXk,3047
+foamlib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+foamlib/_cases/__init__.py,sha256=4bHQRLtYh0IBOuuCSwUbipZEPqIF0sypU2xtoc6YW3c,166
+foamlib/_cases/_async.py,sha256=Rfbq3rerYZdt4lX7YxnStj4LSqwH2j0rAmbPkSDHhP0,4995
+foamlib/_cases/_base.py,sha256=jHgZAR1z7pZHPC0XTDTNXVfTJ8BKFv_ESYwUz2NPzWw,11416
+foamlib/_cases/_sync.py,sha256=irMprDmcvjvdIj82griGhXvDU_L9UnyAbyJjS74Z3ug,3961
+foamlib/_files/__init__.py,sha256=vDkPj8u8bX_I_m2YfeKvXBgwg8D1ufyFCfHGHKN3JPQ,140
+foamlib/_files/_base.py,sha256=YA5a-i5HZuA3JslCD6r-DwZzpSA8r42dqSXef286Ako,2050
+foamlib/_files/_files.py,sha256=4rZb3HMJADmJBGmRpChiujJNX1UIxhgHI5YPEmEOWvE,10784
+foamlib/_files/_io.py,sha256=pGYMoLI5Dz2Y90EB1CtklZiffpDTGuQbbbkyqRe0JAo,2115
+foamlib/_files/_parsing.py,sha256=SW1c1adDTg3e65hhZv5ZFDX8j654E88FDn13zl8gJ8c,7694
+foamlib/_files/_serialization.py,sha256=LCeaLWtNvkcs0dfowL7nViiByxw7U_fvgueVjFliipU,3462
+foamlib-0.3.12.dist-info/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
+foamlib-0.3.12.dist-info/METADATA,sha256=5DDxoDLrNBs1fXupfQCTxSzb6Z1a3w34IvImEgiSrRc,5458
+foamlib-0.3.12.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+foamlib-0.3.12.dist-info/top_level.txt,sha256=ZdVYtetXGwPwyfL-WhlhbTFQGAwKX5P_gXxtH9JYFPI,8
+foamlib-0.3.12.dist-info/RECORD,,

{foamlib-0.3.11.dist-info → foamlib-0.3.12.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (71.1.0)
+Generator: setuptools (72.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

foamlib/_cases.py

@@ -1,630 +0,0 @@
-import asyncio
-import multiprocessing
-import shutil
-import sys
-from contextlib import asynccontextmanager
-from pathlib import Path
-from typing import (
-    Optional,
-    Union,
-    overload,
-)
-
-if sys.version_info >= (3, 9):
-    from collections.abc import (
-        AsyncGenerator,
-        Callable,
-        Collection,
-        Iterator,
-        Sequence,
-        Set,
-    )
-else:
-    from typing import AbstractSet as Set
-    from typing import AsyncGenerator, Callable, Collection, Iterator, Sequence
-
-import aioshutil
-
-from ._files import FoamFieldFile, FoamFile
-from ._util import is_sequence, run_process, run_process_async
-
-
-class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
-    def __init__(self, path: Union[Path, 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[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 / key).is_file():
-                return FoamFieldFile(self.path / key)
-            elif (self.path / f"{key}.gz").is_file():
-                return FoamFieldFile(self.path / f"{key}.gz")
-            else:
-                raise KeyError(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 __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 _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()
-
-        paths = set()
-
-        for p in self.path.iterdir():
-            if p.is_dir():
-                try:
-                    t = float(p.name)
-                except ValueError:
-                    pass
-                else:
-                    if t != 0:
-                        paths.add(p)
-
-                if has_decompose_par_dict and p.name.startswith("processor"):
-                    paths.add(p)
-
-        if (self.path / "0.orig").is_dir() and (self.path / "0").is_dir():
-            paths.add(self.path / "0")
-
-        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.*"))
-
-        return paths
-
-    def _clone_ignore(
-        self,
-    ) -> Callable[[Union[Path, str], Collection[str]], Collection[str]]:
-        clean_paths = self._clean_paths()
-
-        def ignore(path: Union[Path, str], names: Collection[str]) -> Collection[str]:
-            paths = {Path(path) / name for name in names}
-            return {p.name for p in paths.intersection(clean_paths)}
-
-        return ignore
-
-    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"
-
-        if clean.is_file():
-            return clean
-        elif all_clean.is_file():
-            return all_clean
-        else:
-            return None
-
-    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"
-        all_run = self.path / "Allrun"
-        all_run_parallel = self.path / "Allrun-parallel"
-
-        if run.is_file() or all_run.is_file():
-            if run_parallel.is_file() or all_run_parallel.is_file():
-                if parallel:
-                    return run_parallel if run_parallel.is_file() else all_run_parallel
-                elif parallel is False:
-                    return run if run.is_file() else all_run
-                else:
-                    raise ValueError(
-                        "Both (All)run and (All)run-parallel scripts are present. Please specify parallel argument."
-                    )
-            return run if run.is_file() else all_run
-        elif parallel is not False and (
-            run_parallel.is_file() or all_run_parallel.is_file()
-        ):
-            return run_parallel if run_parallel.is_file() else all_run_parallel
-        else:
-            return None
-
-    def _parallel_cmd(
-        self, cmd: Union[Sequence[Union[str, Path]], str, Path]
-    ) -> Union[Sequence[Union[str, Path]], str]:
-        if not is_sequence(cmd):
-            return f"mpiexec -np {self._nprocessors} {cmd} -parallel"
-        else:
-            return [
-                "mpiexec",
-                "-np",
-                str(self._nprocessors),
-                cmd[0],
-                "-parallel",
-                *cmd[1:],
-            ]
-
-    @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)
-
-
-class FoamCase(FoamCaseBase):
-    """
-    An OpenFOAM case.
-
-    Provides methods for running and cleaning cases, as well as accessing files.
-
-    Access the time directories of the case as a sequence, e.g. `case[0]` or `case[-1]`.
-
-    :param path: The path to the case directory.
-    """
-
-    def clean(
-        self,
-        *,
-        script: bool = True,
-        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.
-        """
-        script_path = self._clean_script() if script else None
-
-        if script_path is not None:
-            self.run([script_path], check=check)
-        else:
-            for p in self._clean_paths():
-                if p.is_dir():
-                    shutil.rmtree(p)
-                else:
-                    p.unlink()
-
-    def run(
-        self,
-        cmd: Optional[Union[Sequence[Union[str, Path]], str, Path]] = None,
-        *,
-        script: bool = True,
-        parallel: Optional[bool] = 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.
-        """
-        if cmd is not None:
-            if parallel:
-                cmd = self._parallel_cmd(cmd)
-
-            run_process(
-                cmd,
-                check=check,
-                cwd=self.path,
-            )
-        else:
-            script_path = self._run_script(parallel=parallel) if script else None
-
-            if script_path is not None:
-                return self.run([script_path], check=check)
-
-            else:
-                if not self and (self.path / "0.orig").is_dir():
-                    self.restore_0_dir()
-
-                if (self.path / "system" / "blockMeshDict").is_file():
-                    self.block_mesh()
-
-                if parallel is None:
-                    parallel = (
-                        self._nprocessors > 0
-                        or (self.path / "system" / "decomposeParDict").is_file()
-                    )
-
-                if parallel:
-                    if (
-                        self._nprocessors == 0
-                        and (self.path / "system" / "decomposeParDict").is_file()
-                    ):
-                        self.decompose_par()
-
-                self.run(
-                    [self.application],
-                    parallel=parallel,
-                    check=check,
-                )
-
-    def block_mesh(self, *, check: bool = True) -> None:
-        """Run blockMesh on this case."""
-        self.run(["blockMesh"], check=check)
-
-    def decompose_par(self, *, check: bool = True) -> None:
-        """Decompose this case for parallel running."""
-        self.run(["decomposePar"], check=check)
-
-    def reconstruct_par(self, *, check: bool = True) -> None:
-        """Reconstruct this case after parallel running."""
-        self.run(["reconstructPar"], check=check)
-
-    def restore_0_dir(self) -> None:
-        """Restore the 0 directory from the 0.orig directory."""
-        shutil.rmtree(self.path / "0", ignore_errors=True)
-        shutil.copytree(self.path / "0.orig", self.path / "0")
-
-    def copy(self, dest: Union[Path, str]) -> "FoamCase":
-        """
-        Make a copy of this case.
-
-        :param dest: The destination path.
-        """
-        return FoamCase(shutil.copytree(self.path, dest, symlinks=True))
-
-    def clone(self, dest: Union[Path, str]) -> "FoamCase":
-        """
-        Clone this case (make a clean copy).
-
-        :param dest: The destination path.
-        """
-        if self._clean_script() is not None:
-            copy = self.copy(dest)
-            copy.clean()
-            return copy
-
-        dest = Path(dest)
-
-        shutil.copytree(self.path, dest, symlinks=True, ignore=self._clone_ignore())
-
-        return FoamCase(dest)
-
-
-class AsyncFoamCase(FoamCaseBase):
-    """
-    An OpenFOAM case with asynchronous support.
-
-    Provides methods for running and cleaning cases, as well as accessing files.
-
-    Access the time directories of the case as a sequence, e.g. `case[0]` or `case[-1]`.
-
-    :param path: The path to the case directory.
-    """
-
-    max_cpus = multiprocessing.cpu_count()
-    """
-    Maximum number of CPUs to use for running `AsyncFoamCase`s concurrently. Defaults to the number of CPUs on the system.
-    """
-
-    _reserved_cpus = 0
-    _cpus_cond = None  # Cannot be initialized here yet
-
-    @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:
-                await AsyncFoamCase._cpus_cond.wait_for(
-                    lambda: AsyncFoamCase.max_cpus - AsyncFoamCase._reserved_cpus
-                    >= cpus
-                )
-                AsyncFoamCase._reserved_cpus += cpus
-        try:
-            yield
-        finally:
-            if cpus > 0:
-                async with AsyncFoamCase._cpus_cond:
-                    AsyncFoamCase._reserved_cpus -= cpus
-                    AsyncFoamCase._cpus_cond.notify(cpus)
-
-    async def clean(
-        self,
-        *,
-        script: bool = True,
-        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.
-        """
-        script_path = self._clean_script() if script else None
-
-        if script_path is not None:
-            await self.run([script_path], check=check)
-        else:
-            for p in self._clean_paths():
-                if p.is_dir():
-                    await aioshutil.rmtree(p)  # type: ignore [call-arg]
-                else:
-                    p.unlink()
-
-    async def run(
-        self,
-        cmd: Optional[Union[Sequence[Union[str, Path]], str, Path]] = 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 cpus: The number of CPUs to reserve for the run. The run will wait until the requested number of CPUs is available. If None, autodetect the number of CPUs to reserve.
-        :param check: If True, raise a CalledProcessError if a command returns a non-zero exit code.
-        """
-        if cmd is not None:
-            if cpus is None:
-                if parallel:
-                    cpus = min(self._nprocessors, 1)
-                else:
-                    cpus = 1
-
-            if parallel:
-                cmd = self._parallel_cmd(cmd)
-
-            async with self._cpus(cpus):
-                await run_process_async(
-                    cmd,
-                    check=check,
-                    cwd=self.path,
-                )
-        else:
-            script_path = self._run_script(parallel=parallel) if script else None
-
-            if script_path is not None:
-                if cpus is None:
-                    if self._nprocessors > 0:
-                        cpus = self._nprocessors
-                    else:
-                        nsubdomains = self._nsubdomains
-                        if nsubdomains is not None:
-                            cpus = nsubdomains
-                        else:
-                            cpus = 1
-
-                await self.run([script_path], check=check, cpus=cpus)
-
-            else:
-                if not self and (self.path / "0.orig").is_dir():
-                    await self.restore_0_dir()
-
-                if (self.path / "system" / "blockMeshDict").is_file():
-                    await self.block_mesh()
-
-                if parallel is None:
-                    parallel = (
-                        self._nprocessors > 0
-                        or (self.path / "system" / "decomposeParDict").is_file()
-                    )
-
-                if parallel:
-                    if (
-                        self._nprocessors == 0
-                        and (self.path / "system" / "decomposeParDict").is_file()
-                    ):
-                        await self.decompose_par()
-
-                    if cpus is None:
-                        cpus = min(self._nprocessors, 1)
-                else:
-                    if cpus is None:
-                        cpus = 1
-
-                await self.run(
-                    [self.application],
-                    parallel=parallel,
-                    check=check,
-                    cpus=cpus,
-                )
-
-    async def block_mesh(self, *, check: bool = True) -> None:
-        """Run blockMesh on this case."""
-        await self.run(["blockMesh"], check=check)
-
-    async def decompose_par(self, *, check: bool = True) -> None:
-        """Decompose this case for parallel running."""
-        await self.run(["decomposePar"], check=check)
-
-    async def reconstruct_par(self, *, check: bool = True) -> None:
-        """Reconstruct this case after parallel running."""
-        await self.run(["reconstructPar"], check=check)
-
-    async def restore_0_dir(self) -> None:
-        """Restore the 0 directory from the 0.orig directory."""
-        await aioshutil.rmtree(self.path / "0", ignore_errors=True)  # type: ignore [call-arg]
-        await aioshutil.copytree(self.path / "0.orig", self.path / "0")
-
-    async def copy(self, dest: Union[Path, str]) -> "AsyncFoamCase":
-        """
-        Make a copy of this case.
-
-        :param dest: The destination path.
-        """
-        return AsyncFoamCase(await aioshutil.copytree(self.path, dest, symlinks=True))
-
-    async def clone(self, dest: Union[Path, str]) -> "AsyncFoamCase":
-        """
-        Clone this case (make a clean copy).
-
-        :param dest: The destination path.
-        """
-        if self._clean_script() is not None:
-            copy = await self.copy(dest)
-            await copy.clean()
-            return copy
-
-        dest = Path(dest)
-
-        await aioshutil.copytree(
-            self.path, dest, symlinks=True, ignore=self._clone_ignore()
-        )
-
-        return AsyncFoamCase(dest)

foamlib-0.3.11.dist-info/RECORD

@@ -1,15 +0,0 @@
-foamlib/__init__.py,sha256=m4p7yGjpDi2csSsHt9gXaWEWSPqGqHJjCeawUBzmNUM,432
-foamlib/_cases.py,sha256=LK2EvZTAOejzDU7t2Vgsn7WG9AEdFoQwv5ifjWbyP2Y,21471
-foamlib/_util.py,sha256=vL03aAzpWdZyYIhe2WTxHiz9b4lnttVnRuzqUmZvXXk,3047
-foamlib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-foamlib/_files/__init__.py,sha256=vDkPj8u8bX_I_m2YfeKvXBgwg8D1ufyFCfHGHKN3JPQ,140
-foamlib/_files/_base.py,sha256=YA5a-i5HZuA3JslCD6r-DwZzpSA8r42dqSXef286Ako,2050
-foamlib/_files/_files.py,sha256=4rZb3HMJADmJBGmRpChiujJNX1UIxhgHI5YPEmEOWvE,10784
-foamlib/_files/_io.py,sha256=pGYMoLI5Dz2Y90EB1CtklZiffpDTGuQbbbkyqRe0JAo,2115
-foamlib/_files/_parsing.py,sha256=SW1c1adDTg3e65hhZv5ZFDX8j654E88FDn13zl8gJ8c,7694
-foamlib/_files/_serialization.py,sha256=LCeaLWtNvkcs0dfowL7nViiByxw7U_fvgueVjFliipU,3462
-foamlib-0.3.11.dist-info/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
-foamlib-0.3.11.dist-info/METADATA,sha256=qHXzHhl0N-Sf1igVKDTgMUpYhlqYiIl9FyGEOjnWsFM,5458
-foamlib-0.3.11.dist-info/WHEEL,sha256=Wyh-_nZ0DJYolHNn1_hMa4lM7uDedD_RGVwbmTjyItk,91
-foamlib-0.3.11.dist-info/top_level.txt,sha256=ZdVYtetXGwPwyfL-WhlhbTFQGAwKX5P_gXxtH9JYFPI,8
-foamlib-0.3.11.dist-info/RECORD,,