hydraflow 0.4.5__py3-none-any.whl → 0.5.0__py3-none-any.whl

hydraflow/__init__.py

@@ -1,9 +1,8 @@
 """Integrate Hydra and MLflow to manage and track machine learning experiments."""
 
 from .config import select_config, select_overrides
-from .context import chdir_artifact, chdir_hydra_output, log_run, start_run, watch
+from .context import chdir_artifact, chdir_hydra_output, log_run, start_run
 from .mlflow import list_runs, search_runs, set_experiment
-from .progress import multi_tasks_progress, parallel_progress
 from .run_collection import RunCollection
 from .utils import (
     get_artifact_dir,
@@ -11,6 +10,7 @@ from .utils import (
     get_overrides,
     load_config,
     load_overrides,
+    remove_run,
 )
 
 __all__ = [
@@ -24,12 +24,10 @@ __all__ = [
     "load_config",
     "load_overrides",
     "log_run",
-    "multi_tasks_progress",
-    "parallel_progress",
+    "remove_run",
     "search_runs",
     "select_config",
     "select_overrides",
     "set_experiment",
     "start_run",
-    "watch",
 ]

hydraflow/context.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import logging
 import os
-import time
 from contextlib import contextmanager
 from pathlib import Path
 from typing import TYPE_CHECKING
@@ -12,14 +11,11 @@ from typing import TYPE_CHECKING
 import mlflow
 import mlflow.artifacts
 from hydra.core.hydra_config import HydraConfig
-from watchdog.events import FileModifiedEvent, PatternMatchingEventHandler
-from watchdog.observers import Observer
 
 from hydraflow.mlflow import log_params
-from hydraflow.run_info import get_artifact_dir
 
 if TYPE_CHECKING:
-    from collections.abc import Callable, Iterator
+    from collections.abc import Iterator
 
     from mlflow.entities.run import Run
 
@@ -64,14 +60,8 @@ def log_run(
     output_subdir = output_dir / (hc.output_subdir or "")
     mlflow.log_artifacts(output_subdir.as_posix(), hc.output_subdir)
 
-    def log_artifact(path: Path) -> None:
-        local_path = (output_dir / path).as_posix()
-        mlflow.log_artifact(local_path)
-
     try:
         yield
-        # with watch(log_artifact, output_dir, ignore_log=False):
-        #     yield
 
     except Exception as e:
         msg = f"Error during log_run: {e}"
@@ -146,101 +136,6 @@ def start_run(  # noqa: PLR0913
         yield run
 
 
-@contextmanager
-def watch(
-    callback: Callable[[Path], None],
-    dir: Path | str = "",  # noqa: A002
-    *,
-    timeout: int = 60,
-    ignore_patterns: list[str] | None = None,
-    ignore_log: bool = True,
-) -> Iterator[None]:
-    """Watch the given directory for changes.
-
-    This context manager sets up a file system watcher on the specified directory.
-    When a file modification is detected, the provided function is called with
-    the path of the modified file. The watcher runs for the specified timeout
-    period or until the context is exited.
-
-    Args:
-        callback (Callable[[Path], None]): The function to call when a change is
-            detected. It should accept a single argument of type `Path`,
-            which is the path of the modified file.
-        dir (Path | str): The directory to watch. If not specified,
-            the current MLflow artifact URI is used. Defaults to "".
-        timeout (int): The timeout period in seconds for the watcher
-            to run after the context is exited. Defaults to 60.
-        ignore_patterns (list[str] | None): A list of glob patterns to ignore.
-            Defaults to None.
-        ignore_log (bool): Whether to ignore log files. Defaults to True.
-
-    Yields:
-        None
-
-    Example:
-        ```python
-        with watch(log_artifact, "/path/to/dir"):
-            # Perform operations while watching the directory for changes
-            pass
-        ```
-
-    """
-    dir = dir or get_artifact_dir()  # noqa: A001
-    if isinstance(dir, Path):
-        dir = dir.as_posix()  # noqa: A001
-
-    handler = Handler(callback, ignore_patterns=ignore_patterns, ignore_log=ignore_log)
-    observer = Observer()
-    observer.schedule(handler, dir, recursive=True)
-    observer.start()
-
-    try:
-        yield
-
-    except Exception as e:
-        msg = f"Error during watch: {e}"
-        log.exception(msg)
-        raise
-
-    finally:
-        elapsed = 0
-        while not observer.event_queue.empty():
-            time.sleep(0.2)
-            elapsed += 0.2
-            if elapsed > timeout:
-                break
-
-        observer.stop()
-        observer.join()
-
-
-class Handler(PatternMatchingEventHandler):
-    """Monitor file changes and call the given function when a change is detected."""
-
-    def __init__(
-        self,
-        func: Callable[[Path], None],
-        *,
-        ignore_patterns: list[str] | None = None,
-        ignore_log: bool = True,
-    ) -> None:
-        self.func = func
-
-        if ignore_log:
-            if ignore_patterns:
-                ignore_patterns.append("*.log")
-            else:
-                ignore_patterns = ["*.log"]
-
-        super().__init__(ignore_patterns=ignore_patterns)
-
-    def on_modified(self, event: FileModifiedEvent) -> None:
-        """Modify when a file is modified."""
-        file = Path(str(event.src_path))
-        if file.is_file():
-            self.func(file)
-
-
 @contextmanager
 def chdir_hydra_output() -> Iterator[Path]:
     """Change the current working directory to the hydra output directory.

hydraflow/run_collection.py

@@ -575,7 +575,7 @@ class RunCollection:
         """
         return (func(dir, *args, **kwargs) for dir in self.info.artifact_dir)  # noqa: A001
 
-    def group_by(
+    def groupby(
         self,
         names: str | list[str],
     ) -> dict[str | None | tuple[str | None, ...], RunCollection]:

hydraflow/run_data.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from polars.dataframe import DataFrame
+from pandas import DataFrame
 
 from hydraflow.config import collect_params
 
@@ -33,10 +33,10 @@ class RunCollectionData:
 
     @property
     def config(self) -> DataFrame:
-        """Get the runs' configurations as a polars DataFrame.
+        """Get the runs' configurations as a DataFrame.
 
         Returns:
-            A polars DataFrame containing the runs' configurations.
+            A DataFrame containing the runs' configurations.
 
         """
         return DataFrame(self._runs.map_config(collect_params))

hydraflow/utils.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import shutil
 from pathlib import Path
 from typing import TYPE_CHECKING
 
@@ -9,11 +10,10 @@ import mlflow
 import mlflow.artifacts
 from hydra.core.hydra_config import HydraConfig
 from mlflow.entities import Run
-from mlflow.tracking import artifact_utils
 from omegaconf import DictConfig, OmegaConf
 
 if TYPE_CHECKING:
-    from mlflow.entities import Run
+    from collections.abc import Iterable
 
 
 def get_artifact_dir(run: Run | None = None) -> Path:
@@ -28,10 +28,10 @@ def get_artifact_dir(run: Run | None = None) -> Path:
         The local path to the directory where the artifacts are downloaded.
 
     """
-    if run is None:
-        uri = mlflow.get_artifact_uri()
-    else:
-        uri = artifact_utils.get_artifact_uri(run.info.run_id)
+    uri = mlflow.get_artifact_uri() if run is None else run.info.artifact_uri
+
+    if not (isinstance(uri, str) and uri.startswith("file://")):
+        raise NotImplementedError
 
     return Path(mlflow.artifacts.download_artifacts(uri))
 
@@ -112,3 +112,13 @@ def load_overrides(run: Run) -> list[str]:
     """
     path = get_artifact_dir(run) / ".hydra/overrides.yaml"
     return [str(x) for x in OmegaConf.load(path)]
+
+
+def remove_run(run: Run | Iterable[Run]) -> None:
+    """Remove the given run from the MLflow tracking server."""
+    if not isinstance(run, Run):
+        for r in run:
+            remove_run(r)
+        return
+
+    shutil.rmtree(get_artifact_dir(run).parent)

{hydraflow-0.4.5.dist-info → hydraflow-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: hydraflow
-Version: 0.4.5
+Version: 0.5.0
 Summary: Hydraflow integrates Hydra and MLflow to manage and track machine learning experiments.
 Project-URL: Documentation, https://github.com/daizutabi/hydraflow
 Project-URL: Source, https://github.com/daizutabi/hydraflow
@@ -27,6 +27,7 @@ License: MIT License
         LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
         SOFTWARE.
+License-File: LICENSE
 Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python
@@ -36,12 +37,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.10
 Requires-Dist: hydra-core>=1.3
-Requires-Dist: joblib
 Requires-Dist: mlflow>=2.15
-Requires-Dist: polars
-Requires-Dist: rich
-Requires-Dist: watchdog
-Requires-Dist: watchfiles
 Description-Content-Type: text/markdown
 
 # Hydraflow
@@ -118,16 +114,6 @@ def my_app(cfg: MySQLConfig) -> None:
     with hydraflow.start_run():
         # Your app code below.
 
-        with hydraflow.watch(callback):
-            # Watch files in the MLflow artifact directory.
-            # You can update metrics or log other artifacts
-            # according to the watched files in your callback
-            # function.
-            pass
-
-# Your callback function here.
-def callback(file: Path) -> None:
-    pass
 
 if __name__ == "__main__":
     my_app()

hydraflow-0.5.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+hydraflow/__init__.py,sha256=DKtFjTXHTgceX7rpWHiKqhcpG5xtGIseFvN28f7iwYo,807
+hydraflow/config.py,sha256=MNX9da5bPVDcjnpji7Cm9ndK6ura92pt361m4PRh6_E,4326
+hydraflow/context.py,sha256=3g7OQXWcFvK6PVVbXpQg7Hr8nsJkF9pLFrXNi_3aV5A,5524
+hydraflow/mlflow.py,sha256=kWVK_Xw2hkRnTg33jSP3VW13UZF6_hBGhN52mPmLgvk,8753
+hydraflow/param.py,sha256=c5sc6NwD6DKwZzVwprXzZD5FSi6qRgSHkc6TXBKQEdg,4502
+hydraflow/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hydraflow/run_collection.py,sha256=RQRN50k5m_bDWn4vzOProbnjzVejI5hsr5WSd4owbhQ,26773
+hydraflow/run_data.py,sha256=dpyyfnuH9mCtIZeigMo1iFQo9bafMdEL4i4uI2l0UqY,1525
+hydraflow/run_info.py,sha256=sMXOo20ClaRIommMEzuAbO_OrcXx7M1Yt4FMV7spxz0,998
+hydraflow/utils.py,sha256=jbNrbtIfMqxE4LrdTNd1g7sF68XgAvydGqW5iAZ6n-c,3834
+hydraflow-0.5.0.dist-info/METADATA,sha256=pv7eNdU5mT05N936AWyuLzZfzYSgVrsGZ5d354bD_-8,4697
+hydraflow-0.5.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hydraflow-0.5.0.dist-info/licenses/LICENSE,sha256=IGdDrBPqz1O0v_UwCW-NJlbX9Hy9b3uJ11t28y2srmY,1062
+hydraflow-0.5.0.dist-info/RECORD,,

{hydraflow-0.4.5.dist-info → hydraflow-0.5.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.26.3
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any

hydraflow/asyncio.py

@@ -1,227 +0,0 @@
-"""Provide functionality for running commands and monitoring file changes."""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-from asyncio.subprocess import PIPE
-from pathlib import Path
-from typing import TYPE_CHECKING
-
-import watchfiles
-
-if TYPE_CHECKING:
-    from asyncio.streams import StreamReader
-    from collections.abc import Callable
-
-    from watchfiles import Change
-
-
-# Set up logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-
-async def execute_command(
-    program: str,
-    *args: str,
-    stdout: Callable[[str], None] | None = None,
-    stderr: Callable[[str], None] | None = None,
-    stop_event: asyncio.Event,
-) -> int:
-    """Run a command asynchronously and pass the output to callback functions.
-
-    Args:
-        program (str): The program to run.
-        *args (str): Arguments for the program.
-        stdout (Callable[[str], None] | None): Callback for standard output.
-        stderr (Callable[[str], None] | None): Callback for standard error.
-        stop_event (asyncio.Event): Event to signal when the process is done.
-
-    Returns:
-        int: The return code of the process.
-
-    """
-    try:
-        process = await asyncio.create_subprocess_exec(
-            program,
-            *args,
-            stdout=PIPE,
-            stderr=PIPE,
-        )
-        await asyncio.gather(
-            process_stream(process.stdout, stdout),
-            process_stream(process.stderr, stderr),
-        )
-        returncode = await process.wait()
-
-    except Exception as e:
-        msg = f"Error running command: {e}"
-        logger.exception(msg)
-        returncode = 1
-
-    finally:
-        stop_event.set()
-
-    return returncode
-
-
-async def process_stream(
-    stream: StreamReader | None,
-    callback: Callable[[str], None] | None,
-) -> None:
-    """Read a stream asynchronously and pass each line to a callback function.
-
-    Args:
-        stream (StreamReader | None): The stream to read from.
-        callback (Callable[[str], None] | None): The callback function to handle
-        each line.
-
-    """
-    if stream is None or callback is None:
-        return
-
-    while True:
-        line = await stream.readline()
-        if line:
-            callback(line.decode().strip())
-        else:
-            break
-
-
-async def monitor_file_changes(
-    paths: list[str | Path],
-    callback: Callable[[set[tuple[Change, str]]], None],
-    stop_event: asyncio.Event,
-    **awatch_kwargs,
-) -> None:
-    """Watch file changes in specified paths and pass the changes to a callback.
-
-    Args:
-        paths (list[str | Path]): List of paths to monitor for changes.
-        callback (Callable[[set[tuple[Change, str]]], None]): The callback
-        function to handle file changes.
-        stop_event (asyncio.Event): Event to signal when to stop watching.
-        **awatch_kwargs: Additional keyword arguments to pass to watchfiles.awatch.
-
-    """
-    str_paths = [str(path) for path in paths]
-    try:
-        async for changes in watchfiles.awatch(
-            *str_paths,
-            stop_event=stop_event,
-            **awatch_kwargs,
-        ):
-            callback(changes)
-    except Exception as e:
-        msg = f"Error watching files: {e}"
-        logger.exception(msg)
-        raise
-
-
-async def run_and_monitor(
-    program: str,
-    *args: str,
-    stdout: Callable[[str], None] | None = None,
-    stderr: Callable[[str], None] | None = None,
-    watch: Callable[[set[tuple[Change, str]]], None] | None = None,
-    paths: list[str | Path] | None = None,
-    **awatch_kwargs,
-) -> int:
-    """Run a command and optionally watch for file changes concurrently.
-
-    Args:
-        program (str): The program to run.
-        *args (str): Arguments for the program.
-        stdout (Callable[[str], None] | None): Callback for standard output.
-        stderr (Callable[[str], None] | None): Callback for standard error.
-        watch (Callable[[set[tuple[Change, str]]], None] | None): Callback for
-        file changes.
-        paths (list[str | Path] | None): List of paths to monitor for changes.
-        **awatch_kwargs: Additional keyword arguments to pass to `watchfiles.awatch`.
-
-    """
-    stop_event = asyncio.Event()
-    run_task = asyncio.create_task(
-        execute_command(
-            program,
-            *args,
-            stop_event=stop_event,
-            stdout=stdout,
-            stderr=stderr,
-        ),
-    )
-    if watch and paths:
-        coro = monitor_file_changes(paths, watch, stop_event, **awatch_kwargs)
-        monitor_task = asyncio.create_task(coro)
-    else:
-        monitor_task = None
-
-    try:
-        if monitor_task:
-            await asyncio.gather(run_task, monitor_task)
-        else:
-            await run_task
-
-    except Exception as e:
-        msg = f"Error in run_and_monitor: {e}"
-        logger.exception(msg)
-        raise
-
-    finally:
-        stop_event.set()
-        await run_task
-        if monitor_task:
-            await monitor_task
-
-    return run_task.result()
-
-
-def run(
-    program: str,
-    *args: str,
-    stdout: Callable[[str], None] | None = None,
-    stderr: Callable[[str], None] | None = None,
-    watch: Callable[[set[tuple[Change, str]]], None] | None = None,
-    paths: list[str | Path] | None = None,
-    **awatch_kwargs,
-) -> int:
-    """Run a command synchronously and optionally watch for file changes.
-
-    This function is a synchronous wrapper around the asynchronous
-    `run_and_monitor` function. It runs a specified command and optionally
-    monitors specified paths for file changes, invoking the provided callbacks for
-    standard output, standard error, and file changes.
-
-    Args:
-        program (str): The program to run.
-        *args (str): Arguments for the program.
-        stdout (Callable[[str], None] | None): Callback for handling standard
-            output lines.
-        stderr (Callable[[str], None] | None): Callback for handling standard
-            error lines.
-        watch (Callable[[set[tuple[Change, str]]], None] | None): Callback for
-            handling file changes.
-        paths (list[str | Path] | None): List of paths to monitor for file
-            changes.
-        **awatch_kwargs: Additional keyword arguments to pass to
-            `watchfiles.awatch`.
-
-    Returns:
-        int: The return code of the process.
-
-    """
-    if watch and not paths:
-        paths = [Path.cwd()]
-
-    return asyncio.run(
-        run_and_monitor(
-            program,
-            *args,
-            stdout=stdout,
-            stderr=stderr,
-            watch=watch,
-            paths=paths,
-            **awatch_kwargs,
-        ),
-    )

hydraflow/progress.py

@@ -1,184 +0,0 @@
-"""Context managers and functions for parallel task execution with progress.
-
-Provide context managers and functions to facilitate the execution
-of tasks in parallel while displaying progress updates.
-"""
-
-from __future__ import annotations
-
-from contextlib import contextmanager
-from typing import TYPE_CHECKING, TypeVar
-
-import joblib
-from rich.progress import Progress
-
-if TYPE_CHECKING:
-    from collections.abc import Callable, Iterable, Iterator
-
-    from rich.progress import ProgressColumn
-
-
-# https://github.com/jonghwanhyeon/joblib-progress/blob/main/joblib_progress/__init__.py
-@contextmanager
-def JoblibProgress(  # noqa: N802
-    *columns: ProgressColumn | str,
-    description: str | None = None,
-    total: int | None = None,
-    **kwargs,
-) -> Iterator[Progress]:
-    """Context manager for tracking progress using Joblib with Rich's Progress bar.
-
-    Args:
-        *columns (ProgressColumn | str): Columns to display in the progress bar.
-        description (str | None, optional): A description for the progress task.
-            Defaults to None.
-        total (int | None, optional): The total number of tasks. If None, it will
-            be determined automatically.
-        **kwargs: Additional keyword arguments passed to the Progress instance.
-
-    Yields:
-        Progress: A Progress instance for managing the progress bar.
-
-    Example:
-        ```python
-        with JoblibProgress("task", total=100) as progress:
-            # Your parallel processing code here
-        ```
-
-    """
-    if not columns:
-        columns = Progress.get_default_columns()
-
-    progress = Progress(*columns, **kwargs)
-
-    if description is None:
-        description = "Processing..."
-
-    task_id = progress.add_task(description, total=total)
-    print_progress = joblib.parallel.Parallel.print_progress
-
-    def update_progress(self: joblib.parallel.Parallel) -> None:
-        progress.update(task_id, completed=self.n_completed_tasks, refresh=True)
-        return print_progress(self)
-
-    try:
-        joblib.parallel.Parallel.print_progress = update_progress
-        progress.start()
-        yield progress
-
-    finally:
-        progress.stop()
-        joblib.parallel.Parallel.print_progress = print_progress
-
-
-T = TypeVar("T")
-U = TypeVar("U")
-
-
-def parallel_progress(
-    func: Callable[[T], U],
-    iterable: Iterable[T],
-    *columns: ProgressColumn | str,
-    n_jobs: int = -1,
-    description: str | None = None,
-    **kwargs,
-) -> list[U]:
-    """Execute a function in parallel over an iterable with progress tracking.
-
-    Args:
-        func (Callable[[T], U]): The function to execute on each item in the
-            iterable.
-        iterable (Iterable[T]): An iterable of items to process.
-        *columns (ProgressColumn | str): Additional columns to display in the
-            progress bar.
-        n_jobs (int, optional): The number of jobs to run in parallel.
-            Defaults to -1 (all processors).
-        description (str | None, optional): A description for the progress bar.
-            Defaults to None.
-        **kwargs: Additional keyword arguments passed to the Progress instance.
-
-    Returns:
-        list[U]: A list of results from applying the function to each item in
-        the iterable.
-
-    """
-    iterable = list(iterable)
-    total = len(iterable)
-
-    with JoblibProgress(*columns, description=description, total=total, **kwargs):
-        it = (joblib.delayed(func)(x) for x in iterable)
-        return joblib.Parallel(n_jobs=n_jobs)(it)  # type: ignore
-
-
-def multi_tasks_progress(
-    iterables: Iterable[Iterable[int | tuple[int, int]]],
-    *columns: ProgressColumn | str,
-    n_jobs: int = -1,
-    description: str = "#{:0>3}",
-    main_description: str = "main",
-    transient: bool | None = None,
-    **kwargs,
-) -> None:
-    """Render auto-updating progress bars for multiple tasks concurrently.
-
-    Args:
-        iterables (Iterable[Iterable[int | tuple[int, int]]]): A collection of
-            iterables, each representing a task. Each iterable can yield
-            integers (completed) or tuples of integers (completed, total).
-        *columns (ProgressColumn | str): Additional columns to display in the
-            progress bars.
-        n_jobs (int, optional): Number of jobs to run in parallel. Defaults to
-            -1, which means using all processors.
-        description (str, optional): Format string for describing tasks. Defaults to
-            "#{:0>3}".
-        main_description (str, optional): Description for the main task.
-            Defaults to "main".
-        transient (bool | None, optional): Whether to remove the progress bar
-            after completion. Defaults to None.
-        **kwargs: Additional keyword arguments passed to the Progress instance.
-
-    Returns:
-        None
-
-    """
-    if not columns:
-        columns = Progress.get_default_columns()
-
-    iterables = list(iterables)
-
-    with Progress(*columns, transient=transient or False, **kwargs) as progress:
-        task_main = progress.add_task(main_description, total=None)
-
-        task_ids = [
-            progress.add_task(description.format(i), start=False, total=None)
-            for i in range(len(iterables))
-        ]
-
-        total = {}
-        completed = {}
-
-        def func(i: int) -> None:
-            completed[i] = 0
-            total[i] = None
-            progress.start_task(task_ids[i])
-
-            for index in iterables[i]:
-                if isinstance(index, tuple):
-                    completed[i], total[i] = index[0] + 1, index[1]
-                else:
-                    completed[i] = index + 1
-
-                progress.update(task_ids[i], total=total[i], completed=completed[i])
-
-                if all(t is not None for t in total.values()):
-                    t = sum(total.values())
-                else:
-                    t = None
-                c = sum(completed.values())
-                progress.update(task_main, total=t, completed=c)
-
-            if transient is not False:
-                progress.remove_task(task_ids[i])
-
-        it = (joblib.delayed(func)(i) for i in range(len(iterables)))
-        joblib.Parallel(n_jobs, prefer="threads")(it)

hydraflow-0.4.5.dist-info/RECORD

@@ -1,16 +0,0 @@
-hydraflow/__init__.py,sha256=VbrHKs2Cg93QJ8K9WHYxkXmzOpb8o9ugiwV-mXDT0JE,908
-hydraflow/asyncio.py,sha256=-i1C8KAmNDImrjHnk92Csaa1mpjdK8Vp4ZVaQV-l94s,6634
-hydraflow/config.py,sha256=MNX9da5bPVDcjnpji7Cm9ndK6ura92pt361m4PRh6_E,4326
-hydraflow/context.py,sha256=kz5SvjvjN7Z_2WjHYpO9SWwDfsPT_UeZcsm8pDymhjs,8836
-hydraflow/mlflow.py,sha256=kWVK_Xw2hkRnTg33jSP3VW13UZF6_hBGhN52mPmLgvk,8753
-hydraflow/param.py,sha256=c5sc6NwD6DKwZzVwprXzZD5FSi6qRgSHkc6TXBKQEdg,4502
-hydraflow/progress.py,sha256=zvKX1HCN8_xDOsgYOEcLLhkhdPdep-U8vHrc0XZ-6SQ,6163
-hydraflow/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hydraflow/run_collection.py,sha256=eBNGwtvkRKpOEqcwDUS1tkIFuxY_PVi6SEzzd1PwG5s,26774
-hydraflow/run_data.py,sha256=qeFX1iRvNAorXA9QQIjzr0o2_82TI44eZKp7llKG8GI,1549
-hydraflow/run_info.py,sha256=sMXOo20ClaRIommMEzuAbO_OrcXx7M1Yt4FMV7spxz0,998
-hydraflow/utils.py,sha256=Xq78F2iOkgi9JnCYfX1reQw_Y9K6o8oNYBDEwrf18cI,3552
-hydraflow-0.4.5.dist-info/METADATA,sha256=SOxec-saE-PWA4ViuKI1wAMI7EARLfmOPZv9t6XzInI,5127
-hydraflow-0.4.5.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-hydraflow-0.4.5.dist-info/licenses/LICENSE,sha256=IGdDrBPqz1O0v_UwCW-NJlbX9Hy9b3uJ11t28y2srmY,1062
-hydraflow-0.4.5.dist-info/RECORD,,