foamlib 0.8.5__py3-none-any.whl → 0.8.7__py3-none-any.whl

foamlib/__init__.py

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

foamlib/_cases/_async.py

@@ -99,6 +99,9 @@ class AsyncFoamCase(FoamCaseRunBase):
         cpus: int,
         **kwargs: Any,
     ) -> None:
+        if isinstance(cmd, str):
+            cmd = [*AsyncFoamCase._SHELL, cmd]
+
         async with AsyncFoamCase._cpus(cpus):
             await run_async(cmd, **kwargs)
 

foamlib/_cases/_run.py

@@ -10,13 +10,16 @@ from contextlib import contextmanager
 from pathlib import Path
 from typing import IO, TYPE_CHECKING, Any
 
+from rich.progress import Progress
+
+from ._util import SingletonContextManager
+
 if sys.version_info >= (3, 9):
     from collections.abc import (
         Callable,
         Collection,
         Coroutine,
         Generator,
-        Mapping,
         Sequence,
     )
     from collections.abc import Set as AbstractSet
@@ -27,7 +30,6 @@ else:
         Collection,
         Coroutine,
         Generator,
-        Mapping,
         Sequence,
     )
 
@@ -68,6 +70,10 @@ class FoamCaseRunBase(FoamCaseBase):
 
             return ret
 
+    _SHELL = ("bash", "-c")
+
+    __progress = SingletonContextManager(Progress)
+
     def __delitem__(self, key: int | float | str) -> None:
         shutil.rmtree(self[key].path)
 
@@ -255,38 +261,60 @@ class FoamCaseRunBase(FoamCaseBase):
 
         return script
 
-    def __env(self, *, shell: bool) -> Mapping[str, str] | None:
-        sip_workaround = os.environ.get(
-            "FOAM_LD_LIBRARY_PATH", ""
-        ) and not os.environ.get("DYLD_LIBRARY_PATH", "")
-
-        if not shell or sip_workaround:
-            env = os.environ.copy()
-
-            if not shell:
-                env["PWD"] = str(self.path)
-
-            if sip_workaround:
-                env["DYLD_LIBRARY_PATH"] = env["FOAM_LD_LIBRARY_PATH"]
-
-            return env
-        return None
-
     @contextmanager
     def __output(
         self, cmd: Sequence[str | os.PathLike[str]] | str, *, log: bool
-    ) -> Generator[tuple[int | IO[bytes], int | IO[bytes]], None, None]:
+    ) -> Generator[tuple[int | IO[str], int | IO[str]], None, None]:
         if log:
             if isinstance(cmd, str):
                 name = shlex.split(cmd)[0]
             else:
                 name = Path(cmd[0]).name if isinstance(cmd[0], os.PathLike) else cmd[0]
 
-            with (self.path / f"log.{name}").open("ab") as stdout:
+            with (self.path / f"log.{name}").open("a") as stdout:
                 yield stdout, STDOUT
         else:
             yield DEVNULL, DEVNULL
 
+    @contextmanager
+    def __process_stdout(
+        self, cmd: Sequence[str | os.PathLike[str]] | str
+    ) -> Generator[Callable[[str], None], None, None]:
+        if isinstance(cmd, str):
+            name = shlex.split(cmd)[0]
+        else:
+            name = Path(cmd[0]).name if isinstance(cmd[0], os.PathLike) else cmd[0]
+
+        try:
+            with self.control_dict as control_dict:
+                if control_dict["stopAt"] == "endTime":
+                    control_dict_end_time = control_dict["endTime"]
+                    if isinstance(control_dict_end_time, (int, float)):
+                        end_time = control_dict_end_time
+                    else:
+                        end_time = None
+                else:
+                    end_time = None
+        except (KeyError, FileNotFoundError):
+            end_time = None
+
+        with self.__progress as progress:
+            task = progress.add_task(f"({self.name}) Running {name}...", total=None)
+
+            def process_stdout(line: str) -> None:
+                if line.startswith("Time = "):
+                    try:
+                        time = float(line.split()[2])
+                    except ValueError:
+                        progress.update(task)
+                    else:
+                        progress.update(task, completed=time, total=end_time)
+                else:
+                    progress.update(task)
+
+            yield process_stdout
+            progress.update(task, completed=1, total=1)
+
     def __mkrundir(self) -> Path:
         d = Path(os.environ["FOAM_RUN"], "foamlib")
         d.mkdir(parents=True, exist_ok=True)
@@ -379,15 +407,16 @@ class FoamCaseRunBase(FoamCaseBase):
                 if cpus is None:
                     cpus = 1
 
-            with self.__output(cmd, log=log) as (stdout, stderr):
+            with self.__output(cmd, log=log) as (stdout, stderr), self.__process_stdout(
+                cmd
+            ) as process_stdout:
                 if parallel:
                     if isinstance(cmd, str):
                         cmd = [
                             "mpiexec",
                             "-n",
                             str(cpus),
-                            "/bin/sh",
-                            "-c",
+                            *FoamCaseRunBase._SHELL,
                             f"{cmd} -parallel",
                         ]
                     else:
@@ -396,11 +425,11 @@ class FoamCaseRunBase(FoamCaseBase):
                 yield self._run(
                     cmd,
                     cpus=cpus,
+                    case=self,
                     check=check,
-                    cwd=self.path,
-                    env=self.__env(shell=isinstance(cmd, str)),
                     stdout=stdout,
                     stderr=stderr,
+                    process_stdout=process_stdout,
                     **kwargs,
                 )
 

foamlib/_cases/_slurm.py

@@ -31,10 +31,10 @@ class AsyncSlurmFoamCase(AsyncFoamCase):
             await AsyncFoamCase._run(cmd, cpus=cpus, **kwargs)
             return
 
-        if cpus >= 1:
-            if isinstance(cmd, str):
-                cmd = ["/bin/sh", "-c", cmd]
+        if isinstance(cmd, str):
+            cmd = [*AsyncSlurmFoamCase._SHELL, cmd]
 
+        if cpus >= 1:
             if cpus == 1:
                 cmd = ["srun", *cmd]
 

foamlib/_cases/_subprocess.py

@@ -1,18 +1,18 @@
 from __future__ import annotations
 
 import asyncio
+import os
+import selectors
 import subprocess
 import sys
-from io import BytesIO
-from typing import IO, TYPE_CHECKING
-
-if TYPE_CHECKING:
-    import os
+from io import StringIO
+from pathlib import Path
+from typing import IO
 
 if sys.version_info >= (3, 9):
-    from collections.abc import Mapping, Sequence
+    from collections.abc import Callable, Mapping, Sequence
 else:
-    from typing import Mapping, Sequence
+    from typing import Callable, Mapping, Sequence
 
 CompletedProcess = subprocess.CompletedProcess
 
@@ -32,46 +32,72 @@ PIPE = subprocess.PIPE
 STDOUT = subprocess.STDOUT
 
 
+def _env(case: os.PathLike[str]) -> Mapping[str, str]:
+    env = os.environ.copy()
+
+    env["PWD"] = str(Path(case))
+
+    if os.environ.get("FOAM_LD_LIBRARY_PATH", "") and not os.environ.get(
+        "DYLD_LIBRARY_PATH", ""
+    ):
+        env["DYLD_LIBRARY_PATH"] = env["FOAM_LD_LIBRARY_PATH"]
+
+    return env
+
+
 def run_sync(
-    cmd: Sequence[str | os.PathLike[str]] | str,
+    cmd: Sequence[str | os.PathLike[str]],
     *,
+    case: os.PathLike[str],
     check: bool = True,
-    cwd: os.PathLike[str] | None = None,
-    env: Mapping[str, str] | None = None,
-    stdout: int | IO[bytes] | None = None,
-    stderr: int | IO[bytes] | None = None,
-) -> CompletedProcess[bytes]:
-    if not isinstance(cmd, str) and sys.version_info < (3, 8):
+    stdout: int | IO[str] = DEVNULL,
+    stderr: int | IO[str] = STDOUT,
+    process_stdout: Callable[[str], None] = lambda _: None,
+) -> CompletedProcess[str]:
+    if sys.version_info < (3, 8):
         cmd = [str(arg) for arg in cmd]
 
-    proc = subprocess.Popen(
+    with subprocess.Popen(
         cmd,
-        cwd=cwd,
-        env=env,
-        stdout=stdout,
+        cwd=case,
+        env=_env(case),
+        stdout=PIPE,
         stderr=PIPE,
-        shell=isinstance(cmd, str),
-    )
-
-    if stderr == STDOUT:
-        stderr = stdout
-    if stderr not in (PIPE, DEVNULL):
-        stderr_copy = BytesIO()
-
-        assert not isinstance(stderr, int)
-        if stderr is None:
-            stderr = sys.stderr.buffer
-
+        text=True,
+    ) as proc:
+        assert proc.stdout is not None
         assert proc.stderr is not None
-        for line in proc.stderr:
-            stderr.write(line)
-            stderr_copy.write(line)
 
-        output, _ = proc.communicate()
-        assert not _
-        error = stderr_copy.getvalue()
-    else:
-        output, error = proc.communicate()
+        output = StringIO() if stdout is PIPE else None
+        error = StringIO()
+
+        if stderr is STDOUT:
+            stderr = stdout
+
+        with selectors.DefaultSelector() as selector:
+            selector.register(proc.stdout, selectors.EVENT_READ)
+            selector.register(proc.stderr, selectors.EVENT_READ)
+            open_streams = {proc.stdout, proc.stderr}
+            while open_streams:
+                for key, _ in selector.select():
+                    assert key.fileobj in open_streams
+                    line = key.fileobj.readline()  # type: ignore [union-attr]
+                    if not line:
+                        selector.unregister(key.fileobj)
+                        open_streams.remove(key.fileobj)  # type: ignore [arg-type]
+                    elif key.fileobj is proc.stdout:
+                        process_stdout(line)
+                        if output is not None:
+                            output.write(line)
+                        if stdout not in (DEVNULL, PIPE):
+                            assert not isinstance(stdout, int)
+                            stdout.write(line)
+                    else:
+                        assert key.fileobj is proc.stderr
+                        error.write(line)
+                        if stderr not in (DEVNULL, PIPE):
+                            assert not isinstance(stderr, int)
+                            stderr.write(line)
 
     assert proc.returncode is not None
 
@@ -79,74 +105,84 @@ def run_sync(
         raise CalledProcessError(
             returncode=proc.returncode,
             cmd=cmd,
-            output=output,
-            stderr=error,
+            output=output.getvalue() if output is not None else None,
+            stderr=error.getvalue(),
         )
 
     return CompletedProcess(
-        cmd, returncode=proc.returncode, stdout=output, stderr=error
+        cmd,
+        returncode=proc.returncode,
+        stdout=output.getvalue() if output is not None else None,
+        stderr=error.getvalue(),
     )
 
 
 async def run_async(
-    cmd: Sequence[str | os.PathLike[str]] | str,
+    cmd: Sequence[str | os.PathLike[str]],
     *,
+    case: os.PathLike[str],
     check: bool = True,
-    cwd: os.PathLike[str] | None = None,
-    env: Mapping[str, str] | None = None,
-    stdout: int | IO[bytes] | None = None,
-    stderr: int | IO[bytes] | None = None,
-) -> CompletedProcess[bytes]:
-    if isinstance(cmd, str):
-        proc = await asyncio.create_subprocess_shell(
-            cmd,
-            cwd=cwd,
-            env=env,
-            stdout=stdout,
-            stderr=PIPE,
-        )
+    stdout: int | IO[str] = DEVNULL,
+    stderr: int | IO[str] = STDOUT,
+    process_stdout: Callable[[str], None] = lambda _: None,
+) -> CompletedProcess[str]:
+    if sys.version_info < (3, 8):
+        cmd = [str(arg) for arg in cmd]
 
-    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=PIPE,
-        )
+    proc = await asyncio.create_subprocess_exec(
+        *cmd,
+        cwd=case,
+        env=_env(case),
+        stdout=PIPE,
+        stderr=PIPE,
+    )
 
-    if stderr == STDOUT:
+    if stderr is STDOUT:
         stderr = stdout
-    if stderr not in (PIPE, DEVNULL):
-        stderr_copy = BytesIO()
-
-        assert not isinstance(stderr, int)
-        if stderr is None:
-            stderr = sys.stderr.buffer
-
-        assert proc.stderr is not None
-        async for line in proc.stderr:
-            stderr.write(line)
-            stderr_copy.write(line)
-
-        output, _ = await proc.communicate()
-        assert not _
-        error = stderr_copy.getvalue()
-    else:
-        output, error = await proc.communicate()
 
+    output = StringIO() if stdout is PIPE else None
+    error = StringIO()
+
+    async def tee_stdout() -> None:
+        while True:
+            assert proc.stdout is not None
+            line = (await proc.stdout.readline()).decode()
+            if not line:
+                break
+            process_stdout(line)
+            if output is not None:
+                output.write(line)
+            if stdout not in (DEVNULL, PIPE):
+                assert not isinstance(stdout, int)
+                stdout.write(line)
+
+    async def tee_stderr() -> None:
+        while True:
+            assert proc.stderr is not None
+            line = (await proc.stderr.readline()).decode()
+            if not line:
+                break
+            error.write(line)
+            if stderr not in (DEVNULL, PIPE):
+                assert not isinstance(stderr, int)
+                stderr.write(line)
+
+    await asyncio.gather(tee_stdout(), tee_stderr())
+
+    await proc.wait()
     assert proc.returncode is not None
 
     if check and proc.returncode != 0:
         raise CalledProcessError(
             returncode=proc.returncode,
             cmd=cmd,
-            output=output,
-            stderr=error,
+            output=output.getvalue() if output is not None else None,
+            stderr=error.getvalue(),
         )
 
     return CompletedProcess(
-        cmd, returncode=proc.returncode, stdout=output, stderr=error
+        cmd,
+        returncode=proc.returncode,
+        stdout=output.getvalue() if output is not None else None,
+        stderr=error.getvalue(),
     )

foamlib/_cases/_sync.py

@@ -58,6 +58,9 @@ class FoamCase(FoamCaseRunBase):
         cpus: int,
         **kwargs: Any,
     ) -> None:
+        if isinstance(cmd, str):
+            cmd = [*FoamCase._SHELL, cmd]
+
         run_sync(cmd, **kwargs)
 
     @staticmethod

foamlib/_cases/_util.py

@@ -2,7 +2,17 @@ from __future__ import annotations
 
 import functools
 import sys
-from typing import TYPE_CHECKING, Any, AsyncContextManager, Callable, Generic, TypeVar
+import threading
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    AsyncContextManager,
+    Callable,
+    ContextManager,
+    Generic,
+    TypeVar,
+    cast,
+)
 
 if TYPE_CHECKING:
     from types import TracebackType
@@ -54,3 +64,33 @@ def awaitableasynccontextmanager(
         return _AwaitableAsyncContextManager(cm(*args, **kwargs))
 
     return f
+
+
+class SingletonContextManager(Generic[R]):
+    def __init__(self, factory: Callable[[], ContextManager[R]]) -> None:
+        self._factory = factory
+        self._users = 0
+        self._cm: ContextManager[R] | None = None
+        self._ret: R | None = None
+        self._lock = threading.Lock()
+
+    def __enter__(self) -> R:
+        with self._lock:
+            if self._users == 0:
+                self._cm = self._factory()
+                self._ret = self._cm.__enter__()
+            self._users += 1
+            return cast("R", self._ret)
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool | None:
+        with self._lock:
+            self._users -= 1
+            if self._users == 0:
+                assert self._cm is not None
+                return self._cm.__exit__(exc_type, exc_val, exc_tb)
+            return False

foamlib/_files/_files.py

@@ -100,9 +100,9 @@ class FoamFile(
                 assert isinstance(ret, dict)
                 v = ret[k]
                 assert isinstance(v, dict)
-                ret = cast(File, v)
+                ret = cast("File", v)
 
-            return cast(Dict_, ret)
+            return cast("Dict_", ret)
 
     @property
     def version(self) -> float:
@@ -127,7 +127,7 @@ class FoamFile(
         if ret not in ("ascii", "binary"):
             msg = "format is not 'ascii' or 'binary'"
             raise ValueError(msg)
-        return cast(Literal["ascii", "binary"], ret)
+        return cast("Literal['ascii', 'binary']", ret)
 
     @format.setter
     def format(self, value: Literal["ascii", "binary"]) -> None:
@@ -412,7 +412,7 @@ class FoamFieldFile(FoamFile):
         ) -> Field:
             """Alias of `self["value"]`."""
             return cast(
-                Field,
+                "Field",
                 self["value"],
             )
 
@@ -461,7 +461,7 @@ class FoamFieldFile(FoamFile):
         self,
     ) -> Field:
         """Alias of `self["internalField"]`."""
-        return cast(Field, self["internalField"])
+        return cast("Field", self["internalField"])
 
     @internal_field.setter
     def internal_field(

foamlib/_files/_parsing.py

@@ -16,6 +16,7 @@ else:
 
 import numpy as np
 from pyparsing import (
+    CaselessKeyword,
     Combine,
     Dict,
     Forward,
@@ -157,6 +158,7 @@ def _dict_of(
     data: ParserElement,
     *,
     directive: ParserElement | None = None,
+    data_entry: ParserElement | None = None,
     located: bool = False,
 ) -> ParserElement:
     dict_ = Forward()
@@ -164,7 +166,8 @@ def _dict_of(
     keyword_entry = keyword + (dict_ | (data + Literal(";").suppress()))
 
     if directive is not None:
-        keyword_entry |= directive + data + LineEnd().suppress()  # type: ignore [no-untyped-call]
+        assert data_entry is not None
+        keyword_entry |= directive + data_entry + LineEnd().suppress()
 
     if located:
         keyword_entry = Located(keyword_entry)
@@ -183,15 +186,19 @@ def _keyword_entry_of(
     data: ParserElement,
     *,
     directive: ParserElement | None = None,
+    data_entry: ParserElement | None = None,
     located: bool = False,
 ) -> ParserElement:
     keyword_entry = keyword + (
-        _dict_of(keyword, data, directive=directive, located=located)
+        _dict_of(
+            keyword, data, directive=directive, data_entry=data_entry, located=located
+        )
         | (data + Literal(";").suppress())
     )
 
     if directive is not None:
-        keyword_entry |= directive + data + LineEnd().suppress()  # type: ignore [no-untyped-call]
+        assert data_entry is not None
+        keyword_entry |= directive + data_entry + LineEnd().suppress()
 
     if located:
         keyword_entry = Located(keyword_entry)
@@ -261,7 +268,16 @@ _DICT = _dict_of(_TOKEN, _DATA)
 _DATA_ENTRY = Forward()
 _LIST_ENTRY = _DICT | _KEYWORD_ENTRY | _DATA_ENTRY
 _LIST = _list_of(_LIST_ENTRY)
-_NUMBER = common.signed_integer ^ common.ieee_float
+_NUMBER = (
+    common.number
+    | CaselessKeyword("nan").set_parse_action(lambda: np.nan)
+    | (CaselessKeyword("inf") | CaselessKeyword("infinity")).set_parse_action(
+        lambda: np.inf
+    )
+    | (CaselessKeyword("-inf") | CaselessKeyword("-infinity")).set_parse_action(
+        lambda: -np.inf
+    )
+)
 _DATA_ENTRY <<= _FIELD | _LIST | _DIMENSIONED | _DIMENSIONS | _NUMBER | _SWITCH | _TOKEN
 
 _DATA <<= (
@@ -275,12 +291,16 @@ _DATA <<= (
 def parse_data(s: str) -> Data:
     if not s.strip():
         return ""
-    return cast(Data, _DATA.parse_string(s, parse_all=True)[0])
+    return cast("Data", _DATA.parse_string(s, parse_all=True)[0])
 
 
 _LOCATED_DICTIONARY = Group(
     _keyword_entry_of(
-        _TOKEN, Opt(_DATA, default=""), directive=_DIRECTIVE, located=True
+        _TOKEN,
+        Opt(_DATA, default=""),
+        directive=_DIRECTIVE,
+        data_entry=_DATA_ENTRY,
+        located=True,
     )
 )[...]
 _LOCATED_DATA = Group(Located(_DATA.copy().add_parse_action(lambda tks: ["", tks[0]])))
@@ -421,7 +441,7 @@ class Parsed(Mapping[Tuple[str, ...], Union[Data, EllipsisType]]):
             for k in keywords[:-1]:
                 v = r[k]
                 assert isinstance(v, dict)
-                r = cast(File, v)
+                r = cast("File", v)
 
             assert isinstance(r, dict)
             if keywords:

{foamlib-0.8.5.dist-info → foamlib-0.8.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: foamlib
-Version: 0.8.5
+Version: 0.8.7
 Summary: A Python interface for interacting with OpenFOAM
 Project-URL: Homepage, https://github.com/gerlero/foamlib
 Project-URL: Repository, https://github.com/gerlero/foamlib
@@ -29,6 +29,7 @@ Requires-Dist: aioshutil<2,>=1
 Requires-Dist: numpy<3,>=1
 Requires-Dist: numpy<3,>=1.25.0; python_version >= '3.10'
 Requires-Dist: pyparsing<4,>=3.1.2
+Requires-Dist: rich<14,>=13
 Requires-Dist: typing-extensions<5,>=4; python_version < '3.11'
 Provides-Extra: dev
 Requires-Dist: mypy<2,>=1; extra == 'dev'

foamlib-0.8.7.dist-info/RECORD

@@ -0,0 +1,20 @@
+foamlib/__init__.py,sha256=TrTrsv_QjPqa16duuXQl5FgjxRPwuHlhO-MHOtxUzdY,452
+foamlib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+foamlib/_cases/__init__.py,sha256=_A1TTHuQfS9FH2_33lSEyLtOJZGFHZBco1tWJCVOHks,358
+foamlib/_cases/_async.py,sha256=vXpq5T2gDomuawARsLaUEMjUBhMsZK58q7iVwQpXsYE,7903
+foamlib/_cases/_base.py,sha256=37oBbM3NM-hpG7dKewZvyJNtqSAogMurcbmX-wLIgMU,6727
+foamlib/_cases/_run.py,sha256=IRsozHdXx5tjLYYIWMiKGeaf5188unhp5VwIAZLlr3E,15578
+foamlib/_cases/_slurm.py,sha256=Hzpf5Ugahwq7sUsCfhZ6JgXDOdkoYGGsHGiO7NV8uFs,2331
+foamlib/_cases/_subprocess.py,sha256=VHV2SuOLqa711an6kCuvN6UlIkeh4qqFfdrpNoKzQps,5630
+foamlib/_cases/_sync.py,sha256=e06aGGZ9n6WTWK9eWZhrezsT4yebGhKPE0sn0nwQH8A,5977
+foamlib/_cases/_util.py,sha256=QCizfbuJdOCeF9ogU2R-y-iWX5kfaOA4U2W68t6QlOM,2544
+foamlib/_files/__init__.py,sha256=q1vkjXnjnSZvo45jPAICpWeF2LZv5V6xfzAR6S8fS5A,96
+foamlib/_files/_files.py,sha256=YAKw3RHEw8eCja4JAxobp6BC-2Kyy7AvG1O7yOqyMic,15414
+foamlib/_files/_io.py,sha256=BGbbm6HKxL2ka0YMCmHqZQZ1R4PPQlkvWWb4FHMAS8k,2217
+foamlib/_files/_parsing.py,sha256=XrqG8IcTM--qZYqEHYO_jcCTb7ev9M9kz75T_DQtPuc,14047
+foamlib/_files/_serialization.py,sha256=PvMzNyTja6OKT_GUfExTulx9nMLBjfu0-9yThCKbvxs,5227
+foamlib/_files/_types.py,sha256=m-fFjJnS4sFSavDsijlXpAfEhnbh10RBumSHAT0GOgQ,3408
+foamlib-0.8.7.dist-info/METADATA,sha256=HVzB10Bdz97hbXxBDunpGy-_seeNduk5msDAKVCXmx4,7996
+foamlib-0.8.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+foamlib-0.8.7.dist-info/licenses/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
+foamlib-0.8.7.dist-info/RECORD,,

foamlib-0.8.5.dist-info/RECORD

@@ -1,20 +0,0 @@
-foamlib/__init__.py,sha256=vhMMDd4SJsEtAYoKY35ByJmFCQcyDMEb-WpdS8ERF3g,452
-foamlib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-foamlib/_cases/__init__.py,sha256=_A1TTHuQfS9FH2_33lSEyLtOJZGFHZBco1tWJCVOHks,358
-foamlib/_cases/_async.py,sha256=onECxRLQCF7Kd-GeuLqH_Xv3gbMMhKOSbFaUG5Ttgmk,7822
-foamlib/_cases/_base.py,sha256=37oBbM3NM-hpG7dKewZvyJNtqSAogMurcbmX-wLIgMU,6727
-foamlib/_cases/_run.py,sha256=lveqKZium_qK_eTxYE8jOjwx0eiIoolCBbi56-zLw1o,14420
-foamlib/_cases/_slurm.py,sha256=kj4wqgr3foMyAoUkoHOZODRBmVqH1B9KqAIEEjM8ZBg,2328
-foamlib/_cases/_subprocess.py,sha256=6BlBRxknj2-BFcGkx7oVcuL63_utSaY1Axmsc1qV9j8,3887
-foamlib/_cases/_sync.py,sha256=2BJXB7Nzldb4OgPukqupgYqdceUGkI2mYhhtGPWEBrc,5901
-foamlib/_cases/_util.py,sha256=tK4SM5WT3eEgGsFLnidIySbom1qowBAua9z13gipKJk,1518
-foamlib/_files/__init__.py,sha256=q1vkjXnjnSZvo45jPAICpWeF2LZv5V6xfzAR6S8fS5A,96
-foamlib/_files/_files.py,sha256=V740S36NVunULv8pnyEsJ7lIWbSjk_-LwbP7BBqFsO0,15404
-foamlib/_files/_io.py,sha256=BGbbm6HKxL2ka0YMCmHqZQZ1R4PPQlkvWWb4FHMAS8k,2217
-foamlib/_files/_parsing.py,sha256=uM9eD67Coo5K-F2EWkbzLfpdTr56mUbLw2kE8Q94-PE,13549
-foamlib/_files/_serialization.py,sha256=PvMzNyTja6OKT_GUfExTulx9nMLBjfu0-9yThCKbvxs,5227
-foamlib/_files/_types.py,sha256=m-fFjJnS4sFSavDsijlXpAfEhnbh10RBumSHAT0GOgQ,3408
-foamlib-0.8.5.dist-info/METADATA,sha256=H5RgbkxMQZf-PG38gx3Ckhu3q6eqOYndn457-htff84,7968
-foamlib-0.8.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-foamlib-0.8.5.dist-info/licenses/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
-foamlib-0.8.5.dist-info/RECORD,,