foamlib 0.6.2__py3-none-any.whl → 0.6.4__py3-none-any.whl

foamlib/__init__.py

@@ -1,21 +1,25 @@
 """A Python interface for interacting with OpenFOAM."""
 
-__version__ = "0.6.2"
+__version__ = "0.6.4"
 
 from ._cases import (
     AsyncFoamCase,
+    AsyncSlurmFoamCase,
     CalledProcessError,
     FoamCase,
     FoamCaseBase,
+    FoamCaseRunBase,
 )
 from ._files import FoamFieldFile, FoamFile, FoamFileBase
 
 __all__ = [
-    "FoamCase",
     "AsyncFoamCase",
-    "FoamCaseBase",
+    "AsyncSlurmFoamCase",
+    "CalledProcessError",
     "FoamFile",
+    "FoamCase",
+    "FoamCaseBase",
+    "FoamCaseRunBase",
     "FoamFieldFile",
     "FoamFileBase",
-    "CalledProcessError",
 ]

foamlib/_cases/__init__.py

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

foamlib/_cases/_async.py

@@ -3,7 +3,7 @@ import multiprocessing
 import os
 import sys
 from contextlib import asynccontextmanager
-from typing import Any, Callable, Optional, TypeVar, Union
+from typing import Any, Callable, Optional, TypeVar, Union, overload
 
 if sys.version_info >= (3, 9):
     from collections.abc import (
@@ -23,6 +23,8 @@ else:
 
 import aioshutil
 
+from .._files import FoamFieldFile
+from ._base import FoamCaseBase
 from ._run import FoamCaseRunBase
 from ._subprocess import run_async
 from ._util import ValuedGenerator, awaitableasynccontextmanager
@@ -42,9 +44,25 @@ class AsyncFoamCase(FoamCaseRunBase):
     :param path: The path to the case directory.
     """
 
+    class TimeDirectory(FoamCaseRunBase.TimeDirectory):
+        @property
+        def _case(self) -> "AsyncFoamCase":
+            return AsyncFoamCase(self.path.parent)
+
+        async def cell_centers(self) -> FoamFieldFile:
+            """Write and return the cell centers."""
+            calls = ValuedGenerator(self._cell_centers_calls())
+
+            for coro in calls:
+                await coro
+
+            return calls.value
+
     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.
+    Maximum number of CPUs to use for running instances of `AsyncFoamCase` concurrently. 
+    
+    Defaults to the number of CPUs on the system.
     """
 
     _reserved_cpus = 0
@@ -106,6 +124,23 @@ class AsyncFoamCase(FoamCaseRunBase):
         for coro in self._clean_calls(check=check):
             await coro
 
+    @overload
+    def __getitem__(
+        self, index: Union[int, float, str]
+    ) -> "AsyncFoamCase.TimeDirectory": ...
+
+    @overload
+    def __getitem__(self, index: slice) -> Sequence["AsyncFoamCase.TimeDirectory"]: ...
+
+    def __getitem__(
+        self, index: Union[int, slice, float, str]
+    ) -> Union["AsyncFoamCase.TimeDirectory", Sequence["AsyncFoamCase.TimeDirectory"]]:
+        ret = super().__getitem__(index)
+        if isinstance(ret, FoamCaseBase.TimeDirectory):
+            return AsyncFoamCase.TimeDirectory(ret)
+        else:
+            return [AsyncFoamCase.TimeDirectory(r) for r in ret]
+
     async def run(
         self,
         cmd: Optional[Union[Sequence[Union[str, "os.PathLike[str]"]], str]] = None,
@@ -129,17 +164,20 @@ class AsyncFoamCase(FoamCaseRunBase):
         ):
             await coro
 
-    async def block_mesh(self, *, check: bool = True) -> None:
+    async def block_mesh(self, *, check: bool = True, log: bool = True) -> None:
         """Run blockMesh on this case."""
-        await self.run(["blockMesh"], check=check)
+        for coro in self._block_mesh_calls(check=check, log=log):
+            await coro
 
-    async def decompose_par(self, *, check: bool = True) -> None:
+    async def decompose_par(self, *, check: bool = True, log: bool = True) -> None:
         """Decompose this case for parallel running."""
-        await self.run(["decomposePar"], check=check)
+        for coro in self._decompose_par_calls(check=check, log=log):
+            await coro
 
-    async def reconstruct_par(self, *, check: bool = True) -> None:
+    async def reconstruct_par(self, *, check: bool = True, log: bool = True) -> None:
         """Reconstruct this case after parallel running."""
-        await self.run(["reconstructPar"], check=check)
+        for coro in self._reconstruct_par_calls(check=check, log=log):
+            await coro
 
     async def restore_0_dir(self) -> None:
         """Restore the 0 directory from the 0.orig directory."""

foamlib/_cases/_base.py

@@ -40,6 +40,10 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
         def __init__(self, path: Union["os.PathLike[str]", str]):
             self.path = Path(path).absolute()
 
+        @property
+        def _case(self) -> "FoamCaseBase":
+            return FoamCaseBase(self.path.parent)
+
         @property
         def time(self) -> float:
             """The time that corresponds to this directory."""
@@ -58,7 +62,7 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
 
         def __contains__(self, obj: object) -> bool:
             if isinstance(obj, FoamFieldFile):
-                return obj.path.parent == self.path
+                return obj.path.parent == self.path and obj.path.is_file()
             elif isinstance(obj, str):
                 return (self.path / obj).is_file() or (
                     self.path / f"{obj}.gz"

foamlib/_cases/_run.py

@@ -40,11 +40,36 @@ if sys.version_info >= (3, 11):
 else:
     from typing_extensions import Self
 
+from .._files import FoamFieldFile
 from ._base import FoamCaseBase
 from ._subprocess import DEVNULL, STDOUT
 
 
 class FoamCaseRunBase(FoamCaseBase):
+    class TimeDirectory(FoamCaseBase.TimeDirectory):
+        @abstractmethod
+        def cell_centers(
+            self,
+        ) -> Union[FoamFieldFile, Coroutine[None, None, FoamFieldFile]]:
+            raise NotImplementedError
+
+        @property
+        @abstractmethod
+        def _case(self) -> "FoamCaseRunBase":
+            raise NotImplementedError
+
+        def _cell_centers_calls(self) -> Generator[Any, None, FoamFieldFile]:
+            ret = self["C"]
+
+            if ret not in self:
+                yield self._case.run(
+                    ["postProcess", "-func", "writeCellCentres", "-time", self.name],
+                    cpus=0,
+                    log=False,
+                )
+
+            return ret
+
     def __delitem__(self, key: Union[int, float, str]) -> None:
         shutil.rmtree(self[key].path)
 
@@ -104,13 +129,19 @@ class FoamCaseRunBase(FoamCaseBase):
 
     @abstractmethod
     def block_mesh(
-        self, *, check: bool = True
+        self, *, check: bool = True, log: bool = True
     ) -> Union[None, Coroutine[None, None, None]]:
         raise NotImplementedError
 
     @abstractmethod
     def decompose_par(
-        self, *, check: bool = True
+        self, *, check: bool = True, log: bool = True
+    ) -> Union[None, Coroutine[None, None, None]]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def reconstruct_par(
+        self, *, check: bool = True, log: bool = True
     ) -> Union[None, Coroutine[None, None, None]]:
         raise NotImplementedError
 
@@ -295,6 +326,21 @@ class FoamCaseRunBase(FoamCaseBase):
         yield self._rmtree(self.path / "0", ignore_errors=True)
         yield self._copytree(self.path / "0.orig", self.path / "0", symlinks=True)
 
+    def _block_mesh_calls(
+        self, *, check: bool, log: bool
+    ) -> Generator[Any, None, None]:
+        yield self.run(["blockMesh"], cpus=0, check=check, log=log)
+
+    def _decompose_par_calls(
+        self, *, check: bool, log: bool
+    ) -> Generator[Any, None, None]:
+        yield self.run(["decomposePar"], cpus=0, check=check, log=log)
+
+    def _reconstruct_par_calls(
+        self, *, check: bool, log: bool
+    ) -> Generator[Any, None, None]:
+        yield self.run(["reconstructPar"], cpus=0, check=check, log=log)
+
     def _run_calls(
         self,
         cmd: Optional[Union[Sequence[Union[str, "os.PathLike[str]"]], str]] = None,
@@ -303,6 +349,7 @@ class FoamCaseRunBase(FoamCaseBase):
         cpus: Optional[int],
         check: bool,
         log: bool,
+        **kwargs: Any,
     ) -> Generator[Any, None, None]:
         if cmd is not None:
             if parallel:
@@ -335,6 +382,7 @@ class FoamCaseRunBase(FoamCaseBase):
                     env=self.__env(shell=isinstance(cmd, str)),
                     stdout=stdout,
                     stderr=stderr,
+                    **kwargs,
                 )
 
         else:
@@ -353,7 +401,9 @@ class FoamCaseRunBase(FoamCaseBase):
                     if cpus is None:
                         cpus = 1
 
-                yield self.run([script_path], parallel=False, cpus=cpus, check=check)
+                yield self.run(
+                    [script_path], parallel=False, cpus=cpus, check=check, **kwargs
+                )
 
             else:
                 if not self and (self.path / "0.orig").is_dir():
@@ -383,5 +433,9 @@ class FoamCaseRunBase(FoamCaseBase):
                         cpus = 1
 
                 yield self.run(
-                    [self.application], parallel=parallel, cpus=cpus, check=check
+                    [self.application],
+                    parallel=parallel,
+                    cpus=cpus,
+                    check=check,
+                    **kwargs,
                 )

foamlib/_cases/_slurm.py

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

foamlib/_cases/_sync.py

@@ -3,13 +3,7 @@ import shutil
 import sys
 from pathlib import Path
 from types import TracebackType
-from typing import (
-    Any,
-    Callable,
-    Optional,
-    Type,
-    Union,
-)
+from typing import Any, Callable, Optional, Type, Union, overload
 
 if sys.version_info >= (3, 9):
     from collections.abc import Collection, Sequence
@@ -21,6 +15,8 @@ if sys.version_info >= (3, 11):
 else:
     from typing_extensions import Self
 
+from .._files import FoamFieldFile
+from ._base import FoamCaseBase
 from ._run import FoamCaseRunBase
 from ._subprocess import run_sync
 from ._util import ValuedGenerator
@@ -37,6 +33,22 @@ class FoamCase(FoamCaseRunBase):
     :param path: The path to the case directory.
     """
 
+    class TimeDirectory(FoamCaseRunBase.TimeDirectory):
+        @property
+        def _case(self) -> "FoamCase":
+            return FoamCase(self.path.parent)
+
+        def cell_centers(self) -> FoamFieldFile:
+            """Write and return the cell centers."""
+            calls = ValuedGenerator(self._cell_centers_calls())
+
+            for _ in calls:
+                pass
+
+            print(calls.value)
+
+            return calls.value
+
     def __init__(self, path: Union["os.PathLike[str]", str] = Path()):
         super().__init__(path)
 
@@ -67,6 +79,23 @@ class FoamCase(FoamCaseRunBase):
     ) -> None:
         shutil.copytree(src, dest, symlinks=symlinks, ignore=ignore)
 
+    @overload
+    def __getitem__(
+        self, index: Union[int, float, str]
+    ) -> "FoamCase.TimeDirectory": ...
+
+    @overload
+    def __getitem__(self, index: slice) -> Sequence["FoamCase.TimeDirectory"]: ...
+
+    def __getitem__(
+        self, index: Union[int, slice, float, str]
+    ) -> Union["FoamCase.TimeDirectory", Sequence["FoamCase.TimeDirectory"]]:
+        ret = super().__getitem__(index)
+        if isinstance(ret, FoamCaseBase.TimeDirectory):
+            return FoamCase.TimeDirectory(ret)
+        else:
+            return [FoamCase.TimeDirectory(r) for r in ret]
+
     def __enter__(self) -> Self:
         return self
 
@@ -110,17 +139,20 @@ class FoamCase(FoamCaseRunBase):
         ):
             pass
 
-    def block_mesh(self, *, check: bool = True) -> None:
+    def block_mesh(self, *, check: bool = True, log: bool = True) -> None:
         """Run blockMesh on this case."""
-        self.run(["blockMesh"], check=check)
+        for _ in self._block_mesh_calls(check=check, log=log):
+            pass
 
-    def decompose_par(self, *, check: bool = True) -> None:
+    def decompose_par(self, *, check: bool = True, log: bool = True) -> None:
         """Decompose this case for parallel running."""
-        self.run(["decomposePar"], check=check)
+        for _ in self._decompose_par_calls(check=check, log=log):
+            pass
 
-    def reconstruct_par(self, *, check: bool = True) -> None:
+    def reconstruct_par(self, *, check: bool = True, log: bool = True) -> None:
         """Reconstruct this case after parallel running."""
-        self.run(["reconstructPar"], check=check)
+        for _ in self._reconstruct_par_calls(check=check, log=log):
+            pass
 
     def restore_0_dir(self) -> None:
         """Restore the 0 directory from the 0.orig directory."""
@@ -135,12 +167,12 @@ class FoamCase(FoamCaseRunBase):
 
         :param dst: The destination path. If None, clone to `$FOAM_RUN/foamlib`.
         """
-        cmds = ValuedGenerator(self._copy_calls(dst))
+        calls = ValuedGenerator(self._copy_calls(dst))
 
-        for _ in cmds:
+        for _ in calls:
             pass
 
-        return cmds.value
+        return calls.value
 
     def clone(self, dst: Optional[Union["os.PathLike[str]", str]] = None) -> Self:
         """
@@ -150,9 +182,9 @@ class FoamCase(FoamCaseRunBase):
 
         :param dst: The destination path. If None, clone to `$FOAM_RUN/foamlib`.
         """
-        cmds = ValuedGenerator(self._clone_calls(dst))
+        calls = ValuedGenerator(self._clone_calls(dst))
 
-        for _ in cmds:
+        for _ in calls:
             pass
 
-        return cmds.value
+        return calls.value

foamlib/_files/_io.py

@@ -1,4 +1,5 @@
 import gzip
+import os
 import sys
 from copy import deepcopy
 from pathlib import Path
@@ -19,7 +20,7 @@ from ._parsing import Parsed
 
 
 class FoamFileIO:
-    def __init__(self, path: Union[str, Path]) -> None:
+    def __init__(self, path: Union["os.PathLike[str]", str]) -> None:
         self.path = Path(path).absolute()
 
         self.__contents: Optional[bytes] = None

{foamlib-0.6.2.dist-info → foamlib-0.6.4.dist-info}/METADATA

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

foamlib-0.6.4.dist-info/RECORD

@@ -0,0 +1,22 @@
+foamlib/__init__.py,sha256=bmL3_3H-rn3OrCYQZeUZkDBGgYygbgZJ2pd8dAoAvig,486
+foamlib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+foamlib/_cases/__init__.py,sha256=wTUHcUgU1CBgpu0cUMtksQ5VKG6B8CFu9xc3dWwsQuo,358
+foamlib/_cases/_async.py,sha256=PYODgIkRLHArMf3wtf34jMx7gBGi-K6hoLEhjYK9bOw,7753
+foamlib/_cases/_base.py,sha256=4VWsu22VockyKgU_5tnSMeNrAkMgBKwZo2KGkV65rRQ,6739
+foamlib/_cases/_run.py,sha256=SjA-Qux5NhnhcLz7qiph2DcGYpElAAl_PlTGk6kGeuU,13972
+foamlib/_cases/_slurm.py,sha256=rhGSFJ-3g72TnAYlhECGfs7P7IkeaHL3ysjXfXLdCCc,2308
+foamlib/_cases/_subprocess.py,sha256=GTmHWy1LRD9ujpXJfSTXU2bf87GncpIA0VOR1rQW2fg,3633
+foamlib/_cases/_sync.py,sha256=L1Em9_32zd01RnMvksZ1GU-4okxhcwZgpLQf1c15uAs,6038
+foamlib/_cases/_util.py,sha256=GNndpqw3Jg_S-Hxzl5vwRgD0czcTNb9NYHMhcfBoMBg,1493
+foamlib/_files/__init__.py,sha256=-UqB9YTH6mrJfXCX00kPTAAY20XG64u1MGPw_1ewLVs,148
+foamlib/_files/_base.py,sha256=zaFDjLE6jB7WtGWk8hfKusjLtlGu6CZV16AHJpRUibs,1929
+foamlib/_files/_files.py,sha256=DxM5JmXv19PJrqlKNwuP6SsB0nye6aN1hiPwble7fFM,15657
+foamlib/_files/_io.py,sha256=T8vTEmJDidL03qeX1PUJFND-_vaF0AuC_0lE_zxLz7Q,2447
+foamlib/_files/_parsing.py,sha256=DzgJ53QnohRQyLXn2zOs52RIQ7bJ_fS_S2Z7rmRyVK4,9023
+foamlib/_files/_serialization.py,sha256=pb8_cIVgRhGS_ZV2p3x8p5_lK1SS6xzQHscAYYuOgFY,3407
+foamlib/_files/_util.py,sha256=UMzXmTFgvbp46w6k3oEZJoYC98pFgEK6LN5uLOwrlCg,397
+foamlib-0.6.4.dist-info/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
+foamlib-0.6.4.dist-info/METADATA,sha256=VeyVZAbFPEiSVnWDZ4XNzGYOHuz04fhmNkiGvYQp8KY,6569
+foamlib-0.6.4.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+foamlib-0.6.4.dist-info/top_level.txt,sha256=ZdVYtetXGwPwyfL-WhlhbTFQGAwKX5P_gXxtH9JYFPI,8
+foamlib-0.6.4.dist-info/RECORD,,

foamlib-0.6.2.dist-info/RECORD

@@ -1,21 +0,0 @@
-foamlib/__init__.py,sha256=7q60H9MQAusLbKMVlBGgR2FgYmGi08CcBEBJiCwAmf0,392
-foamlib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-foamlib/_cases/__init__.py,sha256=C0mpRu7c-X-4uVMKmVrZhwIyhBNyvUoCv0o-BQ72RC0,236
-foamlib/_cases/_async.py,sha256=8x8Mkql6XPzMjH4t-NszAEDx4gpjNPnQiWxFkHrcFJU,6436
-foamlib/_cases/_base.py,sha256=1CUkkK4afBxDgP79dmho97WJdj-GLgYhnrCSf_52Eao,6604
-foamlib/_cases/_run.py,sha256=KV5n9eBOR7nAnW1IFfvoudX2IxsJuhpXHzN7XcHnblE,12264
-foamlib/_cases/_subprocess.py,sha256=GTmHWy1LRD9ujpXJfSTXU2bf87GncpIA0VOR1rQW2fg,3633
-foamlib/_cases/_sync.py,sha256=46cXS8ixIpWIJ76iPdnE3rqvHDjd4mF3QYH-jWbYszs,4794
-foamlib/_cases/_util.py,sha256=GNndpqw3Jg_S-Hxzl5vwRgD0czcTNb9NYHMhcfBoMBg,1493
-foamlib/_files/__init__.py,sha256=-UqB9YTH6mrJfXCX00kPTAAY20XG64u1MGPw_1ewLVs,148
-foamlib/_files/_base.py,sha256=zaFDjLE6jB7WtGWk8hfKusjLtlGu6CZV16AHJpRUibs,1929
-foamlib/_files/_files.py,sha256=DxM5JmXv19PJrqlKNwuP6SsB0nye6aN1hiPwble7fFM,15657
-foamlib/_files/_io.py,sha256=uSh5XlgukwJkQSLELa4mshRD2aTajNk5vr_ZsBImSeU,2423
-foamlib/_files/_parsing.py,sha256=DzgJ53QnohRQyLXn2zOs52RIQ7bJ_fS_S2Z7rmRyVK4,9023
-foamlib/_files/_serialization.py,sha256=pb8_cIVgRhGS_ZV2p3x8p5_lK1SS6xzQHscAYYuOgFY,3407
-foamlib/_files/_util.py,sha256=UMzXmTFgvbp46w6k3oEZJoYC98pFgEK6LN5uLOwrlCg,397
-foamlib-0.6.2.dist-info/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
-foamlib-0.6.2.dist-info/METADATA,sha256=zoXLd6rEAjGbdJhQd9AMZ8oD5ME_1YqTuXYz2hGQXdE,6338
-foamlib-0.6.2.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-foamlib-0.6.2.dist-info/top_level.txt,sha256=ZdVYtetXGwPwyfL-WhlhbTFQGAwKX5P_gXxtH9JYFPI,8
-foamlib-0.6.2.dist-info/RECORD,,