mage-ai 0.9.65__py3-none-any.whl → 0.9.67__py3-none-any.whl

mage_ai/io/export_utils.py

@@ -104,6 +104,7 @@ def gen_table_creation_query(
     dtypes: Mapping[str, str],
     schema_name: str,
     table_name: str,
+    auto_clean_name: bool = True,
     case_sensitive: bool = False,
     unique_constraints: List[str] = None,
     overwrite_types: Dict = None,
@@ -123,16 +124,16 @@ def gen_table_creation_query(
     if unique_constraints is None:
         unique_constraints = []
     query = []
-    if overwrite_types is not None:
+    for cname in dtypes:
+        if overwrite_types is not None and cname in overwrite_types.keys():
+            dtypes[cname] = overwrite_types[cname]
 
-        for cname in dtypes:
-            if cname in overwrite_types.keys():
-                dtypes[cname] = overwrite_types[cname]
+        if auto_clean_name:
+            cleaned_col_name = clean_name(cname, case_sensitive=case_sensitive)
+        else:
+            cleaned_col_name = cname
 
-            query.append(f'"{clean_name(cname, case_sensitive=case_sensitive)}" {dtypes[cname]}')
-    else:
-        for cname in dtypes:
-            query.append(f'"{clean_name(cname, case_sensitive=case_sensitive)}" {dtypes[cname]}')
+        query.append(f'"{cleaned_col_name}" {dtypes[cname]}')
 
     if schema_name:
         full_table_name = f'{schema_name}.{table_name}'
@@ -142,7 +143,11 @@ def gen_table_creation_query(
     if unique_constraints:
         unique_constraints_clean = []
         for col in unique_constraints:
-            unique_constraints_clean.append(clean_name(col, case_sensitive=case_sensitive))
+            if auto_clean_name:
+                cleaned_col_name = clean_name(col, case_sensitive=case_sensitive)
+            else:
+                cleaned_col_name = col
+            unique_constraints_clean.append(cleaned_col_name)
         unique_constraints_escaped = [f'"{col}"'
                                       for col in unique_constraints_clean]
         index_name = '_'.join([

mage_ai/io/mssql.py

@@ -11,10 +11,24 @@ from sqlalchemy.engine import URL
 
 from mage_ai.io.base import QUERY_ROW_LIMIT, ExportWritePolicy
 from mage_ai.io.config import BaseConfigLoader, ConfigKey
+from mage_ai.io.constants import UNIQUE_CONFLICT_METHOD_UPDATE
 from mage_ai.io.export_utils import PandasTypes
 from mage_ai.io.sql import BaseSQL
 from mage_ai.shared.parsers import encode_complex
 
+MERGE_TABLE_SQL = '''MERGE {table_name} AS t
+USING (VALUES
+    ({values_placeholder})
+) s({columns})
+ON {on_clause}
+WHEN NOT MATCHED THEN
+    INSERT ({insert})
+    VALUES ({values})
+WHEN MATCHED THEN UPDATE SET
+    {update}
+;
+'''
+
 
 class MSSQL(BaseSQL):
     def __init__(
@@ -36,7 +50,7 @@ class MSSQL(BaseSQL):
             schema=schema,
             port=port,
             verbose=verbose,
-            **kwargs
+            **kwargs,
         )
 
     @property
@@ -71,26 +85,29 @@ class MSSQL(BaseSQL):
                 # ref: https://github.com/mkleehammer/pyodbc/issues/134#issuecomment-281739794
                 # now struct.unpack: e.g., (2017, 3, 16, 10, 35, 18, 500000000, -6, 0)
                 tup = struct.unpack("<6hI2h", dto_value)
-                return datetime(tup[0], tup[1], tup[2], tup[3], tup[4], tup[5], tup[6] // 1000,
-                                timezone(timedelta(hours=tup[7], minutes=tup[8])))
+                return datetime(
+                    tup[0],
+                    tup[1],
+                    tup[2],
+                    tup[3],
+                    tup[4],
+                    tup[5],
+                    tup[6] // 1000,
+                    timezone(timedelta(hours=tup[7], minutes=tup[8])),
+                )
 
             self._ctx.add_output_converter(-155, handle_datetimeoffset)
 
-    def build_create_schema_command(
-        self,
-        schema_name: str
-    ) -> str:
-        return '\n'.join([
+    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'
-            ])
+                f'BEGIN EXEC(\'CREATE SCHEMA {schema_name}\') END',
+            ]
+        )
 
-    def build_create_table_as_command(
-        self,
-        table_name: str,
-        query_string: str
-    ) -> str:
+    def build_create_table_as_command(self, table_name: str, query_string: str) -> str:
         return 'SELECT * INTO {}\nFROM ({}) AS prev'.format(
             table_name,
             query_string,
@@ -98,10 +115,14 @@ class MSSQL(BaseSQL):
 
     def table_exists(self, schema_name: str, table_name: str) -> bool:
         with self.conn.cursor() as cur:
-            cur.execute('\n'.join([
-                'SELECT TOP 1 * FROM information_schema.tables ',
-                f'WHERE table_schema = \'{schema_name}\' AND table_name = \'{table_name}\'',
-            ]))
+            cur.execute(
+                '\n'.join(
+                    [
+                        'SELECT TOP 1 * FROM information_schema.tables ',
+                        f'WHERE table_schema = \'{schema_name}\' AND table_name = \'{table_name}\'',
+                    ]
+                )
+            )
             return len(cur.fetchall()) >= 1
 
     def upload_dataframe(
@@ -146,7 +167,9 @@ class MSSQL(BaseSQL):
 
             # Remove extraneous surrounding double quotes
             # that get added while performing conversion to string.
-            df_[col] = df_[col].apply(lambda x: x.strip('"') if x and isinstance(x, str) else x)
+            df_[col] = df_[col].apply(
+                lambda x: x.strip('"') if x and isinstance(x, str) else x
+            )
         df_.replace({np.NaN: None}, inplace=True)
         for _, row in df_.iterrows():
             values.append(tuple(row))
@@ -159,8 +182,8 @@ class MSSQL(BaseSQL):
         df: DataFrame,
         schema_name: str,
         table_name: str,
-        if_exists: ExportWritePolicy = ExportWritePolicy.REPLACE,
-
+        if_exists: ExportWritePolicy = None,
+        **kwargs,
     ):
         connection_url = URL.create(
             'mssql+pyodbc',
@@ -178,7 +201,55 @@ class MSSQL(BaseSQL):
             connection_url,
             fast_executemany=True,
         )
-        df.to_sql(table_name, engine, schema=schema_name, if_exists=if_exists, index=False)
+
+        unique_conflict_method = kwargs.get('unique_conflict_method')
+        unique_constraints = kwargs.get('unique_constraints')
+
+        if unique_conflict_method and unique_constraints:
+
+            def merge_table(
+                table, conn, keys, data_iter, unique_constraints=unique_constraints
+            ):
+                dbapi_conn = conn.connection
+                with dbapi_conn.cursor() as cur:
+                    if table.schema:
+                        table_name = f'[{table.schema}].[{table.name}]'
+                    else:
+                        table_name = table.name
+
+                    values_placeholder = ', '.join(['?' for i in range(len(keys))])
+                    values = [tuple(row) for row in data_iter]
+                    sql = MERGE_TABLE_SQL.format(
+                        table_name=table_name,
+                        values_placeholder=values_placeholder,
+                        columns=', '.join([f'[{k}]' for k in keys]),
+                        on_clause=' AND '.join(
+                            [f's.[{k}] = t.[{k}]' for k in unique_constraints]
+                        ),
+                        insert=', '.join([f'[{c}]' for c in keys]),
+                        values=', '.join([f's.[{c}]' for c in keys]),
+                        update=', '.join([f'[{c}] = s.[{c}]' for c in keys]),
+                    )
+                    cur.executemany(sql, values)
+
+            if UNIQUE_CONFLICT_METHOD_UPDATE == unique_conflict_method:
+                df.to_sql(
+                    table_name,
+                    engine,
+                    schema=schema_name,
+                    if_exists=if_exists or ExportWritePolicy.APPEND,
+                    index=False,
+                    method=merge_table,
+                )
+                return
+
+        df.to_sql(
+            table_name,
+            engine,
+            schema=schema_name,
+            if_exists=if_exists or ExportWritePolicy.REPLACE,
+            index=False,
+        )
 
     def get_type(self, column: Series, dtype: str) -> str:
         if dtype in (
@@ -210,7 +281,11 @@ class MSSQL(BaseSQL):
             return 'text'
         elif dtype == PandasTypes.BYTES:
             return 'varbinary(255)'
-        elif dtype in (PandasTypes.FLOATING, PandasTypes.DECIMAL, PandasTypes.MIXED_INTEGER_FLOAT):
+        elif dtype in (
+            PandasTypes.FLOATING,
+            PandasTypes.DECIMAL,
+            PandasTypes.MIXED_INTEGER_FLOAT,
+        ):
             return 'decimal'
         elif dtype == PandasTypes.INTEGER:
             max_int, min_int = column.max(), column.min()
@@ -222,7 +297,11 @@ class MSSQL(BaseSQL):
                 return 'bigint'
         elif dtype == PandasTypes.BOOLEAN:
             return 'char(52)'
-        elif dtype in (PandasTypes.TIMEDELTA, PandasTypes.TIMEDELTA64, PandasTypes.PERIOD):
+        elif dtype in (
+            PandasTypes.TIMEDELTA,
+            PandasTypes.TIMEDELTA64,
+            PandasTypes.PERIOD,
+        ):
             return 'bigint'
         elif dtype == PandasTypes.EMPTY:
             return 'char(255)'

mage_ai/io/mysql.py

@@ -52,6 +52,8 @@ class MySQL(BaseSQL):
         dtypes: Mapping[str, str],
         schema_name: str,
         table_name: str,
+        auto_clean_name: bool = True,
+        case_sensitive: bool = False,
         unique_constraints: List[str] = None,
         overwrite_types: Dict = None,
         **kwargs,
@@ -59,15 +61,14 @@ class MySQL(BaseSQL):
         if unique_constraints is None:
             unique_constraints = []
         query = []
-        if overwrite_types is not None:
-            for cname in dtypes:
-                if cname in overwrite_types.keys():
-                    dtypes[cname] = overwrite_types[cname]
-                query.append(f'`{clean_name(cname)}` {dtypes[cname]} NULL')
-
-        else:
-            for cname in dtypes:
-                query.append(f'`{clean_name(cname)}` {dtypes[cname]} NULL')
+        for cname in dtypes:
+            if overwrite_types is not None and cname in overwrite_types.keys():
+                dtypes[cname] = overwrite_types[cname]
+            if auto_clean_name:
+                cleaned_col_name = clean_name(cname, case_sensitive=case_sensitive)
+            else:
+                cleaned_col_name = cname
+            query.append(f'`{cleaned_col_name}` {dtypes[cname]} NULL')
 
         return f'CREATE TABLE {table_name} (' + ','.join(query) + ');'
 

mage_ai/io/oracledb.py

@@ -7,6 +7,9 @@ from pandas import DataFrame, read_sql
 from mage_ai.io.base import QUERY_ROW_LIMIT
 from mage_ai.io.config import BaseConfigLoader, ConfigKey
 from mage_ai.io.sql import BaseSQL
+from mage_ai.server.logger import Logger
+
+logger = Logger().new_server_logger(__name__)
 
 
 class OracleDB(BaseSQL):
@@ -40,8 +43,17 @@ class OracleDB(BaseSQL):
         )
 
     def open(self) -> None:
-        with self.printer.print_msg('Opening connection to OracleDB database (thin mode)'):
-            self._ctx = oracledb.connect(**self.settings)
+        if self.settings['mode'] and self.settings['mode'].lower() == 'thick':
+            logger.info('Initializing Oracle thick mode.')
+            oracledb.init_oracle_client()
+        with self.printer.print_msg(f'Opening connection to OracleDB database \
+                                    ({self.settings["mode"]} mode)'):
+            connection_dsn = "{}:{}/{}".format(
+                self.settings['host'],
+                self.settings['port'],
+                self.settings['service_name'])
+            self._ctx = oracledb.connect(
+                user=self.settings['user'], password=self.settings['password'], dsn=connection_dsn)
 
     def load(
         self,

mage_ai/io/postgres.py

@@ -284,6 +284,7 @@ class Postgres(BaseSQL):
         dtypes: List[str],
         full_table_name: str,
         allow_reserved_words: bool = False,
+        auto_clean_name: bool = True,
         buffer: Union[IO, None] = None,
         case_sensitive: bool = False,
         unique_conflict_method: str = None,
@@ -355,6 +356,7 @@ class Postgres(BaseSQL):
                 cleaned_col = self._clean_column_name(
                     col,
                     allow_reserved_words=allow_reserved_words,
+                    auto_clean_name=auto_clean_name,
                     case_sensitive=case_sensitive,
                 )
                 cleaned_unique_constraints.append(f'"{cleaned_col}"')
@@ -364,6 +366,7 @@ class Postgres(BaseSQL):
                 cleaned_col = self._clean_column_name(
                     col,
                     allow_reserved_words=allow_reserved_words,
+                    auto_clean_name=auto_clean_name,
                     case_sensitive=case_sensitive,
                 )
                 cleaned_columns.append(f'"{cleaned_col}"')

mage_ai/io/sql.py

@@ -52,6 +52,7 @@ class BaseSQL(BaseSQLConnection):
         dtypes: Mapping[str, str],
         schema_name: str,
         table_name: str,
+        auto_clean_name: bool = True,
         case_sensitive: bool = False,
         unique_constraints: List[str] = None,
         overwrite_types: Dict = None,
@@ -63,6 +64,7 @@ class BaseSQL(BaseSQLConnection):
             dtypes,
             schema_name,
             table_name,
+            auto_clean_name=auto_clean_name,
             case_sensitive=case_sensitive,
             unique_constraints=unique_constraints,
             overwrite_types=overwrite_types,
@@ -224,6 +226,7 @@ class BaseSQL(BaseSQLConnection):
         verbose: bool = True,
         # Other optional configs
         allow_reserved_words: bool = False,
+        auto_clean_name: bool = True,
         case_sensitive: bool = False,
         cascade_on_drop: bool = False,
         drop_table_on_replace: bool = False,
@@ -276,12 +279,13 @@ class BaseSQL(BaseSQLConnection):
             df = clean_df_for_export(df, self.clean, dtypes)
 
             # Clean column names
-            col_mapping = {col: self._clean_column_name(
-                                        col,
-                                        allow_reserved_words=allow_reserved_words,
-                                        case_sensitive=case_sensitive)
-                           for col in df.columns}
-            df = df.rename(columns=col_mapping)
+            if auto_clean_name:
+                col_mapping = {col: self._clean_column_name(
+                                            col,
+                                            allow_reserved_words=allow_reserved_words,
+                                            case_sensitive=case_sensitive)
+                               for col in df.columns}
+                df = df.rename(columns=col_mapping)
             dtypes = infer_dtypes(df)
 
         def __process():
@@ -292,6 +296,8 @@ class BaseSQL(BaseSQLConnection):
                     schema_name,
                     table_name,
                     if_exists=if_exists,
+                    unique_conflict_method=unique_conflict_method,
+                    unique_constraints=unique_constraints,
                 )
                 return
 
@@ -340,6 +346,7 @@ class BaseSQL(BaseSQLConnection):
                             db_dtypes,
                             schema_name,
                             table_name,
+                            auto_clean_name=auto_clean_name,
                             case_sensitive=case_sensitive,
                             unique_constraints=unique_constraints,
                             overwrite_types=overwrite_types,
@@ -354,6 +361,7 @@ class BaseSQL(BaseSQLConnection):
                         allow_reserved_words=allow_reserved_words,
                         buffer=buffer,
                         case_sensitive=case_sensitive,
+                        auto_clean_name=auto_clean_name,
                         unique_conflict_method=unique_conflict_method,
                         unique_constraints=unique_constraints,
                         **kwargs,

mage_ai/io/trino.py

@@ -119,6 +119,8 @@ class Trino(BaseSQL):
         dtypes: Mapping[str, str],
         schema_name: str,
         table_name: str,
+        auto_clean_name: bool = True,
+        case_sensitive: bool = False,
         unique_constraints: List[str] = None,
         overwrite_types: Dict = None,
         **kwargs,
@@ -126,14 +128,14 @@ class Trino(BaseSQL):
         if unique_constraints is None:
             unique_constraints = []
         query = []
-        if overwrite_types is not None:
-            for cname in dtypes:
-                if cname in overwrite_types.keys():
-                    dtypes[cname] = overwrite_types[cname]
-                query.append(f'"{clean_name(cname)}" {dtypes[cname]}')
-        else:
-            for cname in dtypes:
-                query.append(f'"{clean_name(cname)}" {dtypes[cname]}')
+        for cname in dtypes:
+            if overwrite_types is not None and cname in overwrite_types.keys():
+                dtypes[cname] = overwrite_types[cname]
+            if auto_clean_name:
+                cleaned_col_name = clean_name(cname, case_sensitive=case_sensitive)
+            else:
+                cleaned_col_name = cname
+            query.append(f'"{cleaned_col_name}" {dtypes[cname]}')
 
         full_table_name = '.'.join(list(filter(lambda x: x, [
             schema_name,

mage_ai/orchestration/db/migrations/versions/90d978a8aef8_update_unique_constraint_for_secret.py

@@ -20,11 +20,17 @@ def upgrade() -> None:
     # ### commands auto generated by Alembic - please adjust! ###
     try:
         bind = op.get_bind()
-        insp = sa.inspect(bind.engine)
-        with op.batch_alter_table('secret', schema=None) as batch_op:
-            unique_constraints = insp.get_unique_constraints('secret')
-            for constraint in unique_constraints:
-                batch_op.drop_constraint(constraint['name'], type_='unique')
+        insp = sa.inspect(bind)
+        if bind.engine.name == 'mssql':
+            indexes = insp.get_indexes('secret')
+            for i in indexes:
+                if i['unique'] is True:
+                    op.execute(f"ALTER TABLE secret DROP CONSTRAINT {i['name']};")
+        else:
+            with op.batch_alter_table('secret', schema=None) as batch_op:
+                unique_constraints = insp.get_unique_constraints('secret')
+                for constraint in unique_constraints:
+                    batch_op.drop_constraint(constraint['name'], type_='unique')
     except ValueError:
         with op.batch_alter_table('secret', schema=None) as batch_op:
             batch_op.add_column(sa.Column('name_new', sa.String(length=255), nullable=True))

mage_ai/orchestration/db/models/schedules.py

@@ -337,6 +337,7 @@ class PipelineSchedule(PipelineScheduleProjectPlatformMixin, BaseModel):
                 last_enabled_at=last_enabled_at,
                 name=trigger_config.name,
                 pipeline_uuid=trigger_config.pipeline_uuid,
+                repo_path=trigger_config.repo_path,
                 schedule_interval=trigger_config.schedule_interval,
                 schedule_type=trigger_config.schedule_type,
                 settings=trigger_config.settings,
@@ -351,6 +352,7 @@ class PipelineSchedule(PipelineScheduleProjectPlatformMixin, BaseModel):
                     existing_trigger.last_enabled_at != kwargs.get('last_enabled_at'),
                     existing_trigger.name != kwargs.get('name'),
                     existing_trigger.pipeline_uuid != kwargs.get('pipeline_uuid'),
+                    existing_trigger.repo_path != kwargs.get('repo_path'),
                     existing_trigger.schedule_interval != kwargs.get('schedule_interval'),
                     existing_trigger.schedule_type != kwargs.get('schedule_type'),
                     existing_trigger.settings != kwargs.get('settings'),
@@ -1548,7 +1550,12 @@ class PipelineRun(PipelineRunProjectPlatformMixin, BaseModel):
             interval_start_datetime = self.execution_date
             interval_start_datetime_previous = None
 
-            if ScheduleInterval.DAILY == self.pipeline_schedule.schedule_interval:
+            if (
+                ScheduleInterval.ONCE == self.pipeline_schedule.schedule_interval
+                or ScheduleInterval.ALWAYS_ON == self.pipeline_schedule.schedule_interval
+            ):
+                pass
+            elif ScheduleInterval.DAILY == self.pipeline_schedule.schedule_interval:
                 interval_seconds = 60 * 60 * 24
             elif ScheduleInterval.HOURLY == self.pipeline_schedule.schedule_interval:
                 interval_seconds = 60 * 60 * 1
@@ -1559,6 +1566,23 @@ class PipelineRun(PipelineRunProjectPlatformMixin, BaseModel):
                 )
             elif ScheduleInterval.WEEKLY == self.pipeline_schedule.schedule_interval:
                 interval_seconds = 60 * 60 * 24 * 7
+            else:
+                try:
+                    cron_itr = croniter(
+                        self.pipeline_schedule.schedule_interval,
+                        self.execution_date,
+                    )
+                    current = cron_itr.get_current(datetime)
+                    interval_start_datetime_previous = cron_itr.get_prev(datetime)
+                    # get_prev and get_next changes the state of the cron iterator, so we need
+                    # to call get_next again to go back to the original state
+                    cron_itr.get_next()
+                    interval_end_datetime = cron_itr.get_next(datetime)
+                    interval_seconds = (
+                        interval_end_datetime.timestamp() - current.timestamp()
+                    )
+                except Exception:
+                    pass
 
             if interval_seconds and not interval_end_datetime:
                 interval_end_datetime = interval_start_datetime + timedelta(

mage_ai/orchestration/db/models/schedules_project_platform.py

@@ -5,6 +5,7 @@ from typing import Dict, List
 
 import dateutil.parser
 import pytz
+from croniter import croniter
 from dateutil.relativedelta import relativedelta
 from sqlalchemy import or_
 from sqlalchemy.sql import func
@@ -298,7 +299,12 @@ class PipelineRunProjectPlatformMixin:
             interval_start_datetime = self.execution_date
             interval_start_datetime_previous = None
 
-            if ScheduleInterval.DAILY == self.pipeline_schedule.schedule_interval:
+            if (
+                ScheduleInterval.ONCE == self.pipeline_schedule.schedule_interval
+                or ScheduleInterval.ALWAYS_ON == self.pipeline_schedule.schedule_interval
+            ):
+                pass
+            elif ScheduleInterval.DAILY == self.pipeline_schedule.schedule_interval:
                 interval_seconds = 60 * 60 * 24
             elif ScheduleInterval.HOURLY == self.pipeline_schedule.schedule_interval:
                 interval_seconds = 60 * 60 * 1
@@ -309,6 +315,23 @@ class PipelineRunProjectPlatformMixin:
                 )
             elif ScheduleInterval.WEEKLY == self.pipeline_schedule.schedule_interval:
                 interval_seconds = 60 * 60 * 24 * 7
+            else:
+                try:
+                    cron_itr = croniter(
+                        self.pipeline_schedule.schedule_interval,
+                        self.execution_date,
+                    )
+                    current = cron_itr.get_current(datetime)
+                    interval_start_datetime_previous = cron_itr.get_prev(datetime)
+                    # get_prev and get_next changes the state of the cron iterator, so we need
+                    # to call get_next again to go back to the original state
+                    cron_itr.get_next()
+                    interval_end_datetime = cron_itr.get_next(datetime)
+                    interval_seconds = (
+                        interval_end_datetime.timestamp() - current.timestamp()
+                    )
+                except Exception:
+                    pass
 
             if interval_seconds and not interval_end_datetime:
                 interval_end_datetime = interval_start_datetime + timedelta(

mage_ai/orchestration/job_manager.py

@@ -1,3 +1,4 @@
+import traceback
 from enum import Enum
 from typing import Callable, Dict, Union
 
@@ -89,4 +90,8 @@ class JobManager:
         return f'{job_type}_{uid}'
 
 
-job_manager = JobManager()
+try:
+    job_manager = JobManager()
+except Exception:
+    traceback.print_exc()
+    job_manager = None

mage_ai/orchestration/pipeline_scheduler_original.py

@@ -240,19 +240,14 @@ class PipelineScheduler:
                     failed_block_runs = self.pipeline_run.failed_block_runs
                     error_msg = 'Failed blocks: '\
                                 f'{", ".join([b.block_uuid for b in failed_block_runs])}.'
-                    self.notification_sender.send_pipeline_run_failure_message(
-                        error=error_msg,
-                        pipeline=self.pipeline,
-                        pipeline_run=self.pipeline_run,
-                    )
+                    self.on_pipeline_run_failure(error_msg)
                 else:
                     self.pipeline_run.complete()
                     self.notification_sender.send_pipeline_run_success_message(
                         pipeline=self.pipeline,
                         pipeline_run=self.pipeline_run,
                     )
-
-                asyncio.run(UsageStatisticLogger().pipeline_run_ended(self.pipeline_run))
+                    asyncio.run(UsageStatisticLogger().pipeline_run_ended(self.pipeline_run))
 
                 self.logger_manager.output_logs_to_destination()
 
@@ -323,12 +318,20 @@ class PipelineScheduler:
                     self.__schedule_blocks(block_runs)
 
     @safe_db_query
-    def on_pipeline_run_failure(self, error: str) -> None:
+    def on_pipeline_run_failure(self, error_msg: str) -> None:
+        failed_block_runs = self.pipeline_run.failed_block_runs
+        for br in failed_block_runs:
+            if br.metrics:
+                message = br.metrics.get('error', {}).get('message')
+                if message:
+                    error_msg += f'\nError for block {br.block_uuid}:\n{message}'
+                    break
+
         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,
+            error=error_msg,
         )
         # Cancel block runs that are still in progress for the pipeline run.
         cancel_block_runs_and_jobs(self.pipeline_run, self.pipeline)
@@ -1422,7 +1425,10 @@ def schedule_all():
     ))
 
     # Sync schedules from yaml file to DB
-    sync_schedules(list(repo_pipelines))
+    try:
+        sync_schedules(list(repo_pipelines))
+    except Exception:
+        logger.exception('Failed to sync schedules')
 
     active_pipeline_schedules = list(PipelineSchedule.active_schedules(
         pipeline_uuids=repo_pipelines,

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.9.65'
+'0.9.67'

mage_ai/server/file_observer.py

@@ -0,0 +1,10 @@
+from watchdog.events import FileSystemEvent, FileSystemEventHandler
+
+from mage_ai.data_preparation.repo_manager import update_settings_on_metadata_change
+
+
+class MetadataEventHandler(FileSystemEventHandler):
+    def on_modified(self, event: FileSystemEvent):
+        super().on_modified(event)
+
+        update_settings_on_metadata_change()