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

datapilot/core/platforms/dbt/insights/checks/check_model_tags.py

@@ -0,0 +1,87 @@
+from typing import List
+
+from datapilot.core.insights.utils import get_severity
+from datapilot.core.platforms.dbt.insights.checks.base import ChecksInsight
+from datapilot.core.platforms.dbt.insights.schema import DBTInsightResult
+from datapilot.core.platforms.dbt.insights.schema import DBTModelInsightResponse
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateResourceType
+
+
+class CheckModelTags(ChecksInsight):
+    NAME = "Model only has valid tags"
+    ALIAS = "check_model_tags"
+    DESCRIPTION = "Ensures that the model has only valid tags from the provided list."
+    REASON_TO_FLAG = "The model has tags that are not in the valid tags list"
+    TAGS_LIST_STR = "tag_list"
+
+    def _build_failure_result(
+        self,
+        node_id: str,
+        tags: List[str],
+    ) -> DBTInsightResult:
+        """
+        Build failure result for the insight if a model's tags are not in the provided tag list.
+        """
+
+        failure_message = f"The model:{node_id}'s tags are not in the provided tag list:\n"
+
+        recommendation = "Update the model's tags to adhere to the provided tag list."
+
+        return DBTInsightResult(
+            type=self.TYPE,
+            name=self.NAME,
+            message=failure_message,
+            recommendation=recommendation,
+            reason_to_flag=self.REASON_TO_FLAG,
+            metadata={"tags": tags},
+        )
+
+    def generate(self, *args, **kwargs) -> List[DBTModelInsightResponse]:
+        """
+        Generate a list of InsightResponse objects for each model in the DBT project,
+        Ensures that the model has only valid tags from the provided list.
+        The provided tag list is in the configuration file.
+        """
+        insights = []
+        self.tag_list = self.get_check_config(self.TAGS_LIST_STR)
+        for node_id, node in self.nodes.items():
+            if self.should_skip_model(node_id):
+                self.logger.debug(f"Skipping model {node_id} as it is not enabled for selected models")
+                continue
+            if node.resource_type == AltimateResourceType.model:
+                if not self.valid_tag(node.config.tags):
+                    insights.append(
+                        DBTModelInsightResponse(
+                            unique_id=node_id,
+                            package_name=node.package_name,
+                            original_file_path=node.original_file_path,
+                            path=node.original_file_path,
+                            insight=self._build_failure_result(node_id, node.config.tags),
+                            severity=get_severity(self.config, self.ALIAS, self.DEFAULT_SEVERITY),
+                        )
+                    )
+        return insights
+
+    def valid_tag(self, tags: List[str]) -> bool:
+        """
+        Check if the tags of the model are in the provided tag list.
+        """
+        if not self.tag_list:
+            return True
+        return all(tag in self.tag_list for tag in tags)
+
+    @classmethod
+    def get_config_schema(cls):
+        config_schema = super().get_config_schema()
+        config_schema["config"] = {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "type": "object",
+            "properties": {
+                cls.TAGS_LIST_STR: {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "List of allowed tags for the model. If not provided, all tags are allowed.",
+                    "default": [],
+                },
+            },
+        }

datapilot/core/platforms/dbt/insights/checks/check_source_childs.py

@@ -0,0 +1,97 @@
+from typing import List
+
+from datapilot.core.insights.utils import get_severity
+from datapilot.core.platforms.dbt.insights.checks.base import ChecksInsight
+from datapilot.core.platforms.dbt.insights.schema import DBTInsightResult
+from datapilot.core.platforms.dbt.insights.schema import DBTModelInsightResponse
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateResourceType
+
+
+class CheckSourceChilds(ChecksInsight):
+    NAME = "Source has allowed number of children"
+    ALIAS = "check_source_childs"
+    DESCRIPTION = "Check the source has a specific number (max/min) of childs"
+    REASON_TO_FLAG = "The source has a number of childs that is not in the valid range"
+    MIN_CHILDS_STR = "min_childs"
+    MAX_CHILDS_STR = "max_childs"
+
+    def _build_failure_result(
+        self,
+        node_id: str,
+        min_childs: int,
+        max_childs: int,
+    ) -> DBTInsightResult:
+        """
+        Build failure result for the insight if a source has a specific number (max/min) of childs
+        """
+        failure_message = f"The source:{node_id} has a number of childs that is not in the valid range:\n"
+        failure_message += f"Min childs: {min_childs}\n"
+        failure_message += f"Max childs: {max_childs}\n"
+
+        recommendation = "Update the source to adhere to the valid range of childs."
+        return DBTInsightResult(
+            type=self.TYPE,
+            name=self.NAME,
+            message=failure_message,
+            recommendation=recommendation,
+            reason_to_flag=self.REASON_TO_FLAG,
+            metadata={"source_unique_id": node_id, "min_childs": min_childs, "max_childs": max_childs},
+        )
+
+    def generate(self, *args, **kwargs) -> List[DBTModelInsightResponse]:
+        """
+        Generate a list of InsightResponse objects for each source in the DBT project,
+        Check the source has a specific number (max/min) of childs
+        The min and max number of childs is in the configuration file.
+        """
+        insights = []
+        self.min_childs = self.get_check_config(self.MIN_CHILDS_STR)
+        self.max_childs = self.get_check_config(self.MAX_CHILDS_STR)
+        for node_id, node in self.sources.items():
+            if self.should_skip_model(node_id):
+                self.logger.debug(f"Skipping model {node_id} as it is not enabled for selected models")
+                continue
+            if node.resource_type == AltimateResourceType.source:
+                if not self.valid_childs(node_id):
+                    insights.append(
+                        DBTModelInsightResponse(
+                            unique_id=node_id,
+                            package_name=node.package_name,
+                            original_file_path=node.original_file_path,
+                            path=node.original_file_path,
+                            insight=self._build_failure_result(node_id, min_childs=self.min_childs, max_childs=self.max_childs),
+                            severity=get_severity(self.config, self.ALIAS, self.DEFAULT_SEVERITY),
+                        )
+                    )
+        return insights
+
+    def valid_childs(self, source_unique_id: str) -> bool:
+        """
+        Check if the source has a specific number (max/min) of childs
+        """
+        source_childs = self.children_map.get(source_unique_id, [])
+        if self.min_childs and len(source_childs) < self.min_childs:
+            return False
+        if self.max_childs and len(source_childs) > self.max_childs:
+            return False
+        return True
+
+    @classmethod
+    def get_config_schema(cls):
+        config_schema = super().get_config_schema()
+        config_schema["config"] = {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "type": "object",
+            "properties": {
+                cls.MAX_CHILDS_STR: {
+                    "type": "integer",
+                    "description": "The maximum number of childs a model can have.",
+                },
+                cls.MIN_CHILDS_STR: {
+                    "type": "integer",
+                    "description": "The minimum number of childs a model can have.",
+                    "default": "0",
+                },
+            },
+        }
+        return config_schema

datapilot/core/platforms/dbt/insights/checks/check_source_columns_have_desc.py

@@ -0,0 +1,96 @@
+from typing import List
+from typing import Sequence
+from typing import Set
+from typing import Tuple
+
+from datapilot.core.insights.utils import get_severity
+from datapilot.core.platforms.dbt.insights.checks.base import ChecksInsight
+from datapilot.core.platforms.dbt.insights.schema import DBTInsightResult
+from datapilot.core.platforms.dbt.insights.schema import DBTModelInsightResponse
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateResourceType
+from datapilot.core.platforms.dbt.wrappers.catalog.wrapper import BaseCatalogWrapper
+from datapilot.utils.formatting.utils import numbered_list
+
+
+class CheckSourceColumnsHaveDescriptions(ChecksInsight):
+    NAME = "Source columns have descriptions"
+    ALIAS = "check_source_columns_have_desc"
+    DESCRIPTION = "Ensures that the source has columns with descriptions in the properties file (usually schema.yml)."
+    REASON_TO_FLAG = "Missing descriptions for columns in the source can lead to confusion and inconsistency in analysis. "
+
+    def __init__(self, catalog_wrapper: BaseCatalogWrapper, *args, **kwargs):
+        self.catalog = catalog_wrapper
+        super().__init__(*args, **kwargs)
+
+    def _build_failure_result(self, model_unique_id: str, columns: Sequence[str]) -> DBTInsightResult:
+        """
+        Build failure result for the insight if a source has columns without descriptions.
+        """
+        failure_message = f"The source:{model_unique_id} has columns without descriptions:\n"
+        failure_message += numbered_list(columns)
+
+        recommendation = "Update the source to include descriptions for all columns."
+        return DBTInsightResult(
+            type=self.TYPE,
+            name=self.NAME,
+            message=failure_message,
+            recommendation=recommendation,
+            reason_to_flag=self.REASON_TO_FLAG,
+            metadata={"source_unique_id": model_unique_id, "columns": columns},
+        )
+
+    def generate(self, *args, **kwargs) -> List[DBTModelInsightResponse]:
+        """
+        Generate the insight response for the check. This method is called by the insight runner to generate the insight
+        response for the check.
+        Ensures that the source has columns with descriptions in the properties file (usually schema.yml).
+
+
+        Args:
+            *args: Variable length argument list.
+            **kwargs: Arbitrary keyword arguments.
+        Returns:
+            List[DBTModelInsightResponse]: List of insight responses for the check.
+
+        """
+        insights = []
+        for node_id, node in self.sources.items():
+            if self.should_skip_model(node_id):
+                self.logger.debug(f"Skipping model {node_id} as it is not enabled for selected models")
+                continue
+            if node.resource_type == AltimateResourceType.source:
+                missing_columns = self._check_source_columns(node_id)
+                if missing_columns:
+                    insights.append(
+                        DBTModelInsightResponse(
+                            unique_id=node_id,
+                            package_name=node.package_name,
+                            path=node.original_file_path,
+                            original_file_path=node.original_file_path,
+                            insight=self._build_failure_result(node_id, missing_columns),
+                            severity=get_severity(self.config, self.ALIAS, self.DEFAULT_SEVERITY),
+                        )
+                    )
+        return insights
+
+    def _check_source_columns(self, node_id) -> Tuple[int, Set[str]]:
+        columns_with_missing_descriptions = set()
+        for column_name, column_node in self.get_node(node_id).columns.items():
+            if not column_node.description:
+                columns_with_missing_descriptions.add(column_name)
+        return columns_with_missing_descriptions
+
+    @classmethod
+    def has_all_required_data(cls, has_manifest: bool, has_catalog: bool, **kwargs) -> Tuple[bool, str]:
+        """
+        Check if all required data is available for the insight to run.
+        :param has_manifest: A boolean indicating if manifest is available.
+        :return: A boolean indicating if all required data is available.
+        """
+        if not has_manifest:
+            return False, "Manifest is required for insight to run."
+
+        if not has_catalog:
+            return False, "Catalog is required for insight to run."
+
+        return True, ""

datapilot/core/platforms/dbt/insights/checks/check_source_has_all_columns.py

@@ -0,0 +1,103 @@
+from typing import ClassVar
+from typing import List
+from typing import Sequence
+from typing import Set
+from typing import Tuple
+
+from datapilot.core.insights.utils import get_severity
+from datapilot.core.platforms.dbt.insights.checks.base import ChecksInsight
+from datapilot.core.platforms.dbt.insights.schema import DBTInsightResult
+from datapilot.core.platforms.dbt.insights.schema import DBTModelInsightResponse
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateResourceType
+from datapilot.core.platforms.dbt.wrappers.catalog.wrapper import BaseCatalogWrapper
+from datapilot.utils.formatting.utils import numbered_list
+
+
+class CheckSourceHasAllColumns(ChecksInsight):
+    NAME = "Source has all columns"
+    ALIAS = "check_source_has_all_columns"
+    DESCRIPTION = "Ensures that all columns in the database are also specified in the properties file. (usually schema.yml)."
+    REASON_TO_FLAG = "Missing columns in the source can lead to confusion and inconsistency in analysis. "
+    FILES_REQUIRED: ClassVar = ["Manifest", "Catalog"]
+
+    def __init__(self, catalog_wrapper: BaseCatalogWrapper, *args, **kwargs):
+        self.catalog = catalog_wrapper
+        super().__init__(*args, **kwargs)
+
+    def _build_failure_result(self, source_unique_id: str, columns: Sequence[str]) -> DBTInsightResult:
+        """
+        Build failure result for the insight if a source has missing columns.
+        """
+        failure_message = f"The source:{source_unique_id} has missing columns:\n"
+        failure_message += numbered_list(columns)
+
+        recommendation = "Update the source to include all columns."
+        return DBTInsightResult(
+            type=self.TYPE,
+            name=self.NAME,
+            message=failure_message,
+            recommendation=recommendation,
+            reason_to_flag=self.REASON_TO_FLAG,
+            metadata={"source_unique_id": source_unique_id, "columns": columns},
+        )
+
+    def generate(self, *args, **kwargs) -> List[DBTModelInsightResponse]:
+        """
+        Generate the insight response for the check. This method is called by the insight runner to generate the insight
+        response for the check.
+        Ensures that the source has all columns in the properties file (usually schema.yml).
+        """
+        insights = []
+        for node_id, node in self.sources.items():
+            if self.should_skip_model(node_id):
+                self.logger.debug(f"Skipping model {node_id} as it is not enabled for selected models")
+                continue
+            if node.resource_type == AltimateResourceType.source:
+                missing_columns = self._check_source_columns(node_id)
+                if missing_columns:
+                    insights.append(
+                        DBTModelInsightResponse(
+                            unique_id=node_id,
+                            package_name=node.package_name,
+                            original_file_path=node.original_file_path,
+                            path=node.original_file_path,
+                            insight=self._build_failure_result(node_id, list(missing_columns)),
+                            severity=get_severity(self.config, self.ALIAS, self.DEFAULT_SEVERITY),
+                        )
+                    )
+        return insights
+
+    def _check_source_columns(self, node_id) -> Tuple[int, Set[str]]:
+        """
+        Check if the source has all columns
+        Checking if the source has all columns as defined in the catalog.
+        Ensuring that the source has all columns helps in maintaining data integrity and consistency.
+        """
+        missing_columns = set()
+        schema = self.catalog.get_schema()
+        if node_id not in schema:
+            return missing_columns
+        catalog_columns = schema[node_id].keys()
+        for col_name in self.get_node(node_id).columns.items():
+            if col_name not in catalog_columns:
+                missing_columns.add(col_name)
+        return missing_columns
+
+    @classmethod
+    def has_all_required_data(cls, has_manifest: bool, has_catalog: bool, **kwargs) -> Tuple[bool, str]:
+        """
+        Check if all required data is available for the insight to run.
+        :param has_manifest: A boolean indicating if manifest is available.
+        :return: A boolean indicating if all required data is available.
+        """
+        if not has_manifest:
+            return False, "Manifest is required for insight to run."
+
+        if not has_catalog:
+            return False, "Catalog is required for insight to run."
+
+        return True, ""
+
+    @classmethod
+    def requires_catalog(cls) -> bool:
+        return True

datapilot/core/platforms/dbt/insights/checks/check_source_has_freshness.py

@@ -0,0 +1,94 @@
+from typing import List
+
+from datapilot.core.insights.utils import get_severity
+from datapilot.core.platforms.dbt.insights.checks.base import ChecksInsight
+from datapilot.core.platforms.dbt.insights.schema import DBTInsightResult
+from datapilot.core.platforms.dbt.insights.schema import DBTModelInsightResponse
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateResourceType
+
+
+class CheckSourceHasFreshness(ChecksInsight):
+    NAME = "Source has freshness options"
+    ALIAS = "check_source_has_freshness"
+    DESCRIPTION = "Ensures that the source has freshness options"
+    REASON_TO_FLAG = "Missing freshness options for the source can lead to confusion and inconsistency in analysis. "
+    FRESHNESS_STR = "freshness"
+
+    def _build_failure_result(self, source_id: int, missing_keys) -> DBTInsightResult:
+        """
+        Build failure result for the insight if a model's parent schema is not whitelist or in blacklist.
+        """
+        missing_keys = ", ".join(missing_keys)
+        failure_message = f"The source:{source_id} does not have freshness options defined for the following keys:\n {missing_keys}"
+
+        recommendation = "Define the freshness options for the source to ensure consistency in analysis."
+
+        return DBTInsightResult(
+            type=self.TYPE,
+            name=self.NAME,
+            message=failure_message,
+            recommendation=recommendation,
+            reason_to_flag=self.REASON_TO_FLAG,
+            metadata={"source_id": source_id, "missing_keys": missing_keys},
+        )
+
+    def generate(self, *args, **kwargs) -> List[DBTModelInsightResponse]:
+        """
+        Generate the insight response for the check. This method is called by the insight runner to generate the insight
+        response for the check.
+        Ensures that the source has freshness options
+        """
+        self.freshness_keys = self.get_check_config(self.FRESHNESS_STR) or []
+        insights = []
+        for node_id, node in self.sources.items():
+            if self.should_skip_model(node_id):
+                self.logger.debug(f"Skipping model {node_id} as it is not enabled for selected models")
+                continue
+            if node.resource_type == AltimateResourceType.source:
+                missing_keys = self._check_source_has_freshness(node_id)
+                if missing_keys:
+                    insights.append(
+                        DBTModelInsightResponse(
+                            unique_id=node_id,
+                            package_name=node.package_name,
+                            original_file_path=node.original_file_path,
+                            path=node.original_file_path,
+                            insight=self._build_failure_result(node_id, missing_keys),
+                            severity=get_severity(self.config, self.ALIAS, self.DEFAULT_SEVERITY),
+                        )
+                    )
+        return insights
+
+    def _check_source_has_freshness(self, source_id: str) -> List[str]:
+        source = self.get_node(source_id)
+        freshness = source.freshness.dict() if source.freshness else {}
+
+        if not freshness:
+            return False
+
+        missing_keys = []
+        for key in self.freshness_keys:
+            if key not in freshness:
+                missing_keys.append(key)
+
+        return missing_keys
+
+    @classmethod
+    def get_config_schema(cls):
+        config_schema = super().get_config_schema()
+        config_schema["config"] = {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "type": "object",
+            "properties": {
+                cls.FRESHNESS_STR: {
+                    "type": "array",
+                    "description": "The freshness options that should be defined for the source. If not provided, all freshness options are allowed.",
+                    "items": {
+                        "type": "string",
+                        "enum": ["error_after", "warn_after"],
+                    },
+                },
+            },
+            "required": [cls.FRESHNESS_STR],
+        }
+        return config_schema

datapilot/core/platforms/dbt/insights/checks/check_source_has_labels_keys.py

@@ -0,0 +1,110 @@
+from typing import List
+from typing import Sequence
+from typing import Set
+from typing import Tuple
+
+from datapilot.core.insights.utils import get_severity
+from datapilot.core.platforms.dbt.insights.checks.base import ChecksInsight
+from datapilot.core.platforms.dbt.insights.schema import DBTInsightResult
+from datapilot.core.platforms.dbt.insights.schema import DBTModelInsightResponse
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateResourceType
+from datapilot.utils.formatting.utils import numbered_list
+
+
+class CheckSourceHasLabelsKeys(ChecksInsight):
+    NAME = "Check source has labels keys"
+    ALIAS = "check_source_has_labels_keys"
+    DESCRIPTION = (
+        "Checks that the source has the specified labels keys as defined in the properties file. "
+        "Ensuring that the source has the required labels keys helps in maintaining metadata consistency and understanding."
+    )
+    REASON_TO_FLAG = (
+        "Missing labels keys in the source can lead to inconsistency in metadata management and understanding of the source. "
+        "It's important to ensure that the source includes all the required labels keys as per the configuration."
+    )
+    LABEL_KEYS_STR = "labels_keys"
+    ALLOW_EXTRA_KEYS_STR = "allow_extra_keys"
+
+    def generate(self, *args, **kwargs) -> List[DBTModelInsightResponse]:
+        insights = []
+        self.labels_keys = self.get_check_config(self.LABEL_KEYS_STR)
+        self.allow_extra_keys = self.get_check_config(self.ALLOW_EXTRA_KEYS_STR)
+
+        for node_id, node in self.sources.items():
+            if self.should_skip_model(node_id):
+                self.logger.debug(f"Skipping model {node_id} as it is not enabled for selected models")
+                continue
+            if node.resource_type == AltimateResourceType.source:
+                status_code, missing_keys, extra_keys = self._check_labels_keys(node_id)
+                if status_code == 1:
+                    insights.append(
+                        DBTModelInsightResponse(
+                            unique_id=node_id,
+                            package_name=node.package_name,
+                            path=node.original_file_path,
+                            original_file_path=node.original_file_path,
+                            insight=self._build_failure_result(node_id, missing_keys, extra_keys),
+                            severity=get_severity(self.config, self.ALIAS, self.DEFAULT_SEVERITY),
+                        )
+                    )
+        return insights
+
+    def _build_failure_result(self, model_unique_id: str, missing_keys: Sequence[str], extra_keys: Sequence[str]) -> DBTInsightResult:
+        failure_message = ""
+        if missing_keys:
+            failure_message += (
+                f"The model `{model_unique_id}` is missing the following labels keys: {missing_keys}. "
+                "Ensure that the model has the required labels keys."
+            )
+        if extra_keys:
+            failure_message += (
+                f"The model `{model_unique_id}` has the following extra labels keys: {extra_keys}. "
+                "Ensure that the model does not include any extra labels keys."
+            )
+        recommendation = (
+            "Add the following labels keys to the model `{model_unique_id}`: {missing_keys}. "
+            "Ensuring that the model has the required labels keys helps in maintaining metadata consistency and understanding."
+        )
+        return DBTInsightResult(
+            failure_message=failure_message.format(model_unique_id=model_unique_id, missing_keys=numbered_list(missing_keys)),
+            recommendation=recommendation.format(model_unique_id=model_unique_id, missing_keys=numbered_list(missing_keys)),
+            metadata={"model_unique_id": model_unique_id, "missing_keys": missing_keys},
+        )
+
+    def _check_labels_keys(self, node_id) -> Tuple[int, Set[str]]:
+        status_code = 0
+        missing_keys = set(self.labels_keys) - set(self.get_node(node_id).label)
+        config = self.get_node(node_id).config.dict() if self.get_node(node_id).config else {}
+        labels = config.get("labels", {})
+        label_keys = set(labels.keys())
+        extra_keys = set()
+        if missing_keys:
+            status_code = 1
+        if not self.allow_extra_keys:
+            extra_keys = label_keys - set(self.labels_keys)
+            if extra_keys:
+                status_code = 1
+        return status_code, missing_keys, extra_keys
+
+    @classmethod
+    def get_config_schema(cls):
+        config_schema = super().get_config_schema()
+        config_schema["config"] = {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "type": "object",
+            "properties": {
+                cls.LABEL_KEYS_STR: {
+                    "type": "array",
+                    "items": {
+                        "type": "string",
+                    },
+                    "description": "A list of meta keys that should be present in the model.",
+                },
+                cls.ALLOW_EXTRA_KEYS_STR: {
+                    "type": "boolean",
+                    "default": False,
+                },
+            },
+            "required": [cls.LABEL_KEYS_STR],
+        }
+        return config_schema

datapilot/core/platforms/dbt/insights/checks/check_source_has_loader.py

@@ -0,0 +1,62 @@
+from typing import List
+
+from datapilot.core.insights.utils import get_severity
+from datapilot.core.platforms.dbt.insights.checks.base import ChecksInsight
+from datapilot.core.platforms.dbt.insights.schema import DBTInsightResult
+from datapilot.core.platforms.dbt.insights.schema import DBTModelInsightResponse
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateResourceType
+
+
+class CheckSourceHasLoader(ChecksInsight):
+    NAME = "Source has loader"
+    ALIAS = "check_source_has_loader"
+    DESCRIPTION = "Check if the source has a loader"
+    REASON_TO_FLAG = "Missing loader for the source can lead to confusion and inconsistency in analysis. "
+
+    def _build_failure_result(self, source_id: int) -> DBTInsightResult:
+        """
+        Build failure result for the insight if a model's parent schema is not whitelist or in blacklist.
+        """
+        failure_message = f"The source:{source_id} does not have a loader defined.\n"
+
+        recommendation = "Define the loader for the source to ensure consistency in analysis."
+
+        return DBTInsightResult(
+            type=self.TYPE,
+            name=self.NAME,
+            message=failure_message,
+            recommendation=recommendation,
+            reason_to_flag=self.REASON_TO_FLAG,
+            metadata={"source_id": source_id},
+        )
+
+    def generate(self, *args, **kwargs) -> List[DBTModelInsightResponse]:
+        """
+        Generate the insight response for the check. This method is called by the insight runner to generate the insight
+        response for the check.
+        Ensures that the source has a loader option
+        """
+        insights = []
+        for node_id, node in self.sources.items():
+            if self.should_skip_model(node_id):
+                self.logger.debug(f"Skipping source {node_id} as it is not enabled for selected models")
+                continue
+            if node.resource_type == AltimateResourceType.source:
+                if not self._check_source_has_loader(node_id):
+                    insights.append(
+                        DBTModelInsightResponse(
+                            unique_id=node_id,
+                            package_name=node.package_name,
+                            original_file_path=node.original_file_path,
+                            path=node.original_file_path,
+                            insight=self._build_failure_result(node_id),
+                            severity=get_severity(self.config, self.ALIAS, self.DEFAULT_SEVERITY),
+                        )
+                    )
+        return insights
+
+    def _check_source_has_loader(self, source_unique_id: str) -> bool:
+        source = self.get_node(source_unique_id)
+        if not source.loader:
+            return False
+        return True