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

datapilot/core/platforms/dbt/insights/governance/public_models_without_contracts.py

@@ -0,0 +1,89 @@
+from typing import List
+
+from datapilot.core.insights.utils import get_severity
+from datapilot.core.platforms.dbt.insights.governance.base import DBTGovernanceInsight
+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 AltimateAccess
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateResourceType
+
+
+class DBTPublicModelWithoutContracts(DBTGovernanceInsight):
+    """
+    DBTUndocumentedPublicModels identifies public models that are not documented.
+    """
+
+    NAME = "Public models without contracts"
+    ALIAS = "public_models_without_contracts"
+    DESCRIPTION = "Identify public models that don't have contracts."
+    REASON_TO_FLAG = (
+        "Public models are accessible to all downstream consumers, making it crucial to have clear "
+        "contracts that specify data types and columns. This ensures consistency and predictability "
+        "in data consumption."
+    )
+    FAILURE_MESSAGE = (
+        "Model `{model_unique_id}` is marked as public but does not have a contract. "
+        "This can lead to ambiguity regarding data types and columns, impacting downstream consumers."
+    )
+    RECOMMENDATION = (
+        "Enhance the model `{model_unique_id}` by adding clear contract entries for columns along "
+        "with their data types. Contracts provide essential documentation and guarantees for downstream consumers."
+    )
+
+    def _build_failure_result(
+        self,
+        model_unique_id: str,
+    ) -> DBTInsightResult:
+        """
+        Build failure result for the insight if a model is a root model with 0 direct parents.
+
+        :param model_unique_id: Unique ID of the current model being evaluated.
+        :return: An instance of InsightResult containing failure message and recommendation.
+        """
+        self.logger.debug(f"Building failure result model {model_unique_id} is public but not documented.")
+
+        failure = self.FAILURE_MESSAGE.format(
+            model_unique_id=model_unique_id,
+        )
+        recommendation = self.RECOMMENDATION.format(
+            model_unique_id=model_unique_id,
+        )
+
+        return DBTInsightResult(
+            type=self.TYPE,
+            name=self.NAME,
+            message=failure,
+            recommendation=recommendation,
+            reason_to_flag=self.REASON_TO_FLAG,
+            metadata={
+                "model": model_unique_id,
+            },
+        )
+
+    def generate(self, *args, **kwargs) -> List[DBTModelInsightResponse]:
+        """
+        Generate a list of InsightResponse objects for each model in the DBT project,
+        identifying root models with 0 direct parents.
+        """
+        self.logger.debug("Generating insights for public models without contracts")
+        insights = []
+        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 and node.access == AltimateAccess.public:
+                if (not node.contract) or (not node.contract.enforced):
+                    self.logger.debug(f"Found public model {node_id} without contract enforced")
+                    insight_result = self._build_failure_result(node_id)
+                    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=insight_result,
+                            severity=get_severity(self.config, self.ALIAS, self.DEFAULT_SEVERITY),
+                        )
+                    )
+        self.logger.debug("Finished generating insights for public models without contracts")
+        return insights

datapilot/core/platforms/dbt/insights/governance/undocumented_columns.py

@@ -0,0 +1,148 @@
+from typing import ClassVar
+from typing import List
+from typing import Tuple
+
+from datapilot.core.insights.utils import get_severity
+from datapilot.core.platforms.dbt.insights.governance.base import DBTGovernanceInsight
+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 DBTMissingDocumentation(DBTGovernanceInsight):
+    """
+    DBTDocumentationStaleColumns identifies columns that have been documented but are no longer present in the model.
+    """
+
+    NAME = "Missing documentation"
+    ALIAS = "missing_documentation"
+    DESCRIPTION = (
+        "Detects columns and models in the dbt project that lack documentation. Proper documentation is essential "
+        "for understanding data structures and facilitating collaboration and usage of the dbt project."
+    )
+    REASON_TO_FLAG = (
+        "Missing documentation for columns and models can lead to confusion and hinder effective data "
+        "modeling and analysis. It's important to document data structures comprehensively."
+    )
+    FAILURE_MESSAGE = (
+        "The following columns in the model `{model_unique_id}` are missing documentation:\n{columns}. "
+        "Lack of documentation can impede understanding and usage of the model."
+    )
+    RECOMMENDATION = (
+        "Enhance the documentation for the columns listed above in the model `{model_unique_id}`. "
+        "Documentation provides valuable context and aids in data understanding and collaboration."
+    )
+    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,
+        model_unique_id: str,
+        model_description_is_missing: bool,
+        columns: List[str],
+    ) -> DBTInsightResult:
+        """
+        Build failure result for the insight if a model is a root model with 0 direct parents.
+
+        :param model_unique_id: Unique ID of the current model being evaluated.
+        :param columns: List of columns that are documented but no longer present in the model.
+        :return: An instance of InsightResult containing failure message and recommendation.
+        """
+        self.logger.debug(f"Building failure result for model {model_unique_id} with stale columns {columns}")
+        failure_message = ""
+        if model_description_is_missing:
+            failure_message += f"The model {model_unique_id} is missing a description.\n"
+
+        if columns:
+            failure_message += self.FAILURE_MESSAGE.format(
+                columns=numbered_list(columns),
+                model_unique_id=model_unique_id,
+            )
+
+        recommendation = self.RECOMMENDATION.format(model_unique_id=model_unique_id)
+
+        return DBTInsightResult(
+            type=self.TYPE,
+            name=self.NAME,
+            message=failure_message,
+            recommendation=recommendation,
+            reason_to_flag=self.REASON_TO_FLAG,
+            metadata={
+                "columns": columns,
+                "model_unique_id": model_unique_id,
+                "model_description_is_missing": model_description_is_missing,
+            },
+        )
+
+    def _get_columns_documented(self, node_id) -> List[str]:
+        """
+        Get the list of columns that are documented for a given node.
+        :param node_id: The unique ID of the node.
+        :return: A list of column names.
+        """
+        columns = []
+        for column_name, column_node in self.get_node(node_id).columns.items():
+            if column_node.description:
+                columns.append(column_name.lower())
+        return columns
+
+    def _get_columns_in_model(self, node_id) -> List[str]:
+        if node_id not in self.catalog.get_schema():
+            return []
+        return [k.lower() for k in self.catalog.get_schema()[node_id].keys()]
+
+    def generate(self, *args, **kwargs) -> List[DBTModelInsightResponse]:
+        """
+        Generate a list of InsightResponse objects for each model in the DBT project,
+        identifying root models with 0 direct parents.
+        :return: A list of InsightResponse objects.
+        """
+        insights = []
+        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:
+                model_description_is_missing = not node.description
+                columns_documented = self._get_columns_documented(node_id)
+                db_columns = self._get_columns_in_model(node_id)
+                columns_missing_documentation = list(set(db_columns) - set(columns_documented))
+                if columns_missing_documentation:
+                    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,
+                                model_description_is_missing,
+                                columns_missing_documentation,
+                            ),
+                            severity=get_severity(self.config, self.ALIAS, self.DEFAULT_SEVERITY),
+                        )
+                    )
+
+        return insights
+
+    @classmethod
+    def has_all_required_data(cls, has_manifest: bool, has_catalog: bool, **kwargs) -> Tuple[bool, str]:
+        """
+        return False
+        """
+        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/governance/undocumented_public_models.py

@@ -0,0 +1,110 @@
+from typing import List
+from typing import Optional
+
+from datapilot.core.insights.utils import get_severity
+from datapilot.core.platforms.dbt.insights.governance.base import DBTGovernanceInsight
+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 AltimateAccess
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateManifestNode
+from datapilot.core.platforms.dbt.schemas.manifest import AltimateResourceType
+from datapilot.utils.formatting.utils import numbered_list
+
+
+# TODO: Include catalog information to make this better!
+class DBTUndocumentedPublicModels(DBTGovernanceInsight):
+    """
+    DBTUndocumentedPublicModels identifies public models that are not documented.
+    """
+
+    NAME = "Undocumented public models"
+    ALIAS = "undocumented_public_models"
+    DESCRIPTION = "Identify public models that don't have documentation."
+    REASON_TO_FLAG = (
+        "Public models are accessible to a wide range of data consumers. To promote understanding and usability, "
+        "it's essential to document these models comprehensively."
+    )
+    FAILURE_MESSAGE = (
+        "Model `{model_unique_id}` is marked as public but is not documented. "
+        "Lack of documentation can lead to confusion for data consumers."
+    )
+    RECOMMENDATION = (
+        "For best practices, ensure that all models with public access are documented adequately. "
+        "Documentation enhances data understanding and facilitates collaboration among data consumers."
+    )
+
+    def _build_failure_result(
+        self,
+        model_unique_id: str,
+        model_description_is_missing: bool,
+        columns: Optional[List[str]] = None,
+    ) -> DBTInsightResult:
+        """
+        Build failure result for the insight if a model is a root model with 0 direct parents.
+
+        :param model_unique_id: Unique ID of the current model being evaluated.
+        :param model_description_is_missing: Whether the model description is missing.
+        :param columns: List of columns that are missing documentation.
+        :return: An instance of InsightResult containing failure message and recommendation.
+        """
+        self.logger.debug(f"Building failure result model {model_unique_id} is public but not documented.")
+
+        failure = self.FAILURE_MESSAGE.format(
+            model_unique_id=model_unique_id,
+        )
+        failure += "Missing Model documentation." if model_description_is_missing else ""
+
+        failure += f"\n Columns missing documentation: {numbered_list(columns)}" if columns else ""
+
+        return DBTInsightResult(
+            type=self.TYPE,
+            name=self.NAME,
+            message=failure,
+            recommendation=self.RECOMMENDATION,
+            reason_to_flag=self.REASON_TO_FLAG,
+            metadata={
+                "model": model_unique_id,
+                "columns_without_documentation": columns,
+                "model_description_missing": model_description_is_missing,
+            },
+        )
+
+    def _get_missing_column_documentation(self, node: AltimateManifestNode) -> List[str]:
+        columns = []
+        for column in node.columns:
+            if not column.description:
+                columns.append(column.name)
+        return columns
+
+    def generate(self, *args, **kwargs) -> List[DBTModelInsightResponse]:
+        """
+        Generate a list of InsightResponse objects for each model in the DBT project,
+        identifying root models with 0 direct parents.
+        """
+        self.logger.debug("Generating insights for undocumented public models")
+        insights = []
+        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 node.access == AltimateAccess.public:
+                    missing_model_documentation = not node.description
+                    missing_columns = self._get_missing_column_documentation(node)
+                    if missing_model_documentation or 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,
+                                    not missing_model_documentation,
+                                    missing_columns,
+                                ),
+                                severity=get_severity(self.config, self.ALIAS, self.DEFAULT_SEVERITY),
+                            )
+                        )
+
+        return insights

datapilot/core/platforms/dbt/insights/modelling/README.md

@@ -0,0 +1,15 @@
+## Insights
+
+
+- Direct Join to Source | Done
+- Downstream Models Dependent on Source | Done
+- Duplicate Sources | Done
+- Hard Coded References | Done
+- Model Fanout | Done
+- Multiple Sources Joined | Done
+- Rejoining of Upstream Concepts
+- Root Models | Done
+- Source Fanout | Done
+- Staging Models Dependent on Downstream Models | Done
+- Staging Models Dependent on Other Staging Models | Done
+- Unused Sources | Done

datapilot/core/platforms/dbt/insights/modelling/base.py

@@ -0,0 +1,31 @@
+from abc import abstractmethod
+from typing import Any
+from typing import Dict
+from typing import Optional
+from typing import Tuple
+
+from datapilot.core.platforms.dbt.insights.base import DBTInsight
+
+
+class DBTModellingInsight(DBTInsight):
+    NAME = "DBTModellingInsight"
+    TYPE = "Modelling"
+
+    def __init__(self, config: Optional[Dict[str, Any]] = None, *args, **kwargs):
+        self.config = config or {}
+        super().__init__(*args, **kwargs)
+
+    @abstractmethod
+    def generate(self, *args, **kwargs) -> dict:
+        pass
+
+    @classmethod
+    def has_all_required_data(cls, has_manifest: 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."
+        return True, ""

datapilot/core/platforms/dbt/insights/modelling/direct_join_to_source.py

@@ -0,0 +1,125 @@
+from typing import Dict
+from typing import List
+from typing import Optional
+
+from datapilot.core.insights.utils import get_severity
+from datapilot.core.platforms.dbt.constants import MODEL
+from datapilot.core.platforms.dbt.constants import SOURCE
+from datapilot.core.platforms.dbt.insights.modelling.base import DBTModellingInsight
+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 DBTDirectJoinSource(DBTModellingInsight):
+    """
+    DBTDirectJoinSource is used to ensure that DBT models have a proper mapping
+    from source to staging models and to flag any direct dependencies on multiple
+    sources without intermediate staging models.
+    Ref: https://github.com/dbt-labs/dbt-project-evaluator/blob/main/models/marts/dag/fct_direct_join_to_source.sql
+    """
+
+    ALIAS = "source_staging_model_integrity"
+    NAME = "Source-Staging Model Integrity"
+    DESCRIPTION = "A model should not have direct joins to both sources and other staging models. "
+    REASON_TO_FLAG = (
+        "Flagged when a model directly joins a source and a model without a staging intermediary. "
+        "Direct source-model joins bypass the staging layer, leading to potential inconsistencies in data handling."
+    )
+    FAILURE_MESSAGE = (
+        "Model `{current_model_unique_id}` has direct joins to both sources and other models. "
+        "\n### Detected Sources\n{sources}\n\n### Connected Models \n{models}"
+    )
+    RECOMMENDATION = (
+        "Create a dedicated staging model for the source(s) and modify `{current_model_unique_id}` "
+        "to depend on this staging model. This ensures consistent initial data processing steps."
+    )
+
+    def _build_failure_result(self, current_model_unique_id: str, dependencies: Dict) -> DBTInsightResult:
+        """
+        Build failure result for the insight if a model is directly joining to a source
+        and other models.
+
+        :param current_model_unique_id: Unique ID of the current model being evaluated.
+        :param dependencies: A dictionary of dependencies categorized as 'source' and 'model'.
+        :return: An instance of InsightResult containing failure message and recommendation and metadata.
+        """
+        self.logger.debug(f"Found multiple sources and models for {current_model_unique_id}")
+        failure = self.FAILURE_MESSAGE.format(
+            current_model_unique_id=current_model_unique_id,
+            sources=numbered_list(dependencies["source"]),
+            models=numbered_list(dependencies["model"]),
+        )
+        recommendation = self.RECOMMENDATION.format(current_model_unique_id=current_model_unique_id)
+
+        return DBTInsightResult(
+            type=self.TYPE,
+            name=self.NAME,
+            message=failure,
+            recommendation=recommendation,
+            reason_to_flag=self.REASON_TO_FLAG,
+            metadata={
+                "model": current_model_unique_id,
+                "dependencies": dependencies,
+            },
+        )
+
+    def _check_dependency_on_both_models_and_sources(self, current_node) -> Optional[DBTInsightResult]:
+        """
+        Check if the current node has dependencies on both models and sources or multiple sources.
+
+        :param current_node: The node representing the current model.
+        :return: A list of InsightResult instances with recommendations for each violation.
+        """
+        self.logger.debug(f"Checking dependencies for model {current_node.unique_id}")
+        dependencies = {
+            MODEL: [],
+            SOURCE: [],
+        }
+        excluded_nodes = self.config.get("excluded_nodes", [])
+        for dependent_unique_id in current_node.depends_on.nodes:
+            if dependent_unique_id in excluded_nodes:
+                self.logger.debug(f"Skipping dependency {dependent_unique_id} as it is excluded list of the config")
+                continue
+            dependent_node = self.get_node(dependent_unique_id)
+            if dependent_node.resource_type == AltimateResourceType.model:
+                self.logger.debug(f"Found dependent model {dependent_unique_id} for model {current_node.unique_id}")
+                dependencies[MODEL].append(dependent_node.unique_id)
+            elif dependent_node.resource_type == AltimateResourceType.source:
+                self.logger.debug(f"Found dependent source {dependent_unique_id} for model {current_node.unique_id}")
+                dependencies[SOURCE].append(dependent_node.unique_id)
+        if dependencies[MODEL] and dependencies[SOURCE]:
+            self.logger.debug(f"Found dependencies on both models and sources for model {current_node.unique_id}")
+            return self._build_failure_result(current_node.unique_id, dependencies)
+        else:
+            self.logger.debug(f"No dependencies on both models and sources for model {current_node.unique_id}")
+        return None
+
+    def generate(self, *args, **kwargs) -> List[DBTModelInsightResponse]:
+        """
+        Generate a list of InsightResponse objects for each model in the DBT project,
+        containing insights about direct source dependencies.
+        :return: A list of InsightResponse objects.
+        """
+        self.logger.debug(f"Generating insights for DBTDirectJoinSource for project {self.project_name}")
+        recommendations = []
+        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:
+                recommendation = self._check_dependency_on_both_models_and_sources(node)
+                if recommendation:
+                    self.logger.debug(f"Found recommendation for model {node_id} in DBTDirectJoinSource")
+                    recommendations.append(
+                        DBTModelInsightResponse(
+                            unique_id=node_id,
+                            package_name=node.package_name,
+                            path=node.path,
+                            original_file_path=node.original_file_path,
+                            insight=recommendation,
+                            severity=get_severity(self.config, self.ALIAS, self.DEFAULT_SEVERITY),
+                        )
+                    )
+        return recommendations

datapilot/core/platforms/dbt/insights/modelling/downstream_models_dependent_on_source.py

@@ -0,0 +1,113 @@
+from typing import ClassVar
+from typing import List
+
+from datapilot.config.utils import get_regex_configuration
+from datapilot.core.insights.utils import get_severity
+from datapilot.core.platforms.dbt.constants import INTERMEDIATE
+from datapilot.core.platforms.dbt.constants import MART
+from datapilot.core.platforms.dbt.insights.modelling.base import DBTModellingInsight
+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.utils import classify_model_type
+from datapilot.utils.formatting.utils import numbered_list
+
+
+class DBTDownstreamModelsDependentOnSource(DBTModellingInsight):
+    """
+    DBTDownstreamModelsDependentOnSource identifies downstream models (either marts or intermediate)
+    in a dbt project that depend directly on a source node.
+    """
+
+    NAME = "Downstream models dependent on source"
+    ALIAS = "downstream_source_dependence"
+    DESCRIPTION = "Downstream models should not depend directly on source nodes. "
+    REASON_TO_FLAG = (
+        "Direct dependency of marts or intermediate models on a source node suggests a missing staging model. "
+        "Staging models serve as atomic units, maintaining a one-to-one relationship with source data tables, "
+        "while providing a consistent format for downstream consumption."
+    )
+    FAILURE_MESSAGE = (
+        "Downstream model `{current_model_unique_id}` of type {model_type} is directly dependent on a source nodes."
+        "Direct source dependencies bypass the critical staging layer, leading to potential data consistency issues."
+        " Source dependencies: {source_dependencies}"
+    )
+    RECOMMENDATION = (
+        "Introduce or utilize an existing staging model for the source node involved. Refactor the downstream model "
+        "`{current_model_unique_id}` to select from this staging layer, ensuring a proper abstraction layer between "
+        "raw data and downstream data artifacts."
+    )
+    MODEL_TYPES: ClassVar[List[str]] = [INTERMEDIATE, MART]
+
+    def _build_failure_result(
+        self,
+        current_model_unique_id: str,
+        source_dependencies: List[str],
+        model_type: str,
+    ) -> DBTInsightResult:
+        """
+        Build failure result for the insight if a downstream model depends directly on a source node.
+
+        :param current_model_unique_id: Unique ID of the current model being evaluated.
+        :param source_dependencies: List of source dependencies for the current model.
+        :return: An instance of InsightResult containing failure message and recommendation.
+        """
+        self.logger.debug(f"Building failure result for model {current_model_unique_id} with direct source dependencies")
+
+        failure = self.FAILURE_MESSAGE.format(
+            current_model_unique_id=current_model_unique_id,
+            model_type=model_type,
+            source_dependencies=numbered_list(source_dependencies),
+        )
+
+        return DBTInsightResult(
+            type=self.TYPE,
+            name=self.NAME,
+            message=failure,
+            recommendation=self.RECOMMENDATION.format(current_model_unique_id=current_model_unique_id),
+            reason_to_flag=self.REASON_TO_FLAG,
+            metadata={
+                "model": current_model_unique_id,
+                "source_dependencies": source_dependencies,
+                "model_type": model_type,
+            },
+        )
+
+    def generate(self, *args, **kwargs) -> List[DBTModelInsightResponse]:
+        """
+        Generate a list of InsightResponse objects for each downstream model in the DBT project,
+        identifying those that depend directly on source nodes.
+        :return: A list of InsightResponse objects.
+        """
+        self.logger.debug(f"Generating insights for DBTDownstreamModelsDependentOnSource for project {self.manifest.get_package()}")
+        insights = []
+        regex_configuration = get_regex_configuration(self.config)
+        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:
+                model_type = classify_model_type(node.name, node.original_file_path, regex_configuration)
+                source_dependencies = [
+                    dependent_node_id
+                    for dependent_node_id in node.depends_on.nodes
+                    if self.get_node(dependent_node_id).resource_type == AltimateResourceType.source
+                ]
+
+                if source_dependencies and model_type in self.MODEL_TYPES:
+                    self.logger.debug(f"Found downstream model {node_id} of type {model_type} with direct source dependencies")
+                    insight_result = self._build_failure_result(node.unique_id, source_dependencies, model_type)
+                    insights.append(
+                        DBTModelInsightResponse(
+                            unique_id=node_id,
+                            package_name=node.package_name,
+                            path=node.path,
+                            original_file_path=node.original_file_path,
+                            insight=insight_result,
+                            severity=get_severity(self.config, self.ALIAS, self.DEFAULT_SEVERITY),
+                        )
+                    )
+        self.logger.debug(
+            f"Finished generating insights for DBTDownstreamModelsDependentOnSource. Found  {len(insights)} models with direct source dependencies"
+        )
+        return insights