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

dbt_bouncer/checks/manifest/check_seeds.py

@@ -0,0 +1,63 @@
+import re
+from typing import TYPE_CHECKING, Literal
+
+from pydantic import ConfigDict, Field
+
+from dbt_bouncer.check_base import BaseCheck
+
+if TYPE_CHECKING:
+    from dbt_bouncer.artifact_parsers.parsers_manifest import (
+        DbtBouncerSeedBase,
+    )
+
+from dbt_bouncer.checks.common import DbtBouncerFailedCheckError
+from dbt_bouncer.utils import get_clean_model_name
+
+
+class CheckSeedNames(BaseCheck):
+    """Seed must have a name that matches the supplied regex.
+
+    Parameters:
+        seed_name_pattern (str): Regexp the seed name must match.
+
+    Receives:
+        seed (DbtBouncerSeedBase): The DbtBouncerSeedBase object to check.
+
+    Other Parameters:
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the seed path. Seed paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the seed path. Only seed paths that match the pattern will be checked.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
+
+    Example(s):
+        ```yaml
+        manifest_checks:
+            - name: check_seed_names
+              include: ^seeds
+              model_name_pattern: ^raw_
+        ```
+
+    """
+
+    model_config = ConfigDict(extra="forbid", protected_namespaces=())
+
+    name: Literal["check_seed_names"]
+    seed: "DbtBouncerSeedBase | None" = Field(default=None)
+    seed_name_pattern: str
+
+    def execute(self) -> None:
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If model name does not match regex.
+
+        """
+        if self.seed is None:
+            raise DbtBouncerFailedCheckError("self.seed is None")
+        if (
+            re.compile(self.seed_name_pattern.strip()).match(str(self.seed.name))
+            is None
+        ):
+            raise DbtBouncerFailedCheckError(
+                f"`{get_clean_model_name(self.seed.unique_id)}` does not match the supplied regex `{self.seed_name_pattern.strip()}`."
+            )

dbt_bouncer/checks/manifest/check_semantic_models.py

@@ -1,31 +1,30 @@
-# mypy: disable-error-code="union-attr"
-
-
-from typing import TYPE_CHECKING, List, Literal
+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 (
         DbtBouncerModelBase,
         DbtBouncerSemanticModelBase,
     )
 
 from pydantic import Field
 
+from dbt_bouncer.checks.common import DbtBouncerFailedCheckError
+
 
 class CheckSemanticModelOnNonPublicModels(BaseCheck):
     """Semantic models should be based on public models only.
 
     Receives:
-        models (List[DbtBouncerModelBase]): List of DbtBouncerModelBase objects parsed from `manifest.json`.
+        models (list[DbtBouncerModelBase]): List of DbtBouncerModelBase objects parsed from `manifest.json`.
         semantic_model (DbtBouncerSemanticModelBase): The DbtBouncerSemanticModelBase 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 semantic model path (i.e the .yml file where the semantic model is configured). Semantic model paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the semantic model path (i.e the .yml file where the semantic model is configured). Only semantic 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 semantic model path (i.e the .yml file where the semantic model is configured). Semantic model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the semantic model path (i.e the .yml file where the semantic model is configured). Only semantic model paths that match the pattern will be checked.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -35,24 +34,33 @@ class CheckSemanticModelOnNonPublicModels(BaseCheck):
 
     """
 
-    models: List["DbtBouncerModelBase"] = Field(default=[])
+    models: list["DbtBouncerModelBase"] = Field(default=[])
     name: Literal["check_semantic_model_based_on_non_public_models"]
-    semantic_model: "DbtBouncerSemanticModelBase" = Field(default=None)
+    semantic_model: "DbtBouncerSemanticModelBase | None" = Field(default=None)
 
     def execute(self) -> None:
-        """Execute the check."""
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If semantic model is based on non-public models.
+
+        """
+        if self.semantic_model is None:
+            raise DbtBouncerFailedCheckError("self.semantic_model is None")
+
         non_public_upstream_dependencies = []
-        for model in self.semantic_model.depends_on.nodes:
+        for model in getattr(self.semantic_model.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.semantic_model.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"Semantic model `{self.semantic_model.name}` is based on a model(s) that is not public: {non_public_upstream_dependencies}."
-        )
+        if non_public_upstream_dependencies:
+            raise DbtBouncerFailedCheckError(
+                f"Semantic model `{self.semantic_model.name}` is based on a model(s) that is not public: {non_public_upstream_dependencies}."
+            )

dbt_bouncer/checks/manifest/check_snapshots.py

@@ -1,30 +1,31 @@
-# mypy: disable-error-code="union-attr"
 import re
-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 (
         DbtBouncerSnapshotBase,
     )
 
+from dbt_bouncer.checks.common import DbtBouncerFailedCheckError
+
 
 class CheckSnapshotHasTags(BaseCheck):
     """Snapshots must have the specified tags.
 
     Parameters:
-        criteria: (Optional[Literal["any", "all", "one"]]): Whether the snapshot must have any, all, or exactly one of the specified tags. Default: `all`.
+        criteria: (Literal["any", "all", "one"] | None): Whether the snapshot must have any, all, or exactly one of the specified tags. Default: `all`.
         snapshot (DbtBouncerSnapshotBase): The DbtBouncerSnapshotBase object to check.
-        tags (List[str]): List of tags to check for.
+        tags (list[str]): List of tags to check for.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the snapshot path. Snapshot paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the snapshot path. Only snapshot 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 snapshot path. Snapshot paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the snapshot path. Only snapshot paths that match the pattern will be checked.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -39,22 +40,35 @@ class CheckSnapshotHasTags(BaseCheck):
 
     criteria: Literal["any", "all", "one"] = Field(default="all")
     name: Literal["check_snapshot_has_tags"]
-    snapshot: "DbtBouncerSnapshotBase" = Field(default=None)
-    tags: List[str]
+    snapshot: "DbtBouncerSnapshotBase | None" = Field(default=None)
+    tags: list[str]
 
     def execute(self) -> None:
-        """Execute the check."""
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If snapshot does not have required tags.
+
+        """
+        if self.snapshot is None:
+            raise DbtBouncerFailedCheckError("self.snapshot is None")
+        snapshot_tags = self.snapshot.tags or []
         if self.criteria == "any":
-            assert any(tag in self.snapshot.tags for tag in self.tags), (
-                f"`{self.snapshot.name}` does not have any of the required tags: {self.tags}."
-            )
+            if not any(tag in snapshot_tags for tag in self.tags):
+                raise DbtBouncerFailedCheckError(
+                    f"`{self.snapshot.name}` does not have any of the required tags: {self.tags}."
+                )
         elif self.criteria == "all":
-            missing_tags = [tag for tag in self.tags if tag not in self.snapshot.tags]
-            assert not missing_tags, (
-                f"`{self.snapshot.name}` is missing required tags: {missing_tags}."
-            )
-        elif self.criteria == "one":
-            assert sum(tag in self.snapshot.tags for tag in self.tags) == 1, (
+            missing_tags = [tag for tag in self.tags if tag not in snapshot_tags]
+            if missing_tags:
+                raise DbtBouncerFailedCheckError(
+                    f"`{self.snapshot.name}` is missing required tags: {missing_tags}."
+                )
+        elif (
+            self.criteria == "one"
+            and sum(tag in snapshot_tags for tag in self.tags) != 1
+        ):
+            raise DbtBouncerFailedCheckError(
                 f"`{self.snapshot.name}` must have exactly one of the required tags: {self.tags}."
             )
 
@@ -69,10 +83,10 @@ class CheckSnapshotNames(BaseCheck):
         snapshot (DbtBouncerSnapshotBase): The DbtBouncerSnapshotBase 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 snapshot path. Snapshot paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the snapshot path. Only snapshot 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 snapshot path. Snapshot paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the snapshot path. Only snapshot paths that match the pattern will be checked.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -85,14 +99,24 @@ class CheckSnapshotNames(BaseCheck):
     """
 
     name: Literal["check_snapshot_names"]
-    snapshot: "DbtBouncerSnapshotBase" = Field(default=None)
+    snapshot: "DbtBouncerSnapshotBase | None" = Field(default=None)
     snapshot_name_pattern: str
 
     def execute(self) -> None:
-        """Execute the check."""
-        assert (
-            re.compile(self.snapshot_name_pattern.strip()).match(self.snapshot.name)
-            is not None
-        ), (
-            f"`{self.snapshot.name}` does not match the supplied regex `{self.snapshot_name_pattern.strip()})`."
-        )
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If snapshot name does not match regex.
+
+        """
+        if self.snapshot is None:
+            raise DbtBouncerFailedCheckError("self.snapshot is None")
+        if (
+            re.compile(self.snapshot_name_pattern.strip()).match(
+                str(self.snapshot.name)
+            )
+            is None
+        ):
+            raise DbtBouncerFailedCheckError(
+                f"`{self.snapshot.name}` does not match the supplied regex `{self.snapshot_name_pattern.strip()})`."
+            )