hydraflow 0.17.2__py3-none-any.whl → 0.18.0__py3-none-any.whl

hydraflow/core/collection.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import random
+import re
 from collections.abc import Hashable, Iterable, Sequence
 from dataclasses import MISSING
 from typing import TYPE_CHECKING, Concatenate, overload
@@ -417,6 +419,7 @@ class Collection[I](Sequence[I]):
         function: Callable[Concatenate[I, P], R],
         n_jobs: int = -1,
         backend: str = "multiprocessing",
+        progress: bool = False,
         *args: P.args,
         **kwargs: P.kwargs,
     ) -> list[R]:
@@ -431,6 +434,7 @@ class Collection[I](Sequence[I]):
             n_jobs (int): Number of jobs to run in parallel. -1 means using all
                 processors.
             backend (str): Parallelization backend.
+            progress (bool): Whether to display a progress bar.
             *args: Additional positional arguments to pass to the function.
             **kwargs: Additional keyword arguments to pass to the function.
 
@@ -448,40 +452,82 @@ class Collection[I](Sequence[I]):
 
         """
         parallel = Parallel(n_jobs=n_jobs, backend=backend, return_as="list")
-        return parallel(delayed(function)(i, *args, **kwargs) for i in self)  # type: ignore
+        it = (delayed(function)(i, *args, **kwargs) for i in self)
+
+        if not progress:
+            return parallel(it)  # type: ignore
+
+        from hydraflow.utils.progress import Progress
+
+        with Progress(*Progress.get_default_columns()) as p:
+            p.add_task("", total=len(self))
+            return parallel(it)  # type: ignore
 
     def to_frame(
         self,
-        *keys: str,
+        *keys: str | tuple[str, Any | Callable[[I], Any]],
         defaults: dict[str, Any | Callable[[I], Any]] | None = None,
+        n_jobs: int = 0,
+        backend: str = "multiprocessing",
+        progress: bool = False,
         **kwargs: Callable[[I], Any],
     ) -> DataFrame:
         """Convert the collection to a Polars DataFrame.
 
+        This method converts the items in the collection into a Polars DataFrame.
+        It allows specifying multiple keys, where each key can be a string or a tuple.
+        If a tuple is provided, the first element is treated as the key and the second
+        element as the default value for that key.
+
         Args:
-            *keys (str): The keys to include as columns in the DataFrame.
-            defaults (dict[str, Any | Callable[[T], Any]] | None): Default
-                values for the keys. If a callable, it will be called with
-                the item and the value returned will be used as the
-                default.
-            **kwargs (Callable[[I], Any]): Additional columns to compute
-                using callables that take an item and return a value.
+            *keys (str | tuple[str, Any | Callable[[I], Any]]): The keys to include
+                as columns in the DataFrame. If a tuple is provided, the first element
+                is the key and the second element is the default value.
+            defaults (dict[str, Any | Callable[[I], Any]] | None): Default values
+                for the keys. If a callable, it will be called with the item and the
+                value returned will be used as the default.
+            n_jobs (int): Number of jobs to run in parallel. 0 means no parallelization.
+                Default to 0.
+            backend (str): Parallelization backend.
+            progress (bool): Whether to display a progress bar.
+            **kwargs (Callable[[I], Any]): Additional columns to compute using
+                callables that take an item and return a value.
 
         Returns:
-            DataFrame: A Polars DataFrame containing the specified data
-            from the items.
+            DataFrame: A Polars DataFrame containing the specified data from the items.
+
+        Examples:
+            ```python
+            # Convert to DataFrame with single keys
+            df = collection.to_frame("name", "age")
+
+            # Convert to DataFrame with keys and default values
+            df = collection.to_frame(("name", "Unknown"), ("age", 0))
+            ```
 
         """
         if defaults is None:
             defaults = {}
 
-        data = {k: self.to_list(k, defaults.get(k, MISSING)) for k in keys}
+        keys_ = []
+        for k in keys:
+            if isinstance(k, tuple):
+                keys_.append(k[0])
+                defaults[k[0]] = k[1]
+            else:
+                keys_.append(k)
+
+        data = {k: self.to_list(k, defaults.get(k, MISSING)) for k in keys_}
         df = DataFrame(data)
 
         if not kwargs:
             return df
 
-        columns = [Series(k, self.map(v)) for k, v in kwargs.items()]
+        kv = kwargs.items()
+        if n_jobs == 0:
+            return df.with_columns(Series(k, self.map(v)) for k, v in kv)
+
+        columns = [Series(k, self.pmap(v, n_jobs, backend, progress)) for k, v in kv]
         return df.with_columns(*columns)
 
     def group_by(self, *by: str) -> GroupBy[Self, I]:
@@ -518,6 +564,266 @@ class Collection[I](Sequence[I]):
 
         return GroupBy(by, groups)
 
+    def sample(self, k: int, seed: int | None = None) -> Self:
+        """Sample a random subset of items from the collection.
+
+        This method returns a new collection containing a random sample
+        of items from the original collection. The sample is drawn without
+        replacement, meaning each item can only appear once in the sample.
+
+        Args:
+            k (int): The number of items to sample.
+            seed (int | None): The seed for the random number generator.
+                If provided, the sample will be reproducible.
+
+        Returns:
+            Self: A new collection containing a random sample of items.
+
+        Raises:
+            ValueError: If the sample size is greater than the collection size.
+
+        """
+        n = len(self)
+        if k < 1 or k > n:
+            msg = f"Sample size ({k}) must be between 1 and {n}"
+            raise ValueError(msg)
+
+        if seed is not None:
+            random.seed(seed)
+
+        return self.__class__(random.sample(self._items, k), self._get)
+
+    def shuffle(self, seed: int | None = None) -> Self:
+        """Shuffle the items in the collection.
+
+        This method returns a new collection with the items in random order.
+
+        Args:
+            seed (int | None): The seed for the random number generator.
+                If provided, the sample will be reproducible.
+
+        Returns:
+            Self: A new collection containing the items in random order.
+
+        """
+        return self.sample(len(self), seed)
+
+    def eq(
+        self,
+        left: str,
+        right: str,
+        *,
+        default: Any | Callable[[I], Any] = MISSING,
+    ) -> Callable[[I], bool]:
+        """Create a predicate function that checks if two attributes are equal.
+
+        Args:
+            left (str): The name of the left attribute to compare.
+            right (str): The name of the right attribute to compare.
+            default (Any | Callable[[I], Any], optional): The default value
+                to use if either attribute is not found. If callable, it
+                will be called with the item.
+
+        Returns:
+            Callable[[I], bool]: A function that takes an item and returns
+            True if the values of the specified attributes are equal.
+
+        Examples:
+            ```python
+            # Find items where attribute 'a' equals attribute 'b'
+            equal_items = collection.filter(collection.eq('a', 'b'))
+            ```
+
+        """
+        return lambda i: self._get(i, left, default) == self._get(i, right, default)
+
+    def ne(
+        self,
+        left: str,
+        right: str,
+        *,
+        default: Any | Callable[[I], Any] = MISSING,
+    ) -> Callable[[I], bool]:
+        """Create a predicate function that checks if two attributes are not equal.
+
+        Args:
+            left (str): The name of the left attribute to compare.
+            right (str): The name of the right attribute to compare.
+            default (Any | Callable[[I], Any], optional): The default value
+                to use if either attribute is not found. If callable, it
+                will be called with the item.
+
+        Returns:
+            Callable[[I], bool]: A function that takes an item and returns
+            True if the values of the specified attributes are not equal.
+
+        Examples:
+            ```python
+            # Find items where attribute 'a' is not equal to attribute 'b'
+            unequal_items = collection.filter(collection.ne('a', 'b'))
+            ```
+
+        """
+        return lambda i: self._get(i, left, default) != self._get(i, right, default)
+
+    def gt(
+        self,
+        left: str,
+        right: str,
+        *,
+        default: Any | Callable[[I], Any] = MISSING,
+    ) -> Callable[[I], bool]:
+        """Create a predicate function that checks if the left > the right.
+
+        Args:
+            left (str): The name of the left attribute to compare.
+            right (str): The name of the right attribute to compare.
+            default (Any | Callable[[I], Any], optional): The default value
+                to use if either attribute is not found. If callable, it
+                will be called with the item.
+
+        Returns:
+            Callable[[I], bool]: A function that takes an item and returns
+            True if the left attribute value is greater than the right attribute value.
+
+        Examples:
+            ```python
+            # Find items where attribute 'a' is greater than attribute 'b'
+            items = collection.filter(collection.gt('a', 'b'))
+            ```
+
+        """
+        return lambda i: self._get(i, left, default) > self._get(i, right, default)
+
+    def lt(
+        self,
+        left: str,
+        right: str,
+        *,
+        default: Any | Callable[[I], Any] = MISSING,
+    ) -> Callable[[I], bool]:
+        """Create a predicate function that checks if the left < the right.
+
+        Args:
+            left (str): The name of the left attribute to compare.
+            right (str): The name of the right attribute to compare.
+            default (Any | Callable[[I], Any], optional): The default value
+                to use if either attribute is not found. If callable, it
+                will be called with the item.
+
+        Returns:
+            Callable[[I], bool]: A function that takes an item and returns
+            True if the left attribute value is less than the right attribute value.
+
+        Examples:
+            ```python
+            # Find items where attribute 'a' is less than attribute 'b'
+            items = collection.filter(collection.lt('a', 'b'))
+            ```
+
+        """
+        return lambda i: self._get(i, left, default) < self._get(i, right, default)
+
+    def ge(
+        self,
+        left: str,
+        right: str,
+        *,
+        default: Any | Callable[[I], Any] = MISSING,
+    ) -> Callable[[I], bool]:
+        """Create a predicate function that checks if the left >= the right.
+
+        Args:
+            left (str): The name of the left attribute to compare.
+            right (str): The name of the right attribute to compare.
+            default (Any | Callable[[I], Any], optional): The default value.
+
+        Returns:
+            Callable[[I], bool]: A predicate function for filtering.
+
+        """
+        return lambda i: self._get(i, left, default) >= self._get(i, right, default)
+
+    def le(
+        self,
+        left: str,
+        right: str,
+        *,
+        default: Any | Callable[[I], Any] = MISSING,
+    ) -> Callable[[I], bool]:
+        """Create a predicate function that checks if the left <= the right.
+
+        Args:
+            left (str): The name of the left attribute to compare.
+            right (str): The name of the right attribute to compare.
+            default (Any | Callable[[I], Any], optional): The default value.
+
+        Returns:
+            Callable[[I], bool]: A predicate function for filtering.
+
+        """
+        return lambda i: self._get(i, left, default) <= self._get(i, right, default)
+
+    def startswith(
+        self,
+        key: str,
+        prefix: str,
+        *,
+        default: Any | Callable[[I], Any] = MISSING,
+    ) -> Callable[[I], bool]:
+        """Create a predicate function that checks if an attribute starts with a prefix.
+
+        Args:
+            key (str): The name of the attribute to check.
+            prefix (str): The prefix to check for.
+            default (Any | Callable[[I], Any], optional): The default value.
+
+        Returns:
+            Callable[[I], bool]: A predicate function for filtering.
+
+        """
+        return lambda i: str(self._get(i, key, default)).startswith(prefix)
+
+    def endswith(
+        self,
+        key: str,
+        suffix: str,
+        *,
+        default: Any | Callable[[I], Any] = MISSING,
+    ) -> Callable[[I], bool]:
+        """Create a predicate function that checks if an attribute ends with a suffix.
+
+        Args:
+            key (str): The name of the attribute to check.
+            suffix (str): The suffix to check for.
+            default (Any | Callable[[I], Any], optional): The default value.
+
+        Returns:
+            Callable[[I], bool]: A predicate function for filtering.
+
+        """
+        return lambda i: str(self._get(i, key, default)).endswith(suffix)
+
+    def match(
+        self,
+        key: str,
+        pattern: str | re.Pattern,
+        *,
+        default: Any | Callable[[I], Any] = MISSING,
+    ) -> Callable[[I], bool]:
+        """Create a predicate function that checks if an attribute matches a pattern.
+
+        Args:
+            key (str): The name of the attribute to check.
+            pattern (str | re.Pattern): The pattern to check for.
+            default (Any | Callable[[I], Any], optional): The default value.
+
+        Returns:
+            Callable[[I], bool]: A predicate function for filtering.
+
+        """
+        return lambda i: re.match(pattern, str(self._get(i, key, default))) is not None
+
 
 def to_hashable(value: Any) -> Hashable:
     """Convert a value to a hashable instance.
@@ -565,9 +871,7 @@ def matches(value: Any, criterion: Any) -> bool:
 
     Args:
         value: The value to be compared with the criterion.
-        criterion: The criterion to match against.
-            Can be:
-
+        criterion: The criterion to match against. Can be:
             - A callable that takes the value and returns a boolean
             - A list or set to check membership
             - A tuple of length 2 to check range inclusion

hydraflow/core/main.py

@@ -35,6 +35,8 @@ Example:
 
 from __future__ import annotations
 
+import logging
+import sys
 from functools import wraps
 from pathlib import Path
 from typing import TYPE_CHECKING
@@ -53,6 +55,8 @@ if TYPE_CHECKING:
 
     from mlflow.entities import Run
 
+log = logging.getLogger("hydraflow")
+
 
 def main[C](
     node: C | type[C],
@@ -62,6 +66,7 @@ def main[C](
     force_new_run: bool = False,
     match_overrides: bool = False,
     rerun_finished: bool = False,
+    dry_run: bool = False,
     update: Callable[[C], C | None] | None = None,
 ):
     """Decorator for configuring and running MLflow experiments with Hydra.
@@ -81,6 +86,9 @@ def main[C](
             instead of full config. Defaults to False.
         rerun_finished: If True, allows rerunning completed runs. Defaults to
             False.
+        dry_run: If True, starts the hydra job but does not run the application
+            itself. This allows users to preview the configuration and
+            settings without executing the actual run. Defaults to False.
         update: A function that takes a configuration and returns a new
             configuration or None. The function can modify the configuration in-place
             and/or return it. If the function returns None, the original (potentially
@@ -93,6 +101,10 @@ def main[C](
     import mlflow
     from mlflow.entities import RunStatus
 
+    if "--dry-run" in sys.argv:
+        dry_run = True
+        sys.argv.remove("--dry-run")
+
     finished = RunStatus.to_string(RunStatus.FINISHED)
 
     def decorator(app: Callable[[Run, C], None]) -> Callable[[], None]:
@@ -102,7 +114,6 @@ def main[C](
         @wraps(app)
         def inner_decorator(cfg: C) -> None:
             hc = HydraConfig.get()
-            experiment = mlflow.set_experiment(hc.job.name)
 
             if update:
                 if cfg_ := update(cfg):
@@ -112,6 +123,12 @@ def main[C](
                 cfg_path = hydra_dir.joinpath("config.yaml")
                 OmegaConf.save(cfg, cfg_path)
 
+            if dry_run:
+                log.info("Dry run:\n%s", OmegaConf.to_yaml(cfg).rstrip())
+                return
+
+            experiment = mlflow.set_experiment(hc.job.name)
+
             if force_new_run:
                 run_id = None
             else:

hydraflow/core/run.py

@@ -31,6 +31,7 @@ from functools import cached_property
 from pathlib import Path
 from typing import TYPE_CHECKING, cast, overload
 
+import polars as pl
 from omegaconf import DictConfig, OmegaConf
 
 from .run_info import RunInfo
@@ -39,6 +40,9 @@ if TYPE_CHECKING:
     from collections.abc import Iterator
     from typing import Any, Self
 
+    from polars import Expr
+    from polars._typing import PolarsDataType
+
     from .run_collection import RunCollection
 
 
@@ -216,9 +220,7 @@ class Run[C, I = None]:
                 (can use dot notation like "section.subsection.param"),
                 or a tuple of strings to set multiple related configuration
                 values at once.
-            value: The value to set.
-                This can be:
-
+            value: The value to set. This can be:
                 - For string keys: Any value, or a callable that returns
                   a value
                 - For tuple keys: An iterable with the same length as the
@@ -264,9 +266,7 @@ class Run[C, I = None]:
 
         Args:
             key: The key to look for. Can use dot notation for
-                nested keys in configuration.
-                Special keys:
-
+                nested keys in configuration. Special keys:
                 - "cfg": Returns the configuration object
                 - "impl": Returns the implementation object
                 - "info": Returns the run information object
@@ -314,6 +314,33 @@ class Run[C, I = None]:
         msg = f"No such key: {key}"
         raise AttributeError(msg)
 
+    def lit(
+        self,
+        key: str,
+        default: Any | Callable[[Self], Any] = MISSING,
+        *,
+        dtype: PolarsDataType | None = None,
+    ) -> Expr:
+        """Create a Polars literal expression from a run key.
+
+        Args:
+            key (str): The key to look up in the run's configuration or info.
+            default (Any | Callable[[Run], Any], optional): Default value to
+                use if the key is missing. If a callable is provided, it will be
+                called with the Run instance.
+            dtype (PolarsDataType | None): Explicit data type for the literal
+                expression.
+
+        Returns:
+            Expr: A Polars literal expression aliased to the provided key.
+
+        Raises:
+            AttributeError: If the key is not found and no default is provided.
+
+        """
+        value = self.get(key, default)
+        return pl.lit(value, dtype).alias(key)
+
     def to_dict(self, flatten: bool = True) -> dict[str, Any]:
         """Convert the Run to a dictionary.
 

hydraflow/core/run_collection.py

@@ -194,7 +194,7 @@ class RunCollection[R: Run[Any, Any], I = None](Collection[R]):
 
         """
         for run in self:
-            yield from run.path(relative_dir).iterdir()
+            yield from run.iterdir(relative_dir)
 
     def glob(self, pattern: str, relative_dir: str = "") -> Iterator[Path]:
         """Glob the artifact directories for all runs in the collection.
@@ -212,4 +212,4 @@ class RunCollection[R: Run[Any, Any], I = None](Collection[R]):
 
         """
         for run in self:
-            yield from run.path(relative_dir).glob(pattern)
+            yield from run.glob(pattern, relative_dir)

hydraflow/utils/progress.py

@@ -0,0 +1,90 @@
+"""Provide a progress bar for parallel task execution.
+
+This module defines the `Progress` class, which provides a visual
+progress bar for tracking the execution of parallel tasks. It integrates
+with the `joblib` library to display the progress of tasks being executed
+in parallel, allowing users to monitor the completion status in real-time.
+
+The `Progress` class can be customized to show different columns of
+information, such as the elapsed time and the number of completed tasks.
+It also provides methods to start and stop the progress display, as well
+as to update the progress based on the number of completed tasks.
+
+Example:
+    ```python
+    from hydraflow.utils.progress import Progress
+    from joblib import Parallel, delayed
+
+    with Progress(*Progress.get_default_columns()) as progress:
+        Parallel(n_jobs=4)(delayed(function)(x) for x in iterable)
+    ```
+
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from joblib.parallel import Parallel
+from rich.progress import MofNCompleteColumn, SpinnerColumn, TimeElapsedColumn
+from rich.progress import Progress as Super
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from rich.progress import ProgressColumn
+
+
+# https://github.com/jonghwanhyeon/joblib-progress/blob/main/joblib_progress/__init__.py
+class Progress(Super):
+    """A progress bar for tracking parallel task execution.
+
+    This class extends the `rich.progress.Progress` class to provide
+    a visual progress bar specifically designed for monitoring the
+    execution of tasks running in parallel using the `joblib` library.
+    It allows users to see the completion status of tasks in real-time
+    and can be customized to display various columns of information.
+    """
+
+    _print_progress: Callable[[Parallel], None] | None = None
+
+    def start(self) -> None:
+        """Start the progress display."""
+        super().start()
+
+        self._print_progress = Parallel.print_progress
+
+        def _update(parallel: Parallel) -> None:
+            update(self, parallel)
+
+        Parallel.print_progress = _update  # type: ignore
+
+    def stop(self) -> None:
+        """Stop the progress display."""
+        if self._print_progress:
+            Parallel.print_progress = self._print_progress  # type: ignore
+
+        super().stop()
+
+    @classmethod
+    def get_default_columns(cls) -> tuple[ProgressColumn, ...]:
+        """Get the default columns used for a new Progress instance."""
+        return (
+            SpinnerColumn(),
+            TimeElapsedColumn(),
+            *Super.get_default_columns(),
+            MofNCompleteColumn(),
+        )
+
+
+def update(progress: Progress, parallel: Parallel) -> None:
+    """Update the progress bar."""
+    if progress.task_ids:
+        task_id = progress.task_ids[-1]
+    else:
+        task_id = progress.add_task("", total=None)
+
+    progress.update(task_id, completed=parallel.n_completed_tasks, refresh=True)
+
+    if progress._print_progress:  # noqa: SLF001
+        progress._print_progress(parallel)  # noqa: SLF001

{hydraflow-0.17.2.dist-info → hydraflow-0.18.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hydraflow
-Version: 0.17.2
+Version: 0.18.0
 Summary: HydraFlow seamlessly integrates Hydra and MLflow to streamline ML experiment management, combining Hydra's configuration management with MLflow's tracking capabilities.
 Project-URL: Documentation, https://daizutabi.github.io/hydraflow/
 Project-URL: Source, https://github.com/daizutabi/hydraflow
@@ -47,7 +47,6 @@ Requires-Dist: omegaconf>=2.3
 Requires-Dist: polars>=1.26
 Requires-Dist: python-ulid>=3.0.0
 Requires-Dist: rich>=13.9
-Requires-Dist: ruff>=0.11
 Requires-Dist: typer>=0.15
 Description-Content-Type: text/markdown
 

{hydraflow-0.17.2.dist-info → hydraflow-0.18.0.dist-info}/RECORD

@@ -2,13 +2,13 @@ hydraflow/__init__.py,sha256=_cLLokEv0pUlwvG8RMnjOwCTtDQBs0-RgGbtDk5m_Xg,794
 hydraflow/cli.py,sha256=3rGr___wwp8KazjLGQ7JO_IgAMqLyMlcVSs_QJK7g0Y,3135
 hydraflow/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hydraflow/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hydraflow/core/collection.py,sha256=RSYgS4VsGjSm0Inrz4GAng_jmm-Ct_VSDmZ9rvKFQQw,19472
+hydraflow/core/collection.py,sha256=wiwbzv8p2psdoV2U4K3ROUIm8jS6fg7b_R34qBl0BaY,30249
 hydraflow/core/context.py,sha256=6vpwe0Xfl6mzh2hHLE-4uB9Hjew-CK4pA0KFihQ80U8,4168
 hydraflow/core/group_by.py,sha256=Pnw-oA5aXHeRG9lMLz-bKc8drqQ8LIRsWzvVn153iyQ,5488
 hydraflow/core/io.py,sha256=B3-jPuJWttRgpbIpy_XA-Z2qpXzNF1ATwyYEwA7Pv3w,5172
-hydraflow/core/main.py,sha256=pgr2b9A4VoZuwbApE71NElmV64MFJv8UKda05q4uCqk,6010
-hydraflow/core/run.py,sha256=Kbq4s47f6KDNeyNUwrUpW55FrWlf5CCpmdgVCMakU2g,14046
-hydraflow/core/run_collection.py,sha256=sdbkjs01ougaqXlp88gGC10TmO_7s-UEQozLl0jMI4Y,6771
+hydraflow/core/main.py,sha256=6X58M-xpJPql7xqLR3gpa4XMePvZ6Q1diMSqTZf2Jrw,6542
+hydraflow/core/run.py,sha256=rt97EXJ72fdMsuh4AKL-dxRfnQQ4Yzo2ZpTocTR5Wr8,15034
+hydraflow/core/run_collection.py,sha256=JgCdu0_hvgAoeScdDuXQrEWKQhCzoL-v-g53cR9Sm_c,6759
 hydraflow/core/run_info.py,sha256=SMOTZXEa7OBV_XjTyctk5gJGrggmYwhePvRF8CLF1kU,1616
 hydraflow/executor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hydraflow/executor/aio.py,sha256=xXsmBPIPdBlopv_1h0FdtOvoKUcuW7PQeKCV2d_lN9I,2122
@@ -16,8 +16,10 @@ hydraflow/executor/conf.py,sha256=8Xq4UAenRKJIl1NBgNbSfv6VUTJhdwPLayZIEAsiBR0,41
 hydraflow/executor/io.py,sha256=18wnHpCMQRGYL-oN2841h9W2aSW_X2SmO68Lx-3FIbU,1043
 hydraflow/executor/job.py,sha256=6QeJ18OMeocXeM04rCYL46GgArfX1SvZs9_4HTomTgE,5436
 hydraflow/executor/parser.py,sha256=RxP8qpDaJ8VLqZ51VlPFyVitWctObhkE_3iPIsY66Cs,14610
-hydraflow-0.17.2.dist-info/METADATA,sha256=zEjD1acRRed6Le0G8-KjkWtUYaxXKB6JO9T6StRNkVM,7535
-hydraflow-0.17.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hydraflow-0.17.2.dist-info/entry_points.txt,sha256=XI0khPbpCIUo9UPqkNEpgh-kqK3Jy8T7L2VCWOdkbSM,48
-hydraflow-0.17.2.dist-info/licenses/LICENSE,sha256=IGdDrBPqz1O0v_UwCW-NJlbX9Hy9b3uJ11t28y2srmY,1062
-hydraflow-0.17.2.dist-info/RECORD,,
+hydraflow/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hydraflow/utils/progress.py,sha256=a-CHvioyGCeiUKawqPcV8i1nhzunm5-r5AlLbzd5epw,3048
+hydraflow-0.18.0.dist-info/METADATA,sha256=Hd6O1Ah70Gitxtfav0w40d18RgCnIvZ7J0e1OjDBczY,7509
+hydraflow-0.18.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hydraflow-0.18.0.dist-info/entry_points.txt,sha256=XI0khPbpCIUo9UPqkNEpgh-kqK3Jy8T7L2VCWOdkbSM,48
+hydraflow-0.18.0.dist-info/licenses/LICENSE,sha256=IGdDrBPqz1O0v_UwCW-NJlbX9Hy9b3uJ11t28y2srmY,1062
+hydraflow-0.18.0.dist-info/RECORD,,