scalable-pypeline 2.0.10__py2.py3-none-any.whl → 2.1.0__py2.py3-none-any.whl

pypeline/pipelines/middleware/pypeline_middleware.py

@@ -0,0 +1,188 @@
+from copy import copy
+
+import networkx as nx
+from dramatiq import Middleware
+
+from pypeline.barrier import LockingParallelBarrier
+from pypeline.constants import PARALLEL_PIPELINE_CALLBACK_BARRIER_TTL
+from pypeline.utils.module_utils import get_callable
+from pypeline.utils.pipeline_utils import get_execution_graph
+from pypeline.utils.dramatiq_utils import register_lazy_actor
+
+
+class PypelineMiddleware(Middleware):
+
+    def __init__(self, redis_url):
+        self.redis_url = redis_url
+
+    def after_process_message(self, broker, message, *, result=None, exception=None):
+
+        if exception is not None:
+            return
+
+        if "pipeline" not in message.options:
+            return
+
+        pipeline = message.options["pipeline"]
+        pipeline_config = pipeline["config"]
+        task_replacements = message.options["task_replacements"]
+        execution_id = message.options["execution_id"]
+        task_definitions = pipeline_config["taskDefinitions"]
+        task_name = message.options["task_name"]
+        task_key = f"{execution_id}-{task_name}"
+
+        # Signal to other jobs that current job is finished
+        locking_parallel_barrier = LockingParallelBarrier(
+            self.redis_url,
+            task_key=task_key,
+            lock_key=f"{message.options['root_execution_id']}-lock",
+        )
+        try:
+            locking_parallel_barrier.acquire_lock(
+                timeout=PARALLEL_PIPELINE_CALLBACK_BARRIER_TTL
+            )
+            _ = locking_parallel_barrier.decrement_task_count()
+        finally:
+            locking_parallel_barrier.release_lock()
+
+        graph = get_execution_graph(pipeline_config)
+        children_tasks = pipeline_config["dagAdjacency"].get(task_name, [])
+
+        messages = []
+        for child in children_tasks:
+            child_ancestors = sorted(nx.ancestors(graph, child))
+
+            ancestor_tasks_complete = True
+
+            for ancestor in child_ancestors:
+                task_key = f"{execution_id}-{ancestor}"
+
+                locking_parallel_barrier = LockingParallelBarrier(
+                    self.redis_url,
+                    task_key=task_key,
+                    lock_key=f"{message.options['root_execution_id']}-lock",
+                )
+                try:
+                    locking_parallel_barrier.acquire_lock(
+                        timeout=PARALLEL_PIPELINE_CALLBACK_BARRIER_TTL
+                    )
+
+                    if locking_parallel_barrier.task_exists():
+                        remaining_tasks = locking_parallel_barrier.get_task_count()
+                    else:
+                        remaining_tasks = None
+                finally:
+                    locking_parallel_barrier.release_lock()
+
+                if not remaining_tasks:
+                    task_key = f"{message.options['root_execution_id']}-{ancestor}"
+
+                    locking_parallel_barrier = LockingParallelBarrier(
+                        self.redis_url,
+                        task_key=task_key,
+                        lock_key=f"{message.options['root_execution_id']}-lock",
+                    )
+                    try:
+                        locking_parallel_barrier.acquire_lock(
+                            timeout=PARALLEL_PIPELINE_CALLBACK_BARRIER_TTL
+                        )
+
+                        if locking_parallel_barrier.task_exists():
+                            remaining_tasks = locking_parallel_barrier.get_task_count()
+                        else:
+                            raise Exception(
+                                f"Parent task {ancestor} barrier lock not found"
+                            )
+                    finally:
+                        locking_parallel_barrier.release_lock()
+                if remaining_tasks >= 1:
+                    ancestor_tasks_complete = False
+                    break
+
+            # If the child's ancestor tasks aren't complete move onto the next child to check
+            if not ancestor_tasks_complete:
+                break
+
+            if message.options["root_execution_id"] == message.options["execution_id"]:
+                for scenario in message.options["scenarios"]:
+                    child_predecessors = list(graph.predecessors(child))
+                    if (
+                        child in scenario["tasksToRunInScenario"]
+                        and task_name in child_predecessors
+                        and task_name not in scenario["tasksToRunInScenario"]
+                    ):
+                        task_key = f"{scenario['execution_id']}-{child}"
+                        locking_parallel_barrier = LockingParallelBarrier(
+                            self.redis_url,
+                            task_key=task_key,
+                            lock_key=f"{message.options['root_execution_id']}-lock",
+                        )
+                        locking_parallel_barrier.set_task_count(1)
+                        handler = task_definitions[child]["handlers"][
+                            task_replacements.get(child, 0)
+                        ]
+
+                        lazy_actor = register_lazy_actor(
+                            broker,
+                            get_callable(handler),
+                            pipeline_config["metadata"],
+                        )
+                        scenario_message = lazy_actor.message()
+                        scenario_message.options["pipeline"] = pipeline
+                        scenario_message.options["task_replacements"] = (
+                            task_replacements
+                        )
+                        scenario_message.options["execution_id"] = scenario[
+                            "execution_id"
+                        ]
+
+                        scenario_message.options["task_name"] = child
+                        scenario_message.options["root_execution_id"] = message.options[
+                            "root_execution_id"
+                        ]
+                        scenario_message.options["scenarios"] = message.options[
+                            "scenarios"
+                        ]
+                        if "settings" in message.kwargs:
+                            scenario_message.kwargs["settings"] = copy(
+                                message.kwargs["settings"]
+                            )
+                            scenario_message.kwargs["settings"]["execution_id"] = (
+                                scenario["execution_id"]
+                            )
+                        messages.append(scenario_message)
+            task_key = f"{execution_id}-{child}"
+            locking_parallel_barrier = LockingParallelBarrier(
+                self.redis_url,
+                task_key=task_key,
+                lock_key=f"{message.options['root_execution_id']}-lock",
+            )
+            locking_parallel_barrier.set_task_count(1)
+            handler = task_definitions[child]["handlers"][
+                task_replacements.get(child, 0)
+            ]
+            lazy_actor = register_lazy_actor(
+                broker,
+                get_callable(handler),
+                pipeline_config["metadata"],
+            )
+
+            child_message = lazy_actor.message()
+            child_message.options["pipeline"] = pipeline
+            child_message.options["task_replacements"] = task_replacements
+            child_message.options["execution_id"] = execution_id
+            child_message.options["task_name"] = child
+            child_message.options["root_execution_id"] = message.options[
+                "root_execution_id"
+            ]
+            child_message.options["scenarios"] = message.options["scenarios"]
+            if "settings" in message.kwargs:
+                child_message.kwargs["settings"] = message.kwargs["settings"]
+                child_message.kwargs["settings"]["execution_id"] = message.options[
+                    "execution_id"
+                ]
+
+            messages.append(child_message)
+
+        for new_message in messages:
+            broker.enqueue(new_message)

pypeline/utils/dramatiq_utils.py

@@ -0,0 +1,126 @@
+import os.path
+import sys
+import typing
+from typing import Optional, Callable, Union, Awaitable
+from functools import wraps
+from typing import TYPE_CHECKING, TypeVar
+from dramatiq import Broker, actor as register_actor
+
+from pypeline.constants import (
+    DEFAULT_TASK_MAX_RETRY,
+    DEFAULT_TASK_MIN_BACKOFF,
+    MS_IN_SECONDS,
+    DEFAULT_TASK_MAX_BACKOFF,
+    DEFAULT_TASK_TTL,
+    DEFAULT_RESULT_TTL,
+)
+
+if TYPE_CHECKING:
+    from typing_extensions import ParamSpec
+
+    P = ParamSpec("P")
+else:
+    P = TypeVar("P")
+
+R = TypeVar("R")
+
+
+def guess_code_directory(broker):
+    actor = next(iter(broker.actors.values()))
+    modname, *_ = actor.fn.__module__.partition(".")
+    mod = sys.modules[modname]
+    return os.path.dirname(mod.__file__)
+
+
+def list_managed_actors(broker, queues):
+    queues = set(queues)
+    all_actors = broker.actors.values()
+    if not queues:
+        return all_actors
+    else:
+        return [a for a in all_actors if a.queue_name in queues]
+
+
+def register_lazy_actor(
+    broker: Broker,
+    fn: Optional[Callable[P, Union[Awaitable[R], R]]] = None,
+    pipeline_meta: typing.Dict = {},
+    **kwargs,
+) -> typing.Type["LazyActor"]:
+    kwargs["queue_name"] = pipeline_meta.get("queue", "default")
+    kwargs["max_retries"] = pipeline_meta.get("maxRetry", DEFAULT_TASK_MAX_RETRY)
+    # Convert from seconds to milliseconds
+    kwargs["min_backoff"] = (
+        pipeline_meta.get("retryBackoff", DEFAULT_TASK_MIN_BACKOFF) * MS_IN_SECONDS
+    )
+    kwargs["max_backoff"] = (
+        pipeline_meta.get("retryBackoffMax", DEFAULT_TASK_MAX_BACKOFF) * MS_IN_SECONDS
+    )
+    kwargs["time_limit"] = pipeline_meta.get("maxTtl", DEFAULT_TASK_TTL) * MS_IN_SECONDS
+    # Always store results for registered pipeline actors
+    kwargs["store_results"] = pipeline_meta.get("store_results", True)
+    if kwargs["store_results"]:
+        kwargs["result_ttl"] = (
+            pipeline_meta.get("result_ttl", DEFAULT_RESULT_TTL) * MS_IN_SECONDS
+        )
+    lazy_actor: LazyActor = LazyActor(fn, kwargs)
+    lazy_actor.register(broker)
+    return lazy_actor
+
+
+def ensure_return_value(default_value=None):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            # Call the original function
+            result = func(*args, **kwargs)
+            # Check if the function has returned a value
+            if result is None:
+                # Return the default value if the function returned None
+                return default_value
+            return result
+
+        return wrapper
+
+    return decorator
+
+
+class LazyActor(object):
+    # Intermediate object that register actor on broker an call.
+
+    def __init__(self, fn, kw):
+        self.fn = fn
+        self.kw = kw
+        self.actor = None
+
+    def __call__(self, *a, **kw):
+        return self.fn(*a, **kw)
+
+    def __repr__(self):
+        return "<%s %s.%s>" % (
+            self.__class__.__name__,
+            self.fn.__module__,
+            self.fn.__name__,
+        )
+
+    def __getattr__(self, name):
+        if not self.actor:
+            raise AttributeError(name)
+        return getattr(self.actor, name)
+
+    def register(self, broker):
+        self.actor = register_actor(
+            actor_name=f"{self.fn.__module__}.{self.fn.__name__}",
+            broker=broker,
+            **self.kw,
+        )(ensure_return_value(default_value=True)(self.fn))
+
+    # Next is regular actor API.
+    def send(self, *a, **kw):
+        return self.actor.send(*a, **kw)
+
+    def message(self, *a, **kw):
+        return self.actor.message(*a, **kw)
+
+    def send_with_options(self, *a, **kw):
+        return self.actor.send_with_options(*a, **kw)

pypeline/utils/module_utils.py

@@ -1,11 +1,10 @@
 """ Utilities for loading modules/callables based on strings.
 """
-import os
+
 import re
 import logging
 import importlib
 from typing import Callable
-from pypeline.constants import API_ACCESS_KEY, PYPELINE_CLIENT_PKG_NAME
 
 logger = logging.getLogger(__name__)
 
@@ -81,3 +80,29 @@ def match_prefix_suffix(string: str, prefix_p: str, suffix_p: str) -> bool:
     if match_prefix(string, prefix_p) and match_suffix(string, suffix_p):
         return True
     return False
+
+
+def get_module(resource_dot_path: str):
+    """Retrieve the module based on a 'resource dot path'.
+    e.g. package.subdir.feature_file.MyCallable
+    """
+    module_path = ".".join(resource_dot_path.split(".")[:-1])
+    module = importlib.import_module(module_path)
+    return module
+
+
+def get_callable_name(resource_dot_path: str) -> str:
+    """Retrieve the callable based on config string.
+    e.g. package.subdir.feature_file.MyCallable
+    """
+    callable_name = resource_dot_path.split(".")[-1]
+    return callable_name
+
+
+def get_callable(resource_dot_path: str) -> Callable:
+    """Retrieve the actual handler class based on config string.
+    e.g. package.subdir.feature_file.MyCallable
+    """
+    module = get_module(resource_dot_path)
+    callable_name = get_callable_name(resource_dot_path)
+    return getattr(module, callable_name)

pypeline/utils/pipeline_utils.py

@@ -1,10 +1,7 @@
 import logging
 import typing
 import networkx as nx
-from dramatiq import get_broker, Message
-from pypeline.composition import parallel_pipeline
-from pypeline.dramatiq import LazyActor, get_callable, register_lazy_actor
-from pypeline.utils.config_utils import retrieve_latest_pipeline_config
+
 
 T = typing.TypeVar("T")  # T can be any type
 
@@ -124,36 +121,24 @@ def topological_sort_with_parallelism(
         return topological_sort_with_parallelism(graph, executable_nodes)
 
 
-def dag_generator(pipeline_id: str, *args, **kwargs):
-    pipeline_config = retrieve_latest_pipeline_config(pipeline_id=pipeline_id)["config"]
-    graph = get_execution_graph(pipeline_config)
-    optimal_execution_graph = topological_sort_with_parallelism(graph.copy())
-    broker = get_broker()
-
-    registered_actors: typing.Dict[str, LazyActor] = {}
-    broker.actors.clear()
-
-    messages: typing.List[typing.List[Message]] = []
-
-    task_definitions = pipeline_config["taskDefinitions"]
-    for task_group in optimal_execution_graph:
-        message_group = []
-        for task in task_group:
-            module_path = task_definitions[task]["handler"]
-            tmp_handler = get_callable(module_path)
-            lazy_actor = register_lazy_actor(
-                broker, tmp_handler, pipeline_config["metadata"]
-            )
-            registered_actors[task] = lazy_actor
-            if args and not kwargs:
-                message_group.append(registered_actors[task].message(*args))
-            elif kwargs and not args:
-                message_group.append(registered_actors[task].message(**kwargs))
-            elif args and kwargs:
-                message_group.append(registered_actors[task].message(*args, **kwargs))
-            else:
-                message_group.append(registered_actors[task].message())
-        messages.append(message_group)
-    p = parallel_pipeline(messages)
-
-    return p
+def plt_execution_tree(G):
+    import networkx as nx
+    import matplotlib.pyplot as plt
+
+    # Draw the graph
+    plt.figure(figsize=(8, 6))
+    pos = nx.spring_layout(G)  # Compute positions for nodes
+    nx.draw(
+        G,
+        pos,
+        with_labels=True,
+        node_color="lightblue",
+        node_size=3000,
+        edge_color="gray",
+        arrowsize=20,
+        font_size=12,
+    )
+
+    # Show the plot
+    plt.title("Directed Graph Visualization")
+    plt.show()

pypeline/utils/schema_utils.py

@@ -0,0 +1,24 @@
+def get_clean_validation_messages(validation_error):
+    """
+    Extract and format clean validation error messages.
+
+    Args:
+        validation_error (ValidationError): The Marshmallow ValidationError instance.
+
+    Returns:
+        str: A formatted string with all validation error messages.
+    """
+
+    def format_errors(errors, parent_key=""):
+        messages = []
+        for key, value in errors.items():
+            full_key = f"{parent_key}.{key}" if parent_key else key
+            if isinstance(value, dict):
+                # Recursively format nested errors
+                messages.extend(format_errors(value, full_key))
+            else:
+                # Append error messages
+                messages.append(f"{full_key}: {', '.join(value)}")
+        return messages
+
+    return "\n".join(format_errors(validation_error.messages))

{scalable_pypeline-2.0.10.dist-info → scalable_pypeline-2.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: scalable-pypeline
-Version: 2.0.10
+Version: 2.1.0
 Summary: PypeLine - Python pipelines for the Real World
 Home-page: https://gitlab.com/bravos2/pypeline
 Author: Bravos Power Corporation

scalable_pypeline-2.1.0.dist-info/RECORD

@@ -0,0 +1,36 @@
+pypeline/__init__.py,sha256=Xybt2skBZamGMNlLuOX1IG-h4uIxqUDGAO8MIGWrJac,22
+pypeline/barrier.py,sha256=oO964l9qOCOibweOHyNivmAvufdXOke9nz2tdgclouo,1172
+pypeline/constants.py,sha256=coiF8dMP25qIwoNYSnS7oy7hCd4-5yqPFmdPsN93Q1A,2892
+pypeline/dramatiq.py,sha256=LWsl0o0t5FdxewIl87ARZKrNK0ENoYJEJAEVDSNFa40,12272
+pypeline/extensions.py,sha256=BzOTnXhNxap3N7uIUUh_hO6dDwx08Vc_RJDE93_K0Lo,610
+pypeline/pipeline_config_schema.py,sha256=hK2_egtg-YFx_XJDs_NyrOTGKkel7W83X-G0sic52sM,10592
+pypeline/pipeline_settings_schema.py,sha256=7zMXtBT_V4qom_j6JInRVPq0X1f1vQOgH33RNBaLo-o,12136
+pypeline/pypeline_yaml.py,sha256=Og08sUKwOjq7JYPnkg-NIcGbHravYCkC5Arz22rZEtA,16981
+pypeline/schedule_config_schema.py,sha256=vtZV-5wpGcAiYcXxdBPRkrjsbR6x_9E-1PC2elrKKbE,3611
+pypeline/flask/__init__.py,sha256=AdljRh0lMiS8ExgDmgzObwVs8jW7hqQuf83Ml8kn8GQ,491
+pypeline/flask/decorators.py,sha256=ki6jkjZwbDbCWuj7ET7N-ncZwrASp4Fy7257WIYiAAQ,1102
+pypeline/flask/flask_pypeline.py,sha256=Uqyu3PnSP3DoVZUJPqV9chjT4xdRgvcL3OMXxkbdTEg,5490
+pypeline/flask/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypeline/flask/api/pipelines.py,sha256=8Y5dkIVb32dMc0jBI7lB2sQgsAIe7WYmPn-G9tlUY5o,10161
+pypeline/flask/api/schedules.py,sha256=8PKCMdPucaer8opchNlI5aDssK2UqT79hHpeg5BMtTA,1210
+pypeline/pipelines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypeline/pipelines/factory.py,sha256=4HNGUJzYtgBOWP7fStXF0M61CYNAid9l9PGru9HyhXA,4115
+pypeline/pipelines/composition/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypeline/pipelines/composition/parallel_pipeline_composition.py,sha256=pTw9Xb9h4JnV4siFc3JStm5lB-i9djUADo3Kh5K3s7g,12976
+pypeline/pipelines/composition/pypeline_composition.py,sha256=ieTuQZ8zxTtvmPEkrWFbItjGtvO3JUotXcR-Jim2mss,7204
+pypeline/pipelines/middleware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypeline/pipelines/middleware/parallel_pipeline_middleware.py,sha256=kTp6niYoe2nXIiN6EGRfdpxrJyioo0GPxDkfefbGlEk,2821
+pypeline/pipelines/middleware/pypeline_middleware.py,sha256=kvt5A9OxDwpIo0PsH11Im62tH6VquUc6OFoZDw2Gxsk,8036
+pypeline/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypeline/utils/config_utils.py,sha256=rAIATyoW7kGETZ_Z2DqiXtGd7bJp5uPfcLtfNPOYsNs,2167
+pypeline/utils/dramatiq_utils.py,sha256=5GDcOvKY-8S8r---wb6Q8QAywhbKVJ-qILjcYNHei8Y,3658
+pypeline/utils/module_utils.py,sha256=-yEJIukDCoXnmlZVXB6Dww25tH6GdPE5SoFqv6pfdVU,3682
+pypeline/utils/pipeline_utils.py,sha256=kGP1QwCJikGC5QNRtzRXCDVewyRMpWIqERTNnxGLlSY,4795
+pypeline/utils/schema_utils.py,sha256=Fgl0y9Cuo_TZeEx_S3gaSVnLjn6467LTkjb2ek7Ms98,851
+tests/fixtures/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+scalable_pypeline-2.1.0.dist-info/LICENSE,sha256=DVQuDIgE45qn836wDaWnYhSdxoLXgpRRKH4RuTjpRZQ,10174
+scalable_pypeline-2.1.0.dist-info/METADATA,sha256=Oulf-ivIRF8QmuY4zeDajhjwgH_Ae7WMz_7BYO76HC0,5926
+scalable_pypeline-2.1.0.dist-info/WHEEL,sha256=bb2Ot9scclHKMOLDEHY6B2sicWOgugjFKaJsT7vwMQo,110
+scalable_pypeline-2.1.0.dist-info/entry_points.txt,sha256=uWs10ODfHSBKo2Cx_QaUjPHQTpZ3e77j9VlAdRRmMyg,119
+scalable_pypeline-2.1.0.dist-info/top_level.txt,sha256=C7dpkEOc_-nnsAQb28BfQknjD6XHRyS9ZrvVeoIbV7s,15
+scalable_pypeline-2.1.0.dist-info/RECORD,,

scalable_pypeline-2.0.10.dist-info/RECORD

@@ -1,27 +0,0 @@
-pypeline/__init__.py,sha256=QvVarwQu86KS14HXwAYbCqU1tjzA5eNjQxH2V34_iIU,23
-pypeline/barrier.py,sha256=dLDaprH5NB-C7MQjZqPpBBhMjmO0VV_kTonlgweznHc,1096
-pypeline/composition.py,sha256=pTw9Xb9h4JnV4siFc3JStm5lB-i9djUADo3Kh5K3s7g,12976
-pypeline/constants.py,sha256=coiF8dMP25qIwoNYSnS7oy7hCd4-5yqPFmdPsN93Q1A,2892
-pypeline/dramatiq.py,sha256=Y909HoNhH5Berd61N6nHrpE1dTU-zmvimH91SldP-SI,15912
-pypeline/extensions.py,sha256=BzOTnXhNxap3N7uIUUh_hO6dDwx08Vc_RJDE93_K0Lo,610
-pypeline/middleware.py,sha256=kTp6niYoe2nXIiN6EGRfdpxrJyioo0GPxDkfefbGlEk,2821
-pypeline/pipeline_config_schema.py,sha256=DQ_RMucnA0AyrndlW6lkb0orGromcO6C9GgLHyG6lJ0,8013
-pypeline/pypeline_yaml.py,sha256=Og08sUKwOjq7JYPnkg-NIcGbHravYCkC5Arz22rZEtA,16981
-pypeline/schedule_config_schema.py,sha256=vtZV-5wpGcAiYcXxdBPRkrjsbR6x_9E-1PC2elrKKbE,3611
-pypeline/flask/__init__.py,sha256=AdljRh0lMiS8ExgDmgzObwVs8jW7hqQuf83Ml8kn8GQ,491
-pypeline/flask/decorators.py,sha256=ki6jkjZwbDbCWuj7ET7N-ncZwrASp4Fy7257WIYiAAQ,1102
-pypeline/flask/flask_pypeline.py,sha256=Uqyu3PnSP3DoVZUJPqV9chjT4xdRgvcL3OMXxkbdTEg,5490
-pypeline/flask/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pypeline/flask/api/pipelines.py,sha256=RzRmSL5Zaia7ftXmXyDAC0ZAkPoFsvyefzHfIyWhRqk,8118
-pypeline/flask/api/schedules.py,sha256=31lwoFlGv-S-2ahGUCnD5YbmKws8yddj6_PEzzdBi9s,1321
-pypeline/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pypeline/utils/config_utils.py,sha256=rAIATyoW7kGETZ_Z2DqiXtGd7bJp5uPfcLtfNPOYsNs,2167
-pypeline/utils/module_utils.py,sha256=boEP9IYr4p_ick7HlVUfIxOYHQlEmo7dgvDBCQc-C28,2914
-pypeline/utils/pipeline_utils.py,sha256=tt71hLEFgPieokJZlC1rP2dmCTctrOPt7K1rGlbnT4o,5967
-tests/fixtures/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-scalable_pypeline-2.0.10.dist-info/LICENSE,sha256=DVQuDIgE45qn836wDaWnYhSdxoLXgpRRKH4RuTjpRZQ,10174
-scalable_pypeline-2.0.10.dist-info/METADATA,sha256=mFn_XkdRsU4d5oT48HAQNeP9wEUifs2-aWR43-3SG-4,5927
-scalable_pypeline-2.0.10.dist-info/WHEEL,sha256=bb2Ot9scclHKMOLDEHY6B2sicWOgugjFKaJsT7vwMQo,110
-scalable_pypeline-2.0.10.dist-info/entry_points.txt,sha256=uWs10ODfHSBKo2Cx_QaUjPHQTpZ3e77j9VlAdRRmMyg,119
-scalable_pypeline-2.0.10.dist-info/top_level.txt,sha256=C7dpkEOc_-nnsAQb28BfQknjD6XHRyS9ZrvVeoIbV7s,15
-scalable_pypeline-2.0.10.dist-info/RECORD,,