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

mage_ai/data_preparation/executors/streaming_pipeline_executor.py

@@ -2,9 +2,12 @@ import asyncio
 import copy
 import logging
 import os
+import traceback
 from contextlib import redirect_stderr, redirect_stdout
+from datetime import datetime
 from typing import Callable, Dict, List, Union
 
+import pytz
 import yaml
 from jinja2 import Template
 
@@ -12,9 +15,14 @@ from mage_ai.data_preparation.executors.pipeline_executor import PipelineExecuto
 from mage_ai.data_preparation.logging.logger import DictLogger
 from mage_ai.data_preparation.models.constants import BlockLanguage, BlockType
 from mage_ai.data_preparation.models.pipeline import Pipeline
+from mage_ai.data_preparation.shared.retry import RetryConfig
 from mage_ai.data_preparation.shared.stream import StreamToLogger
 from mage_ai.data_preparation.shared.utils import get_template_vars
+from mage_ai.orchestration.db import safe_db_query
+from mage_ai.orchestration.db.models.schedules import PipelineRun
 from mage_ai.shared.hash import merge_dict
+from mage_ai.shared.retry import retry
+from mage_ai.usage_statistics.logger import UsageStatisticLogger
 
 
 class StreamingPipelineExecutor(PipelineExecutor):
@@ -22,6 +30,7 @@ class StreamingPipelineExecutor(PipelineExecutor):
         super().__init__(pipeline, **kwargs)
         # TODO: Support custom log destination for streaming pipelines
         self.parse_and_validate_blocks()
+        self.retry_metadata = dict(attempts=0)
 
     def parse_and_validate_blocks(self):
         """
@@ -67,6 +76,8 @@ class StreamingPipelineExecutor(PipelineExecutor):
         self,
         build_block_output_stdout: Callable[..., object] = None,
         global_vars: Dict = None,
+        pipeline_run_id: int = None,
+        retry_config: Dict = None,
         **kwargs,
     ) -> None:
         # TODOs:
@@ -74,6 +85,7 @@ class StreamingPipelineExecutor(PipelineExecutor):
         # 2. Support flink pipeline
 
         tags = self.build_tags(**kwargs)
+        self.logging_tags = tags
         if build_block_output_stdout:
             stdout_logger = logging.getLogger('streaming_pipeline_executor')
             self.logger = DictLogger(stdout_logger)
@@ -82,24 +94,53 @@ class StreamingPipelineExecutor(PipelineExecutor):
             self.logger = DictLogger(self.logger_manager.logger, logging_tags=tags)
             stdout = StreamToLogger(self.logger, logging_tags=tags)
         try:
-            with redirect_stdout(stdout):
-                with redirect_stderr(stdout):
-                    self.__execute_in_python(
-                        build_block_output_stdout=build_block_output_stdout,
-                        global_vars=global_vars,
-                    )
+            if retry_config is None:
+                retry_config = self.pipeline.retry_config or dict()
+            infinite_retries = False if retry_config else False
+
+            if type(retry_config) is not RetryConfig:
+                retry_config = RetryConfig.load(config=retry_config)
+
+            @retry(
+                retries=retry_config.retries,
+                delay=retry_config.delay,
+                max_delay=retry_config.max_delay,
+                exponential_backoff=retry_config.exponential_backoff,
+                logger=self.logger,
+                logging_tags=self.logging_tags,
+                retry_metadata=self.retry_metadata,
+            )
+            def __execute_with_retry():
+                with redirect_stdout(stdout):
+                    with redirect_stderr(stdout):
+                        self.__execute_in_python(
+                            build_block_output_stdout=build_block_output_stdout,
+                            global_vars=global_vars,
+                            pipeline_run_id=pipeline_run_id,
+                        )
+            __execute_with_retry()
         except Exception as e:
             if not build_block_output_stdout:
                 self.logger.exception(
                         f'Failed to execute streaming pipeline {self.pipeline.uuid}',
                         **merge_dict(dict(error=e), tags),
                     )
+            if not infinite_retries:
+                # If pipeline retry config is present, fail the pipeline after the retries
+                self.__update_pipeline_run_status(
+                    pipeline_run_id,
+                    PipelineRun.PipelineRunStatus.FAILED,
+                    error=e,
+                )
+
             raise e
 
     def __execute_in_python(
         self,
         build_block_output_stdout: Callable[..., object] = None,
-        global_vars: Dict = None
+        global_vars: Dict = None,
+        pipeline_run_id: int = None,
+
     ):
         from mage_ai.streaming.sinks.sink_factory import SinkFactory
         from mage_ai.streaming.sources.base import SourceConsumeMethod
@@ -227,6 +268,35 @@ class StreamingPipelineExecutor(PipelineExecutor):
             for sink in sinks_by_uuid.values():
                 sink.destroy()
 
+    @safe_db_query
+    def __update_pipeline_run_status(
+        self,
+        pipeline_run_id: int,
+        status: PipelineRun.PipelineRunStatus,
+        error: Exception = None,
+    ):
+        if not pipeline_run_id or not status:
+            return
+        pipeline_run = PipelineRun.query.get(pipeline_run_id)
+        pipeline_run.update(
+            status=status,
+            completed_at=datetime.now(tz=pytz.UTC),
+        )
+        if status == PipelineRun.PipelineRunStatus.FAILED:
+            asyncio.run(UsageStatisticLogger().pipeline_run_ended(pipeline_run))
+            error_msg = None
+            stacktrace = None
+            if error is not None:
+                error_msg = str(error)
+                stacktrace = traceback.format_exc()
+            notification_sender = self.pipeline.get_notification_sender()
+            notification_sender.send_pipeline_run_failure_message(
+                pipeline=self.pipeline,
+                pipeline_run=pipeline_run,
+                error=error_msg,
+                stacktrace=stacktrace,
+            )
+
     def __execute_in_flink(self):
         """
         TODO: Implement this method

mage_ai/data_preparation/logging/gcs_logger_manager.py

@@ -10,9 +10,9 @@ from mage_ai.shared.config import BaseConfig
 
 @dataclass
 class GCSConfig(BaseConfig):
-    path_to_credentials: str
     bucket: str
     prefix: str
+    path_to_credentials: str = None
 
 
 class GCSLoggerManager(LoggerManager):
@@ -23,9 +23,12 @@ class GCSLoggerManager(LoggerManager):
     ):
         super().__init__(repo_config=repo_config, **kwargs)
         self.gcs_config = GCSConfig.load(config=self.logging_config.destination_config)
-        credentials = service_account.Credentials.from_service_account_file(
-            self.gcs_config.path_to_credentials
-        )
+        if self.gcs_config.path_to_credentials:
+            credentials = service_account.Credentials.from_service_account_file(
+                self.gcs_config.path_to_credentials
+            )
+        else:
+            credentials = None
         self.gcs_client = storage.Client(credentials=credentials)
 
     def create_log_filepath_dir(self, path):

mage_ai/data_preparation/models/block/__init__.py

@@ -90,7 +90,7 @@ from mage_ai.data_preparation.templates.data_integrations.utils import get_templ
 from mage_ai.data_preparation.templates.template import load_template
 from mage_ai.server.kernel_output_parser import DataType
 from mage_ai.services.spark.config import SparkConfig
-from mage_ai.services.spark.spark import get_spark_session
+from mage_ai.services.spark.spark import SPARK_ENABLED, get_spark_session
 from mage_ai.settings.platform.constants import project_platform_activated
 from mage_ai.settings.repo import get_repo_path
 from mage_ai.shared.array import unique_by
@@ -723,41 +723,6 @@ class Block(DataIntegrationMixin, SparkBlock, ProjectPlatformAccessible):
                 widget=widget,
             )
 
-    @classmethod
-    def block_class_from_type(self, block_type: str, language=None, pipeline=None) -> 'Block':
-        from mage_ai.data_preparation.models.block.constants import BLOCK_TYPE_TO_CLASS
-        from mage_ai.data_preparation.models.block.integration import (
-            DestinationBlock,
-            SourceBlock,
-            TransformerBlock,
-        )
-        from mage_ai.data_preparation.models.block.r import RBlock
-        from mage_ai.data_preparation.models.block.sql import SQLBlock
-        from mage_ai.data_preparation.models.widget import Widget
-
-        if BlockType.CHART == block_type:
-            return Widget
-        elif BlockType.DBT == block_type:
-            from mage_ai.data_preparation.models.block.dbt import DBTBlock
-
-            return DBTBlock
-        elif pipeline and PipelineType.INTEGRATION == pipeline.type:
-            if BlockType.CALLBACK == block_type:
-                return CallbackBlock
-            elif BlockType.CONDITIONAL == block_type:
-                return ConditionalBlock
-            elif BlockType.DATA_LOADER == block_type:
-                return SourceBlock
-            elif BlockType.DATA_EXPORTER == block_type:
-                return DestinationBlock
-            else:
-                return TransformerBlock
-        elif BlockLanguage.SQL == language:
-            return SQLBlock
-        elif BlockLanguage.R == language:
-            return RBlock
-        return BLOCK_TYPE_TO_CLASS.get(block_type)
-
     @classmethod
     def create(
         self,
@@ -777,6 +742,8 @@ class Block(DataIntegrationMixin, SparkBlock, ProjectPlatformAccessible):
         widget: bool = False,
         downstream_block_uuids: List[str] = None,
     ) -> 'Block':
+        from mage_ai.data_preparation.models.block.block_factory import BlockFactory
+
         """
         1. Create a new folder for block_type if not exist
         2. Create a new python file with code template
@@ -870,7 +837,11 @@ class Block(DataIntegrationMixin, SparkBlock, ProjectPlatformAccessible):
                     language,
                 )
 
-        block = self.block_class_from_type(block_type, pipeline=pipeline)(
+        block = BlockFactory.block_class_from_type(
+            block_type,
+            language=language,
+            pipeline=pipeline,
+        )(
             name,
             uuid,
             block_type,
@@ -931,43 +902,16 @@ class Block(DataIntegrationMixin, SparkBlock, ProjectPlatformAccessible):
                     block_uuids[t.value].append(f.split('.')[0])
         return block_uuids
 
-    @classmethod
-    def get_block(
-        self,
-        name,
-        uuid,
-        block_type,
-        configuration=None,
-        content=None,
-        language=None,
-        pipeline=None,
-        status=BlockStatus.NOT_EXECUTED,
-    ) -> 'Block':
-        block_class = self.block_class_from_type(
-            block_type,
-            language=language,
-            pipeline=pipeline,
-        ) or Block
-        return block_class(
-            name,
-            uuid,
-            block_type,
-            configuration=configuration,
-            content=content,
-            language=language,
-            pipeline=pipeline,
-            status=status,
-        )
-
     @classmethod
     def get_block_from_file_path(self, file_path: str) -> 'Block':
         parts = get_path_parts(file_path)
 
         if parts and len(parts) >= 3:
+            from mage_ai.data_preparation.models.block.block_factory import BlockFactory
+
             # If file_path == transformers/test4.py
             # parts ==
             # ('/home/src/default_repo/default_platform2/project3', 'transformers', 'test4.py')
-
             # If project platform platform activated, then parts ==
             # ('/home/src', 'default_repo', 'data_loaders/astral_violet.py')
 
@@ -986,7 +930,7 @@ class Block(DataIntegrationMixin, SparkBlock, ProjectPlatformAccessible):
             configuration = dict(file_path=file_path, file_source=dict(path=file_path))
             language = FILE_EXTENSION_TO_BLOCK_LANGUAGE.get(extension)
 
-            return self.get_block(
+            return BlockFactory.get_block(
                 block_uuid,
                 block_uuid,
                 block_type,
@@ -2445,8 +2389,10 @@ df = get_variable('{self.pipeline.uuid}', '{self.uuid}', 'df')
             return Template(self.executor_type).render(**get_template_vars())
         return self.executor_type
 
-    def get_pipelines_from_cache(self) -> List[Dict]:
-        arr = BlockCache().get_pipelines(self)
+    def get_pipelines_from_cache(self, block_cache: BlockCache = None) -> List[Dict]:
+        if block_cache is None:
+            block_cache = BlockCache()
+        arr = block_cache.get_pipelines(self)
 
         return unique_by(
             arr,
@@ -2497,11 +2443,13 @@ df = get_variable('{self.pipeline.uuid}', '{self.uuid}', 'df')
     def to_dict(
         self,
         include_block_catalog: bool = False,
+        include_block_pipelines: bool = False,
         include_callback_blocks: bool = False,
         include_content: bool = False,
         include_outputs: bool = False,
         include_outputs_spark: bool = False,
         sample_count: int = None,
+        block_cache: BlockCache = None,
         check_if_file_exists: bool = False,
         **kwargs,
     ) -> Dict:
@@ -2515,6 +2463,9 @@ df = get_variable('{self.pipeline.uuid}', '{self.uuid}', 'df')
         if include_block_catalog and self.is_data_integration() and self.pipeline:
             data['catalog'] = self.get_catalog_from_file()
 
+        if include_block_pipelines:
+            data['pipelines'] = self.get_pipelines_from_cache(block_cache=block_cache)
+
         if include_outputs:
             include_outputs_use = include_outputs
             if self.is_using_spark() and self.compute_management_enabled():
@@ -2551,6 +2502,7 @@ df = get_variable('{self.pipeline.uuid}', '{self.uuid}', 'df')
         include_outputs: bool = False,
         include_outputs_spark: bool = False,
         sample_count: int = None,
+        block_cache: BlockCache = None,
         check_if_file_exists: bool = False,
         **kwargs,
     ) -> Dict:
@@ -2596,7 +2548,7 @@ df = get_variable('{self.pipeline.uuid}', '{self.uuid}', 'df')
             data['tags'] = self.tags()
 
         if include_block_pipelines:
-            data['pipelines'] = self.get_pipelines_from_cache()
+            data['pipelines'] = self.get_pipelines_from_cache(block_cache=block_cache)
 
         return data
 
@@ -3093,6 +3045,8 @@ df = get_variable('{self.pipeline.uuid}', '{self.uuid}', 'df')
         return global_vars
 
     def get_spark_session(self):
+        if not SPARK_ENABLED:
+            return None
         if self.spark_init and (not self.pipeline or
                                 not self.pipeline.spark_config):
             return self.spark
@@ -3520,12 +3474,15 @@ df = get_variable('{self.pipeline.uuid}', '{self.uuid}', 'df')
 
             cache = BlockCache()
             if detach:
+                from mage_ai.data_preparation.models.block.block_factory import (
+                    BlockFactory,
+                )
                 """"
                 New block added to pipeline, so it must be added to the block cache.
                 Old block no longer in pipeline, so it must be removed from block cache.
                 """
                 cache.add_pipeline(self, self.pipeline)
-                old_block = self.get_block(
+                old_block = BlockFactory.get_block(
                     old_uuid,
                     old_uuid,
                     self.type,

mage_ai/data_preparation/models/block/block_factory.py

@@ -0,0 +1,77 @@
+from mage_ai.data_preparation.models.block import Block, CallbackBlock, ConditionalBlock
+from mage_ai.data_preparation.models.block.constants import BLOCK_TYPE_TO_CLASS
+from mage_ai.data_preparation.models.block.integration import (
+    DestinationBlock,
+    SourceBlock,
+    TransformerBlock,
+)
+from mage_ai.data_preparation.models.block.r import RBlock
+from mage_ai.data_preparation.models.block.sql import SQLBlock
+from mage_ai.data_preparation.models.constants import (
+    BlockLanguage,
+    BlockStatus,
+    BlockType,
+    PipelineType,
+)
+from mage_ai.data_preparation.models.widget import Widget
+
+try:
+    from mage_ai.data_preparation.models.block.dbt.block_sql import DBTBlockSQL
+    from mage_ai.data_preparation.models.block.dbt.block_yaml import DBTBlockYAML
+except Exception:
+    print('DBT library not installed.')
+
+
+class BlockFactory:
+    @classmethod
+    def block_class_from_type(self, block_type: str, language=None, pipeline=None) -> 'Block':
+        if BlockType.CHART == block_type:
+            return Widget
+        elif BlockType.DBT == block_type:
+            if language == BlockLanguage.YAML:
+                return DBTBlockYAML
+            return DBTBlockSQL
+        elif pipeline and PipelineType.INTEGRATION == pipeline.type:
+            if BlockType.CALLBACK == block_type:
+                return CallbackBlock
+            elif BlockType.CONDITIONAL == block_type:
+                return ConditionalBlock
+            elif BlockType.DATA_LOADER == block_type:
+                return SourceBlock
+            elif BlockType.DATA_EXPORTER == block_type:
+                return DestinationBlock
+            else:
+                return TransformerBlock
+        elif BlockLanguage.SQL == language:
+            return SQLBlock
+        elif BlockLanguage.R == language:
+            return RBlock
+        return BLOCK_TYPE_TO_CLASS.get(block_type)
+
+    @classmethod
+    def get_block(
+        self,
+        name,
+        uuid,
+        block_type,
+        configuration=None,
+        content=None,
+        language=None,
+        pipeline=None,
+        status=BlockStatus.NOT_EXECUTED,
+    ) -> 'Block':
+        block_class = BlockFactory.block_class_from_type(
+            block_type,
+            language=language,
+            pipeline=pipeline,
+        ) or Block
+        return block_class(
+            name,
+            uuid,
+            block_type,
+            configuration=configuration,
+            content=content,
+            language=language,
+            pipeline=pipeline,
+            status=status,
+        )

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

@@ -202,18 +202,29 @@ class DataIntegrationMixin:
             with open(catalog_full_path, mode='w') as f:
                 f.write(json.dumps(catalog))
 
-    def is_data_integration(self) -> bool:
+    def is_data_integration(self, pipeline_project: Project = None) -> bool:
         """
         Check if the block is a data integration block.
         If the data_integration_in_batch_pipeline feature is not enabled, return False.
 
+        Args:
+            pipeline_project (Project, optional): A cached Project value to avoid
+                looking it up many times when called inside loops. Defaults to None.
+
         Returns:
             bool: True if it's a data integration block, False otherwise.
         """
-        if not self.pipeline or not \
-                Project(self.pipeline.repo_config).is_feature_enabled(
-                    FeatureUUID.DATA_INTEGRATION_IN_BATCH_PIPELINE,
-                ):
+        if not self.pipeline:
+
+            return False
+
+        actual_project: Project = pipeline_project
+        if not actual_project:
+            actual_project = Project(self.pipeline.repo_config)
+
+        if not actual_project.is_feature_enabled(
+                        FeatureUUID.DATA_INTEGRATION_IN_BATCH_PIPELINE,
+                    ):
 
             return False
 

mage_ai/data_preparation/models/block/dbt/block.py

@@ -26,19 +26,17 @@ from mage_ai.shared.parsers import encode_complex
 
 
 class DBTBlock(Block):
-    def __new__(cls, *args, **kwargs) -> 'DBTBlock':
+    @classmethod
+    def create(cls, *args, **kwargs) -> 'DBTBlock':
         """
         Factory for the child blocks
         """
         # Import Child blocks here to prevent cycle import
         from mage_ai.data_preparation.models.block.dbt.block_sql import DBTBlockSQL
         from mage_ai.data_preparation.models.block.dbt.block_yaml import DBTBlockYAML
-        if cls is DBTBlock:
-            if kwargs.get('language', BlockLanguage.SQL) == BlockLanguage.YAML:
-                return super(DBTBlock, cls).__new__(DBTBlockYAML)
-            return super(DBTBlock, cls).__new__(DBTBlockSQL)
-        else:
-            return super(DBTBlock, cls).__new__(cls, *args, **kwargs)
+        if kwargs.get('language', BlockLanguage.SQL) == BlockLanguage.YAML:
+            return DBTBlockYAML(*args, **kwargs)
+        return DBTBlockSQL(*args, **kwargs)
 
     @property
     def base_project_path(self) -> Union[str, os.PathLike]:

mage_ai/data_preparation/models/block/dynamic/child.py

@@ -229,3 +229,6 @@ class DynamicChildController:
             block_runs.append(block_run)
 
         return block_runs
+
+    def run_tests(self, **kwargs):
+        pass

mage_ai/data_preparation/models/block/dynamic/variables.py

@@ -6,7 +6,7 @@ from typing import Any, Dict, List, Tuple, Union
 
 import pandas as pd
 
-from mage_ai.data_preparation.models.constants import BlockLanguage
+from mage_ai.data_preparation.models.constants import BlockLanguage, BlockType
 from mage_ai.data_preparation.models.variable import Variable
 from mage_ai.shared.memory import get_memory_usage, get_memory_usage_async
 from mage_ai.shared.strings import to_ordinal_integers
@@ -470,7 +470,7 @@ def fetch_input_variables_for_dynamic_upstream_blocks(
 
             # If dynamic child should reduce its output (which means it passes the entire
             # output to its downstream blocks):
-            if should_reduce_output(upstream_block):
+            if should_reduce_output(upstream_block) and block.type != BlockType.EXTENSION:
                 child_data = []
                 metadata = {}
                 for lazy_variable_set in lazy_variable_controller:

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

@@ -45,4 +45,5 @@ def handle_run_tests(
             global_vars=global_vars,
             logger=logger,
             logging_tags=logging_tags,
+            update_status=False,
         )

mage_ai/data_preparation/models/block/global_data_product/__init__.py

@@ -2,12 +2,15 @@ from logging import Logger
 from typing import Dict, List
 
 from mage_ai.data_preparation.models.block import Block
-from mage_ai.data_preparation.models.global_data_product import GlobalDataProduct
-from mage_ai.orchestration.triggers import global_data_product as trigger
 
 
 class GlobalDataProductBlock(Block):
-    def get_global_data_product(self) -> GlobalDataProduct:
+    def get_global_data_product(self):
+        # Avoid circular dependency of Pipeline class
+        from mage_ai.data_preparation.models.global_data_product import (
+            GlobalDataProduct,
+        )
+
         override_configuration = (self.configuration or {}).get('global_data_product', {})
         global_data_product = GlobalDataProduct.get(override_configuration.get('uuid'))
 
@@ -31,6 +34,9 @@ class GlobalDataProductBlock(Block):
         logging_tags: Dict = None,
         **kwargs,
     ) -> List:
+        # Avoid circular dependency of Pipeline class
+        from mage_ai.orchestration.triggers import global_data_product as trigger
+
         trigger.trigger_and_check_status(
             self.get_global_data_product(),
             block=self,

mage_ai/data_preparation/models/block/integration/__init__.py

@@ -155,7 +155,7 @@ class IntegrationBlock(Block):
                 proc = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
 
                 for line in proc.stdout:
-                    f.write(line.decode()),
+                    f.write(line.decode())
                     print_log_from_line(
                         line,
                         config=config,
@@ -416,9 +416,10 @@ class SourceBlock(IntegrationBlock):
 class DestinationBlock(IntegrationBlock):
     def to_dict(
         self,
-        include_content=False,
-        include_outputs=False,
-        sample_count=None,
+        include_content: bool = False,
+        include_outputs: bool = False,
+        include_block_pipelines: bool = False,
+        sample_count: int = None,
         check_if_file_exists: bool = False,
         destination_table: str = None,
         state_stream: str = None,
@@ -444,6 +445,7 @@ class DestinationBlock(IntegrationBlock):
             super().to_dict(
                 include_content=include_content,
                 include_outputs=include_outputs,
+                include_block_pipelines=include_block_pipelines,
                 sample_count=sample_count,
                 check_if_file_exists=check_if_file_exists,
             ),
@@ -452,9 +454,10 @@ class DestinationBlock(IntegrationBlock):
 
     async def to_dict_async(
         self,
-        include_content=False,
-        include_outputs=False,
-        sample_count=None,
+        include_content: bool = False,
+        include_outputs: bool = False,
+        include_block_pipelines: bool = False,
+        sample_count: int = None,
         check_if_file_exists: bool = False,
         destination_table: str = None,
         state_stream: str = None,
@@ -463,13 +466,14 @@ class DestinationBlock(IntegrationBlock):
         return self.to_dict(
             include_content=include_content,
             include_outputs=include_outputs,
+            include_block_pipelines=include_block_pipelines,
             sample_count=sample_count,
             check_if_file_exists=check_if_file_exists,
             destination_table=destination_table,
             state_stream=state_stream,
         )
 
-    def update(self, data, update_state=False):
+    def update(self, data, update_state=False, **kwargs):
         if update_state:
             from mage_ai.data_preparation.models.pipelines.integration_pipeline import (
                 IntegrationPipeline,
@@ -493,7 +497,7 @@ class DestinationBlock(IntegrationBlock):
                     bookmark_values=bookmark_values
                 )
 
-        return super().update(data)
+        return super().update(data, **kwargs)
 
     def output_variables(self, execution_partition: str = None) -> List[str]:
         return []

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

@@ -233,7 +233,7 @@ class ProjectPlatformAccessible:
                 ),
             )
 
-        return block_class(
+        return block_class.create(
             name,
             uuid,
             block_type,

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

@@ -337,7 +337,7 @@ def execute_sql_code(
             if should_query:
                 return [
                     loader.load(
-                        f'SELECT * FROM {table_name}',
+                        f'SELECT * FROM {schema}.{table_name}',
                         verbose=False,
                     ),
                 ]