mage-ai 0.9.57__py3-none-any.whl → 0.9.59__py3-none-any.whl

mage_ai/io/base.py

@@ -2,7 +2,7 @@ import os
 import re
 from abc import ABC, abstractmethod
 from enum import Enum
-from typing import IO, Any, Callable, Union
+from typing import IO, Any, Callable, Dict, Union
 
 import pandas as pd
 from pandas import DataFrame
@@ -296,6 +296,9 @@ class BaseSQLDatabase(BaseIO):
             col_new = f'_{col_new}'
         return col_new
 
+    def execute_query_raw(self, query: str, configuration: Dict = None, **kwargs) -> None:
+        pass
+
 
 class BaseSQLConnection(BaseSQLDatabase):
     """

mage_ai/io/bigquery.py

@@ -7,6 +7,7 @@ from pandas import DataFrame
 from mage_ai.io.base import QUERY_ROW_LIMIT, BaseSQLDatabase, ExportWritePolicy
 from mage_ai.io.config import BaseConfigLoader, ConfigKey
 from mage_ai.io.export_utils import infer_dtypes
+from mage_ai.shared.custom_logger import DX_PRINTER
 from mage_ai.shared.utils import (
     convert_pandas_dtype_to_python_type,
     convert_python_type_to_bigquery_type,
@@ -232,7 +233,7 @@ FROM `{database}.{schema}.__TABLES_SUMMARY__`
 WHERE table_id = '{table_name}'
 """).to_dataframe()
 
-                full_table_name = f'{database}.{schema}.{table_name}'
+                full_table_name = f'`{database}.{schema}.{table_name}`'
 
                 table_doesnt_exist = df_existing.empty
 
@@ -281,24 +282,25 @@ WHERE table_id = '{table_name}'
 
                 column_types = self.get_column_types(schema, table_name)
 
-                for col in df.columns:
-                    col_type = column_types.get(col)
-                    if not col_type:
-                        continue
+                if df is not None:
+                    for col in df.columns:
+                        col_type = column_types.get(col)
+                        if not col_type:
+                            continue
 
-                    null_rows = df[col].isnull()
-                    if col_type.startswith('ARRAY<STRUCT'):
-                        df.loc[null_rows, col] = df.loc[null_rows, col].apply(lambda x: [{}])
-                    elif col_type.startswith('ARRAY'):
-                        df.loc[null_rows, col] = df.loc[null_rows, col].apply(lambda x: [])
-                    elif col_type.startswith('STRUCT'):
-                        df.loc[null_rows, col] = df.loc[null_rows, col].apply(lambda x: {})
+                        null_rows = df[col].isnull()
+                        if col_type.startswith('ARRAY<STRUCT'):
+                            df.loc[null_rows, col] = df.loc[null_rows, col].apply(lambda x: [{}])
+                        elif col_type.startswith('ARRAY'):
+                            df.loc[null_rows, col] = df.loc[null_rows, col].apply(lambda x: [])
+                        elif col_type.startswith('STRUCT'):
+                            df.loc[null_rows, col] = df.loc[null_rows, col].apply(lambda x: {})
 
-                # Clean column names
-                if type(df) is DataFrame:
-                    df.columns = df.columns.str.replace(' ', '_')
+                    # Clean column names
+                    if type(df) is DataFrame:
+                        df.columns = df.columns.str.replace(' ', '_')
 
-                self.client.load_table_from_dataframe(df, table_id, job_config=config).result()
+                    self.client.load_table_from_dataframe(df, table_id, job_config=config).result()
 
         if verbose:
             with self.printer.print_msg(f'Exporting data to table \'{table_id}\''):
@@ -318,6 +320,13 @@ WHERE table_id = '{table_name}'
             query_string = self._clean_query(query_string)
             self.client.query(query_string, **kwargs)
 
+    def execute_query_raw(self, query: str, configuration: Dict = None, **kwargs) -> None:
+        DX_PRINTER.print(
+            f'BigQuery.execute_query_raw\n{query}',
+        )
+        job = self.client.query(query)
+        return job.result()
+
     def execute_queries(
         self,
         queries: List[str],

mage_ai/io/clickhouse.py

@@ -88,6 +88,9 @@ class ClickHouse(BaseSQLDatabase):
 
         return result
 
+    def execute_query_raw(self, query: str, **kwargs) -> None:
+        return self.client.command(query)
+
     def execute_queries(
         self,
         queries: List[str],

mage_ai/io/druid.py

@@ -101,6 +101,9 @@ class Druid(BaseSQL):
     def execute(self, query_string: str, **query_vars) -> None:
         super().execute(query_string, **query_vars)
 
+    def execute_query_raw(self, query: str, **kwargs) -> None:
+        self.execute(query)
+
     def execute_queries(self,
                         queries: List[str],
                         query_variables: List[Dict] = None,

mage_ai/io/mongodb.py

@@ -80,7 +80,7 @@ class MongoDB(BaseIO):
             data (Union[DataFrame, List[Dict]): Data frame or List of Dictionary to export.
             collection (str): MongoDB collection name.
         """
-        if not data:
+        if data is None:
             return
         collection = collection or self.collection
         if collection is None:

mage_ai/io/pinot.py

@@ -74,6 +74,9 @@ class Pinot(BaseSQL):
     def execute(self, query_string: str, **query_vars) -> None:
         super().execute(query_string, **query_vars)
 
+    def execute_query_raw(self, query: str, **kwargs) -> None:
+        self.execute(query)
+
     def execute_queries(self,
                         queries: List[str],
                         query_variables: List[Dict] = None,

mage_ai/io/postgres.py

@@ -364,3 +364,16 @@ COPY {full_table_name} ({insert_columns}) FROM STDIN (
     , FORCE_NULL({insert_columns})
 );
         """, buffer)
+
+    def execute(self, query_string: str, **query_vars) -> None:
+        """
+        Sends query to the connected database.
+
+        Args:
+            query_string (str): SQL query string to apply on the connected database.
+            query_vars: Variable values to fill in when using format strings in query.
+        """
+        with self.printer.print_msg(f'Executing query \'{query_string}\''):
+            query_string = self._clean_query(query_string)
+            with self.conn.cursor() as cur:
+                cur.execute(query_string, query_vars)

mage_ai/io/snowflake.py

@@ -75,6 +75,10 @@ class Snowflake(BaseSQLConnection):
             with self.conn.cursor() as cur:
                 return cur.execute(query_string, timeout=self.timeout, **kwargs).fetchall()
 
+    def execute_query_raw(self, query: str, **kwargs) -> None:
+        with self.conn.cursor() as cur:
+            return cur.execute(query, timeout=self.timeout).fetchall()
+
     def execute_queries(
         self,
         queries: List[str],

mage_ai/io/spark.py

@@ -1,8 +1,10 @@
-from mage_ai.io.base import BaseSQLDatabase, ExportWritePolicy, QUERY_ROW_LIMIT
-from mage_ai.io.config import BaseConfigLoader, ConfigKey
+from typing import Dict, List, Union
+
 from pandas import DataFrame
 from pyspark.sql import SparkSession
-from typing import Dict, List, Union
+
+from mage_ai.io.base import QUERY_ROW_LIMIT, BaseSQLDatabase, ExportWritePolicy
+from mage_ai.io.config import BaseConfigLoader, ConfigKey
 
 
 class Spark(BaseSQLDatabase):
@@ -63,6 +65,9 @@ class Spark(BaseSQLDatabase):
             query_string = self._clean_query(query_string)
             self.client.sql(query_string, **kwargs)
 
+    def execute_query_raw(self, query: str, **kwargs) -> None:
+        self.client.sql(query)
+
     def execute_query(
         self,
         query: str,

mage_ai/io/sql.py

@@ -123,6 +123,12 @@ class BaseSQL(BaseSQLConnection):
             with self.conn.cursor() as cur:
                 cur.execute(query_string, **query_vars)
 
+    def execute_query_raw(self, query: str, **kwargs) -> None:
+        with self.conn.cursor() as cursor:
+            result = cursor.execute(query)
+        self.conn.commit()
+        return result
+
     def execute_queries(
         self,
         queries: List[str],

mage_ai/orchestration/db/__init__.py

@@ -106,9 +106,7 @@ def get_postgresql_schema(url):
     except ValueError:
         return None
     if parse_result.scheme == 'postgresql+psycopg2':
-        q = parse_qs(
-            parse_result.query.replace('%%', '%')
-        )
+        q = parse_qs(parse_result.query.replace('%%', '%'))
         options = q.get('options')
         if options and len(options) >= 1:
             params = options[0].replace('-c ', '').split(' ')
@@ -118,21 +116,29 @@ def get_postgresql_schema(url):
 
 db_connection = DBConnection()
 
-if db_connection_url.startswith('postgresql'):
-    db_schema = get_postgresql_schema(db_connection_url)
-    if db_schema:
-        db_connection.start_session()
-        db_connection.session.execute(f'CREATE SCHEMA IF NOT EXISTS {db_schema};')
-        # Get the current database name from the query fetchall() result, e.g., [('test_database',)]
-        db_current = db_connection.session.execute('SELECT current_database()').fetchall()[0][0]
-        username, _ = get_user_info_from_db_connection_url(db_connection_url)
-        if username:
-            db_connection.session.execute(
-                f'ALTER ROLE {username} IN DATABASE {db_current} SET search_path TO {db_schema}')
-            db_connection.session.commit()
-            db_connection.close_session()
-            print(f'Set the default PostgreSQL schema for role {username} ',
-                  f'in database {db_current} to {db_schema}')
+
+def set_db_schema():
+    if db_connection_url.startswith('postgresql'):
+        db_schema = get_postgresql_schema(db_connection_url)
+        if db_schema:
+            db_connection.start_session()
+            db_connection.session.execute(f'CREATE SCHEMA IF NOT EXISTS {db_schema};')
+            # Get the current database name from the query fetchall() result
+            # e.g., [('test_database',)]
+            db_current = db_connection.session.execute(
+                'SELECT current_database()'
+            ).fetchall()[0][0]
+            username, _ = get_user_info_from_db_connection_url(db_connection_url)
+            if username:
+                db_connection.session.execute(
+                    f'ALTER ROLE {username} IN DATABASE {db_current} SET search_path TO {db_schema}'
+                )
+                db_connection.session.commit()
+                db_connection.close_session()
+                print(
+                    f'Set the default PostgreSQL schema for role {username} ',
+                    f'in database {db_current} to {db_schema}',
+                )
 
 
 def safe_db_query(func):
@@ -150,10 +156,11 @@ def safe_db_query(func):
                 if retry_count >= DB_RETRY_COUNT:
                     raise e
                 retry_count += 1
+
     return func_with_rollback
 
 
 logging.basicConfig()
 
-if is_dev():
+if is_dev() and not os.getenv('DISABLE_DATABASE_TERMINAL_OUTPUT'):
     logging.getLogger('sqlalchemy.engine').setLevel(logging.INFO)

mage_ai/orchestration/db/cache.py

@@ -1,3 +1,4 @@
+import os
 from typing import Dict
 
 import simplejson
@@ -29,13 +30,13 @@ class CachingQuery(Query):
                 )
                 self.cache_key = str(hash(f'{cache_key_1}:{cache_key_2}'))
 
-            if debug:
+            if debug and not os.getenv('DISABLE_DATABASE_TERMINAL_OUTPUT'):
                 keys_count = len((self.session.cache() or {}).keys())
                 print(f'[INFO] Number of keys in session cache: {keys_count}')
 
             results = self.session.get_results_from_cache(self.cache_key)
             if self.cache_key and results:
-                if debug:
+                if debug and not os.getenv('DISABLE_DATABASE_TERMINAL_OUTPUT'):
                     print(f'[INFO] Cache HIT for cache key: {self.cache_key}')
 
                 return results
@@ -43,7 +44,7 @@ class CachingQuery(Query):
         results = super().all(*args, **kwargs)
 
         if self.cache and self.cache_key:
-            if debug:
+            if debug and not os.getenv('DISABLE_DATABASE_TERMINAL_OUTPUT'):
                 print(f'[INFO] Cache MISS for cache key: {self.cache_key}')
             self.session.cache_results(self.cache_key, results)
 

mage_ai/orchestration/db/models/schedules.py

@@ -31,11 +31,13 @@ from sqlalchemy.sql.functions import coalesce
 
 from mage_ai.data_preparation.logging.logger_manager_factory import LoggerManagerFactory
 from mage_ai.data_preparation.models.block.dynamic.utils import (
+    DynamicBlockFlag,
     all_upstreams_completed,
     dynamically_created_child_block_runs,
-)
-from mage_ai.data_preparation.models.block.utils import (
+    has_dynamic_block_upstream_parent,
+    is_dynamic_block,
     is_dynamic_block_child,
+    is_replicated_block,
     should_reduce_output,
 )
 from mage_ai.data_preparation.models.constants import (
@@ -67,6 +69,7 @@ from mage_ai.settings.platform import project_platform_activated
 from mage_ai.settings.repo import get_repo_path
 from mage_ai.shared.array import find
 from mage_ai.shared.constants import ENV_PROD
+from mage_ai.shared.custom_logger import DX_PRINTER
 from mage_ai.shared.dates import compare
 from mage_ai.shared.hash import ignore_keys, index_by, merge_dict
 from mage_ai.shared.utils import clean_name
@@ -922,11 +925,15 @@ class PipelineRun(PipelineRunProjectPlatformMixin, BaseModel):
             # If this is the original dynamic child block, don’t run until all it’s
             # upstream dynamic child blocks have their upstreams completed.
             if block and block.uuid == block_run.block_uuid and is_dynamic_block_child(block):
+                DX_PRINTER.debug(f'dynamic child original: {block_run.block_uuid}', block=block)
                 upstream_dynamic_child_blocks = \
                     [up_block for up_block in block.upstream_blocks if is_dynamic_block_child(
                         up_block,
                     )]
 
+                for up_block in upstream_dynamic_child_blocks:
+                    DX_PRINTER.debug(f'\tupstream dynamic child: {up_block.uuid}', block=block)
+
                 if upstream_dynamic_child_blocks:
                     if not all(
                         [all_upstreams_completed(
@@ -935,6 +942,12 @@ class PipelineRun(PipelineRunProjectPlatformMixin, BaseModel):
                         ) for up_block in upstream_dynamic_child_blocks],
                     ):
                         continue
+                DX_PRINTER.warning(
+                    f'\tupstream completed for: {block_run.block_uuid}',
+                    block=block,
+                    completed=completed_block_uuids,
+                    all=[b.block_uuid for b in block_runs_all],
+                )
 
             if dynamic_upstream_block_uuids is not None and dynamic_block_index is not None:
                 uuids_to_check = []
@@ -1160,7 +1173,36 @@ class PipelineRun(PipelineRunProjectPlatformMixin, BaseModel):
         db_connection.session.commit()
 
     @classmethod
-    def create(self, create_block_runs: bool = True, **kwargs) -> 'PipelineRun':
+    def create(
+        self,
+        create_block_runs: bool = True,
+        prevent_duplicates: bool = False,
+        **kwargs,
+    ) -> 'PipelineRun':
+        """
+        Create a new PipelineRun instance.
+
+        Args:
+            create_block_runs (bool, optional): Whether to create associated block runs.
+                Default is True.
+            prevent_duplicates (bool, optional): If True, checks for existing PipelineRun with the
+                same execution date, pipeline schedule ID, and pipeline UUID, and returns None
+                if found. Default is False.
+            **kwargs: Additional keyword arguments to be passed to the super().create() method.
+
+        Returns:
+            PipelineRun or None: The created PipelineRun instance if successful, None if
+                prevent_duplicates is True and a matching PipelineRun already exists.
+        """
+        if prevent_duplicates:
+            existing_pipeline_run = PipelineRun.query.filter(
+                PipelineRun.execution_date == kwargs.get('execution_date'),
+                PipelineRun.pipeline_schedule_id == kwargs.get('pipeline_schedule_id'),
+                PipelineRun.pipeline_uuid == kwargs.get('pipeline_uuid'),
+            ).first()
+            if existing_pipeline_run is not None:
+                return None
+
         pipeline_run = super().create(**kwargs)
         pipeline_uuid = kwargs.get('pipeline_uuid')
         if pipeline_uuid is not None and create_block_runs:
@@ -1249,6 +1291,30 @@ class PipelineRun(PipelineRunProjectPlatformMixin, BaseModel):
                     )),
                 ))
 
+            flags = []
+
+            if has_dynamic_block_upstream_parent(block):
+                flags.extend([
+                    DynamicBlockFlag.DYNAMIC_CHILD,
+                    DynamicBlockFlag.ORIGINAL,
+                ])
+            elif is_dynamic_block_child(block):
+                flags.append(DynamicBlockFlag.DYNAMIC_CHILD)
+
+            if is_dynamic_block(block):
+                flags.append(DynamicBlockFlag.DYNAMIC)
+
+            if is_replicated_block(block):
+                flags.append(DynamicBlockFlag.REPLICATED)
+
+            if should_reduce_output(block):
+                flags.append(DynamicBlockFlag.REDUCE_OUTPUT)
+
+            if len(flags) >= 1:
+                create_options['metrics'] = dict(metadata=dict(
+                    flags=flags,
+                ))
+
             block_arr.append((block_uuid, create_options))
 
         from mage_ai.data_preparation.models.global_hooks.pipelines import (
@@ -1416,9 +1482,9 @@ class BlockRun(BlockRunProjectPlatformMixin, BaseModel):
             repo_config=pipeline.repo_config,
         ).get_logs()
 
-    async def logs_async(self):
+    async def logs_async(self, repo_path: str = None):
         if project_platform_activated():
-            return await self.logs_async_project_platform()
+            return await self.logs_async_project_platform(repo_path=repo_path)
 
         pipeline = await Pipeline.get_async(self.pipeline_run.pipeline_uuid)
         return await LoggerManagerFactory.get_logger_manager(
@@ -1529,21 +1595,11 @@ class BlockRun(BlockRunProjectPlatformMixin, BaseModel):
                     ),
                 ]
 
-        # The block_run’s block_uuid for replicated blocks will be in this format:
-        # [block_uuid]:[replicated_block_uuid]
-        # We need to use the original block_uuid to get the proper output.
-
-        # Block runs for dynamic child blocks will have the following block UUID:
-        # [block.uuid]:[index]
-        # Don’t use the original UUID even if the block is a replica because it will get rid of
-        # the dynamic child block index.
-        if block.replicated_block and not is_dynamic_block_child(block):
-            block_uuid = block.uuid
-
         return block.get_outputs(
             execution_partition=self.pipeline_run.execution_partition,
             sample_count=sample_count,
             block_uuid=block_uuid,
+            metadata=self.metrics.get('metadata') if self.metrics else None,
         )
 
 

mage_ai/orchestration/db/models/schedules_project_platform.py

@@ -347,9 +347,8 @@ class PipelineRunProjectPlatformMixin:
 
 
 class BlockRunProjectPlatformMixin:
-    async def logs_async_project_platform(self):
-        repo_path = None
-        if self.pipeline_run and self.pipeline_run.pipeline_schedule:
+    async def logs_async_project_platform(self, repo_path: str = None):
+        if not repo_path and self.pipeline_run and self.pipeline_run.pipeline_schedule:
             repo_path = self.pipeline_run.pipeline_schedule.repo_path
 
         pipeline = await get_pipeline_from_platform_async(

mage_ai/orchestration/pipeline_scheduler_original.py

@@ -131,6 +131,10 @@ class PipelineScheduler:
         if self.pipeline_run.status == PipelineRun.PipelineRunStatus.RUNNING:
             return True
 
+        lock_key = f'pipeline_run_{self.pipeline_run.id}'
+        if not lock.try_acquire_lock(lock_key):
+            return
+
         tags = self.build_tags()
 
         is_integration = PipelineType.INTEGRATION == self.pipeline.type
@@ -167,6 +171,8 @@ class PipelineScheduler:
                 error=error_msg,
             )
             return False
+        finally:
+            lock.release_lock(lock_key)
 
         self.pipeline_run.update(
             started_at=datetime.now(tz=pytz.UTC),
@@ -296,7 +302,7 @@ class PipelineScheduler:
                     error_msg = 'Failed blocks: '\
                                 f'{", ".join([b.block_uuid for b in failed_block_runs])}.'
                 else:
-                    error_msg = 'Pipelien run timed out.'
+                    error_msg = 'Pipeline run timed out.'
                 self.notification_sender.send_pipeline_run_failure_message(
                     pipeline=self.pipeline,
                     pipeline_run=self.pipeline_run,
@@ -1099,6 +1105,7 @@ def run_block(
     return ExecutorFactory.get_block_executor(
         pipeline,
         block_uuid,
+        block_run_id=block_run.id,
         execution_partition=execution_partition,
     ).execute(
         block_run_id=block_run.id,
@@ -1493,16 +1500,17 @@ def schedule_all():
                         )
                     else:
                         payload['create_block_runs'] = False
-                        pipeline_run = PipelineRun.create(**payload)
-                        # Log Git sync status for new pipeline runs if a git sync result exists
-                        if git_sync_result:
-                            pipeline_scheduler = PipelineScheduler(pipeline_run)
-                            log_git_sync(
-                                git_sync_result,
-                                pipeline_scheduler.logger,
-                                pipeline_scheduler.build_tags(),
-                            )
-                        initial_pipeline_runs.append(pipeline_run)
+                        pipeline_run = PipelineRun.create(prevent_duplicates=True, **payload)
+                        if pipeline_run:
+                            # Log Git sync status for new pipeline runs if a git sync result exists
+                            if git_sync_result:
+                                pipeline_scheduler = PipelineScheduler(pipeline_run)
+                                log_git_sync(
+                                    git_sync_result,
+                                    pipeline_scheduler.logger,
+                                    pipeline_scheduler.build_tags(),
+                                )
+                            initial_pipeline_runs.append(pipeline_run)
 
                 # Enforce pipeline concurrency limit
                 pipeline_run_quota = None

mage_ai/orchestration/pipeline_scheduler_project_platform.py

@@ -139,6 +139,10 @@ class PipelineScheduler:
         if self.pipeline_run.status == PipelineRun.PipelineRunStatus.RUNNING:
             return True
 
+        lock_key = f'pipeline_run_{self.pipeline_run.id}'
+        if not lock.try_acquire_lock(lock_key):
+            return
+
         tags = self.build_tags()
 
         is_integration = PipelineType.INTEGRATION == self.pipeline.type
@@ -175,6 +179,8 @@ class PipelineScheduler:
                 error=error_msg,
             )
             return False
+        finally:
+            lock.release_lock(lock_key)
 
         self.pipeline_run.update(
             started_at=datetime.now(tz=pytz.UTC),
@@ -304,7 +310,7 @@ class PipelineScheduler:
                     error_msg = 'Failed blocks: '\
                                 f'{", ".join([b.block_uuid for b in failed_block_runs])}.'
                 else:
-                    error_msg = 'Pipelien run timed out.'
+                    error_msg = 'Pipeline run timed out.'
                 self.notification_sender.send_pipeline_run_failure_message(
                     pipeline=self.pipeline,
                     pipeline_run=self.pipeline_run,
@@ -1114,6 +1120,7 @@ def run_block(
     return ExecutorFactory.get_block_executor(
         pipeline,
         block_uuid,
+        block_run_id=block_run.id,
         execution_partition=execution_partition,
     ).execute(
         block_run_id=block_run.id,
@@ -1559,16 +1566,18 @@ def schedule_all():
                             )
                         else:
                             payload['create_block_runs'] = False
-                            pipeline_run = PipelineRun.create(**payload)
-                            # Log Git sync status for new pipeline runs if a git sync result exists
-                            if git_sync_result:
-                                pipeline_scheduler = PipelineScheduler(pipeline_run)
-                                log_git_sync(
-                                    git_sync_result,
-                                    pipeline_scheduler.logger,
-                                    pipeline_scheduler.build_tags(),
-                                )
-                            initial_pipeline_runs.append(pipeline_run)
+                            pipeline_run = PipelineRun.create(prevent_duplicates=True, **payload)
+                            if pipeline_run:
+                                # Log Git sync status for new pipeline runs if a git sync result
+                                # exists
+                                if git_sync_result:
+                                    pipeline_scheduler = PipelineScheduler(pipeline_run)
+                                    log_git_sync(
+                                        git_sync_result,
+                                        pipeline_scheduler.logger,
+                                        pipeline_scheduler.build_tags(),
+                                    )
+                                initial_pipeline_runs.append(pipeline_run)
 
                     # Enforce pipeline concurrency limit
                     pipeline_run_quota = None

mage_ai/presenters/interactions/constants.py

@@ -5,6 +5,7 @@ INTERACTIONS_DIRECTORY_NAME = 'interactions'
 
 class InteractionInputType(str, Enum):
     CHECKBOX = 'checkbox'
+    CODE = 'code'
     DROPDOWN_MENU = 'dropdown_menu'
     SWITCH = 'switch'
     TEXT_FIELD = 'text_field'

mage_ai/presenters/interactions/models.py

@@ -36,6 +36,7 @@ class InteractionInputOption:
 @dataclass
 class InteractionInputStyle:
     input_type: InteractionInputStyleInputType = None
+    language: str = None
     multiline: bool = None
 
     def __post_init__(self):
@@ -65,10 +66,10 @@ class InteractionInput:
         if self.type and isinstance(self.type, str):
             self.type = InteractionInputType(self.type)
 
-    def to_dict(self) -> Dict:
+    def to_dict(self, **kwargs) -> Dict:
         return dict(
-            options=[i.to_dict() for i in self.options],
-            style=self.style.to_dict() if self.style else None,
+            options=[i.to_dict(**kwargs) for i in self.options],
+            style=self.style.to_dict(**kwargs) if self.style else None,
             type=self.type.value if self.type else None,
         )
 

mage_ai/presenters/pages/models/client_pages/pipeline_schedules.py

@@ -38,7 +38,7 @@ class CreatePage(BasePage):
     @classmethod
     async def disabled(self, current_user: User = None, **kwargs) -> bool:
         pipelines = kwargs.get('pipelines') or []
-        for pipeline in pipelines:
+        for pipeline in [p for p in pipelines if p]:
             pipeline_schedule = PipelineScheduleResource.model_class(pipeline_uuid=pipeline.uuid)
             resource = PipelineScheduleResource(pipeline_schedule, current_user)
             policy = resource.policy_class()(resource, current_user)

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.57'
+'0.9.59'