mage-ai 0.9.12__py3-none-any.whl → 0.9.14__py3-none-any.whl

mage_ai/api/resources/PipelineScheduleResource.py

@@ -1,14 +1,16 @@
+import importlib
 import uuid
 
 from sqlalchemy.orm import selectinload
 
 from mage_ai.api.resources.DatabaseResource import DatabaseResource
-from mage_ai.orchestration.db import safe_db_query
+from mage_ai.orchestration.db import db_connection, safe_db_query
 from mage_ai.orchestration.db.models.schedules import (
     EventMatcher,
     PipelineSchedule,
     pipeline_schedule_event_matcher_association_table,
 )
+from mage_ai.orchestration.db.models.tags import Tag, TagAssociation, TagAssociationWithTag
 from mage_ai.settings.repo import get_repo_path
 from mage_ai.shared.hash import merge_dict
 
@@ -17,6 +19,10 @@ class PipelineScheduleResource(DatabaseResource):
     datetime_keys = ['start_time']
     model_class = PipelineSchedule
 
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.tag_associations_updated = None
+
     @classmethod
     @safe_db_query
     def collection(self, query_arg, meta, user, **kwargs):
@@ -26,7 +32,35 @@ class PipelineScheduleResource(DatabaseResource):
         if global_data_product_uuid:
             global_data_product_uuid = global_data_product_uuid[0]
 
+        tag_names = query_arg.get('tag[]', [])
+        if tag_names:
+            if isinstance(tag_names, str):
+                tag_names = tag_names.split(',')
+
         query = PipelineSchedule.repo_query
+
+        if len(tag_names) >= 1:
+            tag_associations = (
+                TagAssociation.
+                select(
+                    Tag.name,
+                    TagAssociation.taggable_id,
+                    TagAssociation.taggable_type,
+                ).
+                join(
+                    Tag,
+                    Tag.id == TagAssociation.tag_id,
+                ).
+                filter(
+                    Tag.name.in_(tag_names),
+                    TagAssociation.taggable_type == self.model_class.__name__,
+                ).
+                all()
+            )
+            query = query.filter(
+                PipelineSchedule.id.in_([ta.taggable_id for ta in tag_associations]),
+            )
+
         if global_data_product_uuid or pipeline:
             query = (
                 query.
@@ -108,6 +142,128 @@ class PipelineScheduleResource(DatabaseResource):
                 ps = [p for p in PipelineSchedule.query.filter(PipelineSchedule.id.in_(new_ids))]
                 em.update(pipeline_schedules=ps)
 
+        tag_names = payload.pop('tags', None)
+        if tag_names is not None:
+            # 1. Fetch all tag associations
+            # 2. Delete any tag associations that don’t have a tag in tag_names
+            tag_associations_to_keep = []
+            tag_associations_to_delete = []
+            for ta in self.tag_associations:
+                if ta.name in tag_names:
+                    tag_associations_to_keep.append(ta)
+                else:
+                    tag_associations_to_delete.append(ta)
+
+            if len(tag_associations_to_delete) >= 1:
+                delete_query = TagAssociation.__table__.delete().where(
+                    TagAssociation.id.in_(
+                        [ta.id for ta in tag_associations_to_delete],
+                    ),
+                )
+                db_connection.session.execute(delete_query)
+
+            # 3. Fetch all tags in tag_names that aren’t in tag associations
+            existing_tags = Tag.query.filter(
+                Tag.name.in_(tag_names),
+                Tag.name.not_in([ta.name for ta in tag_associations_to_keep]),
+            ).all()
+            existing_tag_pks = []
+            existing_tag_names = []
+            for tag in existing_tags:
+                existing_tag_pks.append(tag.id)
+                existing_tag_names.append(tag.name)
+
+            # 4. Create new tags
+            tag_names_to_keep = [ta.name for ta in tag_associations_to_keep]
+            tag_names_to_create = \
+                [tag_name for tag_name in tag_names if tag_name not in (
+                    existing_tag_names + tag_names_to_keep
+                )]
+
+            new_tags = [Tag(name=tag_name) for tag_name in tag_names_to_create]
+            db_connection.session.bulk_save_objects(
+                new_tags,
+                return_defaults=True,
+            )
+
+            # 5. Create tag associations
+            tag_names_to_use = existing_tag_names.copy()
+            tag_ids_to_use = existing_tag_pks.copy()
+            for tag in new_tags:
+                tag_names_to_use.append(tag.name)
+                tag_ids_to_use.append(tag.id)
+
+            new_tag_associations = [TagAssociation(
+                tag_id=tag_id,
+                taggable_id=self.model.id,
+                taggable_type=self.model.__class__.__name__,
+            ) for tag_id in tag_ids_to_use]
+            db_connection.session.bulk_save_objects(
+                new_tag_associations,
+                return_defaults=True,
+            )
+
+            tag_associations_updated = []
+            for tag_name, new_tag_association in zip(tag_names_to_use, new_tag_associations):
+                taw = TagAssociationWithTag(
+                    id=new_tag_association.id,
+                    name=tag_name,
+                    tag_id=new_tag_association.tag_id,
+                    taggable_id=new_tag_association.taggable_id,
+                    taggable_type=new_tag_association.taggable_type,
+                )
+                tag_associations_updated.append(taw)
+
+            self.tag_associations_updated = tag_associations_updated + tag_associations_to_keep
+
         super().update(payload)
 
         return self
+
+    def get_tag_associations(self):
+        if self.tag_associations_updated is None:
+            return self.tag_associations
+        else:
+            return self.tag_associations_updated
+
+
+def __load_tag_associations(resource):
+    pipeline_schedule_ids = [r.id for r in resource.result_set()]
+    result = (
+        TagAssociation.
+        select(
+            TagAssociation.id,
+            TagAssociation.tag_id,
+            TagAssociation.taggable_id,
+            TagAssociation.taggable_type,
+            Tag.name,
+        ).
+        join(
+            Tag,
+            Tag.id == TagAssociation.tag_id,
+        ).
+        filter(
+            TagAssociation.taggable_id.in_(pipeline_schedule_ids),
+            TagAssociation.taggable_type == resource.model.__class__.__name__,
+        ).
+        all()
+    )
+    TagResource = getattr(
+        importlib.import_module('mage_ai.api.resources.TagResource'),
+        'TagResource',
+    )
+
+    return TagResource.build_result_set(result, resource.current_user)
+
+
+def __select_tag_associations(resource, arr):
+    def _func(res):
+        return resource.id == res.taggable_id
+    return list(filter(_func, arr))
+
+
+PipelineScheduleResource.register_collective_loader(
+    'tag_associations',
+    load=__load_tag_associations,
+    select=__select_tag_associations,
+)

mage_ai/api/resources/SearchResultResource.py

@@ -36,6 +36,7 @@ def filter_results(result: Dict) -> bool:
 
     if block_type in [
         BlockType.CALLBACK,
+        BlockType.CHART,
         BlockType.CONDITIONAL,
         BlockType.EXTENSION,
     ]:

mage_ai/api/resources/TagResource.py

@@ -1,15 +1,28 @@
-from mage_ai.api.resources.GenericResource import GenericResource
+from mage_ai.api.resources.DatabaseResource import DatabaseResource
 from mage_ai.cache.tag import TagCache
+from mage_ai.orchestration.db import safe_db_query
+from mage_ai.orchestration.db.models.tags import Tag
+from mage_ai.shared.array import unique_by
 
 
-class TagResource(GenericResource):
+class TagResource(DatabaseResource):
+    model_class = Tag
+
     @classmethod
+    @safe_db_query
     async def collection(self, query, meta, user, **kwargs):
         cache = await TagCache.initialize_cache()
         tag_uuids = cache.get_tags().keys()
+        tags = sorted(
+            unique_by(
+                list(Tag.query.all()) + [Tag(name=uuid) for uuid in tag_uuids],
+                lambda x: x.name,
+            ),
+            key=lambda x: x.name,
+        )
 
         return self.build_result_set(
-            [dict(uuid=uuid) for uuid in tag_uuids],
+            tags,
             user,
             **kwargs,
         )

mage_ai/data_integrations/sources/constants.py

@@ -38,6 +38,7 @@ SOURCES = sorted([
     dict(name='Pipedrive'),
     dict(name='Postmark'),
     dict(name='Salesforce'),
+    dict(name='Sftp'),
     dict(name='Stripe'),
     dict(name='Twitter Ads'),
     dict(name='Zendesk'),

mage_ai/data_preparation/git/__init__.py

@@ -434,6 +434,24 @@ class Git:
                 for url in remote.urls:
                     if url.lower().startswith('https'):
                         repository_names.append('/'.join(url.split('/')[-2:]).replace('.git', ''))
+
+                        # Remove the token from the URL
+                        # e.g. https://[user]:[token]@[netloc]
+                        parts = url.split('@')
+
+                        parts_arr = []
+                        if len(parts) >= 2:
+                            # https://[user]:[token]
+                            parts2 = parts[0].split(':')
+                            # ['https', '', 'user', 'token']
+                            parts2[len(parts2) - 1] = '[token]'
+                            parts_arr.append(':'.join(parts2))
+                            parts_arr += parts[1:]
+                        else:
+                            parts_arr += parts
+
+                        url = '@'.join(parts_arr)
+
                     urls.append(url)
             except GitCommandError as err:
                 print('WARNING (mage_ai.data_preparation.git.remotes):')

mage_ai/data_preparation/models/block/__init__.py

@@ -17,6 +17,7 @@ import pandas as pd
 import simplejson
 from jinja2 import Template
 
+import mage_ai.data_preparation.decorators
 from mage_ai.cache.block import BlockCache
 from mage_ai.data_cleaner.shared.utils import is_geo_dataframe, is_spark_dataframe
 from mage_ai.data_preparation.logging.logger import DictLogger
@@ -70,6 +71,7 @@ from mage_ai.shared.utils import clean_name as clean_name_orig
 from mage_ai.shared.utils import is_spark_env
 
 PYTHON_COMMAND = 'python3'
+BLOCK_EXISTS_ERROR = '[ERR_BLOCK_EXISTS]'
 
 
 async def run_blocks(
@@ -497,6 +499,7 @@ class Block:
         pipeline=None,
         priority: int = None,
         replicated_block: str = None,
+        require_unique_name: bool = False,
         upstream_block_uuids: List[str] = None,
         config: Dict = None,
         widget: bool = False,
@@ -513,9 +516,14 @@ class Block:
         uuid = clean_name(name)
         language = language or BlockLanguage.PYTHON
 
-        # Don’t create a file if block is replicated from another block
+        # Don’t create a file if block is replicated from another block.
+
+        # Only create a file on the filesystem if the block type isn’t a global data product
+        # because global data products reference a data product which already has its
+        # own files.
         if not replicated_block and \
-                (BlockType.DBT != block_type or BlockLanguage.YAML == language):
+                (BlockType.DBT != block_type or BlockLanguage.YAML == language) and \
+                BlockType.GLOBAL_DATA_PRODUCT != block_type:
 
             block_directory = self.file_directory_name(block_type)
             block_dir_path = os.path.join(repo_path, block_directory)
@@ -527,16 +535,20 @@ class Block:
             file_extension = BLOCK_LANGUAGE_TO_FILE_EXTENSION[language]
             file_path = os.path.join(block_dir_path, f'{uuid}.{file_extension}')
             if os.path.exists(file_path):
-                if pipeline is not None and pipeline.has_block(
+                if (pipeline is not None and pipeline.has_block(
                     uuid,
                     block_type=block_type,
                     extension_uuid=extension_uuid,
-                ):
-                    raise Exception(f'Block {uuid} already exists. Please use a different name.')
-            elif BlockType.GLOBAL_DATA_PRODUCT != block_type:
-                # Only create a file on the filesystem if the block type isn’t a global data product
-                # because global data products reference a data product which already has its
-                # own files.
+                )) or require_unique_name:
+                    """
+                    The BLOCK_EXISTS_ERROR constant is used on the frontend to identify when
+                    a user is trying to create a new block with an existing block name, and
+                    link them to the existing block file so the user can choose to add the
+                    existing block to their pipeline.
+                    """
+                    raise Exception(f'{BLOCK_EXISTS_ERROR} Block {uuid} already exists. \
+                                    Please use a different name.')
+            else:
                 load_template(
                     block_type,
                     config,
@@ -1099,6 +1111,8 @@ class Block:
     ) -> List:
         if logging_tags is None:
             logging_tags = dict()
+        if input_vars is None:
+            input_vars = list()
 
         decorated_functions = []
         test_functions = []
@@ -1166,9 +1180,18 @@ class Block:
                         block_uuid = self.replicated_block
                         block_file_path = self.replicated_block_object.file_path
                     spec = importlib.util.spec_from_file_location(
-                        block_uuid, block_file_path,
+                        block_uuid,
+                        block_file_path,
                     )
                     module = importlib.util.module_from_spec(spec)
+                    # Set the decorators in the module in case they are not defined in the block
+                    # code
+                    setattr(
+                        module,
+                        self.type,
+                        getattr(mage_ai.data_preparation.decorators, self.type),
+                    )
+                    module.test = mage_ai.data_preparation.decorators.test
                     spec.loader.exec_module(module)
                     block_function_updated = getattr(module, block_function.__name__)
                     self.module = module
@@ -2261,7 +2284,7 @@ df = get_variable('{self.pipeline.uuid}', '{block_uuid}', 'df')
                     f'Block {new_uuid} already exists in pipeline. Please use a different name.'
                 )
 
-        if not self.replicated_block:
+        if not self.replicated_block and BlockType.GLOBAL_DATA_PRODUCT != self.type:
             if os.path.exists(new_file_path):
                 raise Exception(f'Block {new_uuid} already exists. Please use a different name.')
 

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

@@ -94,6 +94,7 @@ def parse_attributes(block) -> Dict:
     config = model_config(block.content)
     if config.get('alias'):
         table_name = config['alias']
+    database = config.get('database', None)
 
     full_path = os.path.join(get_repo_path(), 'dbt', file_path)
 
@@ -131,6 +132,7 @@ def parse_attributes(block) -> Dict:
     snapshot = first_folder_name and first_folder_name in snapshot_paths
 
     return dict(
+        database=database,
         dbt_project=dbt_project,
         dbt_project_full_path=dbt_project_full_path,
         file_extension=file_extension,
@@ -456,7 +458,11 @@ def get_profile(block, profile_target: str = None) -> Dict:
     return load_profile(profile_name, profiles_full_path, profile_target)
 
 
-def config_file_loader_and_configuration(block, profile_target: str) -> Dict:
+def config_file_loader_and_configuration(
+    block,
+    profile_target: str,
+    **kwargs,
+) -> Dict:
     profile = get_profile(block, profile_target)
 
     if not profile:
@@ -492,12 +498,15 @@ def config_file_loader_and_configuration(block, profile_target: str) -> Dict:
         )
     elif DataSource.BIGQUERY == profile_type:
         keyfile = profile.get('keyfile')
-        database = profile.get('project')
+        database = kwargs.get('database') or profile.get('project')
         schema = profile.get('dataset')
 
-        config_file_loader = ConfigFileLoader(config=dict(
+        config_file_loader_kwargs = dict(
             GOOGLE_SERVICE_ACC_KEY_FILEPATH=keyfile,
-        ))
+        )
+        if profile.get('location'):
+            config_file_loader_kwargs['GOOGLE_LOCATION'] = profile.get('location')
+        config_file_loader = ConfigFileLoader(config=config_file_loader_kwargs)
         configuration = dict(
             data_provider=profile_type,
             data_provider_database=database,
@@ -573,11 +582,11 @@ def config_file_loader_and_configuration(block, profile_target: str) -> Dict:
             SNOWFLAKE_ROLE=profile.get('role'),
         )
 
-        if 'password' in profile:
+        if profile.get('password', None):
             config['SNOWFLAKE_PASSWORD'] = profile['password']
-        if 'private_key_passphrase' in profile:
+        if profile.get('private_key_passphrase', None):
             config['SNOWFLAKE_PRIVATE_KEY_PASSPHRASE'] = profile['private_key_passphrase']
-        if 'private_key_path' in profile:
+        if profile.get('private_key_path', None):
             config['SNOWFLAKE_PRIVATE_KEY_PATH'] = profile['private_key_path']
 
         config_file_loader = ConfigFileLoader(config=config)
@@ -927,10 +936,12 @@ def execute_query(
     profile_target: str,
     query_string: str,
     limit: int = None,
+    database: str = None,
 ) -> DataFrame:
     config_file_loader, configuration = config_file_loader_and_configuration(
         block,
         profile_target,
+        database=database,
     )
 
     data_provider = configuration['data_provider']
@@ -1304,12 +1315,15 @@ def fetch_model_data(
     # If the model SQL file contains a config with schema, change the schema to use that.
     # https://docs.getdbt.com/reference/resource-configs/schema
     config = model_config(block.content)
+    config_database = config.get('database')
     config_schema = config.get('schema')
+
+    # settings from the dbt_project.yml
+    model_configurations = get_model_configurations_from_dbt_project_settings(block)
+
     if config_schema:
         schema = f'{schema}_{config_schema}'
     else:
-        # settings from the dbt_project.yml
-        model_configurations = get_model_configurations_from_dbt_project_settings(block)
         model_configuration_schema = None
         if model_configurations:
             model_configuration_schema = (model_configurations.get('schema') or
@@ -1318,9 +1332,22 @@ def fetch_model_data(
         if model_configuration_schema:
             schema = f"{schema}_{model_configuration_schema}"
 
+    database = None
+    if config_database:
+        database = config_database
+    elif model_configurations:
+        database = (model_configurations.get('database') or
+                    model_configurations.get('+database'))
+
     query_string = f'SELECT * FROM {schema}.{table_name}'
 
-    return execute_query(block, profile_target, query_string, limit)
+    return execute_query(
+        block,
+        profile_target,
+        query_string,
+        limit,
+        database=database,
+    )
 
 
 def upstream_blocks_from_sources(block: Block) -> List[Block]:

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

@@ -122,7 +122,7 @@ class IntegrationBlock(Block):
                 proc = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
 
                 for line in proc.stdout:
-                    f.write(filter_out_config_values(line.decode(), config)),
+                    f.write(line.decode()),
                     print_log_from_line(
                         line,
                         config=config,

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

@@ -46,6 +46,44 @@ def execute_sql_code(
     config_file_loader: Any = None,
     configuration: Dict = None,
 ) -> List[Any]:
+    """
+    Execute SQL code within the given block's data context.
+
+    Args:
+        block (Block): The block containing the SQL execution context.
+        query (str): The SQL query to execute.
+        dynamic_block_index (int, optional): Index of the dynamic block, if applicable.
+        dynamic_upstream_block_uuids (List[str], optional): List of upstream block UUIDs for
+            dynamic execution.
+        execution_partition (str, optional): The partition for execution.
+        from_notebook (bool, optional): Indicates if execution is from a notebook.
+        global_vars (Dict, optional): Global variables to be used in the execution.
+        config_file_loader (Any, optional): Configuration file loader for data sources.
+        configuration (Dict, optional): Configuration settings for the block. If not provided, the
+            configuration from the block's context will be used. The configuration dictionary may
+            contain the following parameters:
+
+            - `use_raw_sql` (bool): If True, execute the query as raw SQL. Default is False.
+            - `data_provider` (str): The data provider for the execution, e.g., 'bigquery',
+                'clickhouse', etc.
+            - `data_provider_database` (str): The database name for the data provider.
+            - `data_provider_schema` (str): The schema name for the data provider.
+            - `export_write_policy` (str): The write policy for exporting data. Default is
+                ExportWritePolicy.APPEND.
+            - `limit` (int): The maximum number of rows to return in notebook.
+                Default is QUERY_ROW_LIMIT.
+            - `limit_in_pipeline_run` (int): Limit rows when running the block in the pipeline run.
+                Default is QUERY_ROW_LIMIT.
+            - Other provider-specific parameters may also be present.
+    Returns:
+        List[Any]: A list containing the query execution results.
+
+    Note:
+        This method executes the provided SQL query within the context of the given block.
+        It supports various data sources such as BigQuery, ClickHouse, Druid, MSSQL, MySQL,
+        PostgreSQL, Redshift, Snowflake, and Trino, applying relevant configurations and
+        returning the query execution results.
+    """
     configuration = configuration if configuration else block.configuration
     use_raw_sql = configuration.get('use_raw_sql')
 
@@ -68,10 +106,12 @@ def execute_sql_code(
     should_query = block.type in PREVIEWABLE_BLOCK_TYPES
 
     limit = int(configuration.get('limit') or QUERY_ROW_LIMIT)
+    # Limit rows when running the block in the pipeline run
+    limit_in_pipeline_run = int(configuration.get('limit_in_pipeline_run') or QUERY_ROW_LIMIT)
     if from_notebook:
         limit = min(limit, QUERY_ROW_LIMIT)
     else:
-        limit = QUERY_ROW_LIMIT
+        limit = min(limit_in_pipeline_run, QUERY_ROW_LIMIT)
 
     create_upstream_block_tables_kwargs = dict(
         configuration=configuration,
@@ -280,7 +320,9 @@ def execute_sql_code(
                 if should_query:
                     return [
                         loader.load(
-                            f'SELECT * FROM {table_name}',
+                            # Add the limit directly in the SELECT statement
+                            # since io.mssql doesn't support enforcing limit
+                            f'SELECT TOP {limit} * FROM {table_name}',
                             limit=limit,
                             verbose=False,
                         ),

mage_ai/data_preparation/models/custom_templates/utils.py

@@ -56,13 +56,23 @@ def group_and_hydrate_files(
     file_dicts: List[Dict],
     custom_template_class,
 ) -> List:
-    groups = group_by(lambda x: os.path.join(*x.get('parent_names', [])), file_dicts)
+    def _func(x):
+        arr = ['']
 
-    arr = []
+        if x:
+            parent_names = x.get('parent_names', []) or []
+            if parent_names and len(parent_names) >= 1:
+                arr = [str(parent_name) for parent_name in parent_names]
+
+        return os.path.join(*arr)
+
+    groups = group_by(_func, file_dicts)
+
+    custom_templates = []
 
     for template_uuid, _ in groups.items():
         custom_template = custom_template_class.load(template_uuid=template_uuid)
         if custom_template:
-            arr.append(custom_template)
+            custom_templates.append(custom_template)
 
-    return arr
+    return custom_templates

mage_ai/data_preparation/models/global_data_product/__init__.py

@@ -133,6 +133,8 @@ class GlobalDataProduct:
             else:
                 return d
 
+        return None
+
     def is_outdated_after(self, now: datetime = None, return_values: bool = False) -> bool:
         values = {}
         outdated_starting_at = self.outdated_starting_at or {}
@@ -174,6 +176,10 @@ class GlobalDataProduct:
     def next_run_at(self, pipeline_run: 'PipelineRun') -> datetime:
         execution_date = pipeline_run.execution_date
         outdated_at_delta = self.get_outdated_at_delta()
+
+        if not outdated_at_delta:
+            return None
+
         if execution_date and outdated_at_delta:
             execution_date += outdated_at_delta
 
@@ -189,6 +195,8 @@ class GlobalDataProduct:
         now = datetime.utcnow().replace(tzinfo=timezone.utc)
 
         execution_date = self.next_run_at(pipeline_run)
+        if not execution_date:
+            return [False, False]
 
         outdated = execution_date and now >= execution_date
 

mage_ai/data_preparation/models/pipeline.py

@@ -885,6 +885,10 @@ class Pipeline:
                     if block_data.get('has_callback') is not None:
                         block.update(extract(block_data, ['has_callback']))
 
+                    color = block_data.get('color')
+                    if color is not None and color != block.color:
+                        block.update(extract(block_data, ['color']))
+
                     configuration = block_data.get('configuration')
                     if configuration:
                         if configuration.get('dynamic') and not is_dynamic_block(block):

mage_ai/data_preparation/models/variable.py

@@ -430,11 +430,14 @@ class Variable:
         df_output = data.copy()
         # Clean up data types since parquet doesn't support mixed data types
         for c in df_output.columns:
-            c_dtype = df_output[c].dtype
+            df_col = df_output[c]
+            if type(df_col) is pd.DataFrame:
+                raise Exception(f'Please do not use duplicate column name: "{c}"')
+            c_dtype = df_col.dtype
             if not is_object_dtype(c_dtype):
                 column_types[c] = str(c_dtype)
             else:
-                series_non_null = df_output[c].dropna()
+                series_non_null = df_col.dropna()
                 if len(series_non_null) > 0:
                     coltype = type(series_non_null.iloc[0])
                     if is_object_dtype(series_non_null.dtype):