Skip to content

Manifest Checks: Exposures#

Note

The below checks require manifest.json to be present.

Classes:

Name Description
CheckExposureOnModel

Exposures should depend on a model.
CheckExposureOnNonPublicModels

Exposures should be based on public models only.
CheckExposureOnView

Exposures should not be based on views.

CheckExposureOnModel #

Exposures should depend on a model.

Parameters:

Name Type Description Default
max_number_of_models Optional[int]

The maximum number of models an exposure can depend on, defaults to 100.

 required
min_number_of_models Optional[int]

The minimum number of models an exposure can depend on, defaults to 1.

 required

Receives at execution time:

Name Type Description
exposure DbtBouncerExposureBase

The DbtBouncerExposureBase object to check.

Other Parameters (passed via config file):

Name Type Description
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): 

manifest_checks:
    - name: check_exposure_based_on_model

manifest_checks:
    - name: check_exposure_based_on_model
      maximum_number_of_models: 3
      minimum_number_of_models: 1

Source code in src/dbt_bouncer/checks/manifest/check_exposures.py 
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
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})."
        )

CheckExposureOnNonPublicModels #

Exposures should be based on public models only.

Receives at execution time:

Name Type Description
exposure DbtBouncerExposureBase

The DbtBouncerExposureBase object to check.
models List[DbtBouncerModelBase]

List of DbtBouncerModelBase objects parsed from manifest.json.

Other Parameters (passed via config file):

Name Type Description
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): 

manifest_checks:
    - name: check_exposure_based_on_non_public_models

Source code in src/dbt_bouncer/checks/manifest/check_exposures.py 
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
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`.

    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_non_public_models
        ```

    """

    exposure: "DbtBouncerExposureBase" = Field(default=None)
    models: List["DbtBouncerModelBase"] = Field(default=[])
    name: Literal["check_exposure_based_on_non_public_models"]

    def execute(self) -> None:
        """Execute the check."""
        non_public_upstream_dependencies = []
        for model in self.exposure.depends_on.nodes:
            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)

        assert not non_public_upstream_dependencies, (
            f"`{self.exposure.name}` is based on a model(s) that is not public: {non_public_upstream_dependencies}."
        )

CheckExposureOnView #

Exposures should not be based on views.

Parameters:

Name Type Description Default
materializations_to_include Optional[List[str]]

List of materializations to include in the check.

 required

Receives at execution time:

Name Type Description
exposure DbtBouncerExposureBase

The DbtBouncerExposureBase object to check.
models List[DbtBouncerModelBase]

List of DbtBouncerModelBase objects parsed from manifest.json.

Other Parameters (passed via config file):

Name Type Description
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): 

manifest_checks:
    - name: check_exposure_based_on_view

manifest_checks:
    - name: check_exposure_based_on_view
      materializations_to_include:
        - ephemeral
        - my_custom_materialization
        - view

Source code in src/dbt_bouncer/checks/manifest/check_exposures.py 
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
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.

    Receives:
        exposure (DbtBouncerExposureBase): The DbtBouncerExposureBase 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 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_view
        ```
        ```yaml
        manifest_checks:
            - name: check_exposure_based_on_view
              materializations_to_include:
                - ephemeral
                - my_custom_materialization
                - view
        ```

    """

    exposure: "DbtBouncerExposureBase" = Field(default=None)
    materializations_to_include: List[str] = Field(
        default=["ephemeral", "view"],
    )
    models: List["DbtBouncerModelBase"] = Field(default=[])
    name: Literal["check_exposure_based_on_view"]

    def execute(self) -> None:
        """Execute the check."""
        non_table_upstream_dependencies = []
        for model in self.exposure.depends_on.nodes:
            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}."
        )