scalable-pypeline 1.1.5__py2.py3-none-any.whl → 1.2.1__py2.py3-none-any.whl

pypeline/utils/task_utils.py

@@ -2,21 +2,20 @@
 """
 import os
 import logging
+import typing
 import uuid
 from typing import List, Any, Union
 from networkx.classes.digraph import DiGraph
-from celery import chain, signature, chord
+from celery import signature
 
 from pypeline.constants import DEFAULT_TASK_TTL, \
-    DEFAULT_REGULATOR_TASK, CHAIN_SUCCESS_MSG, CHAIN_FAILURE_MSG, \
-    PIPELINE_RUN_WRAPPER_CACHE_KEY, DEFAULT_SUCCESS_TASK, DEFAULT_RESULT_TTL, \
-    PIPELINE_RESULT_CACHE_KEY, DEFAULT_RETRY_TASK, DEFAULT_MAX_RETRY, \
-    DEFAULT_RETRY_TASK_MAX_TTL
-from pypeline.utils.graph_utils import get_execution_graph, get_chainable_tasks
-from pypeline.utils.config_utils import retrieve_latest_pipeline_config, \
-    load_json_config_from_redis, set_json_config_to_redis
+    PIPELINE_RUN_WRAPPER_CACHE_KEY, DEFAULT_RESULT_TTL, \
+    PIPELINE_RESULT_CACHE_KEY
+from pypeline.utils.graph_utils import get_execution_graph
+from pypeline.utils.config_utils import load_json_config_from_redis, set_json_config_to_redis
 from pypeline.pipeline_config_schema import PipelineConfigValidator
 
+
 logger = logging.getLogger(__name__)
 WORKER_NAME = os.environ.get('WORKER_NAME', None)
 
@@ -37,8 +36,7 @@ def get_service_config_for_worker(sermos_config: dict,
 
     service_config = sermos_config.get('serviceConfig', [])
     for service in service_config:
-        if service['serviceType'] == 'celery-worker' and service[
-                'name'] == worker_name:
+        if service['name'] == worker_name:
             return service
 
     raise ValueError('Could not find a service config for worker '
@@ -81,31 +79,31 @@ def get_task_signature(task_path: str,
         # If we still have None or 'default', set the default queue!
         if max_ttl in (None, 'default'):
             max_ttl = DEFAULT_TASK_TTL
-
+    task_id = str(uuid.uuid4())
     kwargs = {
         'event': {
             'access_key': access_key,
             'pipeline_id': pipeline_id,
-            'execution_id': execution_id
+            'execution_id': execution_id,
+            'task_id': task_id
         }
     }
     if custom_event_data is not None:
         kwargs['event'] = {**kwargs['event'], **custom_event_data}
 
-    # TODO where do we inject the 'event' data from sermos yaml schema?
-
     sig = signature(
         task_path,
         args=(),
         kwargs=kwargs,
         immutable=immutable,
-        task_id=str(uuid.uuid4()),
+        task_id=task_id,
         options={
             'queue': queue,
             'expires': 86400,  # Expire after 1 day. TODO make tunable.
             'soft_time_limit': max_ttl,
             'time_limit': max_ttl + 10,  # Add 10s buffer for cleanup
-        })
+        }
+    )
     return sig
 
 
@@ -127,6 +125,7 @@ class PipelineRunWrapper:
     """
     pipeline_id: str = None
     pipeline_config: dict = None  # Pipeline configuration in dictionary format
+    celery_task_status: dict = None # This tracks the state of tasks within the pipeline
     dag_config: dict = None
     execution_id: str = None
     current_event: dict = None  # For single task when from_event(). NOT cached.
@@ -187,7 +186,7 @@ class PipelineRunWrapper:
         during the .load() stage.
         """
         return ('pipeline_config', 'max_ttl', 'max_retry', 'retry_count',
-                'chain_payload', 'pipeline_id')
+                'chain_payload', 'pipeline_id', 'celery_task_status')
 
     def _load_from_cache(self, is_retry=False):
         """ Attempt to load this PipelineRunWrapper from cache.
@@ -215,6 +214,9 @@ class PipelineRunWrapper:
 
         return
 
+    def get_task_celery_status(self, task_id: type[uuid.uuid4()]) -> typing.Union[dict, None]:
+        return next(filter(lambda task: task["task_id"] == task_id, self.celery_task_status), None)
+
     def save_to_cache(self):
         """ Save current state of PipelineRunWrapper to cache, json serialized.
             Re-set the key's TTL
@@ -277,7 +279,8 @@ class PipelineRunWrapper:
                 # object purely for convenience and to provide logical defaults.
                 for key in self._cachable_keys:
                     if key in ('pipeline_config', 'pipeline_id', 'max_retry',
-                               'max_ttl', 'retry_count', 'chain_payload'):
+                               'max_retry', 'max_ttl', 'retry_count',
+                               'chain_payload', 'celery_task_status'):
                         continue
                     setattr(self, key, self.pipeline_config[key])
 
@@ -453,259 +456,6 @@ class PipelineResult:
         }
 
 
-class PipelineGenerator(object):
-    """ Allows an API endpoint to generate a functional pipeline based on the
-        requested pipeline id. Allows API to then issue the tasks asynchronously
-        to initiate the pipeline. Thereafter, celery will monitor status and
-        handle success/failure modes so the API web worker can return
-        immediately.
-
-        The primary purpose is to unpack the pipeline config, create the
-        requisite cached entities to track pipeline progress, and apply the
-        chained pipeline tasks asynchronously so Celery can take over.
-
-        Usage:
-            gen = PipelineGenerator(pipeline_id)
-            chain = gen.generate_chain()
-            chain.on_error(custom_error_task.s())  # Optional add error handling
-            chain.delay()
-    """
-    def __init__(self,
-                 pipeline_id: str,
-                 access_key: str = None,
-                 execution_id: str = None,
-                 queue: str = None,
-                 default_task_ttl: int = None,
-                 regulator_queue: str = None,
-                 regulator_task: str = None,
-                 success_queue: str = None,
-                 success_task: str = None,
-                 retry_task: str = None,
-                 add_retry: bool = True,
-                 default_max_retry: int = None,
-                 chain_payload: dict = None):
-        super().__init__()
-        self.pipeline_id = pipeline_id
-        self.access_key = access_key
-
-        pipeline_config_api_resp = retrieve_latest_pipeline_config(
-            pipeline_id=self.pipeline_id, access_key=self.access_key)
-
-        if pipeline_config_api_resp is None:
-            raise ValueError("Unable to load Pipeline Configuration for "
-                             f"pipeline id: {self.pipeline_id} ...")
-
-        # The only part of the API response used for any 'pipeline config'
-        # is the `config` key. The API nests it under `config` to preserve
-        # ability to add additional detail at a later date.
-        self.pipeline_config = pipeline_config_api_resp.get('config', {})
-        schema_version = pipeline_config_api_resp.get('schemaVersion')
-        PipelineConfigValidator(config_dict=self.pipeline_config,
-                                schema_version=schema_version)
-
-        self.execution_id = execution_id  # UUID string
-        self.good_to_go = False  # Indicates initialization/loading success
-        self.loading_message = None  # Allows access to success/error messages
-        self.is_retry = False if self.execution_id is None else True
-        self.add_retry = add_retry
-        self.retry_task = retry_task\
-            if retry_task is not None else DEFAULT_RETRY_TASK
-
-        self.default_max_retry = default_max_retry \
-            if default_max_retry is not None else \
-            self.pipeline_config['metadata'].get('maxRetry', DEFAULT_MAX_RETRY)
-
-        # Queue on which to place tasks by default and default TTL per task
-        # These can be overridden in PipelineConfig.config['taskDefinitions']
-        self.queue = queue \
-            if queue is not None \
-            else self.pipeline_config['metadata']['queue']
-        self.default_task_ttl = default_task_ttl \
-            if default_task_ttl is not None else \
-            self.pipeline_config['metadata'].get('maxTtl', DEFAULT_TASK_TTL)
-
-        # See docstring in self._get_regulator()
-        self.regulator_queue = regulator_queue \
-            if regulator_queue is not None \
-            else self.pipeline_config['metadata']['queue']
-        self.regulator_task = regulator_task\
-            if regulator_task is not None else DEFAULT_REGULATOR_TASK
-
-        # See docstring in self._get_success_task()
-        self.success_queue = success_queue \
-            if success_queue is not None \
-            else self.pipeline_config['metadata']['queue']
-        self.success_task = success_task\
-            if success_task is not None else DEFAULT_SUCCESS_TASK
-
-        # Optional data to pass to each step in chain
-        self.chain_payload = chain_payload\
-            if chain_payload is not None else {}
-
-        self.pipeline_wrapper = None  # Allows access to the PipelineRunWrapper
-        self.chain = None  # Must be intentionally built with generate_chain()
-
-        try:
-            # Generate our wrapper for this pipeline_id / execution_id
-            self.pipeline_wrapper = PipelineRunWrapper(
-                pipeline_id=self.pipeline_id,
-                pipeline_config=self.pipeline_config,
-                execution_id=self.execution_id,
-                max_ttl=self.default_task_ttl,
-                max_retry=self.default_max_retry,
-                chain_payload=self.chain_payload)
-
-            # Loads pipeline config from remote or cache if it's already there
-            # `is_retry` will be True for any PipelineGenerator instantiated
-            # with an execution_id. This flag helps the wrapper increment the
-            # retry count and determine if this should be deadlettered.
-            # This step also saves the valid/initialized run wrapper to cache.
-            self.pipeline_wrapper.load(is_retry=self.is_retry)
-
-            # Set all variables that were established from the run wrapper
-            # initialization. Notably, default_task_ttl can be overloaded
-            # if the pipeline config has an explicit maxTtl set in metadata.
-            self.good_to_go = self.pipeline_wrapper.good_to_go
-            self.loading_message = self.pipeline_wrapper.loading_message
-            self.execution_id = self.pipeline_wrapper.execution_id
-
-        except Exception as e:
-            fail_msg = "Failed to load Pipeline for id {} ... {}".format(
-                self.pipeline_id, e)
-            self.loading_message = fail_msg
-            logger.error(fail_msg)
-            raise e
-
-    def _get_regulator(self):
-        """ Create a chain regulator celery task signature.
-
-            For a chain(), if each element is a group() then celery does not
-            properly adhere to the chain elements occurring sequentially. If you
-            insert a task that is not a group() in between, though, then the
-            chain operates as expected.
-        """
-        return signature(self.regulator_task,
-                         queue=self.regulator_queue,
-                         immutable=True)
-
-    def _get_success_task(self):
-        """ A final 'success' task that's added to the end of every pipeline.
-
-            This stores the 'success' state in the cached result. Users can
-            set other values by using TaskRunner().save_result()
-        """
-        return get_task_signature(task_path=self.success_task,
-                                  queue=self.success_queue,
-                                  pipeline_id=self.pipeline_id,
-                                  execution_id=self.execution_id)
-
-    def _get_retry_task(self):
-        """ The retry task will re-invoke a chain.
-        """
-        return get_task_signature(task_path=self.retry_task,
-                                  queue=self.queue,
-                                  access_key=self.access_key,
-                                  pipeline_id=self.pipeline_id,
-                                  execution_id=self.execution_id,
-                                  max_ttl=DEFAULT_RETRY_TASK_MAX_TTL,
-                                  custom_event_data={
-                                      'queue': self.queue,
-                                      'default_task_ttl':
-                                      self.default_task_ttl,
-                                      'add_retry': self.add_retry,
-                                      'chain_payload': self.chain_payload
-                                  })
-
-    def _get_signature(self, node):
-        """ Create a celery task signature based on a graph node.
-        """
-        metadata = self.pipeline_config['metadata']
-        node_config = self.pipeline_config['taskDefinitions'][node]
-
-        # Node config takes precedence, pipeline metadata as default
-        queue = node_config.get('queue', metadata['queue'])
-        max_ttl = node_config.get('maxTtl', metadata.get('maxTtl', None))
-
-        # Ensures task signatures include requisite information to retrieve
-        # PipelineRunWrapper from cache using the pipeline id, and execution id.
-        # We set immutable=True to ensure each client task can be defined
-        # with this specific signature (event)
-        # http://docs.celeryproject.org/en/master/userguide/canvas.html#immutability
-        return get_task_signature(task_path=node_config.get('handler'),
-                                  queue=queue,
-                                  access_key=self.access_key,
-                                  pipeline_id=self.pipeline_id,
-                                  execution_id=self.execution_id,
-                                  max_ttl=max_ttl,
-                                  immutable=True,
-                                  task_config=node_config)
-
-    def generate_chain(self):
-        """ Generate the full pipeline chain.
-        """
-        logger.debug(f'Starting Pipeline {self.pipeline_id}')
-
-        if not self.good_to_go:
-            logger.info("Chain deemed to be not good to go.")
-            if self.loading_message is None:
-                self.loading_message = CHAIN_FAILURE_MSG
-            return None
-
-        try:
-            # Create the task chain such that all concurrent tasks are grouped
-            # and all high level node groups are run serially
-            G = self.pipeline_wrapper.execution_graph
-
-            total_tasks = 0
-            pipeline_chain = []
-            chainable_tasks = get_chainable_tasks(G, None, [])
-
-            # Current chord+chain solution based on
-            # https://stackoverflow.com/questions/15123772/celery-chaining-groups-and-subtasks-out-of-order-execution
-            # Look also at last comment from Nov 7, 2017 here
-            # https://github.com/celery/celery/issues/3597
-            # Big outstanding bug in Celery related to failures in chords that
-            # results in really nasty log output. See
-            # https://github.com/celery/celery/issues/4834
-            for i, node_group in enumerate(chainable_tasks):
-                total_tasks += len(node_group)
-                this_group = []
-                for node in node_group:
-                    node_signature = self._get_signature(node)
-                    this_group.append(node_signature)
-
-                if len(this_group) <= 1:
-                    this_group.append(self._get_regulator())
-
-                the_chord = chord(header=this_group,
-                                  body=self._get_regulator())
-
-                pipeline_chain.append(the_chord)
-
-            # Add a 'finished/success' task to the end of all pipelines
-            pipeline_chain.append(
-                chord(header=self._get_success_task(),
-                      body=self._get_regulator()))
-
-            the_chain = chain(*pipeline_chain)
-
-            # Add retry
-            if self.add_retry:
-                the_chain.link_error(self._get_retry_task())
-
-            self.loading_message = CHAIN_SUCCESS_MSG
-
-            self.chain = the_chain
-        except Exception as e:
-            self.loading_message = CHAIN_FAILURE_MSG + " {}".format(e)
-            logger.exception(e)
-            the_chain = None
-
-        self.chain = the_chain
-
-        return the_chain
-
-
 class TaskRunner:
     """ Run tasks in Sermos
     """
@@ -737,7 +487,6 @@ class TaskRunner:
                     If not specified, system default is used.
         """
         try:
-            # TODO consider whether to add access key/deployment id here
             worker = get_task_signature(task_path=task_path,
                                         queue=queue,
                                         max_ttl=max_ttl,
@@ -789,7 +538,7 @@ class TaskRunner:
                             grouping_key:
                             task_payload_list[idx:idx + max_per_task]
                         }
-                        # TODO consider whether to add access key/deployment id here
+
                         worker = get_task_signature(
                             task_path=task_path,
                             queue=queue,

{scalable_pypeline-1.1.5.dist-info → scalable_pypeline-1.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: scalable-pypeline
-Version: 1.1.5
+Version: 1.2.1
 Summary: PypeLine - Python pipelines for the Real World
 Home-page: https://gitlab.com/bravos2/pypeline
 Author: Bravos Power Corporation
@@ -27,19 +27,21 @@ Requires-Dist: awscli (>=1.11) ; extra == 'dev'
 Requires-Dist: pylint (>=2.5.3) ; extra == 'dev'
 Requires-Dist: pip-licenses ; extra == 'dev'
 Provides-Extra: flask
-Requires-Dist: Flask (>=1.1.1) ; extra == 'flask'
-Requires-Dist: flask-smorest (>=0.23.0) ; extra == 'flask'
+Requires-Dist: Werkzeug (==2.0.3) ; extra == 'flask'
+Requires-Dist: Flask (<2,>=1.1.2) ; extra == 'flask'
+Requires-Dist: flask-smorest (<0.29,>=0.23.0) ; extra == 'flask'
+Requires-Dist: Jinja2 (==3.0.3) ; extra == 'flask'
 Provides-Extra: test
 Requires-Dist: pytest-cov (<3,>=2.6.1) ; extra == 'test'
 Requires-Dist: tox (<4,>=3.14.1) ; extra == 'test'
 Requires-Dist: mock (<2,>=1) ; extra == 'test'
-Requires-Dist: moto (<2,>=1.3.16) ; extra == 'test'
+Requires-Dist: moto (>=1.3.16) ; extra == 'test'
 Requires-Dist: responses (<0.11,>=0.10.16) ; extra == 'test'
 Requires-Dist: fakeredis (<3,>=2.10.3) ; extra == 'test'
 Requires-Dist: importlib-metadata (<5,>=4.12) ; extra == 'test'
 Provides-Extra: web
 Requires-Dist: gunicorn ; extra == 'web'
-Requires-Dist: gevent ; extra == 'web'
+Requires-Dist: gevent (<22,>=21.12.0) ; extra == 'web'
 Provides-Extra: workers
 Requires-Dist: celery[redis] (<6,>=5.1.2) ; extra == 'workers'
 Requires-Dist: networkx (>=2.4) ; extra == 'workers'

{scalable_pypeline-1.1.5.dist-info → scalable_pypeline-1.2.1.dist-info}/RECORD

@@ -1,30 +1,33 @@
-pypeline/__init__.py,sha256=hTCioFruYR1lv7FF57n5II-8lYry8FuIYb1fA4g2ccc,22
-pypeline/celery.py,sha256=lsvnb4NSZW84mGG2aur_LoqK_oVcagexRRZiIzyQAUg,11499
+pypeline/__init__.py,sha256=kmfHpHo2YhSrigutlRQs8qXIR8nEm-D-c8lScQQN64M,22
+pypeline/celery.py,sha256=rbMCQQqevhdcyFYJSyoQT2b_NAbL3Inc9S789AtzN_w,9038
 pypeline/celery_beat.py,sha256=KNmEpZEFOadVTwtRJtgX0AirSSNq65PFLJer4Hsq-xw,10759
-pypeline/constants.py,sha256=EndrXrXr8Ef_tlOCmuQp-yFe2JI-MyDt02Hww3_X73k,4191
+pypeline/constants.py,sha256=VxCIBXpEsXiLxDN3PV2pxNd3bx6Gfpk3g1nTI3XMxUI,4185
 pypeline/extensions.py,sha256=_tv62NtJDrwQUM9mablHUmYyBf8TXlIZmf1LM1rlHtc,599
 pypeline/generators.py,sha256=kRcJCohOMMljar6_nAaICTdNX1cNGyfkSvtl52Pd_hc,6776
 pypeline/logging_config.py,sha256=QbUbSqLtxUOlqLkY0sWxVe9VGFKjghZ-MrlduZmtgLw,5503
-pypeline/pipeline_config_schema.py,sha256=uG-NtOZAYbdI6cvVJ8OCpORN-6mMta9kwvKI6U_PzW4,6763
+pypeline/pipeline_config_schema.py,sha256=wmUCpCDOXPj5-qTNd6oHC1XszfQfXZLr9_DYmjHzK3o,8691
 pypeline/schedule_config_schema.py,sha256=rGN-tGC9fj-Nc_CVasBUQAOzn2OvYyj0V_S6Az3sq6I,7385
-pypeline/sermos_yaml.py,sha256=olo-Tb5jqGSk186_1GVCAsOgGBM7k36y6AOVvbDsesg,29081
+pypeline/sermos_yaml.py,sha256=A0rFabU0ib9-IY64HZuYvB7sL06sTl84myTYmNSLK3g,17336
 pypeline/flask/__init__.py,sha256=_kh1kQcpuU7yNYH36AtMsaCMYru5l43lYsRBe0lTgKE,523
 pypeline/flask/decorators.py,sha256=zH9OB6DqxLUDSDBMs1Nd3Pt3qYdsAOoD8RL2MliRyRs,2298
 pypeline/flask/flask_sermos.py,sha256=D-mTlJENm8MCYgNmCFwHeZb43XoUBsTO8ER1YqnSL3M,5791
 pypeline/flask/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pypeline/flask/api/pipelines.py,sha256=SjF2hZnlcykUr6bMtZJRGdXZEBJ9v6LQ86wrhSM9P6I,8295
+pypeline/flask/api/pipelines.py,sha256=l12HnLC6GQfF6cd5gEnQjIgzO7xajZtidJ04JQMIwn8,8821
 pypeline/flask/api/schedules.py,sha256=AHiGYzZL__1sq5KZho75VwPWCn9Pz_ooNM179uKuQ7Q,2314
-pypeline/flask/api/utils.py,sha256=6sYy8efvKXQO8QCPpq4cE2eIlJlgAgDtiA9duwzJFO4,1389
+pypeline/flask/api/utils.py,sha256=bkUBZIbJHaG9nYahHI2J0NqoqoSlQ6j4aArY9q2ggqE,1302
+pypeline/pipeline/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pypeline/pipeline/chained_task.py,sha256=G7pakmdUZK29E9X3_I5I2cTxTcEuRlXi_BeDAMJt8Qg,2961
+pypeline/pipeline/generator.py,sha256=Nt65IIs5jc2XCQqWUaOoJIdpaEvQvxJgQSnj9DuYX3s,11509
 pypeline/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pypeline/utils/config_utils.py,sha256=SwpYy6Xk2apDK2GEb61ctHJh7q8IUo3bHOegE_xsDDk,13029
 pypeline/utils/graph_utils.py,sha256=prs0ATCYCxWGWx8s9_gg3PtwJA1DORIIwUlMfKRjHJM,4642
 pypeline/utils/module_utils.py,sha256=X4O2TdBvvoboK6PxzK18UuKbod9l2BfTIrALk_dI0tM,4166
-pypeline/utils/task_utils.py,sha256=CQQZT1OXKKadPtQRCrps5OGxwX74s18k4IZMWBISeOo,33793
+pypeline/utils/task_utils.py,sha256=p66d4xcuPuBsqtcnaXgqfNXU3-ZSe4lvN11MkJ5_8XY,22222
 tests/fixtures/__init__.py,sha256=vHbv5BMJXGb6XX764sChg5Ax7fixPuijiYNBuxgVTUQ,41
 tests/fixtures/s3_fixtures.py,sha256=jbsp0WeIibLtjdV1nPSkEuJf1n6e9O7LO-kNFkMqylo,1694
-scalable_pypeline-1.1.5.dist-info/LICENSE,sha256=DVQuDIgE45qn836wDaWnYhSdxoLXgpRRKH4RuTjpRZQ,10174
-scalable_pypeline-1.1.5.dist-info/METADATA,sha256=-9G7GWC3voH2OCEZrC8Fhm4AVR_bCJEbqatShTIgD3k,6048
-scalable_pypeline-1.1.5.dist-info/WHEEL,sha256=bb2Ot9scclHKMOLDEHY6B2sicWOgugjFKaJsT7vwMQo,110
-scalable_pypeline-1.1.5.dist-info/entry_points.txt,sha256=ZDh7vdDaHrZD0RwUCiZidXg5-d2fBOYcEo7E6CL4g0U,56
-scalable_pypeline-1.1.5.dist-info/top_level.txt,sha256=C7dpkEOc_-nnsAQb28BfQknjD6XHRyS9ZrvVeoIbV7s,15
-scalable_pypeline-1.1.5.dist-info/RECORD,,
+scalable_pypeline-1.2.1.dist-info/LICENSE,sha256=DVQuDIgE45qn836wDaWnYhSdxoLXgpRRKH4RuTjpRZQ,10174
+scalable_pypeline-1.2.1.dist-info/METADATA,sha256=kczf4M1kyCRZFFbeV4jDKltmHCnmRAMwCjyXxKN8EoY,6174
+scalable_pypeline-1.2.1.dist-info/WHEEL,sha256=bb2Ot9scclHKMOLDEHY6B2sicWOgugjFKaJsT7vwMQo,110
+scalable_pypeline-1.2.1.dist-info/entry_points.txt,sha256=ZDh7vdDaHrZD0RwUCiZidXg5-d2fBOYcEo7E6CL4g0U,56
+scalable_pypeline-1.2.1.dist-info/top_level.txt,sha256=C7dpkEOc_-nnsAQb28BfQknjD6XHRyS9ZrvVeoIbV7s,15
+scalable_pypeline-1.2.1.dist-info/RECORD,,