mage-ai 0.9.69__py3-none-any.whl → 0.9.71__py3-none-any.whl

mage_ai/orchestration/db/models/schedules_project_platform.py

@@ -39,13 +39,22 @@ class PipelineScheduleProjectPlatformMixin:
     def repo_query_project_platform(cls):
         repo_paths = []
 
-        queries = Project().repo_path_for_database_query('pipeline_schedules')
+        context_data = dict()
+        queries = Project(
+            context_data=context_data,
+        ).repo_path_for_database_query('pipeline_schedules')
         if queries:
             repo_paths.extend(queries)
 
-        repo_paths.extend([d.get(
-            'full_path',
-        ) for d in build_repo_path_for_all_projects(mage_projects_only=True).values()])
+        repo_paths.extend([
+            d.get(
+                'full_path',
+            )
+            for d in build_repo_path_for_all_projects(
+                context_data=context_data,
+                mage_projects_only=True,
+            ).values()
+        ])
 
         return cls.query.filter(
             or_(
@@ -149,14 +158,11 @@ class PipelineScheduleProjectPlatformMixin:
 
         pipeline_use = pipeline or self.pipeline
         if not pipeline_use:
-            try:
-                Pipeline.get(self.pipeline_uuid)
-            except Exception:
-                print(
-                    f'[WARNING] Pipeline {self.pipeline_uuid} cannot be found '
-                    + f'for pipeline schedule ID {self.id}.',
-                )
-                return False
+            print(
+                f'[WARNING] Pipeline {self.pipeline_uuid} cannot be found '
+                + f'for pipeline schedule ID {self.id}.',
+            )
+            return False
 
         if self.schedule_interval == ScheduleInterval.ONCE:
             pipeline_run_count = self.pipeline_runs_count

mage_ai/orchestration/db/models/utils.py

@@ -1,13 +1,14 @@
 from mage_ai.orchestration.db import db_connection, safe_db_query
-from mage_ai.orchestration.db.models.schedules import (
-    Backfill,
-    PipelineRun,
-    PipelineSchedule,
-)
 
 
 @safe_db_query
 def transfer_related_models_for_pipeline(old_uuid: str, new_uuid: str):
+    from mage_ai.orchestration.db.models.schedules import (
+        Backfill,
+        PipelineRun,
+        PipelineSchedule,
+    )
+
     # Migrate pipeline schedules
     PipelineSchedule.query.filter(PipelineSchedule.pipeline_uuid == old_uuid).update({
         PipelineSchedule.pipeline_uuid: new_uuid
@@ -21,3 +22,43 @@ def transfer_related_models_for_pipeline(old_uuid: str, new_uuid: str):
         Backfill.pipeline_uuid: new_uuid
     }, synchronize_session=False)
     db_connection.session.commit()
+
+
+@safe_db_query
+def get_active_project_for_user(user, root_project_uuid: str) -> str:
+    from mage_ai.orchestration.db.models.projects import UserProject
+    return UserProject.query.filter(
+        UserProject.user_id == user.id,
+        UserProject.root_project_uuid == root_project_uuid,
+        UserProject.active.is_(True),
+    ).one_or_none()
+
+
+@safe_db_query
+def activate_project_for_user(user, root_project_uuid: str, project_name: str):
+    from mage_ai.orchestration.db.models.projects import UserProject
+    projects = UserProject.query.filter(
+        UserProject.user_id == user.id,
+        UserProject.root_project_uuid == root_project_uuid,
+    )
+
+    projects.update({
+        UserProject.active: False
+    }, synchronize_session=False)
+
+    project_updated = False
+    for project in projects:
+        if project.project_name == project_name:
+            project.update(active=True, commit=False)
+            project_updated = True
+
+    if not project_updated:
+        UserProject.create(
+            user_id=user.id,
+            root_project_uuid=root_project_uuid,
+            project_name=project_name,
+            active=True,
+            commit=False,
+        )
+
+    db_connection.session.commit()

mage_ai/orchestration/metrics/pipeline_run.py

@@ -4,9 +4,6 @@ from copy import deepcopy
 from typing import Dict, List, Tuple
 
 from mage_ai.data_preparation.models.constants import PipelineType
-from mage_ai.data_preparation.models.pipelines.integration_pipeline import (
-    IntegrationPipeline,
-)
 from mage_ai.orchestration.db.models.schedules import BlockRun, PipelineRun
 from mage_ai.shared.hash import merge_dict
 
@@ -40,6 +37,7 @@ KEY_TO_METRICS = {
 
 def calculate_pipeline_run_metrics(
     pipeline_run: PipelineRun,
+    pipeline,
     logger=None,
     logging_tags: Dict = None,
 ) -> Dict:
@@ -54,7 +52,7 @@ def calculate_pipeline_run_metrics(
             **logging_tags,
         )
     try:
-        __calculate_metrics(pipeline_run)
+        __calculate_metrics(pipeline_run, pipeline)
         if logger:
             logger.info(
                 f'Calculate metrics for pipeline run {pipeline_run.id} completed.',
@@ -72,6 +70,7 @@ def calculate_pipeline_run_metrics(
 def calculate_source_metrics(
     pipeline_run: PipelineRun,
     block_run: BlockRun,
+    pipeline,
     stream: str,
     logger=None,
     logging_tags: Dict = None,
@@ -79,6 +78,7 @@ def calculate_source_metrics(
     return __calculate_block_metrics(
         pipeline_run,
         block_run,
+        pipeline,
         stream,
         KEY_SOURCE,
         logger=logger,
@@ -89,6 +89,7 @@ def calculate_source_metrics(
 def calculate_destination_metrics(
     pipeline_run: PipelineRun,
     block_run: BlockRun,
+    pipeline,
     stream: str,
     logger=None,
     logging_tags: Dict = None,
@@ -96,6 +97,7 @@ def calculate_destination_metrics(
     return __calculate_block_metrics(
         pipeline_run,
         block_run,
+        pipeline,
         stream,
         KEY_DESTINATION,
         logger=logger,
@@ -106,6 +108,7 @@ def calculate_destination_metrics(
 def __calculate_block_metrics(
     pipeline_run: PipelineRun,
     block_run: BlockRun,
+    pipeline,
     stream: str,
     key: str,
     logger=None,
@@ -135,8 +138,6 @@ def __calculate_block_metrics(
             **logging_tags,
         )
     try:
-        pipeline = IntegrationPipeline.get(pipeline_run.pipeline_uuid)
-
         logs_arr = block_run.logs['content'].split('\n')
         logs_by_uuid = {key: [logs_arr]}
         metrics = get_metrics(
@@ -192,7 +193,7 @@ def __calculate_block_metrics(
             )
 
 
-def __calculate_metrics(pipeline_run: PipelineRun) -> Dict:
+def __calculate_metrics(pipeline_run: PipelineRun, pipeline) -> Dict:
     """
     Calculate metrics for an integration pipeline run. Only the "pipeline" field
     in the metrics will be updated by calling this method.
@@ -205,8 +206,6 @@ def __calculate_metrics(pipeline_run: PipelineRun) -> Dict:
     Returns:
         Dict: The calculated metrics.
     """
-    pipeline = IntegrationPipeline.get(pipeline_run.pipeline_uuid)
-
     if PipelineType.INTEGRATION != pipeline.type:
         return
 

mage_ai/orchestration/notification/sender.py

@@ -1,4 +1,5 @@
 import os
+import traceback
 from typing import Dict
 
 from mage_ai.orchestration.notification.config import (
@@ -61,33 +62,54 @@ class NotificationSender:
         if summary is None:
             return
         if self.config.slack_config is not None and self.config.slack_config.is_valid:
-            send_slack_message(self.config.slack_config, details or summary, title)
+            try:
+                send_slack_message(self.config.slack_config, details or summary, title)
+            except Exception:
+                traceback.print_exc()
 
         if self.config.teams_config is not None and self.config.teams_config.is_valid:
-            send_teams_message(self.config.teams_config, summary)
+            try:
+                send_teams_message(self.config.teams_config, summary)
+            except Exception:
+                traceback.print_exc()
 
         if self.config.discord_config is not None and self.config.discord_config.is_valid:
-            send_discord_message(self.config.discord_config, summary, title)
+            try:
+                send_discord_message(self.config.discord_config, summary, title)
+            except Exception:
+                traceback.print_exc()
 
         if self.config.telegram_config is not None and self.config.telegram_config.is_valid:
-            send_telegram_message(self.config.telegram_config, summary, title)
+            try:
+                send_telegram_message(self.config.telegram_config, summary, title)
+            except Exception:
+                traceback.print_exc()
 
         if self.config.google_chat_config is not None and self.config.google_chat_config.is_valid:
-            send_google_chat_message(self.config.google_chat_config, summary)
+            try:
+                send_google_chat_message(self.config.google_chat_config, summary)
+            except Exception:
+                traceback.print_exc()
 
         if self.config.email_config is not None and title is not None:
-            send_email(
-                self.config.email_config,
-                subject=title,
-                message=details or summary,
-            )
+            try:
+                send_email(
+                    self.config.email_config,
+                    subject=title,
+                    message=details or summary,
+                )
+            except Exception:
+                traceback.print_exc()
 
         if self.config.opsgenie_config is not None and self.config.opsgenie_config.is_valid:
-            send_opsgenie_alert(
-                self.config.opsgenie_config,
-                message=title,
-                description=details or summary,
-            )
+            try:
+                send_opsgenie_alert(
+                    self.config.opsgenie_config,
+                    message=title,
+                    description=details or summary,
+                )
+            except Exception:
+                traceback.print_exc()
 
     def send_pipeline_run_success_message(self, pipeline, pipeline_run) -> None:
         if AlertOn.PIPELINE_RUN_SUCCESS in self.config.alert_on:
@@ -157,6 +179,7 @@ class NotificationSender:
             pipeline_run_url=self.__pipeline_run_url(pipeline, pipeline_run),
             pipeline_schedule_id=pipeline_run.pipeline_schedule.id,
             pipeline_schedule_name=pipeline_run.pipeline_schedule.name,
+            pipeline_schedule_description=pipeline_run.pipeline_schedule.description,
             pipeline_uuid=pipeline.uuid,
             stacktrace=stacktrace,
         )

mage_ai/orchestration/pipeline_scheduler_original.py

@@ -23,7 +23,7 @@ from mage_ai.data_preparation.models.triggers import (
     ScheduleInterval,
     ScheduleStatus,
     ScheduleType,
-    get_triggers_by_pipeline,
+    get_triggers_by_pipeline_with_cache,
 )
 from mage_ai.data_preparation.repo_manager import get_repo_config
 from mage_ai.data_preparation.sync.git_sync import get_sync_config
@@ -155,10 +155,12 @@ class PipelineScheduler:
                 if is_integration:
                     clear_source_output_files(
                         self.pipeline_run,
+                        self.pipeline,
                         self.logger,
                     )
                     initialize_state_and_runs(
                         self.pipeline_run,
+                        self.pipeline,
                         self.logger,
                         self.pipeline_run.get_variables(),
                     )
@@ -228,6 +230,7 @@ class PipelineScheduler:
                     tags = self.build_tags()
                     calculate_pipeline_run_metrics(
                         self.pipeline_run,
+                        self.pipeline,
                         logger=self.logger,
                         logging_tags=tags,
                     )
@@ -284,8 +287,7 @@ class PipelineScheduler:
                     or PipelineRun.PipelineRunStatus.FAILED
                 )
                 self.pipeline_run.update(status=status)
-
-                self.on_pipeline_run_failure('Pipeline run timed out.')
+                self.on_pipeline_run_failure('Pipeline run timed out.', status=status)
             elif self.pipeline_run.any_blocks_failed() and not self.allow_blocks_to_fail:
                 self.pipeline_run.update(
                     status=PipelineRun.PipelineRunStatus.FAILED)
@@ -318,30 +320,38 @@ class PipelineScheduler:
                     self.__schedule_blocks(block_runs)
 
     @safe_db_query
-    def on_pipeline_run_failure(self, error_msg: str) -> None:
-        failed_block_runs = self.pipeline_run.failed_block_runs
-        stacktrace = None
-        for br in failed_block_runs:
-            if br.metrics:
-                message = br.metrics.get('error', {}).get('message')
-                if message:
-                    message_split = message.split('\n')
-                    # Truncate the error message if it has too many lines, set max
-                    # lines at 50
-                    if len(message_split) > 50:
-                        message_split = message_split[-50:]
-                        message_split.insert(0, '... (error truncated)')
-                    message = '\n'.join(message_split)
-                    stacktrace = f'Error for block {br.block_uuid}:\n{message}'
-                    break
-
+    def on_pipeline_run_failure(
+        self,
+        error_msg: str,
+        status=PipelineRun.PipelineRunStatus.FAILED,
+    ) -> None:
         asyncio.run(UsageStatisticLogger().pipeline_run_ended(self.pipeline_run))
-        self.notification_sender.send_pipeline_run_failure_message(
-            pipeline=self.pipeline,
-            pipeline_run=self.pipeline_run,
-            error=error_msg,
-            stacktrace=stacktrace,
-        )
+
+        if status == PipelineRun.PipelineRunStatus.FAILED:
+            # Only send notification when pipeline run status is FAILED
+            failed_block_runs = self.pipeline_run.failed_block_runs
+            stacktrace = None
+            for br in failed_block_runs:
+                if br.metrics:
+                    message = br.metrics.get('error', {}).get('message')
+                    if message:
+                        message_split = message.split('\n')
+                        # Truncate the error message if it has too many lines, set max
+                        # lines at 50
+                        if len(message_split) > 50:
+                            message_split = message_split[-50:]
+                            message_split.insert(0, '... (error truncated)')
+                        message = '\n'.join(message_split)
+                        stacktrace = f'Error for block {br.block_uuid}:\n{message}'
+                        break
+
+            self.notification_sender.send_pipeline_run_failure_message(
+                pipeline=self.pipeline,
+                pipeline_run=self.pipeline_run,
+                error=error_msg,
+                stacktrace=stacktrace,
+            )
+
         # Cancel block runs that are still in progress for the pipeline run.
         cancel_block_runs_and_jobs(self.pipeline_run, self.pipeline)
 
@@ -456,6 +466,7 @@ class PipelineScheduler:
 
                 calculate_pipeline_run_metrics(
                     self.pipeline_run,
+                    self.pipeline,
                     logger=self.logger,
                     logging_tags=tags,
                 )
@@ -478,6 +489,7 @@ class PipelineScheduler:
         if PipelineType.INTEGRATION == self.pipeline.type:
             calculate_pipeline_run_metrics(
                 self.pipeline_run,
+                self.pipeline,
                 logger=self.logger,
                 logging_tags=tags,
             )
@@ -1062,6 +1074,7 @@ def run_integration_stream(
                     calculate_source_metrics(
                         pipeline_run,
                         block_run,
+                        pipeline,
                         stream=tap_stream_id,
                         logger=pipeline_scheduler.logger,
                         logging_tags=merge_dict(tags_updated, dict(tags=tags2)),
@@ -1070,6 +1083,7 @@ def run_integration_stream(
                     calculate_destination_metrics(
                         pipeline_run,
                         block_run,
+                        pipeline,
                         stream=tap_stream_id,
                         logger=pipeline_scheduler.logger,
                         logging_tags=merge_dict(tags_updated, dict(tags=tags2)),
@@ -1156,7 +1170,7 @@ def run_block(
         else:
             repo_path = get_repo_path()
         retry_config = merge_dict(
-            get_repo_config(repo_path).retry_config or dict(),
+            get_repo_config(repo_path=repo_path).retry_config or dict(),
             block.retry_config or dict(),
         )
 
@@ -1246,9 +1260,10 @@ def configure_pipeline_run_payload(
 @safe_db_query
 def retry_pipeline_run(
     pipeline_run: Dict,
+    repo_path: str,
 ) -> 'PipelineRun':
     pipeline_uuid = pipeline_run['pipeline_uuid']
-    pipeline = Pipeline.get(pipeline_uuid, check_if_exists=True)
+    pipeline = Pipeline.get(pipeline_uuid, check_if_exists=True, repo_path=repo_path)
     if pipeline is None or not pipeline.is_valid_pipeline(pipeline.dir_path):
         raise Exception(f'Pipeline {pipeline_uuid} is not a valid pipeline.')
 
@@ -1392,7 +1407,7 @@ def check_sla():
                 else pipeline_run.created_at
             if compare(start_date + timedelta(seconds=sla), current_time) == -1:
                 # passed SLA for pipeline_run
-                pipeline = Pipeline.get(pipeline_schedule.pipeline_uuid)
+                pipeline = pipeline_schedule.pipeline
                 notification_sender = NotificationSender(
                     NotificationConfig.load(
                         config=merge_dict(
@@ -1429,7 +1444,7 @@ def schedule_all():
     schedules, so that needs to be addressed at some point.
     """
     db_connection.session.expire_all()
-
+    repo_config = get_repo_config()
     repo_pipelines = set(Pipeline.get_all_pipelines_all_projects(
         get_repo_path(),
         disable_pipelines_folder_creation=True,
@@ -1494,6 +1509,7 @@ def schedule_all():
 
     for pipeline_uuid, pipeline, active_schedules in gen_pipeline_with_schedules(
         active_pipeline_schedules,
+        repo_config=repo_config,
     ):
         concurrency_config = ConcurrencyConfig.load(config=pipeline.concurrency_config)
         pipeline_runs_to_start = []
@@ -1524,6 +1540,7 @@ def schedule_all():
                 should_schedule = pipeline_schedule.should_schedule(
                     previous_runtimes=previous_runtimes,
                     pipeline=pipeline,
+                    repo_config=repo_config,
                 )
                 initial_pipeline_runs = [
                     r for r in pipeline_schedule.pipeline_runs
@@ -1661,6 +1678,7 @@ def schedule_all():
 
 def gen_pipeline_with_schedules_single_project(
     active_pipeline_schedules: List[PipelineSchedule],
+    repo_config=None,
 ) -> Generator[Tuple[str, Pipeline, List[PipelineSchedule]], None, None]:
     """
     Generate pipelines with associated schedules for a single project.
@@ -1674,6 +1692,8 @@ def gen_pipeline_with_schedules_single_project(
             - The pipeline object.
             - A list of active schedules associated with the pipeline.
     """
+    # Avoid calling get_repo_config repeatedly in Pipeline init method.
+    repo_config = repo_config or get_repo_config()
     pipeline_schedules_by_pipeline = collections.defaultdict(list)
     for schedule in active_pipeline_schedules:
         pipeline_schedules_by_pipeline[schedule.pipeline_uuid].append(schedule)
@@ -1682,15 +1702,21 @@ def gen_pipeline_with_schedules_single_project(
     # each pipeline.
     for pipeline_uuid, active_schedules in pipeline_schedules_by_pipeline.items():
         try:
-            pipeline = Pipeline.get(pipeline_uuid)
+            pipeline = Pipeline.get(
+                pipeline_uuid,
+                repo_path=get_repo_path(),
+                repo_config=repo_config,
+            )
         except Exception as e:
             print(f'Error fetching pipeline {pipeline_uuid}: {e}')
+            traceback.print_exc()
             continue
         yield pipeline_uuid, pipeline, active_schedules
 
 
 def gen_pipeline_with_schedules_project_platform(
     active_pipeline_schedules: List[PipelineSchedule],
+    repo_config=None,
 ) -> Generator[Tuple[str, Pipeline, List[PipelineSchedule]], None, None]:
     """
     Generate pipelines with associated schedules for project platform.
@@ -1754,6 +1780,7 @@ def gen_pipeline_with_schedules_project_platform(
                 )
             except Exception as e:
                 print(f'Error fetching pipeline {pipeline_uuid}: {e}')
+                traceback.print_exc()
                 continue
             yield pipeline_uuid, pipeline, active_schedules
 
@@ -1805,8 +1832,12 @@ def sync_schedules(pipeline_uuids: List[str]):
 
     # Sync schedule configs from triggers.yaml to DB
     for pipeline_uuid in pipeline_uuids:
-        pipeline_triggers = get_triggers_by_pipeline(pipeline_uuid)
-        logger.debug(f'Sync pipeline trigger configs for {pipeline_uuid}: {pipeline_triggers}.')
+        pipeline_triggers, from_cache = get_triggers_by_pipeline_with_cache(pipeline_uuid)
+        logger.debug(f'Sync pipeline trigger configs for {pipeline_uuid}: {pipeline_triggers}.'
+                     f'From cache: {from_cache}')
+        if from_cache:
+            # No updates need to be made to database
+            continue
         for pipeline_trigger in pipeline_triggers:
             if pipeline_trigger.envs and get_env() not in pipeline_trigger.envs:
                 continue

mage_ai/orchestration/pipeline_scheduler_project_platform.py

@@ -1120,7 +1120,7 @@ def run_block(
             repo_path = get_repo_path()
 
         retry_config = merge_dict(
-            get_repo_config(repo_path).retry_config or dict(),
+            get_repo_config(repo_path=repo_path).retry_config or dict(),
             block.retry_config or dict(),
         )
 

mage_ai/orchestration/run_status_checker.py

@@ -1,6 +1,7 @@
 from datetime import datetime, timedelta, timezone
 
 from mage_ai.data_preparation.models.pipeline import Pipeline
+from mage_ai.data_preparation.models.utils import warn_for_repo_path
 from mage_ai.orchestration.db.models.schedules import (
     BlockRun,
     PipelineRun,
@@ -23,10 +24,11 @@ BLOCK_FAILURE_STATUSES = [
 def check_status(
     pipeline_uuid: str,
     execution_date: datetime,
+    repo_path: str = None,
     block_uuid: str = None,
     hours: int = 24,
 ) -> bool:
-    __validate_pipeline_and_block(pipeline_uuid, block_uuid)
+    __validate_pipeline_and_block(pipeline_uuid, block_uuid, repo_path=repo_path)
 
     execution_date = execution_date.replace(tzinfo=timezone.utc)
     pipeline_run = (
@@ -62,11 +64,16 @@ def check_status(
             return pipeline_run.status == PipelineRun.PipelineRunStatus.COMPLETED
 
 
-def __validate_pipeline_and_block(pipeline_uuid, block_uuid):
-    if pipeline_uuid not in Pipeline.get_all_pipelines(get_repo_path()):
+def __validate_pipeline_and_block(pipeline_uuid: str, block_uuid: str, repo_path: str = None):
+    warn_for_repo_path(repo_path=repo_path)
+
+    if repo_path is None:
+        repo_path = get_repo_path()
+
+    if pipeline_uuid not in Pipeline.get_all_pipelines(repo_path=repo_path):
         raise Exception('Pipeline not found, stopping sensor...')
 
-    pipeline = Pipeline(pipeline_uuid, get_repo_path())
+    pipeline = Pipeline.get(pipeline_uuid, repo_path=repo_path)
 
     if block_uuid is not None:
         block = pipeline.get_block(block_uuid)

mage_ai/orchestration/triggers/api.py

@@ -1,9 +1,11 @@
 from datetime import datetime
-from typing import Dict, Optional
+from typing import Dict, List, Optional, Union
 
 from mage_ai.api.resources.PipelineScheduleResource import PipelineScheduleResource
+from mage_ai.data_preparation.models.block.remote.models import RemoteBlock
 from mage_ai.data_preparation.models.pipeline import Pipeline
 from mage_ai.data_preparation.models.triggers import ScheduleStatus, ScheduleType
+from mage_ai.data_preparation.models.utils import warn_for_repo_path
 from mage_ai.orchestration.db.models.schedules import PipelineRun, PipelineSchedule
 from mage_ai.orchestration.triggers.constants import (
     DEFAULT_POLL_INTERVAL,
@@ -14,10 +16,12 @@ from mage_ai.orchestration.triggers.utils import (
     create_and_start_pipeline_run,
 )
 from mage_ai.settings.platform import project_platform_activated
+from mage_ai.settings.repo import get_repo_path
 
 
 def trigger_pipeline(
     pipeline_uuid: str,
+    repo_path: str = None,
     variables: Dict = None,
     check_status: bool = False,
     error_on_failure: bool = False,
@@ -25,12 +29,30 @@ def trigger_pipeline(
     poll_timeout: Optional[float] = None,
     schedule_name: str = None,
     verbose: bool = True,
+    remote_blocks: List[Union[Dict, RemoteBlock]] = None,
+    return_remote_blocks: bool = False,
     _should_schedule: bool = False,  # For internal use only (e.g. running hooks from notebook).
 ) -> PipelineRun:
     if variables is None:
         variables = {}
 
-    pipeline = Pipeline.get(pipeline_uuid, all_projects=project_platform_activated())
+    warn_for_repo_path(repo_path)
+
+    if remote_blocks:
+        arr = []
+        for remote_block in remote_blocks:
+            if isinstance(remote_block, dict):
+                remote_block = RemoteBlock.load(**remote_block)
+            arr.append(remote_block.to_dict())
+        variables['remote_blocks'] = arr
+
+    repo_path_use = repo_path or get_repo_path()
+    pipeline = Pipeline.get(
+        pipeline_uuid,
+        all_projects=project_platform_activated(),
+        repo_path=repo_path_use,
+        use_repo_path=repo_path is not None,
+    )
 
     pipeline_schedule = __fetch_or_create_pipeline_schedule(pipeline, schedule_name=schedule_name)
 
@@ -50,6 +72,23 @@ def trigger_pipeline(
             verbose=verbose,
         )
 
+    if return_remote_blocks and pipeline_run and pipeline_run.pipeline:
+        pipeline = pipeline_run.pipeline
+
+        return [
+            dict(
+                remote_blocks=[
+                    RemoteBlock.load(
+                        block_uuid=block.uuid,
+                        execution_partition=pipeline_run.execution_partition,
+                        pipeline_uuid=pipeline.uuid,
+                        repo_path=pipeline.repo_path,
+                    )
+                    for block in pipeline.blocks_by_uuid.values()
+                ],
+            ),
+        ]
+
     return pipeline_run