dbt-bouncer 1.31.2rc3__py3-none-any.whl → 2.0.0rc1__py3-none-any.whl

dbt_bouncer/checks/manifest/check_exposures.py

@@ -1,34 +1,33 @@
-# mypy: disable-error-code="union-attr"
-
-
-from typing import TYPE_CHECKING, List, Literal
+from typing import TYPE_CHECKING, Literal
 
 from pydantic import Field
 
 from dbt_bouncer.check_base import BaseCheck
 
 if TYPE_CHECKING:
-    from dbt_bouncer.artifact_parsers.parsers_common import (
+    from dbt_bouncer.artifact_parsers.parsers_manifest import (
         DbtBouncerExposureBase,
         DbtBouncerModelBase,
     )
 
+from dbt_bouncer.checks.common import DbtBouncerFailedCheckError
+
 
 class CheckExposureOnModel(BaseCheck):
     """Exposures should depend on a model.
 
     Parameters:
-        maximum_number_of_models (Optional[int]): The maximum number of models an exposure can depend on, defaults to 100.
-        minimum_number_of_models (Optional[int]): The minimum number of models an exposure can depend on, defaults to 1.
+        maximum_number_of_models (int | None): The maximum number of models an exposure can depend on, defaults to 100.
+        minimum_number_of_models (int | None): The minimum number of models an exposure can depend on, defaults to 1.
 
     Receives:
         exposure (DbtBouncerExposureBase): The DbtBouncerExposureBase object to check.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the exposure path (i.e the .yml file where the exposure is configured). Exposure paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the exposure path (i.e the .yml file where the exposure is configured). Only exposure paths that match the pattern will be checked.
-        severity (Optional[Literal["error", "warn"]]): Severity level of the check. Default: `error`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the exposure path (i.e the .yml file where the exposure is configured). Exposure paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the exposure path (i.e the .yml file where the exposure is configured). Only exposure paths that match the pattern will be checked.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -44,35 +43,47 @@ class CheckExposureOnModel(BaseCheck):
 
     """
 
-    exposure: "DbtBouncerExposureBase" = Field(default=None)
+    exposure: "DbtBouncerExposureBase | None" = Field(default=None)
     maximum_number_of_models: int = Field(default=100)
     minimum_number_of_models: int = Field(default=1)
     name: Literal["check_exposure_based_on_model"]
 
     def execute(self) -> None:
-        """Execute the check."""
-        number_of_upstream_models = len(self.exposure.depends_on.nodes)
+        """Execute the check.
 
-        assert self.minimum_number_of_models <= number_of_upstream_models, (
-            f"`{self.exposure.name}` is based on less models ({number_of_upstream_models}) than the minimum permitted ({self.minimum_number_of_models})."
-        )
-        assert number_of_upstream_models <= self.maximum_number_of_models, (
-            f"`{self.exposure.name}` is based on more models ({number_of_upstream_models}) than the maximum permitted ({self.maximum_number_of_models})."
+        Raises:
+            DbtBouncerFailedCheckError: If upstream models number is not within limits.
+
+        """
+        if self.exposure is None:
+            raise DbtBouncerFailedCheckError("self.exposure is None")
+        depends_on = self.exposure.depends_on
+        number_of_upstream_models = (
+            len(getattr(depends_on, "nodes", []) or []) if depends_on else 0
         )
 
+        if number_of_upstream_models < self.minimum_number_of_models:
+            raise DbtBouncerFailedCheckError(
+                f"`{self.exposure.name}` is based on less models ({number_of_upstream_models}) than the minimum permitted ({self.minimum_number_of_models})."
+            )
+        if number_of_upstream_models > self.maximum_number_of_models:
+            raise DbtBouncerFailedCheckError(
+                f"`{self.exposure.name}` is based on more models ({number_of_upstream_models}) than the maximum permitted ({self.maximum_number_of_models})."
+            )
+
 
 class CheckExposureOnNonPublicModels(BaseCheck):
     """Exposures should be based on public models only.
 
     Receives:
         exposure (DbtBouncerExposureBase): The DbtBouncerExposureBase object to check.
-        models (List[DbtBouncerModelBase]): List of DbtBouncerModelBase objects parsed from `manifest.json`.
+        models (list[DbtBouncerModelBase]): List of DbtBouncerModelBase objects parsed from `manifest.json`.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the exposure path (i.e the .yml file where the exposure is configured). Exposure paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the exposure path (i.e the .yml file where the exposure is configured). Only exposure paths that match the pattern will be checked.
-        severity (Optional[Literal["error", "warn"]]): Severity level of the check. Default: `error`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the exposure path (i.e the .yml file where the exposure is configured). Exposure paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the exposure path (i.e the .yml file where the exposure is configured). Only exposure paths that match the pattern will be checked.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -82,44 +93,52 @@ class CheckExposureOnNonPublicModels(BaseCheck):
 
     """
 
-    exposure: "DbtBouncerExposureBase" = Field(default=None)
-    models: List["DbtBouncerModelBase"] = Field(default=[])
+    exposure: "DbtBouncerExposureBase | None" = Field(default=None)
+    models: list["DbtBouncerModelBase"] = Field(default=[])
     name: Literal["check_exposure_based_on_non_public_models"]
 
     def execute(self) -> None:
-        """Execute the check."""
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If exposure is based on non-public models.
+
+        """
+        if self.exposure is None:
+            raise DbtBouncerFailedCheckError("self.exposure is None")
         non_public_upstream_dependencies = []
-        for model in self.exposure.depends_on.nodes:
+        for model in getattr(self.exposure.depends_on, "nodes", []) or []:
             if (
                 next(m for m in self.models if m.unique_id == model).resource_type
                 == "model"
                 and next(m for m in self.models if m.unique_id == model).package_name
                 == self.exposure.package_name
             ):
-                model = next(m for m in self.models if m.unique_id == model)
-                if model.access.value != "public":
-                    non_public_upstream_dependencies.append(model.name)
+                model_obj = next(m for m in self.models if m.unique_id == model)
+                if model_obj.access and model_obj.access.value != "public":
+                    non_public_upstream_dependencies.append(model_obj.name)
 
-        assert not non_public_upstream_dependencies, (
-            f"`{self.exposure.name}` is based on a model(s) that is not public: {non_public_upstream_dependencies}."
-        )
+        if non_public_upstream_dependencies:
+            raise DbtBouncerFailedCheckError(
+                f"`{self.exposure.name}` is based on a model(s) that is not public: {non_public_upstream_dependencies}."
+            )
 
 
 class CheckExposureOnView(BaseCheck):
     """Exposures should not be based on views.
 
     Parameters:
-        materializations_to_include (Optional[List[str]]): List of materializations to include in the check.
+        materializations_to_include (list[str] | None): List of materializations to include in the check.
 
     Receives:
         exposure (DbtBouncerExposureBase): The DbtBouncerExposureBase object to check.
-        models (List[DbtBouncerModelBase]): List of DbtBouncerModelBase objects parsed from `manifest.json`.
+        models (list[DbtBouncerModelBase]): List of DbtBouncerModelBase objects parsed from `manifest.json`.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the exposure path (i.e the .yml file where the exposure is configured). Exposure paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the exposure path (i.e the .yml file where the exposure is configured). Only exposure paths that match the pattern will be checked.
-        severity (Optional[Literal["error", "warn"]]): Severity level of the check. Default: `error`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the exposure path (i.e the .yml file where the exposure is configured). Exposure paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the exposure path (i.e the .yml file where the exposure is configured). Only exposure paths that match the pattern will be checked.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -137,27 +156,35 @@ class CheckExposureOnView(BaseCheck):
 
     """
 
-    exposure: "DbtBouncerExposureBase" = Field(default=None)
-    materializations_to_include: List[str] = Field(
+    exposure: "DbtBouncerExposureBase | None" = Field(default=None)
+    materializations_to_include: list[str] = Field(
         default=["ephemeral", "view"],
     )
-    models: List["DbtBouncerModelBase"] = Field(default=[])
+    models: list["DbtBouncerModelBase"] = Field(default=[])
     name: Literal["check_exposure_based_on_view"]
 
     def execute(self) -> None:
-        """Execute the check."""
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If exposure is based on a model that is not a table.
+
+        """
+        if self.exposure is None:
+            raise DbtBouncerFailedCheckError("self.exposure is None")
         non_table_upstream_dependencies = []
-        for model in self.exposure.depends_on.nodes:
+        for model in getattr(self.exposure.depends_on, "nodes", []) or []:
             if (
                 next(m for m in self.models if m.unique_id == model).resource_type
                 == "model"
                 and next(m for m in self.models if m.unique_id == model).package_name
                 == self.exposure.package_name
             ):
-                model = next(m for m in self.models if m.unique_id == model)
-                if model.config.materialized in self.materializations_to_include:
-                    non_table_upstream_dependencies.append(model.name)
-
-        assert not non_table_upstream_dependencies, (
-            f"`{self.exposure.name}` is based on a model that is not a table: {non_table_upstream_dependencies}."
-        )
+                model_obj = next(m for m in self.models if m.unique_id == model)
+                if model_obj.config.materialized in self.materializations_to_include:
+                    non_table_upstream_dependencies.append(model_obj.name)
+
+        if non_table_upstream_dependencies:
+            raise DbtBouncerFailedCheckError(
+                f"`{self.exposure.name}` is based on a model that is not a table: {non_table_upstream_dependencies}."
+            )

dbt_bouncer/checks/manifest/check_lineage.py

@@ -1,18 +1,17 @@
-# mypy: disable-error-code="union-attr"
-
 import re
-from typing import TYPE_CHECKING, List, Literal, Optional
+from typing import TYPE_CHECKING, Literal
 
 from dbt_bouncer.check_base import BaseCheck
 
 if TYPE_CHECKING:
-    from dbt_bouncer.artifact_parsers.parsers_common import (
+    from dbt_bouncer.artifact_parsers.parsers_manifest import (
         DbtBouncerManifest,
         DbtBouncerModelBase,
     )
 
 from pydantic import Field
 
+from dbt_bouncer.checks.common import DbtBouncerFailedCheckError
 from dbt_bouncer.utils import clean_path_str, get_clean_model_name
 
 
@@ -25,13 +24,13 @@ class CheckLineagePermittedUpstreamModels(BaseCheck):
     Receives:
         manifest_obj (DbtBouncerManifest): The manifest object.
         model (DbtBouncerModelBase): The DbtBouncerModelBase object to check.
-        models (List[DbtBouncerModelBase]): List of DbtBouncerModelBase objects parsed from `manifest.json`.
+        models (list[DbtBouncerModelBase]): List of DbtBouncerModelBase objects parsed from `manifest.json`.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
-        severity (Optional[Literal["error", "warn"]]): Severity level of the check. Default: `error`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -49,18 +48,27 @@ class CheckLineagePermittedUpstreamModels(BaseCheck):
 
     """
 
-    manifest_obj: "DbtBouncerManifest" = Field(default=None)
-    model: "DbtBouncerModelBase" = Field(default=None)
-    models: List["DbtBouncerModelBase"] = Field(default=[])
+    manifest_obj: "DbtBouncerManifest | None" = Field(default=None)
+    model: "DbtBouncerModelBase | None" = Field(default=None)
+    models: list["DbtBouncerModelBase"] = Field(default=[])
     name: Literal["check_lineage_permitted_upstream_models"]
-    package_name: Optional[str] = Field(default=None)
+    package_name: str | None = Field(default=None)
     upstream_path_pattern: str
 
     def execute(self) -> None:
-        """Execute the check."""
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If upstream models are not permitted.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
+        if self.manifest_obj is None:
+            raise DbtBouncerFailedCheckError("self.manifest_obj is None")
         upstream_models = [
             x
-            for x in self.model.depends_on.nodes
+            for x in getattr(self.model.depends_on, "nodes", []) or []
             if x.split(".")[0] == "model"
             and x.split(".")[1]
             == (self.package_name or self.manifest_obj.manifest.metadata.project_name)
@@ -77,9 +85,10 @@ class CheckLineagePermittedUpstreamModels(BaseCheck):
             )
             is None
         ]
-        assert not not_permitted_upstream_models, (
-            f"`{get_clean_model_name(self.model.unique_id)}` references upstream models that are not permitted: {[m.split('.')[-1] for m in not_permitted_upstream_models]}."
-        )
+        if not_permitted_upstream_models:
+            raise DbtBouncerFailedCheckError(
+                f"`{get_clean_model_name(self.model.unique_id)}` references upstream models that are not permitted: {[m.split('.')[-1] for m in not_permitted_upstream_models]}."
+            )
 
 
 class CheckLineageSeedCannotBeUsed(BaseCheck):
@@ -89,10 +98,10 @@ class CheckLineageSeedCannotBeUsed(BaseCheck):
         model (DbtBouncerModelBase): The DbtBouncerModelBase object to check.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
-        severity (Optional[Literal["error", "warn"]]): Severity level of the check. Default: `error`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -103,16 +112,26 @@ class CheckLineageSeedCannotBeUsed(BaseCheck):
 
     """
 
-    model: "DbtBouncerModelBase" = Field(default=None)
+    model: "DbtBouncerModelBase | None" = Field(default=None)
     name: Literal["check_lineage_seed_cannot_be_used"]
 
     def execute(self) -> None:
-        """Execute the check."""
-        assert not [
-            x for x in self.model.depends_on.nodes if x.split(".")[0] == "seed"
-        ], (
-            f"`{get_clean_model_name(self.model.unique_id)}` references a seed even though this is not permitted."
-        )
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If seed is referenced.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
+        if [
+            x
+            for x in getattr(self.model.depends_on, "nodes", []) or []
+            if x.split(".")[0] == "seed"
+        ]:
+            raise DbtBouncerFailedCheckError(
+                f"`{get_clean_model_name(self.model.unique_id)}` references a seed even though this is not permitted."
+            )
 
 
 class CheckLineageSourceCannotBeUsed(BaseCheck):
@@ -122,10 +141,10 @@ class CheckLineageSourceCannotBeUsed(BaseCheck):
         model (DbtBouncerModelBase): The DbtBouncerModelBase object to check.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
-        severity (Optional[Literal["error", "warn"]]): Severity level of the check. Default: `error`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -136,13 +155,23 @@ class CheckLineageSourceCannotBeUsed(BaseCheck):
 
     """
 
-    model: "DbtBouncerModelBase" = Field(default=None)
+    model: "DbtBouncerModelBase | None" = Field(default=None)
     name: Literal["check_lineage_source_cannot_be_used"]
 
     def execute(self) -> None:
-        """Execute the check."""
-        assert not [
-            x for x in self.model.depends_on.nodes if x.split(".")[0] == "source"
-        ], (
-            f"`{get_clean_model_name(self.model.unique_id)}` references a source even though this is not permitted."
-        )
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If source is referenced.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
+        if [
+            x
+            for x in getattr(self.model.depends_on, "nodes", []) or []
+            if x.split(".")[0] == "source"
+        ]:
+            raise DbtBouncerFailedCheckError(
+                f"`{get_clean_model_name(self.model.unique_id)}` references a source even though this is not permitted."
+            )