dbt-bouncer 1.25.0__tar.gz → 1.27.0__tar.gz

{dbt_bouncer-1.25.0 → dbt_bouncer-1.27.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dbt-bouncer
-Version: 1.25.0
+Version: 1.27.0
 Summary: Configure and enforce conventions for your dbt project.
 License: MIT
 Keywords: python,cli,dbt,CI/CD
@@ -8,12 +8,10 @@ Author: Padraic Slattery
 Author-email: pgoslatara@gmail.com
 Maintainer: Padraic Slattery
 Maintainer-email: pgoslatara@gmail.com
-Requires-Python: >=3.9.2,<3.14
+Requires-Python: >=3.11,<3.14
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
@@ -22,12 +20,13 @@ Requires-Dist: dbt-artifacts-parser (>=0.8)
 Requires-Dist: h11 (>=0.16.0)
 Requires-Dist: jinja2 (>=3,<4)
 Requires-Dist: jinja2-simple-tags (<1)
-Requires-Dist: levenshtein (>=0.26.1,<1)
+Requires-Dist: levenshtein (>=0.26.1,<0.27.3)
 Requires-Dist: packaging (<25)
 Requires-Dist: poetry (>=2.0.1,<3.0.0)
 Requires-Dist: progress
 Requires-Dist: pydantic (>=2,<3)
 Requires-Dist: pyyaml (<7)
+Requires-Dist: rapidfuzz (<3.14.0)
 Requires-Dist: requests (>=2,<3)
 Requires-Dist: semver (<4)
 Requires-Dist: tabulate (<1)

{dbt_bouncer-1.25.0 → dbt_bouncer-1.27.0}/pyproject.toml

@@ -4,8 +4,6 @@ classifiers = [
   "Programming Language :: Python",
   "Programming Language :: Python :: 3",
   "Programming Language :: Python :: 3 :: Only",
-  "Programming Language :: Python :: 3.9",
-  "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
@@ -16,11 +14,12 @@ dependencies =[
   "h11 (>=0.16.0)", # To fix security warning
   "jinja2 (>=3,<4)",
   "jinja2-simple-tags (<1)",
-  "levenshtein (>=0.26.1,<1)",
+  "levenshtein (>=0.26.1,<0.27.3)",
   "packaging (<25)",
   "progress",
   "pydantic (>=2,<3)",
   "pyyaml (<7)",
+  "rapidfuzz (<3.14.0)",
   "requests (>=2,<3)",
   "tabulate (<1)",
   "toml (<1)",
@@ -39,8 +38,8 @@ maintainers = [{name="Padraic Slattery",email="pgoslatara@gmail.com"}]
 name = "dbt-bouncer"
 readme = "README.md"
 repository = "https://github.com/godatadriven/dbt-bouncer"
-requires-python = ">=3.9.2,<3.14"
-version = "1.25.0"
+requires-python = ">=3.11,<3.14"
+version = "1.27.0"
 
 [project.scripts]
 dbt-bouncer = "dbt_bouncer.main:cli"

{dbt_bouncer-1.25.0 → dbt_bouncer-1.27.0}/src/dbt_bouncer/checks/catalog/check_columns.py

@@ -3,6 +3,8 @@
 import re
 from typing import TYPE_CHECKING, List, Literal, Optional
 
+from pydantic import ConfigDict, Field
+
 if TYPE_CHECKING:
     import warnings
 
@@ -16,7 +18,7 @@ if TYPE_CHECKING:
         DbtBouncerTestBase,
     )
 
-from pydantic import Field, model_validator
+from pydantic import model_validator
 
 from dbt_bouncer.check_base import BaseCheck
 
@@ -130,7 +132,7 @@ class CheckColumnHasSpecifiedTest(BaseCheck):
 class CheckColumnNameCompliesToColumnType(BaseCheck):
     """Columns with the specified regexp naming pattern must have data types that comply to the specified regexp pattern or list of data types.
 
-    Note: Oe of `type_pattern` or `types` must be specified.
+    Note: One of `type_pattern` or `types` must be specified.
 
     Parameters:
         column_name_pattern (str): Regex pattern to match the model name.
@@ -228,6 +230,54 @@ class CheckColumnNameCompliesToColumnType(BaseCheck):
         return self
 
 
+class CheckColumnNames(BaseCheck):
+    """Columns must have a name that matches the supplied regex.
+
+    Parameters:
+        columns_name_pattern (str): Regexp the column name must match.
+
+    Receives:
+        catalog_node (CatalogNodes): The CatalogNodes object to check.
+        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.
+        materialization (Optional[Literal["ephemeral", "incremental", "table", "view"]]): Limit check to models with the specified materialization.
+        severity (Optional[Literal["error", "warn"]]): Severity level of the check. Default: `error`.
+
+    Example(s):
+        ```yaml
+        catalog_checks:
+            - name: check_column_names
+              column_name_pattern: [a-z_] # Lowercase only, underscores allowed
+        ```
+
+    """
+
+    model_config = ConfigDict(extra="forbid", protected_namespaces=())
+
+    catalog_node: "CatalogNodes" = Field(default=None)
+    column_name_pattern: str
+    models: List["DbtBouncerModelBase"] = Field(default=[])
+    name: Literal["check_column_names"]
+
+    def execute(self) -> None:
+        """Execute the check."""
+        if self.is_catalog_node_a_model(self.catalog_node, self.models):
+            non_complying_columns: List[str] = []
+            non_complying_columns.extend(
+                v.name
+                for _, v in self.catalog_node.columns.items()
+                if re.fullmatch(self.column_name_pattern.strip(), v.name) is None
+            )
+
+            assert not non_complying_columns, (
+                f"`{self.catalog_node.unique_id.split('.')[-1]}` has columns ({non_complying_columns}) that do not match the supplied regex: `{self.column_name_pattern.strip()}`."
+            )
+
+
 class CheckColumnsAreAllDocumented(BaseCheck):
     """All columns in a model should be included in the model's properties file, i.e. `.yml` file.
 

{dbt_bouncer-1.25.0 → dbt_bouncer-1.27.0}/src/dbt_bouncer/checks/manifest/check_exposures.py

@@ -14,6 +14,53 @@ if TYPE_CHECKING:
     )
 
 
+class CheckExposureOnModel(BaseCheck):
+    """Exposures should depend on a model.
+
+    Parameters:
+        max_number_of_models (Optional[int]): The maximum number of models an exposure can depend on, defaults to 100.
+        min_number_of_models (Optional[int]): 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`.
+
+    Example(s):
+        ```yaml
+        manifest_checks:
+            - name: check_exposure_based_on_model
+        ```
+        ```yaml
+        manifest_checks:
+            - name: check_exposure_based_on_model
+              maximum_number_of_models: 3
+              minimum_number_of_models: 1
+        ```
+
+    """
+
+    exposure: "DbtBouncerExposureBase" = 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)
+
+        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})."
+        )
+
+
 class CheckExposureOnNonPublicModels(BaseCheck):
     """Exposures should be based on public models only.
 

{dbt_bouncer-1.25.0 → dbt_bouncer-1.27.0}/src/dbt_bouncer/checks/manifest/check_models.py

@@ -14,6 +14,7 @@ if TYPE_CHECKING:
         UnitTests,
     )
     from dbt_bouncer.artifact_parsers.parsers_common import (
+        DbtBouncerExposureBase,
         DbtBouncerManifest,
         DbtBouncerModelBase,
         DbtBouncerTestBase,
@@ -521,6 +522,49 @@ class CheckModelHasContractsEnforced(BaseCheck):
         )
 
 
+class CheckModelHasExposure(BaseCheck):
+    """Models must have an exposure.
+
+    Receives:
+        exposures (List[DbtBouncerExposureBase]):  List of DbtBouncerExposureBase objects parsed from `manifest.json`.
+        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.
+        materialization (Optional[Literal["ephemeral", "incremental", "table", "view"]]): Limit check to models with the specified materialization.
+        severity (Optional[Literal["error", "warn"]]): Severity level of the check. Default: `error`.
+
+    Example(s):
+        ```yaml
+        manifest_checks:
+            - name: check_model_has_exposure
+              description: Ensure all marts are part of an exposure.
+              include: ^models/marts
+        ```
+
+    """
+
+    model_config = ConfigDict(extra="forbid", protected_namespaces=())
+
+    exposures: List["DbtBouncerExposureBase"] = Field(default=[])
+    model: "DbtBouncerModelBase" = Field(default=None)
+    name: Literal["check_model_has_exposure"]
+
+    def execute(self) -> None:
+        """Execute the check."""
+        has_exposure = False
+        for e in self.exposures:
+            for m in e.depends_on.nodes:
+                if m == self.model.unique_id:
+                    has_exposure = True
+
+        assert has_exposure, (
+            f"`{get_clean_model_name(self.model.unique_id)}` does not have an associated exposure."
+        )
+
+
 class CheckModelHasMetaKeys(BaseCheck):
     """The `meta` config for models must have the specified keys.
 

{dbt_bouncer-1.25.0 → dbt_bouncer-1.27.0}/src/dbt_bouncer/runner.py

@@ -14,6 +14,7 @@ from tabulate import tabulate
 from dbt_bouncer.utils import (
     create_github_comment_file,
     get_check_objects,
+    get_nested_value,
     resource_in_path,
 )
 
@@ -114,14 +115,36 @@ def runner(
             iterate_value = next(iter(iterate_over_value))
             for i in locals()[f"{iterate_value}s"]:
                 check_i = copy.deepcopy(check)
+                if iterate_value in ["model", "semantic_model", "snapshot", "source"]:
+                    try:
+                        d = getattr(i, iterate_value).config.meta
+                    except Exception:
+                        d = getattr(i, iterate_value).meta
+                elif iterate_value in ["catalog_node", "run_result"]:
+                    d = {}
+                elif iterate_value in ["macro"]:
+                    d = i.meta
+                else:
+                    try:
+                        d = i.config.meta
+                    except Exception:
+                        d = i.meta
+                meta_config = get_nested_value(
+                    d,
+                    ["dbt-bouncer", "skip_checks"],
+                    [],
+                )
                 if resource_in_path(check_i, i) and (
-                    iterate_over_value != {"model"}
-                    or (
-                        iterate_over_value == {"model"}
-                        and check_i.materialization == i.model.config.materialized
-                        if check_i.materialization is not None
-                        else True
+                    (
+                        iterate_over_value != {"model"}
+                        or (
+                            iterate_over_value == {"model"}
+                            and check_i.materialization == i.model.config.materialized
+                            if check_i.materialization is not None
+                            else True
+                        )
                     )
+                    and (check_i.name not in meta_config if meta_config != [] else True)
                 ):
                     check_run_id = (
                         f"{check_i.name}:{check_i.index}:{i.unique_id.split('.')[-1]}"

{dbt_bouncer-1.25.0 → dbt_bouncer-1.27.0}/src/dbt_bouncer/utils.py

@@ -9,7 +9,7 @@ import re
 import sys
 from functools import lru_cache
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, List, Mapping, Type
+from typing import TYPE_CHECKING, Any, Dict, List, Mapping, Optional, Type
 
 import click
 import yaml
@@ -58,6 +58,39 @@ def create_github_comment_file(
         f.write(md_formatted_comment)
 
 
+def get_nested_value(
+    d: Dict[str, Any], keys: List[str], default: Optional[Any] = None
+) -> Any:
+    """Retrieve a value from a nested dictionary using a list of keys.
+
+    This function safely traverses a dictionary structure, allowing access to
+    deeply nested values. If any key in the `keys` list does not exist at
+    its respective level, the function returns the specified default value.
+
+    Args:
+        d: The dictionary to traverse.
+        keys: A list of strings representing the sequence of keys to follow
+              to reach the desired nested value.
+        default: The value to return if any key in the `keys` list is not
+                 found at its corresponding level, or if an intermediate
+                 value is not a dictionary. Defaults to None.
+
+    Returns:
+        The value found at the specified nested path, or the `default` value
+        if any part of the path is invalid or not found.
+
+    """
+    current_level = d
+    for key in keys:
+        if isinstance(current_level, dict):
+            current_level = current_level.get(key, default)  # type: ignore[assignment]
+            if current_level is default and key != keys[-1]:
+                return default
+        else:
+            return default
+    return current_level
+
+
 def resource_in_path(check, resource) -> bool:
     """Validate that a check is applicable to a specific resource path.
 

{dbt_bouncer-1.25.0 → dbt_bouncer-1.27.0}/src/dbt_bouncer/version.py

@@ -5,4 +5,4 @@ def version() -> str:
         str: The version of `dbt-bouncer`.
 
     """
-    return "1.25.0"
+    return "1.27.0"