FlowerPower 0.31.0__py3-none-any.whl → 0.31.2__py3-none-any.whl

flowerpower/pipeline/manager.py

@@ -580,11 +580,32 @@ class PipelineManager:
         """
         return self._lifecycle_manager.list_pipelines()
 
-    def show_pipelines(self) -> None:
-        """Display all available pipelines in a formatted table.
+    def show_pipelines(self, format: str = "table") -> None:
+        """Display all available pipelines in a selected format.
 
-        Uses rich formatting for terminal display.
+        Args:
+            format: One of "table", "json", or "yaml". Defaults to "table".
         """
+        fmt = (format or "table").lower()
+        if fmt == "table":
+            return self.registry.show_pipelines()
+        names = self._lifecycle_manager.list_pipelines()
+        try:
+            if fmt == "json":
+                import json
+                print(json.dumps(names))
+                return None
+            if fmt == "yaml":
+                import yaml  # type: ignore
+                print(yaml.safe_dump(names, sort_keys=False))
+                return None
+        except Exception as e:
+            warnings.warn(
+                f"Failed to format pipelines as {fmt}: {e}. Falling back to table.",
+                RuntimeWarning,
+            )
+            return self.registry.show_pipelines()
+        warnings.warn(f"Unknown format '{format}', using table.", RuntimeWarning)
         return self.registry.show_pipelines()
 
     @property
@@ -985,7 +1006,13 @@ class PipelineManager:
         )
 
     # Visualizer Delegations
-    def save_dag(self, name: str, format: str = "png", reload: bool = False) -> None:
+    def save_dag(
+        self,
+        name: str,
+        format: str = "png",
+        reload: bool = False,
+        output_path: str | None = None,
+    ) -> str:
         """Save pipeline DAG visualization to a file.
 
         Creates a visual representation of the pipeline's directed acyclic graph (DAG)
@@ -1020,7 +1047,9 @@ class PipelineManager:
             ...     reload=True
             ... )
         """
-        self.visualizer.save_dag(name=name, format=format, reload=reload)
+        return self.visualizer.save_dag(
+            name=name, format=format, reload=reload, output_path=output_path
+        )
 
     def show_dag(
         self, name: str, format: str = "png", reload: bool = False, raw: bool = False

flowerpower/pipeline/visualizer.py

@@ -67,7 +67,8 @@ class PipelineVisualizer:
         name: str,
         format: str = "png",
         reload: bool = False,
-    ):
+        output_path: str | None = None,
+    ) -> str:
         """
         Save an image of the graph of functions for a given pipeline name.
 
@@ -86,25 +87,38 @@ class PipelineVisualizer:
         """
         dag = self._get_dag_object(name=name, reload=reload)
 
-        # Use project_cfg attributes for path and filesystem access
-        graph_dir = posixpath.join(self.project_cfg.base_dir, "graphs")
-        self._fs.makedirs(graph_dir, exist_ok=True)
-
-        output_path = posixpath.join(
-            graph_dir, name
-        )  # Output filename is just the pipeline name
-        output_path_with_ext = f"{output_path}.{format}"
+        # Determine final output path
+        if output_path is None:
+            graph_dir = posixpath.join(self.project_cfg.base_dir, "graphs")
+            self._fs.makedirs(graph_dir, exist_ok=True)
+            base = posixpath.join(graph_dir, name)
+            final_path = f"{base}.{format}"
+            render_path = base
+        else:
+            # If output_path already has an extension, use as-is; otherwise append format
+            if "." in posixpath.basename(output_path):
+                final_path = output_path
+                # Remove extension for graphviz render base path
+                render_path = final_path.rsplit(".", 1)[0]
+                fmt = final_path.rsplit(".", 1)[1]
+                if fmt != format:
+                    # Honor explicit extension if it differs from format argument
+                    format = fmt
+            else:
+                final_path = f"{output_path}.{format}"
+                render_path = output_path
 
         # Render the DAG using the graphviz object returned by display_all_functions
         dag.render(
-            output_path,  # graphviz appends the format automatically
+            render_path,  # graphviz appends the format automatically
             format=format,
             cleanup=True,
             view=False,
         )
         print(
-            f"📊 Saved graph for [bold blue]{self.project_cfg.name}.{name}[/bold blue] to [green]{output_path_with_ext}[/green]"
+            f"📊 Saved graph for [bold blue]{self.project_cfg.name}.{name}[/bold blue] to [green]{final_path}[/green]"
         )
+        return final_path
 
     def show_dag(
         self,

flowerpower/utils/misc.py

@@ -9,218 +9,219 @@ from typing import Any
 import msgspec
 from fsspec_utils import AbstractFileSystem, filesystem
 from .security import validate_file_path
+from fsspec_utils.utils import run_parallel
 
-if importlib.util.find_spec("joblib"):
-    from joblib import Parallel, delayed
-    from rich.progress import (BarColumn, Progress, TextColumn,
-                               TimeElapsedColumn)
+# if importlib.util.find_spec("joblib"):
+#     from joblib import Parallel, delayed
+#     from rich.progress import (BarColumn, Progress, TextColumn,
+#                                TimeElapsedColumn)
 
-    def _prepare_parallel_args(
-        args: tuple, kwargs: dict
-    ) -> tuple[list, list, dict, dict, int]:
-        """Prepare and validate arguments for parallel execution.
+#     def _prepare_parallel_args(
+#         args: tuple, kwargs: dict
+#     ) -> tuple[list, list, dict, dict, int]:
+#         """Prepare and validate arguments for parallel execution.
         
-        Args:
-            args: Positional arguments
-            kwargs: Keyword arguments
+#         Args:
+#             args: Positional arguments
+#             kwargs: Keyword arguments
             
-        Returns:
-            tuple: (iterables, fixed_args, iterable_kwargs, fixed_kwargs, first_iterable_len)
+#         Returns:
+#             tuple: (iterables, fixed_args, iterable_kwargs, fixed_kwargs, first_iterable_len)
             
-        Raises:
-            ValueError: If no iterable arguments or length mismatch
-        """
-        iterables = []
-        fixed_args = []
-        iterable_kwargs = {}
-        fixed_kwargs = {}
-        first_iterable_len = None
-
-        # Process positional arguments
-        for arg in args:
-            if isinstance(arg, (list, tuple)) and not isinstance(arg[0], (list, tuple)):
-                iterables.append(arg)
-                if first_iterable_len is None:
-                    first_iterable_len = len(arg)
-                elif len(arg) != first_iterable_len:
-                    raise ValueError(
-                        f"Iterable length mismatch: argument has length {len(arg)}, expected {first_iterable_len}"
-                    )
-            else:
-                fixed_args.append(arg)
-
-        # Process keyword arguments
-        for key, value in kwargs.items():
-            if isinstance(value, (list, tuple)) and not isinstance(
-                value[0], (list, tuple)
-            ):
-                if first_iterable_len is None:
-                    first_iterable_len = len(value)
-                elif len(value) != first_iterable_len:
-                    raise ValueError(
-                        f"Iterable length mismatch: {key} has length {len(value)}, expected {first_iterable_len}"
-                    )
-                iterable_kwargs[key] = value
-            else:
-                fixed_kwargs[key] = value
-
-        if first_iterable_len is None:
-            raise ValueError("At least one iterable argument is required")
-
-        return iterables, fixed_args, iterable_kwargs, fixed_kwargs, first_iterable_len
-
-    def _execute_parallel_with_progress(
-        func: callable,
-        iterables: list,
-        fixed_args: list,
-        iterable_kwargs: dict,
-        fixed_kwargs: dict,
-        param_combinations: list,
-        parallel_kwargs: dict,
-    ) -> list:
-        """Execute parallel tasks with progress tracking.
+#         Raises:
+#             ValueError: If no iterable arguments or length mismatch
+#         """
+#         iterables = []
+#         fixed_args = []
+#         iterable_kwargs = {}
+#         fixed_kwargs = {}
+#         first_iterable_len = None
+
+#         # Process positional arguments
+#         for arg in args:
+#             if isinstance(arg, (list, tuple)) and not isinstance(arg[0], (list, tuple)):
+#                 iterables.append(arg)
+#                 if first_iterable_len is None:
+#                     first_iterable_len = len(arg)
+#                 elif len(arg) != first_iterable_len:
+#                     raise ValueError(
+#                         f"Iterable length mismatch: argument has length {len(arg)}, expected {first_iterable_len}"
+#                     )
+#             else:
+#                 fixed_args.append(arg)
+
+#         # Process keyword arguments
+#         for key, value in kwargs.items():
+#             if isinstance(value, (list, tuple)) and not isinstance(
+#                 value[0], (list, tuple)
+#             ):
+#                 if first_iterable_len is None:
+#                     first_iterable_len = len(value)
+#                 elif len(value) != first_iterable_len:
+#                     raise ValueError(
+#                         f"Iterable length mismatch: {key} has length {len(value)}, expected {first_iterable_len}"
+#                     )
+#                 iterable_kwargs[key] = value
+#             else:
+#                 fixed_kwargs[key] = value
+
+#         if first_iterable_len is None:
+#             raise ValueError("At least one iterable argument is required")
+
+#         return iterables, fixed_args, iterable_kwargs, fixed_kwargs, first_iterable_len
+
+#     def _execute_parallel_with_progress(
+#         func: callable,
+#         iterables: list,
+#         fixed_args: list,
+#         iterable_kwargs: dict,
+#         fixed_kwargs: dict,
+#         param_combinations: list,
+#         parallel_kwargs: dict,
+#     ) -> list:
+#         """Execute parallel tasks with progress tracking.
         
-        Args:
-            func: Function to execute
-            iterables: List of iterable arguments
-            fixed_args: List of fixed arguments
-            iterable_kwargs: Dictionary of iterable keyword arguments
-            fixed_kwargs: Dictionary of fixed keyword arguments
-            param_combinations: List of parameter combinations
-            parallel_kwargs: Parallel execution configuration
+#         Args:
+#             func: Function to execute
+#             iterables: List of iterable arguments
+#             fixed_args: List of fixed arguments
+#             iterable_kwargs: Dictionary of iterable keyword arguments
+#             fixed_kwargs: Dictionary of fixed keyword arguments
+#             param_combinations: List of parameter combinations
+#             parallel_kwargs: Parallel execution configuration
             
-        Returns:
-            list: Results from parallel execution
-        """
-        results = [None] * len(param_combinations)
-        with Progress(
-            TextColumn("[progress.description]{task.description}"),
-            BarColumn(),
-            "[progress.percentage]{task.percentage:>3.0f}%",
-            TimeElapsedColumn(),
-            transient=True,
-        ) as progress:
-            task = progress.add_task(
-                "Running in parallel...", total=len(param_combinations)
-            )
-
-            def wrapper(idx, param_tuple):
-                res = func(
-                    *(list(param_tuple[: len(iterables)]) + fixed_args),
-                    **{
-                        k: v
-                        for k, v in zip(
-                            iterable_kwargs.keys(), param_tuple[len(iterables) :]
-                        )
-                    },
-                    **fixed_kwargs,
-                )
-                progress.update(task, advance=1)
-                return idx, res
-
-            for idx, result in Parallel(**parallel_kwargs)(
-                delayed(wrapper)(i, param_tuple)
-                for i, param_tuple in enumerate(param_combinations)
-            ):
-                results[idx] = result
-        return results
-
-    def _execute_parallel_without_progress(
-        func: callable,
-        iterables: list,
-        fixed_args: list,
-        iterable_kwargs: dict,
-        fixed_kwargs: dict,
-        param_combinations: list,
-        parallel_kwargs: dict,
-    ) -> list:
-        """Execute parallel tasks without progress tracking.
+#         Returns:
+#             list: Results from parallel execution
+#         """
+#         results = [None] * len(param_combinations)
+#         with Progress(
+#             TextColumn("[progress.description]{task.description}"),
+#             BarColumn(),
+#             "[progress.percentage]{task.percentage:>3.0f}%",
+#             TimeElapsedColumn(),
+#             transient=True,
+#         ) as progress:
+#             task = progress.add_task(
+#                 "Running in parallel...", total=len(param_combinations)
+#             )
+
+#             def wrapper(idx, param_tuple):
+#                 res = func(
+#                     *(list(param_tuple[: len(iterables)]) + fixed_args),
+#                     **{
+#                         k: v
+#                         for k, v in zip(
+#                             iterable_kwargs.keys(), param_tuple[len(iterables) :]
+#                         )
+#                     },
+#                     **fixed_kwargs,
+#                 )
+#                 progress.update(task, advance=1)
+#                 return idx, res
+#
+#             for idx, result in Parallel(**parallel_kwargs)(
+#                 delayed(wrapper)(i, param_tuple)
+#                 for i, param_tuple in enumerate(param_combinations)
+#             ):
+#                 results[idx] = result
+#         return results
+
+#     def _execute_parallel_without_progress(
+#         func: callable,
+#         iterables: list,
+#         fixed_args: list,
+#         iterable_kwargs: dict,
+#         fixed_kwargs: dict,
+#         param_combinations: list,
+#         parallel_kwargs: dict,
+#     ) -> list:
+#         """Execute parallel tasks without progress tracking.
         
-        Args:
-            func: Function to execute
-            iterables: List of iterable arguments
-            fixed_args: List of fixed arguments
-            iterable_kwargs: Dictionary of iterable keyword arguments
-            fixed_kwargs: Dictionary of fixed keyword arguments
-            param_combinations: List of parameter combinations
-            parallel_kwargs: Parallel execution configuration
+#         Args:
+#             func: Function to execute
+#             iterables: List of iterable arguments
+#             fixed_args: List of fixed arguments
+#             iterable_kwargs: Dictionary of iterable keyword arguments
+#             fixed_kwargs: Dictionary of fixed keyword arguments
+#             param_combinations: List of parameter combinations
+#             parallel_kwargs: Parallel execution configuration
             
-        Returns:
-            list: Results from parallel execution
-        """
-        return Parallel(**parallel_kwargs)(
-            delayed(func)(
-                *(list(param_tuple[: len(iterables)]) + fixed_args),
-                **{
-                    k: v
-                    for k, v in zip(
-                        iterable_kwargs.keys(), param_tuple[len(iterables) :]
-                    )
-                },
-                **fixed_kwargs,
-            )
-            for param_tuple in param_combinations
-        )
-
-    def run_parallel(
-        func: callable,
-        *args,
-        n_jobs: int = -1,
-        backend: str = "threading",
-        verbose: bool = True,
-        **kwargs,
-    ) -> list[any]:
-        """Runs a function for a list of parameters in parallel.
-
-        Args:
-            func (Callable): function to run in parallel
-            *args: Positional arguments. Can be single values or iterables
-            n_jobs (int, optional): Number of joblib workers. Defaults to -1
-            backend (str, optional): joblib backend. Valid options are
-                `loky`,`threading`, `mutliprocessing` or `sequential`. Defaults to "threading"
-            verbose (bool, optional): Show progress bar. Defaults to True
-            **kwargs: Keyword arguments. Can be single values or iterables
-
-        Returns:
-            list[any]: Function output
-
-        Examples:
-            >>> # Single iterable argument
-            >>> run_parallel(func, [1,2,3], fixed_arg=42)
-
-            >>> # Multiple iterables in args and kwargs
-            >>> run_parallel(func, [1,2,3], val=[7,8,9], fixed=42)
-
-            >>> # Only kwargs iterables
-            >>> run_parallel(func, x=[1,2,3], y=[4,5,6], fixed=42)
-        """
-        parallel_kwargs = {"n_jobs": n_jobs, "backend": backend, "verbose": 0}
-
-        # Prepare and validate arguments
-        iterables, fixed_args, iterable_kwargs, fixed_kwargs, first_iterable_len = _prepare_parallel_args(
-            args, kwargs
-        )
-
-        # Create parameter combinations
-        all_iterables = iterables + list(iterable_kwargs.values())
-        param_combinations = list(zip(*all_iterables))
-
-        # Execute with or without progress tracking
-        if not verbose:
-            return _execute_parallel_without_progress(
-                func, iterables, fixed_args, iterable_kwargs, fixed_kwargs,
-                param_combinations, parallel_kwargs
-            )
-        else:
-            return _execute_parallel_with_progress(
-                func, iterables, fixed_args, iterable_kwargs, fixed_kwargs,
-                param_combinations, parallel_kwargs
-            )
-
-else:
-
-    def run_parallel(*args, **kwargs):
-        raise ImportError("joblib not installed")
+#         Returns:
+#             list: Results from parallel execution
+#         """
+#         return Parallel(**parallel_kwargs)(
+#             delayed(func)(
+#                 *(list(param_tuple[: len(iterables)]) + fixed_args),
+#                 **{
+#                     k: v
+#                     for k, v in zip(
+#                         iterable_kwargs.keys(), param_tuple[len(iterables) :]
+#                     )
+#                 },
+#                 **fixed_kwargs,
+#             )
+#             for param_tuple in param_combinations
+#         )
+
+#     def run_parallel(
+#         func: callable,
+#         *args,
+#         n_jobs: int = -1,
+#         backend: str = "threading",
+#         verbose: bool = True,
+#         **kwargs,
+#     ) -> list[any]:
+#         """Runs a function for a list of parameters in parallel.
+
+#         Args:
+#             func (Callable): function to run in parallel
+#             *args: Positional arguments. Can be single values or iterables
+#             n_jobs (int, optional): Number of joblib workers. Defaults to -1
+#             backend (str, optional): joblib backend. Valid options are
+#                 `loky`,`threading`, `mutliprocessing` or `sequential`. Defaults to "threading"
+#             verbose (bool, optional): Show progress bar. Defaults to True
+#             **kwargs: Keyword arguments. Can be single values or iterables
+
+#         Returns:
+#             list[any]: Function output
+
+#         Examples:
+#             >>> # Single iterable argument
+#             >>> run_parallel(func, [1,2,3], fixed_arg=42)
+
+#             >>> # Multiple iterables in args and kwargs
+#             >>> run_parallel(func, [1,2,3], val=[7,8,9], fixed=42)
+
+#             >>> # Only kwargs iterables
+#             >>> run_parallel(func, x=[1,2,3], y=[4,5,6], fixed=42)
+#         """
+#         parallel_kwargs = {"n_jobs": n_jobs, "backend": backend, "verbose": 0}
+
+#         # Prepare and validate arguments
+#         iterables, fixed_args, iterable_kwargs, fixed_kwargs, first_iterable_len = _prepare_parallel_args(
+#             args, kwargs
+#         )
+
+#         # Create parameter combinations
+#         all_iterables = iterables + list(iterable_kwargs.values())
+#         param_combinations = list(zip(*all_iterables))
+
+#         # Execute with or without progress tracking
+#         if not verbose:
+#             return _execute_parallel_without_progress(
+#                 func, iterables, fixed_args, iterable_kwargs, fixed_kwargs,
+#                 param_combinations, parallel_kwargs
+#             )
+#         else:
+#             return _execute_parallel_with_progress(
+#                 func, iterables, fixed_args, iterable_kwargs, fixed_kwargs,
+#                 param_combinations, parallel_kwargs
+#             )
+
+# else:
+
+#     def run_parallel(*args, **kwargs):
+#         raise ImportError("joblib not installed")
 
 
 def get_partitions_from_path(

{flowerpower-0.31.0.dist-info → flowerpower-0.31.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: FlowerPower
-Version: 0.31.0
+Version: 0.31.2
 Summary: A simple workflow framework for building and managing data processing pipelines
 Author-email: "Volker L." <ligno.blades@gmail.com>
 Project-URL: Homepage, https://github.com/legout/flowerpower

{flowerpower-0.31.0.dist-info → flowerpower-0.31.2.dist-info}/RECORD

@@ -21,10 +21,10 @@ flowerpower/pipeline/config_manager.py,sha256=0u_Nn_XGafjW3LmhGyp39CP9KXfLo02Z9i
 flowerpower/pipeline/executor.py,sha256=AAiMbNKIQKNrumu1lavG_yVK9rzhPYjZAIt0BxAbJjc,4567
 flowerpower/pipeline/io.py,sha256=phYJhN4LZ0c6d8_udEQ4C9cGzeV3Ku0hsj0gyE1n2UY,16246
 flowerpower/pipeline/lifecycle_manager.py,sha256=JKJXdgdwhH8yUYdwlAJp5-dSbDFFb-EqmgiY-O5KIoA,7670
-flowerpower/pipeline/manager.py,sha256=XLrCY5x9WmQithe0QmeYonR4LyqzqSQHR-y7cL6DKr4,41143
+flowerpower/pipeline/manager.py,sha256=NTjdWu_SzOmeLvnD5ruJzI72UOx_UFLxhNrUipPK43g,42138
 flowerpower/pipeline/pipeline.py,sha256=x4nQeKC7irJoD6x2RzU52dN4VGWJFSGTDYKNuDhG7fk,15742
 flowerpower/pipeline/registry.py,sha256=gIc1N7yRm95dEhc5WnZapTK827VeydGxZSYcWFqB10U,30122
-flowerpower/pipeline/visualizer.py,sha256=EVpjv-TUe1zGvdEAWyShJcVXurm02W0jkLbj7z1uAv4,4953
+flowerpower/pipeline/visualizer.py,sha256=5DI9A7JhiwreRjZPIu5FbQCoI65W0cDC8c2iPkpkOGY,5612
 flowerpower/plugins/io/__init__.py,sha256=ZmSdKoh3TavJagOz0vUItnEqAh3mAM1QpAWj0KufF_k,222
 flowerpower/settings/__init__.py,sha256=XKQa8AI9VrX8ievs-suq3Cm6PBt4cJ78ZHVIjUbXCyA,130
 flowerpower/settings/_backend.py,sha256=Up1RBqAs3jtDUOV-9wEpL68Qmom-dRWMOeHXIh0F3lw,4273
@@ -40,14 +40,14 @@ flowerpower/utils/config.py,sha256=JC_kKq9-VJrW7ndWiehm5s-C0JG4_4oBffuwhVbaibQ,1
 flowerpower/utils/executor.py,sha256=AqO1RLxI9uKWX9OPu9uK6yOX2CNQMptRKpvcG2o-tak,6258
 flowerpower/utils/filesystem.py,sha256=W5kpJ0IERSsI3hQd7XFtbuk9bcIXidl7Qgw2bQVOkd0,6346
 flowerpower/utils/logging.py,sha256=WUnpoEmr9H5MGFF68jlshhEJcuMtW49M7VVRstmqIAg,1192
-flowerpower/utils/misc.py,sha256=iRfGHxVYCBqk5SsydR_jKBvsGXmI1mOqc_1UyNJKjr4,14236
+flowerpower/utils/misc.py,sha256=_BbAXmcbhDm5Y-RpW-HhJ5txu8KoaDQjdmRJwzNs7aM,14649
 flowerpower/utils/monkey.py,sha256=vJMYANjZI13PNbEQThdX0EFP1_6bGNHgnpF7HwReNyM,58
 flowerpower/utils/open_telemetry.py,sha256=fQWJWbIQFtKIxMBjAWeF12NGnqT0isO3A3j-DSOv_vE,949
 flowerpower/utils/security.py,sha256=7TPwD4nqjVm2rFBjJ0qM86wEQql-9j3Jo8udV3mSBoA,7113
 flowerpower/utils/templates.py,sha256=ouyEeSDqa9PjW8c32fGpcINlpC0WToawRFZkMPtwsLE,1591
-flowerpower-0.31.0.dist-info/licenses/LICENSE,sha256=9AkLexxrmr0aBgSHiqxpJk9wgazpP1CTJyiDyr56J9k,1063
-flowerpower-0.31.0.dist-info/METADATA,sha256=z11b6gBDVqqNGH3y_SF0n_xgJbRV0qd69TmtTo2pJqg,17202
-flowerpower-0.31.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-flowerpower-0.31.0.dist-info/entry_points.txt,sha256=61X11i5a2IwC9LBiP20XCDl5zMOigGCjMCx17B7bDbQ,52
-flowerpower-0.31.0.dist-info/top_level.txt,sha256=VraH4WtEUfSxs5L-rXwDQhzQb9eLHTUtgvmFZ2dAYnA,12
-flowerpower-0.31.0.dist-info/RECORD,,
+flowerpower-0.31.2.dist-info/licenses/LICENSE,sha256=9AkLexxrmr0aBgSHiqxpJk9wgazpP1CTJyiDyr56J9k,1063
+flowerpower-0.31.2.dist-info/METADATA,sha256=Gv1RElnrVxJg_h-INW7QnoKkjy5G0OYjrzu55AsDwnw,17202
+flowerpower-0.31.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+flowerpower-0.31.2.dist-info/entry_points.txt,sha256=61X11i5a2IwC9LBiP20XCDl5zMOigGCjMCx17B7bDbQ,52
+flowerpower-0.31.2.dist-info/top_level.txt,sha256=VraH4WtEUfSxs5L-rXwDQhzQb9eLHTUtgvmFZ2dAYnA,12
+flowerpower-0.31.2.dist-info/RECORD,,