mage-ai 0.9.47__py3-none-any.whl → 0.9.48__py3-none-any.whl

mage_ai/api/presenters/PipelinePresenter.py

@@ -11,6 +11,7 @@ from mage_ai.data_preparation.models.project.constants import FeatureUUID
 class PipelinePresenter(BasePresenter):
     default_attributes = [
         'blocks',
+        'cache_block_output_in_memory',
         'concurrency_config',
         'created_at',
         'data_integration',

mage_ai/data_preparation/executors/block_executor.py

@@ -84,6 +84,8 @@ class BlockExecutor:
         self,
         analyze_outputs: bool = False,
         block_run_id: int = None,
+        block_run_outputs_cache: Dict[str, List] = None,
+        cache_block_output_in_memory: bool = False,
         callback_url: Union[str, None] = None,
         global_vars: Union[Dict, None] = None,
         input_from_output: Union[Dict, None] = None,
@@ -105,6 +107,10 @@ class BlockExecutor:
         Args:
             analyze_outputs: Whether to analyze the outputs of the block.
             block_run_id: The ID of the block run.
+            block_run_outputs_cache: block uuid to block outputs mapping. It's used when
+                cache_block_output_in_memory is set to True.
+            cache_block_output_in_memory: Whether to cache the block output in memory. By default,
+                the block output is persisted on disk.
             callback_url: The URL for the callback.
             global_vars: Global variables for the block execution.
             input_from_output: Input from the output of a previous block.
@@ -512,6 +518,8 @@ class BlockExecutor:
                         return self._execute(
                             analyze_outputs=analyze_outputs,
                             block_run_id=block_run_id,
+                            block_run_outputs_cache=block_run_outputs_cache,
+                            cache_block_output_in_memory=cache_block_output_in_memory,
                             callback_url=callback_url,
                             global_vars=global_vars,
                             update_status=update_status,
@@ -620,6 +628,8 @@ class BlockExecutor:
         self,
         analyze_outputs: bool = False,
         block_run_id: int = None,
+        block_run_outputs_cache: Dict[str, List] = None,
+        cache_block_output_in_memory: bool = False,
         callback_url: Union[str, None] = None,
         global_vars: Union[Dict, None] = None,
         update_status: bool = False,
@@ -640,7 +650,11 @@ class BlockExecutor:
 
         Args:
             analyze_outputs: Whether to analyze the outputs of the block.
+            block_run_outputs_cache: block uuid to block outputs mapping. It's used when
+                cache_block_output_in_memory is set to True.
             callback_url: The URL for the callback.
+            cache_block_output_in_memory: Whether to cache the block output in memory. By default,
+                the block output is persisted on disk.
             global_vars: Global variables for the block execution.
             update_status: Whether to update the status of the block execution.
             input_from_output: Input from the output of a previous block.
@@ -659,7 +673,10 @@ class BlockExecutor:
             logging_tags = dict()
 
         extra_options = {}
-        store_variables = True
+        if cache_block_output_in_memory:
+            store_variables = False
+        else:
+            store_variables = True
         is_data_integration = False
 
         if self.project.is_feature_enabled(FeatureUUID.DATA_INTEGRATION_IN_BATCH_PIPELINE):
@@ -957,6 +974,7 @@ class BlockExecutor:
 
         result = self.block.execute_sync(
             analyze_outputs=analyze_outputs,
+            block_run_outputs_cache=block_run_outputs_cache,
             execution_partition=self.execution_partition,
             global_vars=global_vars,
             logger=self.logger,
@@ -979,6 +997,7 @@ class BlockExecutor:
                 global_vars=global_vars,
                 logger=self.logger,
                 logging_tags=logging_tags,
+                outputs=result if cache_block_output_in_memory else None,
             )
         elif PipelineType.INTEGRATION != self.pipeline.type and \
                 (not is_data_integration or BlockLanguage.PYTHON == self.block.language):
@@ -987,6 +1006,7 @@ class BlockExecutor:
                 global_vars=global_vars,
                 logger=self.logger,
                 logging_tags=logging_tags,
+                outputs=result if cache_block_output_in_memory else None,
                 update_tests=False,
                 dynamic_block_uuid=dynamic_block_uuid,
             )

mage_ai/data_preparation/executors/pipeline_executor.py

@@ -89,7 +89,10 @@ class PipelineExecutor:
         if global_vars is None:
             global_vars = dict()
 
-        def create_block_task(block_run: BlockRun) -> asyncio.Task:
+        def create_block_task(
+            block_run: BlockRun,
+            block_run_outputs_cache: Dict[str, List],
+        ) -> asyncio.Task:
             async def execute_block() -> None:
                 executor_kwargs = dict(
                     pipeline=self.pipeline,
@@ -102,22 +105,34 @@ class PipelineExecutor:
                     block_run_data['started_at'] = datetime.now(tz=pytz.UTC)
 
                 block_run.update(**block_run_data)
-                BlockExecutor(**executor_kwargs).execute(
+                return BlockExecutor(**executor_kwargs).execute(
                     block_run_id=block_run.id,
+                    block_run_outputs_cache=block_run_outputs_cache,
+                    cache_block_output_in_memory=self.pipeline.cache_block_output_in_memory,
                     global_vars=global_vars,
                     pipeline_run_id=pipeline_run.id,
                 )
 
             return asyncio.create_task(execute_block())
 
+        block_run_outputs_cache = dict()
+
         while not pipeline_run.all_blocks_completed(allow_blocks_to_fail):
+            # Update the statuses of the block runs to CONDITION_FAILED or UPSTREAM_FAILED.
+            pipeline_run.update_block_run_statuses(pipeline_run.initial_block_runs)
             executable_block_runs = pipeline_run.executable_block_runs(
                 allow_blocks_to_fail=allow_blocks_to_fail,
             )
             if not executable_block_runs:
                 return
-            block_run_tasks = [create_block_task(b) for b in executable_block_runs]
-            await asyncio.gather(*block_run_tasks)
+            block_run_tasks = [
+                create_block_task(b, block_run_outputs_cache=block_run_outputs_cache)
+                for b in executable_block_runs]
+            block_run_outputs = await asyncio.gather(*block_run_tasks)
+            if self.pipeline.cache_block_output_in_memory:
+                for idx, block_run in enumerate(executable_block_runs):
+                    block_run_outputs_cache[block_run.block_uuid] = \
+                        block_run_outputs[idx].get('output', [])
 
     def build_tags(self, **kwargs):
         default_tags = dict(

mage_ai/data_preparation/models/block/__init__.py

@@ -978,6 +978,7 @@ class Block(DataIntegrationMixin, SparkBlock):
     def execute_sync(
         self,
         analyze_outputs: bool = False,
+        block_run_outputs_cache: Dict[str, List] = None,
         build_block_output_stdout: Callable[..., object] = None,
         custom_code: str = None,
         execution_partition: str = None,
@@ -1039,6 +1040,7 @@ class Block(DataIntegrationMixin, SparkBlock):
                 )
 
             output = self.execute_block(
+                block_run_outputs_cache=block_run_outputs_cache,
                 build_block_output_stdout=build_block_output_stdout,
                 custom_code=custom_code,
                 execution_partition=execution_partition,
@@ -1218,6 +1220,7 @@ class Block(DataIntegrationMixin, SparkBlock):
 
     def execute_block(
         self,
+        block_run_outputs_cache: Dict[str, List] = None,
         build_block_output_stdout: Callable[..., object] = None,
         custom_code: str = None,
         execution_partition: str = None,
@@ -1272,11 +1275,12 @@ class Block(DataIntegrationMixin, SparkBlock):
             else:
                 input_vars, kwargs_vars, upstream_block_uuids = self.fetch_input_variables(
                     input_args,
-                    execution_partition,
-                    global_vars,
+                    block_run_outputs_cache=block_run_outputs_cache,
                     dynamic_block_index=dynamic_block_index,
                     dynamic_upstream_block_uuids=dynamic_upstream_block_uuids,
+                    execution_partition=execution_partition,
                     from_notebook=from_notebook,
+                    global_vars=global_vars,
                 )
 
             outputs_from_input_vars = {}
@@ -1535,24 +1539,48 @@ class Block(DataIntegrationMixin, SparkBlock):
     def fetch_input_variables(
         self,
         input_args,
-        execution_partition: str = None,
-        global_vars: Dict = None,
+        block_run_outputs_cache: Dict[str, List] = None,
+        data_integration_settings_mapping: Dict = None,
         dynamic_block_index: int = None,
         dynamic_upstream_block_uuids: List[str] = None,
+        execution_partition: str = None,
         from_notebook: bool = False,
+        global_vars: Dict = None,
         upstream_block_uuids: List[str] = None,
-        data_integration_settings_mapping: Dict = None,
     ) -> Tuple[List, List, List]:
+        """
+        Fetch input variables for the current block's execution.
+
+        Args:
+            input_args: The input arguments required for the block's execution.
+            block_run_outputs_cache (Optional[Dict[str, List]]): A dictionary mapping block run
+                UUIDs to their outputs.
+            data_integration_settings_mapping (Optional[Dict]): A dictionary containing data
+                integration settings.
+            dynamic_block_index (Optional[int]): The index of the dynamic block, if applicable.
+            dynamic_upstream_block_uuids (Optional[List[str]]): The UUIDs of the dynamic upstream
+                blocks.
+            execution_partition (Optional[str]): The execution partition for the block.
+            from_notebook (Optional[bool]): A boolean indicating whether the execution is
+                triggered from a notebook.
+            global_vars (Optional[Dict]): A dictionary containing global variables.
+            upstream_block_uuids (Optional[List[str]]): List of UUIDs of upstream blocks.
+
+        Returns:
+            Tuple[List, List, List]: A tuple containing the input variables, kwargs variables, and
+                upstream block UUIDs.
+        """
         variables = fetch_input_variables(
             self.pipeline,
             upstream_block_uuids or self.upstream_block_uuids,
             input_args,
-            execution_partition,
-            global_vars,
-            dynamic_block_index,
-            dynamic_upstream_block_uuids,
-            from_notebook=from_notebook,
+            block_run_outputs_cache=block_run_outputs_cache,
             data_integration_settings_mapping=data_integration_settings_mapping,
+            dynamic_block_index=dynamic_block_index,
+            dynamic_upstream_block_uuids=dynamic_upstream_block_uuids,
+            execution_partition=execution_partition,
+            from_notebook=from_notebook,
+            global_vars=global_vars,
         )
 
         return variables
@@ -2292,6 +2320,7 @@ df = get_variable('{self.pipeline.uuid}', '{block_uuid}', 'df')
         global_vars: Dict = None,
         logger: Logger = None,
         logging_tags: Dict = None,
+        outputs: List[Any] = None,
         update_tests: bool = True,
         dynamic_block_uuid: str = None,
     ) -> None:
@@ -2321,12 +2350,13 @@ df = get_variable('{self.pipeline.uuid}', '{block_uuid}', 'df')
         else:
             test_functions = self.test_functions
 
-        outputs = self.get_raw_outputs(
-            dynamic_block_uuid or self.uuid,
-            execution_partition=execution_partition,
-            from_notebook=from_notebook,
-            global_vars=global_vars,
-        )
+        if outputs is None:
+            outputs = self.get_raw_outputs(
+                dynamic_block_uuid or self.uuid,
+                execution_partition=execution_partition,
+                from_notebook=from_notebook,
+                global_vars=global_vars,
+            )
 
         if logger and 'logger' not in global_vars:
             global_vars['logger'] = logger
@@ -3095,8 +3125,8 @@ class ConditionalBlock(AddonBlock):
             if parent_block is not None:
                 input_vars, kwargs_vars, _ = parent_block.fetch_input_variables(
                     None,
-                    execution_partition,
-                    global_vars,
+                    execution_partition=execution_partition,
+                    global_vars=global_vars,
                     dynamic_block_index=dynamic_block_index,
                     dynamic_upstream_block_uuids=dynamic_upstream_block_uuids,
                 )
@@ -3171,11 +3201,11 @@ class CallbackBlock(AddonBlock):
             # Fetch input variables
             input_vars, kwargs_vars, upstream_block_uuids = self.fetch_input_variables(
                 None,
-                execution_partition,
-                global_vars,
                 dynamic_block_index=dynamic_block_index,
                 dynamic_upstream_block_uuids=dynamic_upstream_block_uuids,
+                execution_partition=execution_partition,
                 from_notebook=from_notebook,
+                global_vars=global_vars,
                 upstream_block_uuids=[parent_block.uuid] if parent_block else None,
             )
 

mage_ai/data_preparation/models/block/data_integration/mixins.py

@@ -453,13 +453,13 @@ class DataIntegrationMixin:
         # Get the output as inputs for this block
         input_vars_fetched, kwargs_vars, up_block_uuids = self.fetch_input_variables(
             input_vars,
-            execution_partition,
-            global_vars,
+            data_integration_settings_mapping=data_integration_settings_mapping,
             dynamic_block_index=dynamic_block_index,
             dynamic_upstream_block_uuids=dynamic_upstream_block_uuids,
+            execution_partition=execution_partition,
             from_notebook=from_notebook,
+            global_vars=global_vars,
             upstream_block_uuids=block_uuids_to_fetch,
-            data_integration_settings_mapping=data_integration_settings_mapping,
         )
 
         if block_uuids_to_fetch and is_debug():
@@ -515,13 +515,13 @@ class DataIntegrationMixin:
                             kwargs_vars_inner, \
                             _up_block_uuids = self.fetch_input_variables(
                                 None,
-                                execution_partition,
-                                global_vars,
+                                data_integration_settings_mapping=data_integration_settings_mapping,
                                 dynamic_block_index=dynamic_block_index,
                                 dynamic_upstream_block_uuids=dynamic_upstream_block_uuids,
+                                execution_partition=execution_partition,
                                 from_notebook=from_notebook,
+                                global_vars=global_vars,
                                 upstream_block_uuids=[up_uuid],
-                                data_integration_settings_mapping=data_integration_settings_mapping,
                             )
 
                         if input_vars_inner:

mage_ai/data_preparation/models/block/data_integration/utils.py

@@ -662,11 +662,11 @@ def convert_block_output_data_for_destination(
     input_vars_fetched, _kwargs_vars, upstream_block_uuids = \
         block.fetch_input_variables(
             None,
-            partition,
-            global_vars,
             dynamic_block_index=dynamic_block_index,
             dynamic_upstream_block_uuids=dynamic_upstream_block_uuids,
+            execution_partition=partition,
             from_notebook=from_notebook,
+            global_vars=global_vars,
             upstream_block_uuids=[stream],
         )
 

mage_ai/data_preparation/models/block/sql/bigquery.py

@@ -29,8 +29,8 @@ def create_upstream_block_tables(
 
     input_vars, kwargs_vars, upstream_block_uuids = block.fetch_input_variables(
         None,
-        execution_partition,
-        None,
+        execution_partition=execution_partition,
+        global_vars=None,
         dynamic_block_index=dynamic_block_index,
         dynamic_upstream_block_uuids=dynamic_upstream_block_uuids,
     )

mage_ai/data_preparation/models/block/sql/snowflake.py

@@ -35,8 +35,8 @@ def create_upstream_block_tables(
 
     input_vars, kwargs_vars, upstream_block_uuids = block.fetch_input_variables(
         None,
-        execution_partition,
-        None,
+        execution_partition=execution_partition,
+        global_vars=None,
         dynamic_block_index=dynamic_block_index,
         dynamic_upstream_block_uuids=dynamic_upstream_block_uuids,
     )

mage_ai/data_preparation/models/block/sql/trino.py

@@ -32,8 +32,8 @@ def create_upstream_block_tables(
 
     input_vars, kwargs_vars, upstream_block_uuids = block.fetch_input_variables(
         None,
-        execution_partition,
-        None,
+        execution_partition=execution_partition,
+        global_vars=None,
         dynamic_block_index=dynamic_block_index,
         dynamic_upstream_block_uuids=dynamic_upstream_block_uuids,
     )

mage_ai/data_preparation/models/block/sql/utils/shared.py

@@ -370,8 +370,8 @@ def create_upstream_block_tables(
 
     input_vars, kwargs_vars, upstream_block_uuids = block.fetch_input_variables(
         None,
-        execution_partition,
-        None,
+        execution_partition=execution_partition,
+        global_vars=None,
         dynamic_block_index=dynamic_block_index,
         dynamic_upstream_block_uuids=dynamic_upstream_block_uuids,
     )

mage_ai/data_preparation/models/block/utils.py

@@ -647,12 +647,13 @@ def fetch_input_variables(
     pipeline,
     upstream_block_uuids: List[str],
     input_args: List[Any],
-    execution_partition: str = None,
-    global_vars: Dict = None,
+    block_run_outputs_cache: Dict[str, List] = None,
+    data_integration_settings_mapping: Dict = None,
     dynamic_block_index: int = None,
     dynamic_upstream_block_uuids: List[str] = None,
+    execution_partition: str = None,
     from_notebook: bool = False,
-    data_integration_settings_mapping: Dict = None,
+    global_vars: Dict = None,
 ) -> Tuple[List, List, List]:
     """
     Fetches the input variables for a block.
@@ -683,6 +684,7 @@ def fetch_input_variables(
             upstream_block_uuids_final = upstream_block_uuids
     elif pipeline is not None:
         input_vars = [None for i in range(len(upstream_block_uuids))]
+        # A mapping from upstream block UUID to a list of variable names
         input_variables_by_uuid = input_variables(
             pipeline,
             upstream_block_uuids,
@@ -695,6 +697,7 @@ def fetch_input_variables(
             input_args=input_args,
             data_integration_settings_mapping=data_integration_settings_mapping,
         )
+        # Block UUIDs
         keys = input_variables_by_uuid.keys()
         reduce_output_indexes = []
 
@@ -708,8 +711,10 @@ def fetch_input_variables(
                 input_vars[idx] = global_data_product.get_outputs()
                 continue
 
+            # Block output variables for upstream_block_uuid
             variables = input_variables_by_uuid[upstream_block_uuid]
 
+            # Fetch variable values
             if should_reduce:
                 variable_values = [reduce_output_from_block(
                     upstream_block,
@@ -722,19 +727,23 @@ def fetch_input_variables(
                     spark=spark,
                 ) for variable_uuid in variables]
             else:
-                variable_values = [
-                    pipeline.get_block_variable(
-                        upstream_block_uuid,
-                        var,
-                        from_notebook=from_notebook,
-                        global_vars=global_vars,
-                        input_args=input_args,
-                        partition=execution_partition,
-                        raise_exception=True,
-                        spark=spark,
-                    )
-                    for var in variables
-                ]
+                # Getting input variables from cache the cache is not empty
+                if block_run_outputs_cache:
+                    variable_values = block_run_outputs_cache.get(upstream_block_uuid, [])
+                else:
+                    variable_values = [
+                        pipeline.get_block_variable(
+                            upstream_block_uuid,
+                            var,
+                            from_notebook=from_notebook,
+                            global_vars=global_vars,
+                            input_args=input_args,
+                            partition=execution_partition,
+                            raise_exception=True,
+                            spark=spark,
+                        )
+                        for var in variables
+                    ]
 
             upstream_in_dynamic_upstream = False
             if dynamic_upstream_block_uuids:

mage_ai/data_preparation/models/pipeline.py

@@ -64,6 +64,8 @@ class Pipeline:
     def __init__(self, uuid, repo_path=None, config=None, repo_config=None, catalog=None):
         self.block_configs = []
         self.blocks_by_uuid = {}
+        # Can only be set True when run_pipeline_in_one_process is True
+        self.cache_block_output_in_memory = False
         self.concurrency_config = dict()
         self.created_at = None
         self.data_integration = None
@@ -507,6 +509,7 @@ class Pipeline:
         self.type = config.get('type') or self.type
 
         self.block_configs = config.get('blocks') or []
+        self.cache_block_output_in_memory = config.get('cache_block_output_in_memory', False)
         self.callback_configs = config.get('callbacks') or []
         self.concurrency_config = config.get('concurrency_config') or dict()
         self.conditional_configs = config.get('conditionals') or []
@@ -634,6 +637,7 @@ class Pipeline:
             updated_at = updated_at.isoformat()
 
         base = dict(
+            cache_block_output_in_memory=self.cache_block_output_in_memory,
             concurrency_config=self.concurrency_config,
             created_at=self.created_at,
             data_integration=self.data_integration if not exclude_data_integration else None,
@@ -865,6 +869,7 @@ class Pipeline:
                 should_update_block_cache = True
 
         for key in [
+            'cache_block_output_in_memory',
             'data_integration',
             'executor_type',
             'retry_config',

mage_ai/data_preparation/models/project/__init__.py

@@ -35,8 +35,6 @@ class Project():
         features = self.repo_config.features
 
         for uuid in FeatureUUID:
-            if FeatureUUID.GLOBAL_HOOKS == uuid:
-                continue
             key = uuid.value
             data[key] = features.get(key) if features else None
 

mage_ai/io/chroma.py

@@ -61,7 +61,6 @@ class Chroma(BaseIO):
             DataFrame: Data frame object loaded from the chroma query fuction.
             Chroma query function requries dictionary contains number of results matched.
         """
-        print(f"Testing data: {data}")
         converted_array = []
         if data[column_name] is None:
             for _ in range(item_length):
@@ -132,6 +131,8 @@ class Chroma(BaseIO):
         df: DataFrame,
         document_column: str,
         collection: str = None,
+        id_column: str = None,
+        metadata_column: str = None,
         **kwargs,
     ) -> None:
         """
@@ -143,11 +144,19 @@ class Chroma(BaseIO):
             df (DataFrame): Data frame to export.
             document_column (str): name of the document.
         """
-        docs = df[f'{document_column}'].tolist()
-        ids = [str(x) for x in df.index.tolist()]
+        docs = df[document_column].tolist()
+        if id_column is None:
+            ids = [str(x) for x in df.index.tolist()]
+        else:
+            ids = df[id_column].apply(str).tolist()
         collection_client = self.client.get_or_create_collection(
                 name=self.collection if collection is None else collection)
-        return collection_client.add(
+        insert_kwargs = dict(
             documents=docs,
             ids=ids,
         )
+        if metadata_column:
+            insert_kwargs['metadatas'] = df[metadata_column].tolist()
+        return collection_client.add(
+            **insert_kwargs
+        )

mage_ai/orchestration/db/models/schedules.py

@@ -902,6 +902,77 @@ class PipelineRun(BaseModel):
 
         return executable_block_runs
 
+    def update_block_run_statuses(self, block_runs: List['BlockRun']) -> None:
+        """Update the statuses of the block runs to CONDITION_FAILED or UPSTREAM_FAILED.
+
+        This method updates the statuses of the block runs based on the pipeline run's block runs.
+        It retrieves the block UUIDs for failed block runs and conditionally failed block runs.
+        It maps the block run statuses to their corresponding block UUIDs.
+
+        The method iterates overthe provided block runs and checks if their dynamic upstream block
+        UUIDs or upstream block UUIDs match the failed or conditionally failed block UUIDs.
+        * If there is a match, the block run's status is updated accordingly.
+        * If no updates are made for a block run, it is added to the list of not updated block runs.
+
+        The method refreshes the pipeline run and continues iterating through block runs until no
+        more updates can be made.
+
+        Args:
+            block_runs (List[BlockRun]): A list of block runs to update.
+
+        Returns:
+            None
+        """
+        pipeline = self.pipeline
+
+        failed_block_uuids = set(
+            b.block_uuid for b in self.block_runs
+            if b.status in [
+                BlockRun.BlockRunStatus.UPSTREAM_FAILED,
+                BlockRun.BlockRunStatus.FAILED,
+            ]
+        )
+        condition_failed_block_uuids = set(
+            b.block_uuid for b in self.block_runs
+            if b.status in [
+                BlockRun.BlockRunStatus.CONDITION_FAILED,
+            ]
+        )
+
+        statuses = {
+            BlockRun.BlockRunStatus.CONDITION_FAILED: condition_failed_block_uuids,
+            BlockRun.BlockRunStatus.UPSTREAM_FAILED: failed_block_uuids,
+        }
+        not_updated_block_runs = []
+        for block_run in block_runs:
+            updated_status = False
+            dynamic_upstream_block_uuids = block_run.metrics and block_run.metrics.get(
+                'dynamic_upstream_block_uuids',
+            )
+
+            for status, block_uuids in statuses.items():
+                upstream_block_uuids = []
+                if dynamic_upstream_block_uuids:
+                    upstream_block_uuids = dynamic_upstream_block_uuids
+                else:
+                    block = pipeline.get_block(block_run.block_uuid)
+                    if block:
+                        upstream_block_uuids = block.upstream_block_uuids
+                if any(
+                    b in block_uuids
+                    for b in upstream_block_uuids
+                ):
+                    block_run.update(status=status)
+                    updated_status = True
+
+            if not updated_status:
+                not_updated_block_runs.append(block_run)
+
+        self.refresh()
+        # keep iterating through block runs until no more updates can be made
+        if len(block_runs) != len(not_updated_block_runs):
+            self.update_block_run_statuses(not_updated_block_runs)
+
     @classmethod
     @safe_db_query
     def active_runs_for_pipelines(