altimate-datapilot-cli 0.0.8__py3-none-any.whl

datapilot/core/insights/utils.py

@@ -0,0 +1,20 @@
+from typing import Dict
+from typing import Optional
+
+from datapilot.core.insights.schema import Severity
+from datapilot.schemas.constants import CONFIG_METRICS
+from datapilot.schemas.constants import CONFIG_SEVERITY
+
+
+def get_severity(
+    config: Optional[Dict],
+    alias: str,
+    default_severity: Severity,
+):
+    if config is None:
+        return default_severity
+
+    insights = config.get(CONFIG_METRICS, {})
+    metric = insights.get(alias, {})
+    severity = metric.get(CONFIG_SEVERITY, default_severity)
+    return severity

datapilot/core/platforms/dbt/cli/cli.py

@@ -0,0 +1,112 @@
+import logging
+
+import click
+
+from datapilot.clients.altimate.utils import check_token_and_instance
+from datapilot.clients.altimate.utils import onboard_manifest
+from datapilot.clients.altimate.utils import validate_credentials
+from datapilot.config.config import load_config
+from datapilot.core.platforms.dbt.constants import MODEL
+from datapilot.core.platforms.dbt.constants import PROJECT
+from datapilot.core.platforms.dbt.executor import DBTInsightGenerator
+from datapilot.core.platforms.dbt.formatting import generate_model_insights_table
+from datapilot.core.platforms.dbt.formatting import generate_project_insights_table
+from datapilot.core.platforms.dbt.utils import load_catalog
+from datapilot.core.platforms.dbt.utils import load_manifest
+from datapilot.utils.formatting.utils import tabulate_data
+
+logging.basicConfig(level=logging.INFO)
+
+
+# New dbt group
+@click.group()
+def dbt():
+    """DBT specific commands."""
+
+
+@dbt.command("project-health")
+@click.option(
+    "--manifest-path",
+    required=True,
+    help="Path to the DBT manifest file",
+)
+@click.option(
+    "--catalog-path",
+    required=False,
+    help="Path to the DBT catalog file",
+)
+@click.option(
+    "--config-path",
+    required=False,
+    help="Path to the DBT config file",
+)
+@click.option(
+    "--select",
+    required=False,
+    default=None,
+    help="Selective model testing. Specify one or more models to run tests on.",
+)
+def project_health(manifest_path, catalog_path, config_path=None, select=None):
+    """
+    Validate the DBT project's configuration and structure.
+    :param manifest_path: Path to the DBT manifest file.
+    """
+    config = None
+    if config_path:
+        config = load_config(config_path)
+    selected_models = []
+    if select:
+        selected_models = select.split(" ")
+    manifest = load_manifest(manifest_path)
+    catalog = load_catalog(catalog_path) if catalog_path else None
+    insight_generator = DBTInsightGenerator(manifest=manifest, catalog=catalog, config=config, selected_models=selected_models)
+    reports = insight_generator.run()
+
+    package_insights = reports[PROJECT]
+    model_insights = reports[MODEL]
+    model_report = generate_model_insights_table(model_insights)
+    if len(model_report) > 0:
+        click.echo("--" * 50)
+        click.echo("Model Insights")
+        click.echo("--" * 50)
+    for model_id, report in model_report.items():
+        click.echo(f"Model: {model_id}")
+        click.echo(f"File path: {report['path']}")
+        click.echo(tabulate_data(report["table"], headers="keys"))
+        click.echo("\n")
+
+    if len(package_insights) > 0:
+        project_report = generate_project_insights_table(package_insights)
+        click.echo("--" * 50)
+        click.echo("Project Insights")
+        click.echo("--" * 50)
+        click.echo(tabulate_data(project_report, headers="keys"))
+
+
+@dbt.command("onboard")
+@click.option("--token", prompt="API Token", help="Your API token for authentication.")
+@click.option("--instance-name", prompt="Instance Name", help="Your tenant ID.")
+@click.option("--dbt_core_integration_id", prompt="DBT Core Integration ID", help="DBT Core Integration ID")
+@click.option("--manifest-path", required=True, prompt="Manifest Path", help="Path to the manifest file.")
+@click.option("--backend-url", required=False, help="Altimate's Backend URL", default="https://api.myaltimate.com")
+def onboard(token, instance_name, dbt_core_integration_id, manifest_path, backend_url="https://api.myaltimate.com", env=None):
+    """Onboard a manifest file to DBT."""
+    check_token_and_instance(token, instance_name)
+
+    if not validate_credentials(token, backend_url, instance_name):
+        click.echo("Error: Invalid credentials.")
+        return
+
+    # This will throw error if manifest file is incorrect
+    try:
+        load_manifest(manifest_path)
+    except Exception as e:
+        click.echo(f"Error: {e}")
+        return
+
+    response = onboard_manifest(token, instance_name, dbt_core_integration_id, manifest_path, backend_url)
+
+    if response["ok"]:
+        click.echo("Manifest onboarded successfully!")
+    else:
+        click.echo(f"{response['message']}")

datapilot/core/platforms/dbt/constants.py

@@ -0,0 +1,34 @@
+SEED = "seed"
+MACRO = "macro"
+TEST = "test"
+MODEL = "model"
+SOURCE = "source"
+
+
+PROJECT = "project"
+SQL = "sql"
+
+# Model Types
+MART: str = "mart"
+STAGING = "staging"
+INTERMEDIATE = "intermediate"
+BASE = "base"
+OTHER = "other"
+
+# MATERIALIZATION
+TABLE = "table"
+INCREMENTAL = "incremental"
+VIEW = "view"
+EPHEMERAL = "ephemeral"
+
+
+MATERIALIZED = [TABLE, INCREMENTAL]
+NON_MATERIALIZED = [VIEW, EPHEMERAL]
+
+
+GENERIC = "generic"
+SINGULAR = "singular"
+OTHER_TEST_NODE = "other_test_node"
+
+
+FOLDER = "folder"

datapilot/core/platforms/dbt/exceptions.py

@@ -0,0 +1,6 @@
+class AltimateInvalidManifestError(Exception):
+    pass
+
+
+class AltimateCLIArgumentError(Exception):
+    pass

datapilot/core/platforms/dbt/executor.py

@@ -0,0 +1,157 @@
+import logging
+
+# from src.utils.formatting.utils import generate_model_insights_table
+from typing import Dict
+from typing import List
+from typing import Optional
+
+from datapilot.core.platforms.dbt.constants import MODEL
+from datapilot.core.platforms.dbt.constants import PROJECT
+from datapilot.core.platforms.dbt.exceptions import AltimateCLIArgumentError
+from datapilot.core.platforms.dbt.factory import DBTFactory
+from datapilot.core.platforms.dbt.insights import INSIGHTS
+from datapilot.core.platforms.dbt.schemas.manifest import Catalog
+from datapilot.core.platforms.dbt.schemas.manifest import Manifest
+from datapilot.core.platforms.dbt.utils import get_models
+from datapilot.utils.formatting.utils import RED
+from datapilot.utils.formatting.utils import YELLOW
+from datapilot.utils.formatting.utils import color_text
+
+
+class DBTInsightGenerator:
+    def __init__(
+        self,
+        manifest: Manifest,
+        catalog: Optional[Catalog] = None,
+        run_results_path: Optional[str] = None,
+        env: Optional[str] = None,
+        config: Optional[Dict] = None,
+        target: str = "dev",
+        selected_models: Optional[str] = None,
+        selected_model_ids: Optional[List[str]] = None,
+    ):
+        self.run_results_path = run_results_path
+        self.target = target
+        self.env = env
+        self.config = config or {}
+
+        self.manifest_wrapper = DBTFactory.get_manifest_wrapper(manifest)
+        self.manifest_present = True
+        self.catalog_present = False
+        self.catalog_wrapper = None
+
+        if catalog:
+            self.catalog_wrapper = DBTFactory.get_catalog_wrapper(catalog)
+            self.catalog_present = True
+
+        self.run_results_present = False
+        self.logger = logging.getLogger("dbt-insight-generator")
+
+        self.nodes = self.manifest_wrapper.get_nodes()
+        self.macros = self.manifest_wrapper.get_macros()
+        self.sources = self.manifest_wrapper.get_sources()
+        self.exposures = self.manifest_wrapper.get_exposures()
+        self.seeds = self.manifest_wrapper.get_seeds()
+        self.children_map = self.manifest_wrapper.parent_to_child_map(self.nodes)
+        self.tests = self.manifest_wrapper.get_tests()
+        self.project_name = self.manifest_wrapper.get_package()
+        self.selected_models = None
+        self.selected_models_flag = False
+        entities = {
+            "nodes": self.nodes,
+            "sources": self.sources,
+            "exposures": self.exposures,
+            "tests": self.tests,
+        }
+        if selected_model_ids:
+            self.selected_models_flag = True
+            self.selected_models = selected_model_ids
+        elif selected_models:
+            self.selected_models_flag = True
+            self.selected_models = get_models(
+                selected_models,
+                entities=entities,
+            )
+            if not self.selected_models:
+                raise AltimateCLIArgumentError(
+                    f"Invalid values provided in the --select argument. Could not find models associated with pattern: --select {' '.join(selected_models)}"
+                )
+        self.excluded_models = None
+        self.excluded_models_flag = False
+
+    def _check_if_skipped(self, insight):
+        if self.config.get("disabled_insights", False):
+            if insight.ALIAS in self.config.get("disabled_insights", []):
+                return True
+        return False
+
+    def run(self):
+        reports = {
+            MODEL: {},
+            PROJECT: [],
+        }
+        for insight_class in INSIGHTS:
+            # TODO: Skip insight based on config
+
+            run_insight, message = insight_class.has_all_required_data(
+                has_manifest=self.manifest_present,
+                has_catalog=self.catalog_present,
+                has_run_results=self.run_results_present,
+            )
+
+            if run_insight:
+                self.logger.info(f"Running insight {insight_class.NAME}")
+                insight = insight_class(
+                    manifest_wrapper=self.manifest_wrapper,
+                    catalog_wrapper=self.catalog_wrapper,
+                    nodes=self.nodes,
+                    macros=self.macros,
+                    sources=self.sources,
+                    seeds=self.seeds,
+                    exposures=self.exposures,
+                    children_map=self.children_map,
+                    tests=self.tests,
+                    project_name=self.project_name,
+                    config=self.config,
+                    selected_models=self.selected_models,
+                    excluded_models=self.excluded_models,
+                )
+
+                if self._check_if_skipped(insight):
+                    self.logger.info(
+                        color_text(
+                            f"Skipping insight {insight_class.NAME} as it is not enabled in config",
+                            YELLOW,
+                        )
+                    )
+                    continue
+                try:
+                    insights = insight.generate()
+                    num_insights = len(insights)
+                    text = f"Found {num_insights} insights for {insight_class.NAME}"
+                    if num_insights > 0:
+                        self.logger.info(color_text(text, RED))
+                    else:
+                        self.logger.info(f"No insights found for {insight_class.NAME}")
+
+                    for insight in insights:
+                        # Handle MODEL level insights
+                        if insight.insight_level == MODEL:
+                            # Add the insight if the model is selected or if all models are selected
+                            # if self.selected_models_flag and insight.unique_id in self.selected_models or not self.selected_models_flag:
+                            reports[MODEL].setdefault(insight.unique_id, []).append(insight)
+                        # Handle PROJECT level insights, only if all models are selected
+                        elif insight.insight_level == PROJECT:
+                            reports[PROJECT].append(insight)
+
+                except Exception as e:
+                    self.logger.info(
+                        color_text(
+                            f"Error running insight {insight_class.NAME}: {e}. Skipping insight. {message}",
+                            RED,
+                        )
+                    )
+            else:
+                self.logger.info(color_text(f"Skipping insight {insight_class.NAME} as {message}", YELLOW))
+
+        return reports

datapilot/core/platforms/dbt/factory.py

@@ -0,0 +1,22 @@
+from dbt_artifacts_parser.parsers.catalog.catalog_v1 import CatalogV1
+from dbt_artifacts_parser.parsers.manifest.manifest_v11 import ManifestV11
+
+from datapilot.core.platforms.dbt.schemas.manifest import Catalog
+from datapilot.core.platforms.dbt.schemas.manifest import Manifest
+from datapilot.core.platforms.dbt.wrappers.catalog.v1.wrapper import CatalogV1Wrapper
+from datapilot.core.platforms.dbt.wrappers.manifest.v11.wrapper import ManifestV11Wrapper
+from datapilot.exceptions.exceptions import AltimateNotSupportedError
+
+
+class DBTFactory:
+    @classmethod
+    def get_manifest_wrapper(cls, manifest: Manifest):
+        if isinstance(manifest, ManifestV11):
+            return ManifestV11Wrapper(manifest)
+        raise AltimateNotSupportedError(f"Manifest version {manifest.metadata.dbt_schema_version} not supported")
+
+    @classmethod
+    def get_catalog_wrapper(cls, catalog: Catalog):
+        if isinstance(catalog, CatalogV1):
+            return CatalogV1Wrapper(catalog)
+        raise AltimateNotSupportedError(f"Catalog version {catalog.metadata.dbt_schema_version} not supported")

datapilot/core/platforms/dbt/formatting.py

@@ -0,0 +1,45 @@
+from typing import Dict
+from typing import List
+
+from datapilot.core.insights.schema import InsightResult
+from datapilot.core.insights.schema import Severity
+from datapilot.core.platforms.dbt.insights.schema import DBTModelInsightResponse
+from datapilot.core.platforms.dbt.insights.schema import DBTProjectInsightResponse
+from datapilot.utils.formatting.utils import color_based_on_severity
+
+
+def gen_table(insight: InsightResult, severity: Severity) -> Dict[str, str]:
+    return {
+        "name": insight.name,
+        "type": insight.type,
+        "level": color_based_on_severity(severity),
+        "message": insight.message,
+        "recommendation": insight.recommendation,
+        "reason_to_flag": insight.reason_to_flag,
+    }
+
+
+def generate_model_insights_table(model_insights: Dict[str, List[DBTModelInsightResponse]]):
+    results = {}
+
+    for model_id, insights in model_insights.items():
+        for insight in insights:
+            if model_id not in results:
+                results[model_id] = {
+                    "package_name": insight.package_name,
+                    "unique_id": insight.unique_id,
+                    "path": insight.original_file_path,
+                    "table": [],
+                }
+
+            results[model_id]["table"].append(gen_table(insight.insight, insight.severity))
+    return results
+
+
+def generate_project_insights_table(project_insights: List[DBTProjectInsightResponse]):
+    results = []
+
+    for project_insight in project_insights:
+        for insight in project_insight.insights:
+            results.append(gen_table(insight, project_insight.severity))
+    return results

datapilot/core/platforms/dbt/hooks/executor_hook.py

@@ -0,0 +1,86 @@
+import argparse
+import time
+from typing import Optional
+from typing import Sequence
+
+from datapilot.config.config import load_config
+from datapilot.core.platforms.dbt.constants import MODEL
+from datapilot.core.platforms.dbt.constants import PROJECT
+from datapilot.core.platforms.dbt.executor import DBTInsightGenerator
+from datapilot.core.platforms.dbt.formatting import generate_model_insights_table
+from datapilot.core.platforms.dbt.formatting import generate_project_insights_table
+from datapilot.utils.formatting.utils import tabulate_data
+from datapilot.utils.utils import generate_partial_manifest_catalog
+
+
+def main(argv: Optional[Sequence[str]] = None):
+    start_time = time.time()
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--config-path",
+        nargs="*",
+        help="Path of the config file to be used for the insight generation",
+    )
+
+    parser.add_argument(
+        "--base-path",
+        nargs="*",
+        help="Base path of the dbt project",
+    )
+
+    args = parser.parse_known_args(argv)
+    # print(f"args: {args}", file=sys.__stdout__)
+    config = {}
+    if hasattr(args[0], "config_path") and args[0].config_path:
+        # print(f"Using config file: {args[0].config_path[0]}")
+        config = load_config(args[0].config_path[0])
+
+    base_path = "./"
+    if hasattr(args[0], "base_path") and args[0].base_path:
+        base_path = args[0].base_path[0]
+
+    changed_files = args[1]
+    # print(f"Changed files: {changed_files}")
+
+    if not changed_files:
+        # print("No changed files detected - test. Exiting...")
+        return
+
+    # print(f"Changed files: {changed_files}", file=sys.__stdout__)
+    selected_models, manifest, catalog = generate_partial_manifest_catalog(changed_files, base_path=base_path)
+    # print("se1ected models", selected_models, file=sys.__stdout__)
+    insight_generator = DBTInsightGenerator(
+        manifest=manifest,
+        catalog=catalog,
+        config=config,
+        selected_model_ids=selected_models,
+    )
+    reports = insight_generator.run()
+    if reports:
+        model_report = generate_model_insights_table(reports[MODEL])
+        if len(model_report) > 0:
+            print("--" * 50)
+            print("Model Insights")
+            print("--" * 50)
+        for model_id, report in model_report.items():
+            print(f"Model: {model_id}")
+            print(f"File path: {report['path']}")
+            print(tabulate_data(report["table"], headers="keys"))
+            print("\n")
+
+        project_report = generate_project_insights_table(reports[PROJECT])
+        if len(project_report) > 0:
+            print("--" * 50)
+            print("Project Insights")
+            print("--" * 50)
+            print(tabulate_data(project_report, headers="keys"))
+
+        exit(1)
+
+    end_time = time.time()
+    total_time = end_time - start_time
+    print(f"Total time taken: {round(total_time, 2)} seconds")
+
+
+if __name__ == "__main__":
+    exit(main())

datapilot/core/platforms/dbt/insights/__init__.py

@@ -0,0 +1,115 @@
+from datapilot.core.platforms.dbt.insights.checks.check_column_desc_are_same import CheckColumnDescAreSame
+from datapilot.core.platforms.dbt.insights.checks.check_column_name_contract import CheckColumnNameContract
+from datapilot.core.platforms.dbt.insights.checks.check_macro_args_have_desc import CheckMacroArgsHaveDesc
+from datapilot.core.platforms.dbt.insights.checks.check_macro_has_desc import CheckMacroHasDesc
+from datapilot.core.platforms.dbt.insights.checks.check_model_has_all_columns import CheckModelHasAllColumns
+from datapilot.core.platforms.dbt.insights.checks.check_model_has_meta_keys import CheckModelHasMetaKeys
+from datapilot.core.platforms.dbt.insights.checks.check_model_has_properties_file import CheckModelHasPropertiesFile
+from datapilot.core.platforms.dbt.insights.checks.check_model_has_tests_by_group import CheckModelHasTestsByGroup
+from datapilot.core.platforms.dbt.insights.checks.check_model_has_tests_by_name import CheckModelHasTestsByName
+from datapilot.core.platforms.dbt.insights.checks.check_model_has_tests_by_type import CheckModelHasTestsByType
+from datapilot.core.platforms.dbt.insights.checks.check_model_materialization_by_childs import CheckModelMaterializationByChilds
+from datapilot.core.platforms.dbt.insights.checks.check_model_name_contract import CheckModelNameContract
+from datapilot.core.platforms.dbt.insights.checks.check_model_parents_and_childs import CheckModelParentsAndChilds
+from datapilot.core.platforms.dbt.insights.checks.check_model_parents_database import CheckModelParentsDatabase
+from datapilot.core.platforms.dbt.insights.checks.check_model_parents_schema import CheckModelParentsSchema
+from datapilot.core.platforms.dbt.insights.checks.check_model_tags import CheckModelTags
+from datapilot.core.platforms.dbt.insights.checks.check_source_childs import CheckSourceChilds
+from datapilot.core.platforms.dbt.insights.checks.check_source_columns_have_desc import CheckSourceColumnsHaveDescriptions
+from datapilot.core.platforms.dbt.insights.checks.check_source_has_all_columns import CheckSourceHasAllColumns
+from datapilot.core.platforms.dbt.insights.checks.check_source_has_freshness import CheckSourceHasFreshness
+from datapilot.core.platforms.dbt.insights.checks.check_source_has_loader import CheckSourceHasLoader
+from datapilot.core.platforms.dbt.insights.checks.check_source_has_meta_keys import CheckSourceHasMetaKeys
+from datapilot.core.platforms.dbt.insights.checks.check_source_has_tests import CheckSourceHasTests
+from datapilot.core.platforms.dbt.insights.checks.check_source_has_tests_by_group import CheckSourceHasTestsByGroup
+from datapilot.core.platforms.dbt.insights.checks.check_source_has_tests_by_name import CheckSourceHasTestsByName
+from datapilot.core.platforms.dbt.insights.checks.check_source_has_tests_by_type import CheckSourceHasTestsByType
+from datapilot.core.platforms.dbt.insights.checks.check_source_table_has_description import CheckSourceTableHasDescription
+from datapilot.core.platforms.dbt.insights.checks.check_source_tags import CheckSourceTags
+from datapilot.core.platforms.dbt.insights.dbt_test.missing_primary_key_tests import MissingPrimaryKeyTests
+from datapilot.core.platforms.dbt.insights.dbt_test.test_coverage import DBTTestCoverage
+from datapilot.core.platforms.dbt.insights.governance.documentation_on_stale_columns import DBTDocumentationStaleColumns
+from datapilot.core.platforms.dbt.insights.governance.exposures_dependent_on_private_models import DBTExposureDependentOnPrivateModels
+from datapilot.core.platforms.dbt.insights.governance.public_models_without_contracts import DBTPublicModelWithoutContracts
+from datapilot.core.platforms.dbt.insights.governance.undocumented_columns import DBTMissingDocumentation
+from datapilot.core.platforms.dbt.insights.governance.undocumented_public_models import DBTUndocumentedPublicModels
+from datapilot.core.platforms.dbt.insights.modelling.direct_join_to_source import DBTDirectJoinSource
+from datapilot.core.platforms.dbt.insights.modelling.downstream_models_dependent_on_source import DBTDownstreamModelsDependentOnSource
+from datapilot.core.platforms.dbt.insights.modelling.duplicate_sources import DBTDuplicateSources
+from datapilot.core.platforms.dbt.insights.modelling.hard_coded_references import DBTHardCodedReferences
+from datapilot.core.platforms.dbt.insights.modelling.joining_of_upstream_concepts import DBTRejoiningOfUpstreamConcepts
+from datapilot.core.platforms.dbt.insights.modelling.model_fanout import DBTModelFanout
+from datapilot.core.platforms.dbt.insights.modelling.multiple_sources_joined import DBTModelsMultipleSourcesJoined
+from datapilot.core.platforms.dbt.insights.modelling.root_model import DBTRootModel
+from datapilot.core.platforms.dbt.insights.modelling.source_fanout import DBTSourceFanout
+from datapilot.core.platforms.dbt.insights.modelling.staging_model_dependent_on_downstream_models import (
+    DBTStagingModelsDependentOnDownstreamModels,
+)
+from datapilot.core.platforms.dbt.insights.modelling.staging_model_dependent_on_staging_models import (
+    DBTStagingModelsDependentOnStagingModels,
+)
+from datapilot.core.platforms.dbt.insights.modelling.unused_sources import DBTUnusedSources
+from datapilot.core.platforms.dbt.insights.performance.chain_view_linking import DBTChainViewLinking
+from datapilot.core.platforms.dbt.insights.performance.exposure_parent_materializations import DBTExposureParentMaterialization
+from datapilot.core.platforms.dbt.insights.structure.model_directories_structure import DBTModelDirectoryStructure
+from datapilot.core.platforms.dbt.insights.structure.model_naming_conventions import DBTModelNamingConvention
+from datapilot.core.platforms.dbt.insights.structure.source_directories_structure import DBTSourceDirectoryStructure
+from datapilot.core.platforms.dbt.insights.structure.test_directory_structure import DBTTestDirectoryStructure
+
+INSIGHTS = [
+    DBTDirectJoinSource,
+    DBTDownstreamModelsDependentOnSource,
+    DBTDuplicateSources,
+    DBTModelFanout,
+    DBTRootModel,
+    DBTSourceFanout,
+    DBTStagingModelsDependentOnDownstreamModels,
+    DBTStagingModelsDependentOnStagingModels,
+    DBTUnusedSources,
+    DBTModelsMultipleSourcesJoined,
+    DBTHardCodedReferences,
+    DBTRejoiningOfUpstreamConcepts,
+    DBTExposureDependentOnPrivateModels,
+    DBTUndocumentedPublicModels,
+    DBTPublicModelWithoutContracts,
+    DBTChainViewLinking,
+    DBTExposureParentMaterialization,
+    DBTMissingDocumentation,
+    DBTDocumentationStaleColumns,
+    MissingPrimaryKeyTests,
+    DBTTestCoverage,
+    DBTModelDirectoryStructure,
+    DBTModelNamingConvention,
+    DBTSourceDirectoryStructure,
+    DBTTestDirectoryStructure,
+    CheckColumnDescAreSame,
+    CheckColumnNameContract,
+    CheckMacroArgsHaveDesc,
+    CheckMacroHasDesc,
+    CheckModelHasAllColumns,
+    # CheckModelHasLabelsKeys,
+    CheckModelHasMetaKeys,
+    CheckModelHasPropertiesFile,
+    CheckModelHasTestsByName,
+    CheckModelHasTestsByType,
+    CheckModelHasTestsByGroup,
+    CheckModelMaterializationByChilds,
+    CheckModelNameContract,
+    CheckModelParentsAndChilds,
+    CheckModelParentsDatabase,
+    CheckModelParentsSchema,
+    CheckModelTags,
+    CheckSourceChilds,
+    CheckSourceColumnsHaveDescriptions,
+    CheckSourceHasAllColumns,
+    CheckSourceHasFreshness,
+    # CheckSourceHasLabelsKeys,
+    CheckSourceHasLoader,
+    CheckSourceHasMetaKeys,
+    CheckSourceHasTestsByName,
+    CheckSourceHasTestsByType,
+    CheckSourceHasTestsByGroup,
+    CheckSourceHasTests,
+    CheckSourceTableHasDescription,
+    CheckSourceTags,
+]