foamlib 0.4.3__py3-none-any.whl → 0.4.4__py3-none-any.whl

foamlib/__init__.py

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

foamlib/_cases/_async.py

@@ -4,14 +4,15 @@ import sys
 from contextlib import asynccontextmanager
 from pathlib import Path
 from typing import (
+    Callable,
     Optional,
     Union,
 )
 
 if sys.version_info >= (3, 9):
-    from collections.abc import AsyncGenerator, Sequence
+    from collections.abc import AsyncGenerator, Collection, Sequence
 else:
-    from typing import AsyncGenerator, Sequence
+    from typing import AsyncGenerator, Collection, Sequence
 
 import aioshutil
 
@@ -61,6 +62,22 @@ class AsyncFoamCase(FoamCaseBase):
                     AsyncFoamCase._reserved_cpus -= cpus
                     AsyncFoamCase._cpus_cond.notify(cpus)
 
+    @staticmethod
+    async def _rmtree(path: Path, ignore_errors: bool = False) -> None:
+        await aioshutil.rmtree(path, ignore_errors=ignore_errors)  # type: ignore [call-arg]
+
+    @staticmethod
+    async def _copytree(
+        src: Path,
+        dest: Path,
+        *,
+        symlinks: bool = False,
+        ignore: Optional[
+            Callable[[Union[Path, str], Collection[str]], Collection[str]]
+        ] = None,
+    ) -> None:
+        await aioshutil.copytree(src, dest, symlinks=symlinks, ignore=ignore)
+
     async def clean(
         self,
         *,
@@ -73,50 +90,55 @@ class AsyncFoamCase(FoamCaseBase):
         :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()
+        for name, args, kwargs in self._clean_cmds(script=script, check=check):
+            await getattr(self, name)(*args, **kwargs)
 
     async def _run(
         self,
         cmd: Union[Sequence[Union[str, Path]], str, Path],
         *,
+        parallel: bool = False,
+        cpus: int = 1,
         check: bool = True,
     ) -> None:
-        if not is_sequence(cmd):
-            proc = await asyncio.create_subprocess_shell(
-                str(cmd),
-                cwd=self.path,
-                env=self._env(shell=True),
-                stdout=asyncio.subprocess.DEVNULL,
-                stderr=asyncio.subprocess.PIPE if check else asyncio.subprocess.DEVNULL,
-            )
-
-        else:
-            if sys.version_info < (3, 8):
-                cmd = (str(arg) for arg in cmd)
-            proc = await asyncio.create_subprocess_exec(
-                *cmd,
-                cwd=self.path,
-                env=self._env(shell=False),
-                stdout=asyncio.subprocess.DEVNULL,
-                stderr=asyncio.subprocess.PIPE if check else asyncio.subprocess.DEVNULL,
-            )
-
-        stdout, stderr = await proc.communicate()
-
-        assert stdout is None
-        assert proc.returncode is not None
-
-        if check:
-            check_returncode(proc.returncode, cmd, stderr.decode())
+        async with self._cpus(cpus):
+            if not is_sequence(cmd):
+                if parallel:
+                    cmd = f"mpiexec -np {cpus} {cmd} -parallel"
+
+                proc = await asyncio.create_subprocess_shell(
+                    str(cmd),
+                    cwd=self.path,
+                    env=self._env(shell=True),
+                    stdout=asyncio.subprocess.DEVNULL,
+                    stderr=asyncio.subprocess.PIPE
+                    if check
+                    else asyncio.subprocess.DEVNULL,
+                )
+
+            else:
+                if parallel:
+                    cmd = ["mpiexec", "-np", str(cpus), *cmd, "-parallel"]
+
+                if sys.version_info < (3, 8):
+                    cmd = (str(arg) for arg in cmd)
+                proc = await asyncio.create_subprocess_exec(
+                    *cmd,
+                    cwd=self.path,
+                    env=self._env(shell=False),
+                    stdout=asyncio.subprocess.DEVNULL,
+                    stderr=asyncio.subprocess.PIPE
+                    if check
+                    else asyncio.subprocess.DEVNULL,
+                )
+
+            stdout, stderr = await proc.communicate()
+
+            assert stdout is None
+            assert proc.returncode is not None
+
+            if check:
+                check_returncode(proc.returncode, cmd, stderr.decode())
 
     async def run(
         self,
@@ -128,19 +150,9 @@ class AsyncFoamCase(FoamCaseBase):
         check: bool = True,
     ) -> None:
         for name, args, kwargs in self._run_cmds(
-            cmd=cmd, script=script, parallel=parallel, check=check
+            cmd=cmd, script=script, parallel=parallel, cpus=cpus, check=check
         ):
-            if cpus is None:
-                if name == "run":
-                    if kwargs.get("parallel", False):
-                        cpus = max(self._nprocessors, 1)
-                    else:
-                        cpus = 1
-                else:
-                    cpus = 0
-
-            async with self._cpus(cpus):
-                await getattr(self, name)(*args, **kwargs)
+            await getattr(self, name)(*args, **kwargs)
 
     async def block_mesh(self, *, check: bool = True) -> None:
         """Run blockMesh on this case."""
@@ -156,8 +168,8 @@ class AsyncFoamCase(FoamCaseBase):
 
     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")
+        for name, args, kwargs in self._restore_0_dir_cmds():
+            await getattr(self, name)(*args, **kwargs)
 
     async def copy(self, dest: Union[Path, str]) -> "AsyncFoamCase":
         """
@@ -165,7 +177,10 @@ class AsyncFoamCase(FoamCaseBase):
 
         :param dest: The destination path.
         """
-        return AsyncFoamCase(await aioshutil.copytree(self.path, dest, symlinks=True))
+        for name, args, kwargs in self._copy_cmds(dest):
+            await getattr(self, name)(*args, **kwargs)
+
+        return AsyncFoamCase(dest)
 
     async def clone(self, dest: Union[Path, str]) -> "AsyncFoamCase":
         """
@@ -173,15 +188,7 @@ class AsyncFoamCase(FoamCaseBase):
 
         :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()
-        )
+        for name, args, kwargs in self._clone_cmds(dest):
+            await getattr(self, name)(*args, **kwargs)
 
         return AsyncFoamCase(dest)

foamlib/_cases/_base.py

@@ -33,11 +33,10 @@ else:
 
 
 from .._files import FoamFieldFile, FoamFile
-from .._util import is_sequence
 
 
 class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
-    def __init__(self, path: Union[Path, str] = Path()):
+    def __init__(self, path: Union[Path, str, "FoamCaseBase"] = Path()):
         self.path = Path(path).absolute()
 
     class TimeDirectory(Set[FoamFieldFile]):
@@ -254,24 +253,102 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
         else:
             return None
 
+    def _copy_cmds(
+        self, dest: Union[Path, str]
+    ) -> Generator[Tuple[str, Sequence[Any], Mapping[str, Any]], None, None]:
+        yield (
+            "_copytree",
+            (
+                self.path,
+                dest,
+            ),
+            {"symlinks": True},
+        )
+
+    def _clean_cmds(
+        self, *, script: bool = True, check: bool = False
+    ) -> Generator[Tuple[str, Sequence[Any], Mapping[str, Any]], None, None]:
+        script_path = self._clean_script() if script else None
+
+        if script_path is not None:
+            yield ("_run", ([script_path],), {"cpus": 0, "check": check})
+        else:
+            for p in self._clean_paths():
+                if p.is_dir():
+                    yield ("_rmtree", (p,), {})
+                else:
+                    p.unlink()
+
+    def _clone_cmds(
+        self, dest: Union[Path, str]
+    ) -> Generator[Tuple[str, Sequence[Any], Mapping[str, Any]], None, None]:
+        if self._clean_script() is not None:
+            yield ("copy", (dest,), {})
+            yield ("clean", (), {})
+        else:
+            yield (
+                "_copytree",
+                (
+                    self.path,
+                    dest,
+                ),
+                {"symlinks": True, "ignore": self._clone_ignore()},
+            )
+
+    def _restore_0_dir_cmds(
+        self,
+    ) -> Generator[Tuple[str, Sequence[Any], Mapping[str, Any]], None, None]:
+        yield ("_rmtree", (self.path / "0",), {"ignore_errors": True})
+        yield (
+            "_copytree",
+            (
+                self.path / "0.orig",
+                self.path / "0",
+            ),
+            {"symlinks": True},
+        )
+
     def _run_cmds(
         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,
     ) -> Generator[Tuple[str, Sequence[Any], Mapping[str, Any]], None, None]:
         if cmd is not None:
             if parallel:
-                cmd = self._parallel_cmd(cmd)
+                if cpus is None:
+                    cpus = max(self._nprocessors, 1)
+            else:
+                parallel = False
+                if cpus is None:
+                    cpus = 1
+
+            yield ("_run", (cmd,), {"parallel": parallel, "cpus": cpus, "check": check})
 
-            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})
+                if parallel or parallel is None:
+                    if cpus is None:
+                        if self._nprocessors > 0:
+                            cpus = self._nprocessors
+                        elif (self.path / "system" / "decomposeParDict").is_file():
+                            cpus = self._nsubdomains
+                        else:
+                            cpus = 1
+                else:
+                    if cpus is None:
+                        cpus = 1
+
+                yield (
+                    "_run",
+                    ([script_path],),
+                    {"parallel": False, "cpus": cpus, "check": check},
+                )
 
             else:
                 if not self and (self.path / "0.orig").is_dir():
@@ -282,7 +359,8 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
 
                 if parallel is None:
                     parallel = (
-                        self._nprocessors > 0
+                        (cpus is not None and cpus > 1)
+                        or self._nprocessors > 0
                         or (self.path / "system" / "decomposeParDict").is_file()
                     )
 
@@ -293,27 +371,18 @@ class FoamCaseBase(Sequence["FoamCaseBase.TimeDirectory"]):
                     ):
                         yield ("decompose_par", (), {"check": check})
 
+                    if cpus is None:
+                        cpus = max(self._nprocessors, 1)
+                else:
+                    if cpus is None:
+                        cpus = 1
+
                 yield (
-                    "run",
+                    "_run",
                     ([self.application],),
-                    {"parallel": parallel, "check": check},
+                    {"parallel": parallel, "cpus": cpus, "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."""

foamlib/_cases/_sync.py

@@ -3,14 +3,15 @@ import subprocess
 import sys
 from pathlib import Path
 from typing import (
+    Callable,
     Optional,
     Union,
 )
 
 if sys.version_info >= (3, 9):
-    from collections.abc import Sequence
+    from collections.abc import Collection, Sequence
 else:
-    from typing import Sequence
+    from typing import Collection, Sequence
 
 from .._util import is_sequence
 from ._base import FoamCaseBase
@@ -28,6 +29,22 @@ class FoamCase(FoamCaseBase):
     :param path: The path to the case directory.
     """
 
+    @staticmethod
+    def _rmtree(path: Path, *, ignore_errors: bool = False) -> None:
+        shutil.rmtree(path, ignore_errors=ignore_errors)
+
+    @staticmethod
+    def _copytree(
+        src: Path,
+        dest: Path,
+        *,
+        symlinks: bool = False,
+        ignore: Optional[
+            Callable[[Union[Path, str], Collection[str]], Collection[str]]
+        ] = None,
+    ) -> None:
+        shutil.copytree(src, dest, symlinks=symlinks, ignore=ignore)
+
     def clean(
         self,
         *,
@@ -40,25 +57,26 @@ class FoamCase(FoamCaseBase):
         :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()
+        for name, args, kwargs in self._clean_cmds(script=script, check=check):
+            getattr(self, name)(*args, **kwargs)
 
     def _run(
         self,
         cmd: Union[Sequence[Union[str, Path]], str, Path],
         *,
+        parallel: bool = False,
+        cpus: int = 1,
         check: bool = True,
     ) -> None:
         shell = not is_sequence(cmd)
 
+        if parallel:
+            if shell:
+                cmd = f"mpiexec -np {cpus} {cmd} -parallel"
+            else:
+                assert is_sequence(cmd)
+                cmd = ["mpiexec", "-np", str(cpus), *cmd, "-parallel"]
+
         if sys.version_info < (3, 8):
             if shell:
                 cmd = str(cmd)
@@ -113,8 +131,8 @@ class FoamCase(FoamCaseBase):
 
     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")
+        for name, args, kwargs in self._restore_0_dir_cmds():
+            getattr(self, name)(*args, **kwargs)
 
     def copy(self, dest: Union[Path, str]) -> "FoamCase":
         """
@@ -122,7 +140,10 @@ class FoamCase(FoamCaseBase):
 
         :param dest: The destination path.
         """
-        return FoamCase(shutil.copytree(self.path, dest, symlinks=True))
+        for name, args, kwargs in self._copy_cmds(dest):
+            getattr(self, name)(*args, **kwargs)
+
+        return FoamCase(dest)
 
     def clone(self, dest: Union[Path, str]) -> "FoamCase":
         """
@@ -130,13 +151,7 @@ class FoamCase(FoamCaseBase):
 
         :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())
+        for name, args, kwargs in self._clone_cmds(dest):
+            getattr(self, name)(*args, **kwargs)
 
         return FoamCase(dest)

foamlib/_files/_parsing.py

@@ -29,6 +29,7 @@ from pyparsing import (
     Word,
     c_style_comment,
     common,
+    counted_array,
     cpp_style_comment,
     identchars,
     printables,
@@ -42,12 +43,13 @@ def _list_of(entry: ParserElement) -> ParserElement:
         Literal("List") + Literal("<") + common.identifier + Literal(">")
     ).suppress() + (
         (
-            Opt(common.integer).suppress()
-            + (
-                Literal("(").suppress()
-                + Group((entry)[...], aslist=True)
-                + Literal(")").suppress()
-            )
+            counted_array(entry, common.integer + Literal("(").suppress())
+            + Literal(")").suppress()
+        ).set_parse_action(lambda tks: [tks.as_list()])
+        | (
+            Literal("(").suppress()
+            + Group((entry)[...], aslist=True)
+            + Literal(")").suppress()
         )
         | (
             common.integer + Literal("{").suppress() + entry + Literal("}").suppress()
@@ -76,54 +78,59 @@ def _keyword_entry_of(
     return keyword_entry
 
 
-_binary_contents = Forward()
-
-
-def _binary_field_parse_action(tks: ParseResults) -> None:
-    global _binary_contents
-
-    kind, count = tks
-    if kind == "scalar":
-        elsize = 1
-    elif kind == "vector":
-        elsize = 3
-    elif kind == "symmTensor":
-        elsize = 6
-    elif kind == "tensor":
-        elsize = 9
-
-    def unpack(
-        tks: ParseResults,
-    ) -> Sequence[Union[Sequence[float], Sequence[Sequence[float]]]]:
-        bytes_ = tks[0].encode("latin-1")
-
-        arr = array.array("d", bytes_)
+def _unpack_binary_field(
+    tks: ParseResults,
+) -> Sequence[Union[Sequence[float], Sequence[Sequence[float]]]]:
+    elsize = len(tks[0]) // 8
 
-        if elsize != 1:
-            all = [arr[i : i + elsize].tolist() for i in range(0, len(arr), elsize)]
-        else:
-            all = arr.tolist()
+    arr = array.array("d", "".join(tks).encode("latin-1"))
 
-        return [all]
+    all: Union[Sequence[float], Sequence[Sequence[float]]]
 
-    _binary_contents <<= CharsNotIn(exact=count * elsize * 8).set_parse_action(unpack)
+    if elsize != 1:
+        all = [arr[i : i + elsize].tolist() for i in range(0, len(arr), elsize)]
+    else:
+        all = arr.tolist()
 
-    tks.clear()  # type: ignore [no-untyped-call]
+    return [all]
 
 
 _BINARY_FIELD = (
-    (
-        Keyword("nonuniform").suppress()
-        + Literal("List").suppress()
-        + Literal("<").suppress()
-        + common.identifier
-        + Literal(">").suppress()
-        + common.integer
-        + Literal("(").suppress()
-    ).set_parse_action(_binary_field_parse_action, call_during_try=True)
-    + _binary_contents
+    Keyword("nonuniform").suppress()
+    + Literal("List").suppress()
+    + Literal("<").suppress()
+    + (
+        counted_array(
+            CharsNotIn(exact=8),
+            Literal("scalar").suppress()
+            + Literal(">").suppress()
+            + common.integer
+            + Literal("(").suppress(),
+        )
+        | counted_array(
+            CharsNotIn(exact=8 * 3),
+            Literal("vector").suppress()
+            + Literal(">").suppress()
+            + common.integer
+            + Literal("(").suppress(),
+        )
+        | counted_array(
+            CharsNotIn(exact=8 * 6),
+            Literal("symmTensor").suppress()
+            + Literal(">").suppress()
+            + common.integer
+            + Literal("(").suppress(),
+        )
+        | counted_array(
+            CharsNotIn(exact=8 * 9),
+            Literal("tensor").suppress()
+            + Literal(">").suppress()
+            + common.integer
+            + Literal("(").suppress(),
+        )
+    )
     + Literal(")").suppress()
-)
+).set_parse_action(_unpack_binary_field)
 
 
 _SWITCH = (

{foamlib-0.4.3.dist-info → foamlib-0.4.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: foamlib
-Version: 0.4.3
+Version: 0.4.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
@@ -67,9 +67,9 @@ Requires-Dist: mypy <2,>=1 ; extra == 'typing'
 
 It offers the following classes:
 
-* [`FoamFile`](https://foamlib.readthedocs.io/en/stable/#foamlib.FoamFile) (and [`FoamFieldFile`](https://foamlib.readthedocs.io/en/stable/#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/#foamlib.FoamCase): a class for manipulating, executing and accessing the results of OpenFOAM cases.
-* [`AsyncFoamCase`](https://foamlib.readthedocs.io/en/stable/#foamlib.AsyncFoamCase): variant of `FoamCase` with asynchronous methods for running multiple cases at once.
+* [`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.
+* [`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
 
@@ -131,7 +131,6 @@ from foamlib import AsyncFoamCase
 
 async def run_case():
     my_pitz_async = AsyncFoamCase(my_pitz)
-
     await my_pitz_async.run()
 
 asyncio.run(run_case())

{foamlib-0.4.3.dist-info → foamlib-0.4.4.dist-info}/RECORD

@@ -1,19 +1,19 @@
-foamlib/__init__.py,sha256=EfoThBRk5flPnxHT6JVA0jF01z42YT0I3RxCZR3fPp8,446
+foamlib/__init__.py,sha256=r8VZ1cNvef7NfWWxf7GzPuveJO3LrXVwrF5pwgok-eg,446
 foamlib/_util.py,sha256=UMzXmTFgvbp46w6k3oEZJoYC98pFgEK6LN5uLOwrlCg,397
 foamlib/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 foamlib/_cases/__init__.py,sha256=xnQpR64EvFtCh07qnSz7kjQ1IhJXjRDwaZWwQGZhGv4,280
-foamlib/_cases/_async.py,sha256=ehmAedDepDXaRdf8f0IznxDMYAQxoUWSIxbhxG_17Rw,6035
-foamlib/_cases/_base.py,sha256=JrYJplmXV84qwgerdVSCHz2rCI-KWB4IvTBPMkYpecw,12657
-foamlib/_cases/_sync.py,sha256=CloQgd-93jxfSXIt7J5NxcAu3N_iF3eXMKO-NfNOgi4,4522
+foamlib/_cases/_async.py,sha256=WgEunau8GvkI-k4amS98Uxz8O0fZBxLWqzUY3uiAmQQ,6345
+foamlib/_cases/_base.py,sha256=4sndDYfXPWhkSel41e8d00xX3PX22wMrYniA_zb0luo,14958
+foamlib/_cases/_sync.py,sha256=S-9-TOK7PTC3NMKgIdvKWTn4fS34FPccedvm-lpjpH8,5037
 foamlib/_cases/_util.py,sha256=v6sHxHCEgagsVuup0S1xJW-x9py5xj3bUye8PiFfb3o,925
 foamlib/_files/__init__.py,sha256=-UqB9YTH6mrJfXCX00kPTAAY20XG64u1MGPw_1ewLVs,148
 foamlib/_files/_base.py,sha256=zaFDjLE6jB7WtGWk8hfKusjLtlGu6CZV16AHJpRUibs,1929
 foamlib/_files/_files.py,sha256=-3mDRIsaQaxHF74q0Zfzlrhfieb7w_EPOFScSx8wRPE,16245
 foamlib/_files/_io.py,sha256=f_tYI7AqaFsQ8mtK__fEoIUqpYb3YmrI8X5D8updmNM,2084
-foamlib/_files/_parsing.py,sha256=ZDEnMdLfTCn82I5E-IOv-PxGv4w7N2Nvtc4NX7-m0MA,8383
+foamlib/_files/_parsing.py,sha256=8V2CKZ45mKE3f9fP8lAfexIdhPGrq7elIZkpBkkGB6Q,8773
 foamlib/_files/_serialization.py,sha256=3yb9fgjCpDoRfZoLsbZaIFrkZ3vGBzleFRw6IbaZuuY,3408
-foamlib-0.4.3.dist-info/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
-foamlib-0.4.3.dist-info/METADATA,sha256=M-Cy5LK8xxGL-jEtA7jZ0p5y_7iZ-Co6yTePRg1czb0,5457
-foamlib-0.4.3.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
-foamlib-0.4.3.dist-info/top_level.txt,sha256=ZdVYtetXGwPwyfL-WhlhbTFQGAwKX5P_gXxtH9JYFPI,8
-foamlib-0.4.3.dist-info/RECORD,,
+foamlib-0.4.4.dist-info/LICENSE.txt,sha256=5Dte9TUnLZzPRs4NQzl-Jc2-Ljd-t_v0ZR5Ng5r0UsY,35131
+foamlib-0.4.4.dist-info/METADATA,sha256=i9qq7ZU7oFhmn1BO0rz-53wueFfOvEziP4am3x3qBA4,5496
+foamlib-0.4.4.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+foamlib-0.4.4.dist-info/top_level.txt,sha256=ZdVYtetXGwPwyfL-WhlhbTFQGAwKX5P_gXxtH9JYFPI,8
+foamlib-0.4.4.dist-info/RECORD,,

{foamlib-0.4.3.dist-info → foamlib-0.4.4.dist-info}/WHEEL

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