hydraflow 0.4.6__py3-none-any.whl → 0.5.1__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,
@@ -25,13 +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]:
@@ -609,8 +609,8 @@ class RunCollection:
 
     def sort(
         self,
-        key: Callable[[Run], Any] | None = None,
         *,
+        key: Callable[[Run], Any] | None = None,
         reverse: bool = False,
     ) -> None:
         """Sort the runs in the collection.
@@ -652,7 +652,7 @@ class RunCollection:
 
         return [v[0] for v in values]
 
-    def sort_by(
+    def sorted(
         self,
         names: str | list[str],
         *,

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-0.4.6.dist-info → hydraflow-0.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hydraflow
-Version: 0.4.6
+Version: 0.5.1
 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
@@ -37,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
@@ -116,19 +111,9 @@ def my_app(cfg: MySQLConfig) -> None:
     hydraflow.set_experiment()
 
     # Automatically log Hydra config as params.
-    with hydraflow.start_run():
+    with hydraflow.start_run(cfg):
         # 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.1.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=zPrlKwLuzqePj57pXbgKWrE03S_kjxTaxY9trItf6Gc,26772
+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.1.dist-info/METADATA,sha256=ZRMGo-8y9JiUSCijXQMeVkG9Gw0edDRgBdkptMDK0IU,4700
+hydraflow-0.5.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hydraflow-0.5.1.dist-info/licenses/LICENSE,sha256=IGdDrBPqz1O0v_UwCW-NJlbX9Hy9b3uJ11t28y2srmY,1062
+hydraflow-0.5.1.dist-info/RECORD,,

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.6.dist-info/RECORD

@@ -1,16 +0,0 @@
-hydraflow/__init__.py,sha256=4wUu8HR__oM0lTUiIqxO7iP6ubLSfKI6y7_P9_RuYtA,942
-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=jbNrbtIfMqxE4LrdTNd1g7sF68XgAvydGqW5iAZ6n-c,3834
-hydraflow-0.4.6.dist-info/METADATA,sha256=s3eXM1oDcJVWj930b3c_9iKATXLoYZMMDmA9THkCdu8,5149
-hydraflow-0.4.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hydraflow-0.4.6.dist-info/licenses/LICENSE,sha256=IGdDrBPqz1O0v_UwCW-NJlbX9Hy9b3uJ11t28y2srmY,1062
-hydraflow-0.4.6.dist-info/RECORD,,