mage-ai 0.8.91__py3-none-any.whl → 0.8.93__py3-none-any.whl

mage_ai/data_preparation/models/pipeline.py

@@ -41,7 +41,6 @@ from mage_ai.shared.strings import format_enum
 from mage_ai.shared.utils import clean_name
 
 CYCLE_DETECTION_ERR_MESSAGE = 'A cycle was detected in this pipeline'
-METADATA_FILE_NAME = 'metadata.yaml'
 
 
 class Pipeline:
@@ -142,7 +141,7 @@ class Pipeline:
         # Copy pipeline files from template folder
         copy_template_directory('pipeline', pipeline_path)
         # Update metadata.yaml with pipeline config
-        with open(os.path.join(pipeline_path, METADATA_FILE_NAME), 'w') as fp:
+        with open(os.path.join(pipeline_path, PIPELINE_CONFIG_FILE), 'w') as fp:
             yaml.dump(dict(
                 name=name,
                 uuid=uuid,
@@ -291,7 +290,7 @@ class Pipeline:
     @classmethod
     def is_valid_pipeline(self, pipeline_path):
         return os.path.isdir(pipeline_path) and os.path.exists(
-            os.path.join(pipeline_path, METADATA_FILE_NAME)
+            os.path.join(pipeline_path, PIPELINE_CONFIG_FILE)
         )
 
     def block_deletable(self, block, widget=False):
@@ -424,8 +423,10 @@ class Pipeline:
 
         self.block_configs = config.get('blocks') or []
         self.callback_configs = config.get('callbacks') or []
+        self.conditional_configs = config.get('conditionals') or []
         self.executor_type = config.get('executor_type')
         self.executor_config = config.get('executor_confid') or dict()
+        self.spark_config = config.get('spark_config') or dict()
         self.widget_configs = config.get('widgets') or []
 
         self.variables = config.get('variables')
@@ -453,6 +454,7 @@ class Pipeline:
 
         blocks = [build_shared_args_kwargs(c) for c in self.block_configs]
         callbacks = [build_shared_args_kwargs(c) for c in self.callback_configs]
+        conditionals = [build_shared_args_kwargs(c) for c in self.conditional_configs]
         widgets = [build_shared_args_kwargs(c) for c in self.widget_configs]
         all_blocks = blocks + callbacks + widgets
 
@@ -466,6 +468,11 @@ class Pipeline:
             callbacks,
             all_blocks,
         )
+        self.conditionals_by_uuid = self.__initialize_blocks_by_uuid(
+            self.conditional_configs,
+            conditionals,
+            all_blocks,
+        )
         self.widgets_by_uuid = self.__initialize_blocks_by_uuid(
             self.widget_configs,
             widgets,
@@ -493,8 +500,16 @@ class Pipeline:
                     blocks_with_callbacks[upstream_block.uuid] = []
                 blocks_with_callbacks[upstream_block.uuid].append(callback_block)
 
+        blocks_with_conditionals = {}
+        for conditional_block in self.conditionals_by_uuid.values():
+            for upstream_block in conditional_block.upstream_blocks:
+                if upstream_block.uuid not in blocks_with_conditionals:
+                    blocks_with_conditionals[upstream_block.uuid] = []
+                blocks_with_conditionals[upstream_block.uuid].append(conditional_block)
+
         for block in self.blocks_by_uuid.values():
             block.callback_blocks = blocks_with_callbacks.get(block.uuid, [])
+            block.conditional_blocks = blocks_with_conditionals.get(block.uuid, [])
 
         self.validate('A cycle was detected in the loaded pipeline')
 
@@ -532,8 +547,13 @@ class Pipeline:
             updated_at=self.updated_at,
             uuid=self.uuid,
         )
+
         if self.variables is not None:
             base['variables'] = self.variables
+
+        if self.spark_config is not None:
+            base['spark_config'] = self.spark_config
+
         return base
 
     def to_dict(
@@ -553,11 +573,13 @@ class Pipeline:
 
         blocks_data = [b.to_dict(**shared_kwargs) for b in self.blocks_by_uuid.values()]
         callbacks_data = [b.to_dict(**shared_kwargs) for b in self.callbacks_by_uuid.values()]
+        conditionals_data = [b.to_dict(**shared_kwargs) for b in self.conditionals_by_uuid.values()]
         widgets_data = [b.to_dict(**shared_kwargs) for b in self.widgets_by_uuid.values()]
 
         data = dict(
             blocks=blocks_data,
             callbacks=callbacks_data,
+            conditionals=conditionals_data,
             widgets=widgets_data,
         )
 
@@ -594,6 +616,7 @@ class Pipeline:
         include_block_metadata: bool = False,
         include_block_tags: bool = False,
         include_callback_blocks: bool = False,
+        include_conditional_blocks: bool = False,
         include_content: bool = False,
         include_extensions: bool = False,
         include_outputs: bool = False,
@@ -604,6 +627,7 @@ class Pipeline:
             include_block_tags=include_block_tags,
             include_block_metadata=include_block_metadata,
             include_callback_blocks=include_callback_blocks,
+            include_conditional_blocks=include_conditional_blocks,
             include_content=include_content,
             include_outputs=include_outputs,
             sample_count=sample_count,
@@ -614,6 +638,9 @@ class Pipeline:
         callbacks_data = await asyncio.gather(
             *[b.to_dict_async(**shared_kwargs) for b in self.callbacks_by_uuid.values()]
         )
+        conditionals_data = await asyncio.gather(
+            *[b.to_dict_async(**shared_kwargs) for b in self.conditionals_by_uuid.values()]
+        )
         widgets_data = await asyncio.gather(
             *[b.to_dict_async(
                 include_content=include_content,
@@ -624,6 +651,7 @@ class Pipeline:
         data = dict(
             blocks=blocks_data,
             callbacks=callbacks_data,
+            conditionals=conditionals_data,
             widgets=widgets_data,
         )
 
@@ -747,6 +775,9 @@ class Pipeline:
             if 'callbacks' in data:
                 arr.append(('callbacks', data['callbacks'], self.callbacks_by_uuid))
 
+            if 'conditionals' in data:
+                arr.append(('conditionals', data['conditionals'], self.conditionals_by_uuid))
+
             if 'widgets' in data:
                 arr.append(('widgets', data['widgets'], self.widgets_by_uuid))
 
@@ -930,6 +961,13 @@ class Pipeline:
                 upstream_blocks=self.get_blocks(upstream_block_uuids),
                 priority=priority,
             )
+        elif BlockType.CONDITIONAL == block.type:
+            self.conditionals_by_uuid = self.__add_block_to_mapping(
+                self.conditionals_by_uuid,
+                block,
+                upstream_blocks=self.get_blocks(upstream_block_uuids),
+                priority=priority,
+            )
         else:
             self.blocks_by_uuid = self.__add_block_to_mapping(
                 self.blocks_by_uuid,
@@ -957,6 +995,8 @@ class Pipeline:
             mapping = self.extensions.get(extension_uuid, {}).get('blocks_by_uuid', {})
         elif BlockType.CALLBACK == block_type:
             mapping = self.callbacks_by_uuid
+        elif BlockType.CONDITIONAL == block_type:
+            mapping = self.conditionals_by_uuid
         else:
             mapping = self.blocks_by_uuid
 
@@ -984,6 +1024,8 @@ class Pipeline:
                 block_uuid in self.extensions[extension_uuid]['blocks_by_uuid']
         elif BlockType.CALLBACK == block_type:
             return block_uuid in self.callbacks_by_uuid
+        elif BlockType.CONDITIONAL == block_type:
+            return block_uuid in self.conditionals_by_uuid
 
         return block_uuid in self.blocks_by_uuid
 
@@ -991,6 +1033,7 @@ class Pipeline:
         self,
         block: Block,
         callback_block_uuids: List[str] = None,
+        conditional_block_uuids: List[str] = None,
         upstream_block_uuids: List[str] = None,
         widget: bool = False,
     ):
@@ -998,6 +1041,7 @@ class Pipeline:
 
         extension_uuid = block.extension_uuid
         is_callback = BlockType.CALLBACK == block.type
+        is_conditional = BlockType.CONDITIONAL == block.type
         is_extension = BlockType.EXTENSION == block.type
 
         if upstream_block_uuids is not None:
@@ -1010,6 +1054,8 @@ class Pipeline:
                 mapping = self.extensions[extension_uuid].get('blocks_by_uuid', {})
             elif is_callback:
                 mapping = self.callbacks_by_uuid
+            elif is_conditional:
+                mapping = self.conditionals_by_uuid
             else:
                 mapping = self.blocks_by_uuid
 
@@ -1029,8 +1075,8 @@ class Pipeline:
             new_upstream_block_uuids = set(upstream_block_uuids)
             if curr_upstream_block_uuids != new_upstream_block_uuids:
                 # Only set upstream block’s downstream to the current block if current block
-                # is not an extension block and not a callback block
-                if not is_extension and not is_callback:
+                # is not an extension block and not a callback/conditional block
+                if not is_extension and not is_callback and not is_conditional:
                     # There are currently no upstream blocks that are widgets (e.g. chart)
                     upstream_blocks_added = self.get_blocks(
                         new_upstream_block_uuids - curr_upstream_block_uuids,
@@ -1066,6 +1112,22 @@ class Pipeline:
             # Callback blocks don’t have an upstream.
             # The normal block will know about the callback block via the callback_blocks field.
             block.update_callback_blocks(callback_blocks)
+        elif conditional_block_uuids is not None:
+            conditional_blocks = []
+            for conditional_block_uuid in conditional_block_uuids:
+                conditional_block = self.callbacks_by_uuid.get(conditional_block_uuid)
+                if not conditional_block:
+                    raise Exception(
+                        f'Conditional block {conditional_block_uuid}'
+                        f' is not in the {self.uuid} pipeline.',
+                    )
+
+                conditional_blocks.append(conditional_block)
+
+            # Conditional blocks don’t have an upstream.
+            # The normal block will know about the conditional block via the
+            # conditional_blocks field.
+            block.update_conditional_blocks(conditional_blocks)
         else:
             save_kwargs['block_uuid'] = block.uuid
 
@@ -1079,6 +1141,8 @@ class Pipeline:
             })
         elif is_callback:
             self.callbacks_by_uuid[block.uuid] = block
+        elif is_conditional:
+            self.conditionals_by_uuid[block.uuid] = block
         else:
             self.blocks_by_uuid[block.uuid] = block
 
@@ -1117,6 +1181,10 @@ class Pipeline:
             self.callbacks_by_uuid = {
                 new_uuid if k == old_uuid else k: v for k, v in self.callbacks_by_uuid.items()
             }
+        elif BlockType.CONDITIONAL == block.type:
+            self.conditionals_by_uuid = {
+                new_uuid if k == old_uuid else k: v for k, v in self.conditionals_by_uuid.items()
+            }
         elif old_uuid in self.blocks_by_uuid:
             self.blocks_by_uuid = {
                 new_uuid if k == old_uuid else k: v for k, v in self.blocks_by_uuid.items()
@@ -1159,6 +1227,7 @@ class Pipeline:
         force: bool = False,
     ) -> None:
         is_callback = BlockType.CALLBACK == block.type
+        is_conditional = BlockType.CONDITIONAL == block.type
         is_extension = BlockType.EXTENSION == block.type
 
         mapping = {}
@@ -1168,6 +1237,8 @@ class Pipeline:
             mapping = self.extensions.get(block.extension_uuid, {}).get('blocks_by_uuid', {})
         elif is_callback:
             mapping = self.callbacks_by_uuid
+        elif is_conditional:
+            mapping = self.conditionals_by_uuid
         else:
             mapping = self.blocks_by_uuid
 
@@ -1211,6 +1282,8 @@ class Pipeline:
             del self.extensions[block.extension_uuid]['blocks_by_uuid'][block.uuid]
         elif is_callback:
             del self.callbacks_by_uuid[block.uuid]
+        elif is_conditional:
+            del self.conditionals_by_uuid[block.uuid]
         else:
             del self.blocks_by_uuid[block.uuid]
 
@@ -1247,6 +1320,8 @@ class Pipeline:
                 self.extensions[extension_uuid]['blocks_by_uuid'][block_uuid] = block
             elif BlockType.CALLBACK == block.type:
                 current_pipeline.callbacks_by_uuid[block_uuid] = block
+            elif BlockType.CONDITIONAL == block.type:
+                current_pipeline.conditionals_by_uuid[block_uuid] = block
             else:
                 current_pipeline.blocks_by_uuid[block_uuid] = block
             pipeline_dict = current_pipeline.to_dict(include_extensions=True)
@@ -1302,6 +1377,8 @@ class Pipeline:
                 self.extensions[extension_uuid]['blocks_by_uuid'][block_uuid] = block
             elif BlockType.CALLBACK == block_type:
                 current_pipeline.callbacks_by_uuid[block_uuid] = block
+            elif BlockType.CONDITIONAL == block_type:
+                current_pipeline.conditionals_by_uuid[block_uuid] = block
             else:
                 current_pipeline.blocks_by_uuid[block_uuid] = block
             pipeline_dict = current_pipeline.to_dict(include_extensions=True)
@@ -1373,6 +1450,7 @@ class Pipeline:
 
         combined_blocks.update(self.widgets_by_uuid)
         combined_blocks.update(self.callbacks_by_uuid)
+        combined_blocks.update(self.conditionals_by_uuid)
         combined_blocks.update(self.blocks_by_uuid)
         status = {uuid: 'unvisited' for uuid in combined_blocks}
 

mage_ai/data_preparation/repo_manager.py

@@ -9,11 +9,14 @@ import ruamel.yaml
 import yaml
 from jinja2 import Template
 
-from mage_ai.data_preparation.shared.constants import REPO_PATH_ENV_VAR
+from mage_ai.data_preparation.shared.constants import (
+    MAGE_DATA_DIR_ENV_VAR,
+    REPO_PATH_ENV_VAR,
+)
 from mage_ai.data_preparation.templates.utils import copy_template_directory
 from mage_ai.shared.environments import is_test
 
-MAGE_DATA_DIR_ENV_VAR = 'MAGE_DATA_DIR'
+
 if is_test():
     DEFAULT_MAGE_DATA_DIR = './'
 else:

mage_ai/data_preparation/shared/constants.py

@@ -1,2 +1,3 @@
-REPO_PATH_ENV_VAR = 'MAGE_REPO_PATH'
+MAGE_DATA_DIR_ENV_VAR = 'MAGE_DATA_DIR'
 MANAGE_ENV_VAR = 'MAGE_IS_MANAGE_INSTANCE'
+REPO_PATH_ENV_VAR = 'MAGE_REPO_PATH'

mage_ai/data_preparation/templates/conditionals/base.jinja

@@ -0,0 +1,11 @@
+{% block imports %}
+if 'condition' not in globals():
+    from mage_ai.data_preparation.decorators import condition
+{% endblock %}
+
+
+{% block content %}
+@condition
+def evaluate_condition(*args, **kwargs) -> bool:
+    return True
+{% endblock %}

mage_ai/data_preparation/templates/constants.py

@@ -98,6 +98,13 @@ TEMPLATES = [
         name='Trigger pipeline',
         path='callbacks/orchestration/triggers/default.jinja',
     ),
+    dict(
+        block_type=BlockType.CONDITIONAL,
+        description='Base template with empty functions.',
+        language=BlockLanguage.PYTHON,
+        name='Base template',
+        path='conditionals/base.jinja',
+    ),
 ]
 
 TEMPLATES_BY_UUID = index_by(lambda x: x['name'], TEMPLATES)

mage_ai/io/mssql.py

@@ -65,6 +65,16 @@ class MSSQL(BaseSQL):
             )
             self._ctx = pyodbc.connect(connection_string)
 
+    def build_create_schema_command(
+        self,
+        schema_name: str
+    ) -> str:
+        return '\n'.join([
+                'IF NOT EXISTS (',
+                f'SELECT * FROM information_schema.schemata WHERE schema_name = \'{schema_name}\')',
+                f'BEGIN EXEC(\'CREATE SCHEMA {schema_name}\') END'
+            ])
+
     def build_create_table_as_command(
         self,
         table_name: str,
@@ -79,7 +89,7 @@ class MSSQL(BaseSQL):
         with self.conn.cursor() as cur:
             cur.execute('\n'.join([
                 'SELECT TOP 1 * FROM information_schema.tables ',
-                f'WHERE table_name = \'{table_name}\'',
+                f'WHERE table_schema = \'{schema_name}\' AND table_name = \'{table_name}\'',
             ]))
             return len(cur.fetchall()) >= 1
 

mage_ai/io/sql.py

@@ -39,6 +39,12 @@ class BaseSQL(BaseSQLConnection):
         """
         raise Exception('Subclasses must override this method.')
 
+    def build_create_schema_command(
+        self,
+        schema_name: str
+    ) -> str:
+        return f'CREATE SCHEMA IF NOT EXISTS {schema_name};'
+
     def build_create_table_command(
         self,
         dtypes: Mapping[str, str],
@@ -256,7 +262,8 @@ class BaseSQL(BaseSQLConnection):
 
             with self.conn.cursor() as cur:
                 if schema_name:
-                    cur.execute(f'CREATE SCHEMA IF NOT EXISTS {schema_name};')
+                    query = self.build_create_schema_command(schema_name)
+                    cur.execute(query)
 
                 should_create_table = not table_exists
 

mage_ai/orchestration/db/migrations/versions/dfe49d040487_add_condition_failed_status_to_block_.py

@@ -0,0 +1,39 @@
+"""Add condition_failed status to block run status
+
+Revision ID: dfe49d040487
+Revises: e7beb59b44f9
+Create Date: 2023-06-12 10:25:55.734358
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = 'dfe49d040487'
+down_revision = 'e7beb59b44f9'
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    bind = op.get_bind()
+    if bind.engine.name == 'postgresql':
+        with op.get_context().autocommit_block():
+            op.execute("ALTER TYPE blockrunstatus ADD VALUE 'CONDITION_FAILED'")
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    bind = op.get_bind()
+    if bind.engine.name == 'postgresql':
+        op.execute("ALTER TYPE blockrunstatus RENAME TO blockrunstatus_old")
+        op.execute("CREATE TYPE blockrunstatus AS ENUM('INITIAL', 'QUEUED', 'RUNNING', 'COMPLETED', 'FAILED', 'CANCELLED', 'UPSTREAM_FAILED')")
+        op.execute((
+            "ALTER TABLE block_run ALTER COLUMN status TYPE blockrunstatus USING "
+            "status::text::blockrunstatus"
+        ))
+        op.execute("DROP TYPE blockrunstatus_old")
+    # ### end Alembic commands ###

mage_ai/orchestration/db/models/schedules.py

@@ -388,7 +388,10 @@ class PipelineRun(BaseModel):
         )
 
     def all_blocks_completed(self, include_failed_blocks: bool = False) -> bool:
-        statuses = [BlockRun.BlockRunStatus.COMPLETED]
+        statuses = [
+            BlockRun.BlockRunStatus.COMPLETED,
+            BlockRun.BlockRunStatus.CONDITION_FAILED,
+        ]
         if include_failed_blocks:
             statuses.extend([
                 BlockRun.BlockRunStatus.FAILED,
@@ -438,6 +441,7 @@ class BlockRun(BaseModel):
         FAILED = 'failed'
         CANCELLED = 'cancelled'
         UPSTREAM_FAILED = 'upstream_failed'
+        CONDITION_FAILED = 'condition_failed'
 
     pipeline_run_id = Column(Integer, ForeignKey('pipeline_run.id'), index=True)
     block_uuid = Column(String(255))

mage_ai/orchestration/pipeline_scheduler.py

@@ -393,6 +393,17 @@ class PipelineScheduler:
                 BlockRun.BlockRunStatus.FAILED,
             ]
         )
+        condition_failed_block_uuids = set(
+            b.block_uuid for b in self.pipeline_run.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
@@ -400,23 +411,22 @@ class PipelineScheduler:
                 'dynamic_upstream_block_uuids',
             )
 
-            if dynamic_upstream_block_uuids:
-                if all(
-                    b in failed_block_uuids
-                    for b in dynamic_upstream_block_uuids
-                ):
-                    block_run.update(
-                        status=BlockRun.BlockRunStatus.UPSTREAM_FAILED)
-                    updated_status = True
-            else:
-                block = self.pipeline.get_block(block_run.block_uuid)
-                if any(
-                    b in failed_block_uuids
-                    for b in block.upstream_block_uuids
-                ):
-                    block_run.update(
-                        status=BlockRun.BlockRunStatus.UPSTREAM_FAILED)
-                    updated_status = True
+            for status, block_uuids in statuses.items():
+                if dynamic_upstream_block_uuids:
+                    if all(
+                        b in block_uuids
+                        for b in dynamic_upstream_block_uuids
+                    ):
+                        block_run.update(status=status)
+                        updated_status = True
+                else:
+                    block = self.pipeline.get_block(block_run.block_uuid)
+                    if any(
+                        b in block_uuids
+                        for b in block.upstream_block_uuids
+                    ):
+                        block_run.update(status=status)
+                        updated_status = True
 
             if not updated_status:
                 not_updated_block_runs.append(block_run)

mage_ai/server/api/downloads.py

@@ -0,0 +1,64 @@
+from tornado import gen, iostream
+
+from mage_ai.api.utils import authenticate_client_and_token
+from mage_ai.data_preparation.models.pipeline import Pipeline
+from mage_ai.data_preparation.models.variable import VariableType
+from mage_ai.orchestration.db.models.oauth import Oauth2Application
+from mage_ai.orchestration.db.models.schedules import PipelineRun
+from mage_ai.server.api.base import BaseHandler
+from mage_ai.settings import REQUIRE_USER_AUTHENTICATION
+
+
+class ApiDownloadHandler(BaseHandler):
+    async def get(self, pipeline_uuid, block_uuid, **kwargs):
+        self.set_header('Content-Type', 'text/csv')
+        self.set_header('Content-Disposition', 'attachment; filename=' + f'{block_uuid}.csv')
+
+        api_key = self.get_argument('api_key', None, True)
+        token = self.get_argument('token', None, True)
+        if REQUIRE_USER_AUTHENTICATION:
+            authenticated = False
+            if api_key and token:
+                oauth_client = Oauth2Application.query.filter(
+                    Oauth2Application.client_id == api_key,
+                ).first()
+                if oauth_client:
+                    oauth_token, valid = authenticate_client_and_token(oauth_client.id, token)
+                    authenticated = valid and \
+                        oauth_token and \
+                        oauth_token.user
+            if not authenticated:
+                raise Exception('Unauthorized access to download block output.')
+
+        pipeline = Pipeline.get(pipeline_uuid)
+        block = pipeline.get_block(block_uuid)
+        pipeline_run_id = self.get_argument('pipeline_run_id', None)
+        execution_partition = None
+        if pipeline_run_id is not None:
+            pipeline_run = PipelineRun.query.get(pipeline_run_id)
+            execution_partition = pipeline_run.execution_partition
+
+        if block is None:
+            raise Exception(f'Block {block_uuid} does not exist in pipeline {pipeline_uuid}')
+
+        tables = block.get_outputs(
+            execution_partition=execution_partition,
+            include_print_outputs=False,
+            csv_lines_only=True,
+            sample=False,
+            variable_type=VariableType.DATAFRAME,
+        )
+        for data in tables:
+            table = data.get('table', [])
+            line_count = len(table)
+            for line in range(0, line_count):
+                is_last_line = line == line_count - 1
+                try:
+                    csv_line = table[line] if is_last_line else table[line] + '\n'
+                    self.write(csv_line.encode('UTF-8'))
+                except iostream.StreamClosedError:
+                    break
+                if line % 5000 == 0 or is_last_line:
+                    await self.flush()
+                    # Sleep for a nanosecond so other handlers can run and avoid blocking
+                    await gen.sleep(0.000000001)

mage_ai/server/constants.py

@@ -12,4 +12,4 @@ DATAFRAME_OUTPUT_SAMPLE_COUNT = 10
 # Dockerfile depends on it because it runs ./scripts/install_mage.sh and uses
 # the last line to determine the version to install.
 VERSION = \
-'0.8.91'
+'0.8.93'

mage_ai/server/execution_manager.py

@@ -1,4 +1,5 @@
 from distutils.file_util import copy_file
+from mage_ai.data_preparation.models.constants import PIPELINE_CONFIG_FILE
 from mage_ai.data_preparation.models.pipeline import Pipeline
 from typing import Callable
 import asyncio
@@ -78,8 +79,8 @@ def cancel_pipeline_execution(
     config_path = pipeline_execution.previous_config_path
     if config_path is not None and os.path.isdir(config_path):
         copy_file(
-            os.path.join(config_path, 'metadata.yaml'),
-            os.path.join(pipeline.dir_path, 'metadata.yaml'),
+            os.path.join(config_path, PIPELINE_CONFIG_FILE),
+            os.path.join(pipeline.dir_path, PIPELINE_CONFIG_FILE),
         )
         delete_pipeline_copy_config(config_path)