Manifest Checks: Models#

Note

The below checks require manifest.json to be present.

Classes:

Name	Description
`CheckModelAccess`	Models must have the specified access attribute. Requires dbt 1.7+.
`CheckModelCodeDoesNotContainRegexpPattern`	The raw code for a model must not match the specified regexp pattern.
`CheckModelContractsEnforcedForPublicModel`	Public models must have contracts enforced.
`CheckModelDependsOnMacros`	Models must depend on the specified macros.
`CheckModelDependsOnMultipleSources`	Models cannot reference more than one source.
`CheckModelDescriptionContainsRegexPattern`	Models must have a description that matches the provided pattern.
`CheckModelDescriptionPopulated`	Models must have a populated description.
`CheckModelDirectories`	Only specified sub-directories are permitted.
`CheckModelDocumentedInSameDirectory`	Models must be documented in the same directory where they are defined (i.e. `.yml` and `.sql` files are in the same directory).
`CheckModelGrantPrivilege`	Model can have grant privileges that match the specified pattern.
`CheckModelGrantPrivilegeRequired`	Model must have the specified grant privilege.
`CheckModelHasContractsEnforced`	Model must have contracts enforced.
`CheckModelHasMetaKeys`	The `meta` config for models must have the specified keys.
`CheckModelHasNoUpstreamDependencies`	Identify if models have no upstream dependencies as this likely indicates hard-coded tables references.
`CheckModelHasSemiColon`	Model may not end with a semi-colon (`;`).
`CheckModelHasTags`	Models must have the specified tags.
`CheckModelHasUniqueTest`	Models must have a test for uniqueness of a column.
`CheckModelHasUnitTests`	Models must have more than the specified number of unit tests.
`CheckModelLatestVersionSpecified`	Check that the `latest_version` attribute of the model is set.
`CheckModelMaxChainedViews`	Models cannot have more than the specified number of upstream dependents that are not tables.
`CheckModelMaxFanout`	Models cannot have more than the specified number of downstream models.
`CheckModelMaxNumberOfLines`	Models may not have more than the specified number of lines.
`CheckModelMaxUpstreamDependencies`	Limit the number of upstream dependencies a model has.
`CheckModelNames`	Models must have a name that matches the supplied regex.
`CheckModelNumberOfGrants`	Model can have the specified number of privileges.
`CheckModelPropertyFileLocation`	Model properties files must follow the guidance provided by dbt here.
`CheckModelSchemaName`	Models must have a schema name that matches the supplied regex.
`CheckModelVersionAllowed`	Check that the version of the model matches the supplied regex pattern.
`CheckModelVersionPinnedInRef`	Check that the version of the model is always specified in downstream nodes.
`CheckModelsDocumentationCoverage`	Set the minimum percentage of models that have a populated description.
`CheckModelsTestCoverage`	Set the minimum percentage of models that have at least one test.

`CheckModelAccess` #

Models must have the specified access attribute. Requires dbt 1.7+.

Parameters:

Name	Type	Description	Default
`access`	`Literal['private', 'protected', 'public']`	The access level to check for.	required

Receives at execution time:

Name	Type	Description
`model`	`DbtBouncerModelBase`	The DbtBouncerModelBase 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 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):

manifest_checks:
    # Align with dbt best practices that marts should be `public`, everything else should be `protected`
    - name: check_model_access
      access: protected
      include: ^models/intermediate
    - name: check_model_access
      access: public
      include: ^models/marts
    - name: check_model_access
      access: protected
      include: ^models/staging

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelAccess(BaseCheck):
    """Models must have the specified access attribute. Requires dbt 1.7+.

    Parameters:
        access (Literal["private", "protected", "public"]): The access level to check for.

    Receives:
        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:
            # Align with dbt best practices that marts should be `public`, everything else should be `protected`
            - name: check_model_access
              access: protected
              include: ^models/intermediate
            - name: check_model_access
              access: public
              include: ^models/marts
            - name: check_model_access
              access: protected
              include: ^models/staging
        ```

    """

    access: Literal["private", "protected", "public"]
    model: "DbtBouncerModelBase" = Field(default=None)
    name: Literal["check_model_access"]

    def execute(self) -> None:
        """Execute the check."""
        assert self.model.access.value == self.access, (
            f"`{get_clean_model_name(self.model.unique_id)}` has `{self.model.access.value}` access, it should have access `{self.access}`."
        )

`CheckModelCodeDoesNotContainRegexpPattern` #

The raw code for a model must not match the specified regexp pattern.

Parameters:

Name	Type	Description	Default
`regexp_pattern`	`str`	The regexp pattern that should not be matched by the model code.	required

Receives at execution time:

Name	Type	Description
`model`	`DbtBouncerModelBase`	The DbtBouncerModelBase 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 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):

manifest_checks:
    # Prefer `coalesce` over `ifnull`: https://docs.sqlfluff.com/en/stable/rules.html#sqlfluff.rules.sphinx.Rule_CV02
    - name: check_model_code_does_not_contain_regexp_pattern
      regexp_pattern: .*[i][f][n][u][l][l].*

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelCodeDoesNotContainRegexpPattern(BaseCheck):
    """The raw code for a model must not match the specified regexp pattern.

    Parameters:
        regexp_pattern (str): The regexp pattern that should not be matched by the model code.

    Receives:
        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:
            # Prefer `coalesce` over `ifnull`: https://docs.sqlfluff.com/en/stable/rules.html#sqlfluff.rules.sphinx.Rule_CV02
            - name: check_model_code_does_not_contain_regexp_pattern
              regexp_pattern: .*[i][f][n][u][l][l].*
        ```

    """

    model: "DbtBouncerModelBase" = Field(default=None)
    name: Literal["check_model_code_does_not_contain_regexp_pattern"]
    regexp_pattern: str

    def execute(self) -> None:
        """Execute the check."""
        assert (
            re.compile(self.regexp_pattern.strip(), flags=re.DOTALL).match(
                self.model.raw_code
            )
            is None
        ), (
            f"`{get_clean_model_name(self.model.unique_id)}` contains a banned string: `{self.regexp_pattern.strip()}`."
        )

`CheckModelContractsEnforcedForPublicModel` #

Public models must have contracts enforced.

Receives at execution time:

Name	Type	Description
`model`	`DbtBouncerModelBase`	The DbtBouncerModelBase 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 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):

manifest_checks:
    - name: check_model_contract_enforced_for_public_model

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelContractsEnforcedForPublicModel(BaseCheck):
    """Public models must have contracts enforced.

    Receives:
        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_contract_enforced_for_public_model
        ```

    """

    model: "DbtBouncerModelBase" = Field(default=None)
    name: Literal["check_model_contract_enforced_for_public_model"]

    def execute(self) -> None:
        """Execute the check."""
        if self.model.access.value == "public":
            assert self.model.contract.enforced is True, (
                f"`{get_clean_model_name(self.model.unique_id)}` is a public model but does not have contracts enforced."
            )

`CheckModelDependsOnMacros` #

Models must depend on the specified macros.

Parameters:

Name	Type	Description	Default
`criteria`		(Optional[Literal["any", "all", "one"]]): Whether the model must depend on any, all, or exactly one of the specified macros. Default: `any`.	required
`required_macros`		(List[str]): List of macros the model must depend on. All macros must specify a namespace, e.g. `dbt.is_incremental`.	required

Receives at execution time:

Name	Type	Description
`model`	`DbtBouncerModelBase`	The DbtBouncerModelBase 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 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):

manifest_checks:
    - name: check_model_depends_on_macros
      required_macros:
        - dbt.is_incremental
    - name: check_model_depends_on_macros
      criteria: one
      required_macros:
        - my_package.sampler
        - my_package.sampling

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelDependsOnMacros(BaseCheck):
    """Models must depend on the specified macros.

    Parameters:
        criteria: (Optional[Literal["any", "all", "one"]]): Whether the model must depend on any, all, or exactly one of the specified macros. Default: `any`.
        required_macros: (List[str]): List of macros the model must depend on. All macros must specify a namespace, e.g. `dbt.is_incremental`.

    Receives:
        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_depends_on_macros
              required_macros:
                - dbt.is_incremental
            - name: check_model_depends_on_macros
              criteria: one
              required_macros:
                - my_package.sampler
                - my_package.sampling
        ```

    """

    criteria: Literal["any", "all", "one"] = Field(default="all")
    model: "DbtBouncerModelBase" = Field(default=None)
    name: Literal["check_model_depends_on_macros"]
    required_macros: List[str]

    def execute(self) -> None:
        """Execute the check."""
        upstream_macros = [
            (".").join(m.split(".")[1:]) for m in self.model.depends_on.macros
        ]
        if self.criteria == "any":
            assert any(macro in upstream_macros for macro in self.required_macros), (
                f"`{get_clean_model_name(self.model.unique_id)}` does not depend on any of the required macros: {self.required_macros}."
            )
        elif self.criteria == "all":
            missing_macros = [
                macro for macro in self.required_macros if macro not in upstream_macros
            ]
            assert not missing_macros, (
                f"`{get_clean_model_name(self.model.unique_id)}` is missing required macros: {missing_macros}."
            )
        elif self.criteria == "one":
            assert (
                sum(macro in upstream_macros for macro in self.required_macros) == 1
            ), (
                f"`{get_clean_model_name(self.model.unique_id)}` must depend on exactly one of the required macros: {self.required_macros}."
            )

`CheckModelDependsOnMultipleSources` #

Models cannot reference more than one source.

Parameters:

Name	Type	Description	Default
`model`	`DbtBouncerModelBase`	The DbtBouncerModelBase object to check.	required

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 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):

manifest_checks:
    - name: check_model_depends_on_multiple_sources

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelDependsOnMultipleSources(BaseCheck):
    """Models cannot reference more than one source.

    Parameters:
        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_depends_on_multiple_sources
        ```

    """

    model: "DbtBouncerModelBase" = Field(default=None)
    name: Literal["check_model_depends_on_multiple_sources"]

    def execute(self) -> None:
        """Execute the check."""
        num_reffed_sources = sum(
            x.split(".")[0] == "source" for x in self.model.depends_on.nodes
        )
        assert num_reffed_sources <= 1, (
            f"`{get_clean_model_name(self.model.unique_id)}` references more than one source."
        )

`CheckModelDescriptionContainsRegexPattern` #

Models must have a description that matches the provided pattern.

Receives at execution time:

Name	Type	Description
`model`	`DbtBouncerModelBase`	The DbtBouncerModelBase object to check.
`regexp_pattern`	`str`	The regexp pattern that should match the model description.

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 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):

manifest_checks:
    - name: check_model_description_contains_regex_pattern
    - regex_pattern: .*pattern_to_match.*

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelDescriptionContainsRegexPattern(BaseCheck):
    """Models must have a description that matches the provided pattern.

    Receives:
        model (DbtBouncerModelBase): The DbtBouncerModelBase object to check.
        regexp_pattern (str): The regexp pattern that should match the model description.

    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_description_contains_regex_pattern
            - regex_pattern: .*pattern_to_match.*
        ```

    """

    model: "DbtBouncerModelBase" = Field(default=None)
    name: Literal["check_model_description_contains_regex_pattern"]
    regexp_pattern: str

    def execute(self) -> None:
        """Execute the check."""
        assert re.compile(self.regexp_pattern.strip(), flags=re.DOTALL).match(
            self.model.description
        ), (
            f"""`{get_clean_model_name(self.model.unique_id)}`'s description "{self.model.description}" doesn't match the supplied regex: {self.regexp_pattern}."""
        )

`CheckModelDescriptionPopulated` #

Models must have a populated description.

Receives at execution time:

Name	Type	Description
`model`	`DbtBouncerModelBase`	The DbtBouncerModelBase 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 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):

manifest_checks:
    - name: check_model_description_populated

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelDescriptionPopulated(BaseCheck):
    """Models must have a populated description.

    Receives:
        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_description_populated
        ```

    """

    model: "DbtBouncerModelBase" = Field(default=None)
    name: Literal["check_model_description_populated"]

    def execute(self) -> None:
        """Execute the check."""
        assert self.is_description_populated(self.model.description), (
            f"`{get_clean_model_name(self.model.unique_id)}` does not have a populated description."
        )

`CheckModelDirectories` #

Only specified sub-directories are permitted.

Parameters:

Name	Type	Description	Default
`include`	`str`	Regex pattern to the directory to check.	required
`permitted_sub_directories`	`List[str]`	List of permitted sub-directories.	required

Receives at execution time:

Name	Type	Description
`model`	`DbtBouncerModelBase`	The DbtBouncerModelBase 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 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):

manifest_checks:
- name: check_model_directories
  include: models
  permitted_sub_directories:
    - intermediate
    - marts
    - staging

# Restrict sub-directories within `./models/staging`
- name: check_model_directories
  include: ^models/staging
  permitted_sub_directories:
    - crm
    - payments

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelDirectories(BaseCheck):
    """Only specified sub-directories are permitted.

    Parameters:
        include (str): Regex pattern to the directory to check.
        permitted_sub_directories (List[str]): List of permitted sub-directories.

    Receives:
        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_directories
          include: models
          permitted_sub_directories:
            - intermediate
            - marts
            - staging
        ```
        ```yaml
        # Restrict sub-directories within `./models/staging`
        - name: check_model_directories
          include: ^models/staging
          permitted_sub_directories:
            - crm
            - payments
        ```

    """

    include: str
    model: "DbtBouncerModelBase" = Field(default=None)
    name: Literal["check_model_directories"]
    permitted_sub_directories: List[str]

    def execute(self) -> None:
        """Execute the check.

        Raises:
            AssertionError: If model located in `./models`.

        """
        matched_path = re.compile(self.include.strip().rstrip("/")).match(
            clean_path_str(self.model.original_file_path)
        )
        path_after_match = clean_path_str(self.model.original_file_path)[
            matched_path.end() + 1 :
        ]
        directory_to_check = path_after_match.split("/")[0]

        if directory_to_check.replace(".sql", "") == self.model.name:
            raise AssertionError(
                f"`{get_clean_model_name(self.model.unique_id)}` is not located in a valid sub-directory ({self.permitted_sub_directories})."
            )
        else:
            assert directory_to_check in self.permitted_sub_directories, (
                f"`{get_clean_model_name(self.model.unique_id)}` is located in the `{directory_to_check}` sub-directory, this is not a valid sub-directory ({self.permitted_sub_directories})."
            )

`CheckModelDocumentedInSameDirectory` #

Models must be documented in the same directory where they are defined (i.e. .yml and .sql files are in the same directory).

Receives at execution time:

Name	Type	Description
`model`	`DbtBouncerModelBase`	The DbtBouncerModelBase 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 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):

manifest_checks:
    - name: check_model_documented_in_same_directory

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelDocumentedInSameDirectory(BaseCheck):
    """Models must be documented in the same directory where they are defined (i.e. `.yml` and `.sql` files are in the same directory).

    Receives:
        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_documented_in_same_directory
        ```

    """

    model: "DbtBouncerModelBase" = Field(default=None)
    name: Literal["check_model_documented_in_same_directory"]

    def execute(self) -> None:
        """Execute the check."""
        model_sql_dir = clean_path_str(self.model.original_file_path).split("/")[:-1]
        assert (  # noqa: PT018
            hasattr(self.model, "patch_path")
            and clean_path_str(self.model.patch_path) is not None
        ), f"`{get_clean_model_name(self.model.unique_id)}` is not documented."

        model_doc_dir = clean_path_str(
            self.model.patch_path[
                clean_path_str(self.model.patch_path).find("models") :
            ]
        ).split("/")[:-1]

        assert model_doc_dir == model_sql_dir, (
            f"`{get_clean_model_name(self.model.unique_id)}` is documented in a different directory to the `.sql` file: `{'/'.join(model_doc_dir)}` vs `{'/'.join(model_sql_dir)}`."
        )

`CheckModelGrantPrivilege` #

Model can have grant privileges that match the specified pattern.

Receives at execution time:

Name	Type	Description
`model`	`DbtBouncerModelBase`	The DbtBouncerModelBase object to check.
`privilege_pattern`	`str`	Regex pattern to match the privilege.

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 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):

manifest_checks:
    - name: check_model_grant_privilege
      include: ^models/marts
      privilege_pattern: ^select

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelGrantPrivilege(BaseCheck):
    """Model can have grant privileges that match the specified pattern.

    Receives:
        model (DbtBouncerModelBase): The DbtBouncerModelBase object to check.
        privilege_pattern (str): Regex pattern to match the privilege.

    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_grant_privilege
              include: ^models/marts
              privilege_pattern: ^select
        ```

    """

    model: "DbtBouncerModelBase" = Field(default=None)
    name: Literal["check_model_grant_privilege"]
    privilege_pattern: str

    def execute(self) -> None:
        """Execute the check."""
        non_complying_grants = [
            i
            for i in self.model.config.grants
            if re.compile(self.privilege_pattern.strip()).match(i) is None
        ]

        assert not non_complying_grants, (
            f"`{get_clean_model_name(self.model.unique_id)}` has grants (`{self.privilege_pattern}`) that don't comply with the specified regexp pattern ({non_complying_grants})."
        )

`CheckModelGrantPrivilegeRequired` #

Model must have the specified grant privilege.

Receives at execution time:

Name	Type	Description
`model`	`DbtBouncerModelBase`	The DbtBouncerModelBase object to check.
`privilege`	`str`	The privilege that is required.

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 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):

manifest_checks:
    - name: check_model_grant_privilege_required
      include: ^models/marts
      privilege: select

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelGrantPrivilegeRequired(BaseCheck):
    """Model must have the specified grant privilege.

    Receives:
        model (DbtBouncerModelBase): The DbtBouncerModelBase object to check.
        privilege (str): The privilege that is required.

    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_grant_privilege_required
              include: ^models/marts
              privilege: select
        ```

    """

    model: "DbtBouncerModelBase" = Field(default=None)
    name: Literal["check_model_grant_privilege_required"]
    privilege: str

    def execute(self) -> None:
        """Execute the check."""
        assert self.privilege in self.model.config.grants, (
            f"`{get_clean_model_name(self.model.unique_id)}` does not have the required grant privilege (`{self.privilege}`)."
        )

`CheckModelHasContractsEnforced` #

Model must have contracts enforced.

Receives at execution time:

Name	Type	Description
`model`	`DbtBouncerModelBase`	The DbtBouncerModelBase 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 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):

manifest_checks:
    - name: check_model_has_contracts_enforced
      include: ^models/marts

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelHasContractsEnforced(BaseCheck):
    """Model must have contracts enforced.

    Receives:
        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_contracts_enforced
              include: ^models/marts
        ```

    """

    model: "DbtBouncerModelBase" = Field(default=None)
    name: Literal["check_model_has_contracts_enforced"]

    def execute(self) -> None:
        """Execute the check."""
        assert self.model.contract.enforced is True, (
            f"`{get_clean_model_name(self.model.unique_id)}` does not have contracts enforced."
        )

`CheckModelHasMetaKeys` #

The meta config for models must have the specified keys.

Parameters:

Name	Type	Description	Default
`keys`	`NestedDict`	A list (that may contain sub-lists) of required keys.	required
`model`	`DbtBouncerModelBase`	The DbtBouncerModelBase object to check.	required

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 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):

manifest_checks:
    - name: check_model_has_meta_keys
      keys:
        - maturity
        - owner

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelHasMetaKeys(BaseCheck):
    """The `meta` config for models must have the specified keys.

    Parameters:
        keys (NestedDict): A list (that may contain sub-lists) of required keys.
        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_meta_keys
              keys:
                - maturity
                - owner
        ```

    """

    keys: NestedDict
    model: "DbtBouncerModelBase" = Field(default=None)
    name: Literal["check_model_has_meta_keys"]

    def execute(self) -> None:
        """Execute the check."""
        missing_keys = find_missing_meta_keys(
            meta_config=self.model.meta,
            required_keys=self.keys.model_dump(),
        )
        assert missing_keys == [], (
            f"`{get_clean_model_name(self.model.unique_id)}` is missing the following keys from the `meta` config: {[x.replace('>>', '') for x in missing_keys]}"
        )

`CheckModelHasNoUpstreamDependencies` #

Identify if models have no upstream dependencies as this likely indicates hard-coded tables references.

Receives at execution time:

Name	Type	Description
`model`	`DbtBouncerModelBase`	The DbtBouncerModelBase 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 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):

manifest_checks:
    - name: check_model_has_no_upstream_dependencies

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelHasNoUpstreamDependencies(BaseCheck):
    """Identify if models have no upstream dependencies as this likely indicates hard-coded tables references.

    Receives:
        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_no_upstream_dependencies
        ```

    """

    model: "DbtBouncerModelBase" = Field(default=None)
    name: Literal["check_model_has_no_upstream_dependencies"]

    def execute(self) -> None:
        """Execute the check."""
        assert len(self.model.depends_on.nodes) > 0, (
            f"`{get_clean_model_name(self.model.unique_id)}` has no upstream dependencies, this likely indicates hard-coded tables references."
        )

`CheckModelHasSemiColon` #

Model may not end with a semi-colon (;).

Receives at execution time:

Name	Type	Description
`model`	`DbtBouncerModelBase`	The DbtBouncerModelBase 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 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):

manifest_checks:
    - name: check_model_has_semi_colon
      include: ^models/marts

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelHasSemiColon(BaseCheck):
    """Model may not end with a semi-colon (`;`).

    Receives:
        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_semi_colon
              include: ^models/marts
        ```

    """

    model: "DbtBouncerModelBase" = Field(default=None)
    name: Literal["check_model_has_semi_colon"]

    def execute(self) -> None:
        """Execute the check."""
        assert self.model.raw_code.strip()[-1] != ";", (
            f"`{get_clean_model_name(self.model.unique_id)}` ends with a semi-colon, this is not permitted."
        )

`CheckModelHasTags` #

Models must have the specified tags.

Parameters:

Name	Type	Description	Default
`criteria`		(Optional[Literal["any", "all", "one"]]): Whether the model must have any, all, or exactly one of the specified tags. Default: `any`.	required
`model`	`DbtBouncerModelBase`	The DbtBouncerModelBase object to check.	required
`tags`	`List[str]`	List of tags to check for.	required

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 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):

manifest_checks:
    - name: check_model_has_tags
      tags:
        - tag_1
        - tag_2

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelHasTags(BaseCheck):
    """Models must have the specified tags.

    Parameters:
        criteria: (Optional[Literal["any", "all", "one"]]): Whether the model must have any, all, or exactly one of the specified tags. Default: `any`.
        model (DbtBouncerModelBase): The DbtBouncerModelBase object to check.
        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 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_tags
              tags:
                - tag_1
                - tag_2
        ```

    """

    criteria: Literal["any", "all", "one"] = Field(default="all")
    model: "DbtBouncerModelBase" = Field(default=None)
    name: Literal["check_model_has_tags"]
    tags: List[str]

    def execute(self) -> None:
        """Execute the check."""
        if self.criteria == "any":
            assert any(tag in self.model.tags for tag in self.tags), (
                f"`{get_clean_model_name(self.model.unique_id)}` 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.model.tags]
            assert not missing_tags, (
                f"`{get_clean_model_name(self.model.unique_id)}` is missing required tags: {missing_tags}."
            )
        elif self.criteria == "one":
            assert sum(tag in self.model.tags for tag in self.tags) == 1, (
                f"`{get_clean_model_name(self.model.unique_id)}` must have exactly one of the required tags: {self.tags}."
            )

`CheckModelHasUniqueTest` #

Models must have a test for uniqueness of a column.

Parameters:

Name	Type	Description	Default
`accepted_uniqueness_tests`	`Optional[List[str]]`	List of tests that are accepted as uniqueness tests.	required
`model`	`DbtBouncerModelBase`	The DbtBouncerModelBase object to check.	required
`tests`	`List[DbtBouncerTestBase]`	List of DbtBouncerTestBase objects parsed from `manifest.json`.	required

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 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):

manifest_checks:
    - name: check_model_has_unique_test
      include: ^models/marts

manifest_checks:
# Example of allowing a custom uniqueness test
    - name: check_model_has_unique_test
      accepted_uniqueness_tests:
        - dbt_expectations.expect_compound_columns_to_be_unique # i.e. tests from packages must include package name
        - my_custom_uniqueness_test
        - unique

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelHasUniqueTest(BaseCheck):
    """Models must have a test for uniqueness of a column.

    Parameters:
        accepted_uniqueness_tests (Optional[List[str]]): List of tests that are accepted as uniqueness tests.
        model (DbtBouncerModelBase): The DbtBouncerModelBase object to check.
        tests (List[DbtBouncerTestBase]): List of DbtBouncerTestBase 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
        manifest_checks:
            - name: check_model_has_unique_test
              include: ^models/marts
        ```
        ```yaml
        manifest_checks:
        # Example of allowing a custom uniqueness test
            - name: check_model_has_unique_test
              accepted_uniqueness_tests:
                - dbt_expectations.expect_compound_columns_to_be_unique # i.e. tests from packages must include package name
                - my_custom_uniqueness_test
                - unique
        ```

    """

    accepted_uniqueness_tests: Optional[List[str]] = Field(
        default=[
            "dbt_expectations.expect_compound_columns_to_be_unique",
            "dbt_utils.unique_combination_of_columns",
            "unique",
        ],
    )
    model: "DbtBouncerModelBase" = Field(default=None)
    name: Literal["check_model_has_unique_test"]
    tests: List["DbtBouncerTestBase"] = Field(default=[])

    def execute(self) -> None:
        """Execute the check."""
        num_unique_tests = sum(
            test.attached_node == self.model.unique_id
            and (
                (
                    f"{test.test_metadata.namespace}.{test.test_metadata.name}"  # type: ignore[operator]
                    in self.accepted_uniqueness_tests
                )  # tests from packages
                or (
                    test.test_metadata.namespace is None
                    and test.test_metadata.name in self.accepted_uniqueness_tests  # type: ignore[operator]
                )  # tests from within package
            )
            for test in self.tests
            if hasattr(test, "test_metadata")
        )
        assert num_unique_tests >= 1, (
            f"`{get_clean_model_name(self.model.unique_id)}` does not have a test for uniqueness of a column."
        )

`CheckModelHasUnitTests` #

Models must have more than the specified number of unit tests.

Parameters:

Name	Type	Description	Default
`min_number_of_unit_tests`	`Optional[int]`	The minimum number of unit tests that a model must have.	required

Receives at execution time:

Name	Type	Description
`manifest_obj`	`DbtBouncerManifest`	The DbtBouncerManifest object parsed from `manifest.json`.
`model`	`DbtBouncerModelBase`	The DbtBouncerModelBase object to check.
`unit_tests`	`List[UnitTests]`	List of UnitTests 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 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`.

Warning

This check is only supported for dbt 1.8.0 and above.

Example(s):

manifest_checks:
    - name: check_model_has_unit_tests
      include: ^models/marts

manifest_checks:
    - name: check_model_has_unit_tests
      min_number_of_unit_tests: 2

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelHasUnitTests(BaseCheck):
    """Models must have more than the specified number of unit tests.

    Parameters:
        min_number_of_unit_tests (Optional[int]): The minimum number of unit tests that a model must have.

    Receives:
        manifest_obj (DbtBouncerManifest): The DbtBouncerManifest object parsed from `manifest.json`.
        model (DbtBouncerModelBase): The DbtBouncerModelBase object to check.
        unit_tests (List[UnitTests]): List of UnitTests 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`.

    !!! warning

        This check is only supported for dbt 1.8.0 and above.

    Example(s):
        ```yaml
        manifest_checks:
            - name: check_model_has_unit_tests
              include: ^models/marts
        ```
        ```yaml
        manifest_checks:
            - name: check_model_has_unit_tests
              min_number_of_unit_tests: 2
        ```

    """

    manifest_obj: "DbtBouncerManifest" = Field(default=None)
    min_number_of_unit_tests: int = Field(default=1)
    model: "DbtBouncerModelBase" = Field(default=None)
    name: Literal["check_model_has_unit_tests"]
    unit_tests: List["UnitTests"] = Field(default=[])

    def execute(self) -> None:
        """Execute the check."""
        if get_package_version_number(
            self.manifest_obj.manifest.metadata.dbt_version
        ) >= get_package_version_number("1.8.0"):
            num_unit_tests = len(
                [
                    t.unique_id
                    for t in self.unit_tests
                    if t.depends_on.nodes[0] == self.model.unique_id
                ],
            )
            assert num_unit_tests >= self.min_number_of_unit_tests, (
                f"`{get_clean_model_name(self.model.unique_id)}` has {num_unit_tests} unit tests, this is less than the minimum of {self.min_number_of_unit_tests}."
            )
        else:
            logging.warning(
                "The `check_model_has_unit_tests` check is only supported for dbt 1.8.0 and above.",
            )

`CheckModelLatestVersionSpecified` #

Check that the latest_version attribute of the model is set.

Receives at execution time:

Name	Type	Description
`model`	`DbtBouncerModelBase`	The DbtBouncerModelBase 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 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):

manifest_checks:
    - name: check_model_latest_version_specified
      include: ^models/marts

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelLatestVersionSpecified(BaseCheck):
    r"""Check that the `latest_version` attribute of the model is set.

    Receives:
        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_latest_version_specified
              include: ^models/marts
        ```

    """

    model_config = ConfigDict(extra="forbid", protected_namespaces=())

    model: "DbtBouncerModelBase" = Field(default=None)
    name: Literal["check_model_latest_version_specified"]

    def execute(self) -> None:
        """Execute the check."""
        assert self.model.latest_version is not None, (
            f"`{self.model.name}` does not have a specified `latest_version`."
        )

`CheckModelMaxChainedViews` #

Models cannot have more than the specified number of upstream dependents that are not tables.

Parameters:

Name	Type	Description	Default
`materializations_to_include`	`Optional[List[str]]`	List of materializations to include in the check.	required
`max_chained_views`	`Optional[int]`	The maximum number of upstream dependents that are not tables.	required

Receives at execution time:

Name	Type	Description
`model`	`DbtBouncerModelBase`	The DbtBouncerModelBase 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 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):

manifest_checks:
    - name: check_model_max_chained_views

manifest_checks:
    - name: check_model_max_chained_views
      materializations_to_include:
        - ephemeral
        - my_custom_materialization
        - view
      max_chained_views: 5

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelMaxChainedViews(BaseCheck):
    """Models cannot have more than the specified number of upstream dependents that are not tables.

    Parameters:
        materializations_to_include (Optional[List[str]]): List of materializations to include in the check.
        max_chained_views (Optional[int]): The maximum number of upstream dependents that are not tables.

    Receives:
        model (DbtBouncerModelBase): The DbtBouncerModelBase 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
        manifest_checks:
            - name: check_model_max_chained_views
        ```
        ```yaml
        manifest_checks:
            - name: check_model_max_chained_views
              materializations_to_include:
                - ephemeral
                - my_custom_materialization
                - view
              max_chained_views: 5
        ```

    """

    manifest_obj: "DbtBouncerManifest" = Field(default=None)
    materializations_to_include: List[str] = Field(
        default=["ephemeral", "view"],
    )
    max_chained_views: int = Field(
        default=3,
    )
    model: "DbtBouncerModelBase" = Field(default=None)
    models: List["DbtBouncerModelBase"] = Field(default=[])
    name: Literal["check_model_max_chained_views"]

    def execute(self) -> None:
        """Execute the check."""

        def return_upstream_view_models(
            materializations,
            max_chained_views,
            models,
            model_unique_ids_to_check,
            package_name,
            depth=0,
        ):
            """Recursive function to return model unique_id's of upstream models that are views. Depth of recursion can be specified. If no models meet the criteria then an empty list is returned.

            Returns
            -
                List[str]: List of model unique_id's of upstream models that are views.

            """
            if depth == max_chained_views or model_unique_ids_to_check == []:
                return model_unique_ids_to_check

            relevant_upstream_models = []
            for model in model_unique_ids_to_check:
                upstream_nodes = list(
                    next(m2 for m2 in models if m2.unique_id == model).depends_on.nodes,
                )
                if upstream_nodes != []:
                    upstream_models = [
                        m
                        for m in upstream_nodes
                        if m.split(".")[0] == "model"
                        and m.split(".")[1] == package_name
                    ]
                    for i in upstream_models:
                        if (
                            next(
                                m for m in models if m.unique_id == i
                            ).config.materialized
                            in materializations
                        ):
                            relevant_upstream_models.append(i)

            depth += 1
            return return_upstream_view_models(
                materializations=materializations,
                max_chained_views=max_chained_views,
                models=models,
                model_unique_ids_to_check=relevant_upstream_models,
                package_name=package_name,
                depth=depth,
            )

        assert (
            len(
                return_upstream_view_models(
                    materializations=self.materializations_to_include,
                    max_chained_views=self.max_chained_views,
                    models=self.models,
                    model_unique_ids_to_check=[self.model.unique_id],
                    package_name=self.manifest_obj.manifest.metadata.project_name,
                ),
            )
            == 0
        ), (
            f"`{get_clean_model_name(self.model.unique_id)}` has more than {self.max_chained_views} upstream dependents that are not tables."
        )

`CheckModelMaxFanout` #

Models cannot have more than the specified number of downstream models.

Parameters:

Name	Type	Description	Default
`max_downstream_models`	`Optional[int]`	The maximum number of permitted downstream models.	required

Receives at execution time:

Name	Type	Description
`model`	`DbtBouncerModelBase`	The DbtBouncerModelBase 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 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):

manifest_checks:
    - name: check_model_max_fanout
      max_downstream_models: 2

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelMaxFanout(BaseCheck):
    """Models cannot have more than the specified number of downstream models.

    Parameters:
        max_downstream_models (Optional[int]): The maximum number of permitted downstream models.

    Receives:
        model (DbtBouncerModelBase): The DbtBouncerModelBase 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
        manifest_checks:
            - name: check_model_max_fanout
              max_downstream_models: 2
        ```

    """

    max_downstream_models: int = Field(default=3)
    model: "DbtBouncerModelBase" = Field(default=None)
    models: List["DbtBouncerModelBase"] = Field(default=[])
    name: Literal["check_model_max_fanout"]

    def execute(self) -> None:
        """Execute the check."""
        num_downstream_models = sum(
            self.model.unique_id in m.depends_on.nodes for m in self.models
        )

        assert num_downstream_models <= self.max_downstream_models, (
            f"`{get_clean_model_name(self.model.unique_id)}` has {num_downstream_models} downstream models, which is more than the permitted maximum of {self.max_downstream_models}."
        )

`CheckModelMaxNumberOfLines` #

Models may not have more than the specified number of lines.

Parameters:

Name	Type	Description	Default
`max_number_of_lines`	`int`	The maximum number of permitted lines.	required
`model`	`DbtBouncerModelBase`	The DbtBouncerModelBase object to check.	required

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 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):

manifest_checks:
    - name: check_model_max_number_of_lines

manifest_checks:
    - name: check_model_max_number_of_lines
      max_number_of_lines: 150

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelMaxNumberOfLines(BaseCheck):
    """Models may not have more than the specified number of lines.

    Parameters:
        max_number_of_lines (int): The maximum number of permitted lines.

        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_max_number_of_lines
        ```
        ```yaml
        manifest_checks:
            - name: check_model_max_number_of_lines
              max_number_of_lines: 150
        ```

    """

    model: "DbtBouncerModelBase" = Field(default=None)
    name: Literal["check_model_max_number_of_lines"]
    max_number_of_lines: int = Field(default=100)

    def execute(self) -> None:
        """Execute the check."""
        actual_number_of_lines = self.model.raw_code.count("\n") + 1

        assert actual_number_of_lines <= self.max_number_of_lines, (
            f"`{get_clean_model_name(self.model.unique_id)}` has {actual_number_of_lines} lines, this is more than the maximum permitted number of lines ({self.max_number_of_lines})."
        )

`CheckModelMaxUpstreamDependencies` #

Limit the number of upstream dependencies a model has.

Parameters:

Name	Type	Description	Default
`max_upstream_macros`	`Optional[int]`	The maximum number of permitted upstream macros.	required
`max_upstream_models`	`Optional[int]`	The maximum number of permitted upstream models.	required
`max_upstream_sources`	`Optional[int]`	The maximum number of permitted upstream sources.	required

Receives at execution time:

Name	Type	Description
`model`	`DbtBouncerModelBase`	The DbtBouncerModelBase 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 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):

manifest_checks:
    - name: check_model_max_upstream_dependencies
      max_upstream_models: 3

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelMaxUpstreamDependencies(BaseCheck):
    """Limit the number of upstream dependencies a model has.

    Parameters:
        max_upstream_macros (Optional[int]): The maximum number of permitted upstream macros.
        max_upstream_models (Optional[int]): The maximum number of permitted upstream models.
        max_upstream_sources (Optional[int]): The maximum number of permitted upstream sources.

    Receives:
        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_max_upstream_dependencies
              max_upstream_models: 3
        ```

    """

    max_upstream_macros: int = Field(
        default=5,
    )
    max_upstream_models: int = Field(
        default=5,
    )
    max_upstream_sources: int = Field(
        default=1,
    )
    model: "DbtBouncerModelBase" = Field(default=None)
    name: Literal["check_model_max_upstream_dependencies"]

    def execute(self) -> None:
        """Execute the check."""
        num_upstream_macros = len(list(self.model.depends_on.macros))
        num_upstream_models = len(
            [m for m in self.model.depends_on.nodes if m.split(".")[0] == "model"],
        )
        num_upstream_sources = len(
            [m for m in self.model.depends_on.nodes if m.split(".")[0] == "source"],
        )

        assert num_upstream_macros <= self.max_upstream_macros, (
            f"`{get_clean_model_name(self.model.unique_id)}` has {num_upstream_macros} upstream macros, which is more than the permitted maximum of {self.max_upstream_macros}."
        )
        assert num_upstream_models <= self.max_upstream_models, (
            f"`{get_clean_model_name(self.model.unique_id)}` has {num_upstream_models} upstream models, which is more than the permitted maximum of {self.max_upstream_models}."
        )
        assert num_upstream_sources <= self.max_upstream_sources, (
            f"`{get_clean_model_name(self.model.unique_id)}` has {num_upstream_sources} upstream sources, which is more than the permitted maximum of {self.max_upstream_sources}."
        )

`CheckModelNames` #

Models must have a name that matches the supplied regex.

Parameters:

Name	Type	Description	Default
`model_name_pattern`	`str`	Regexp the model name must match.	required

Receives at execution time:

Name	Type	Description
`model`	`DbtBouncerModelBase`	The DbtBouncerModelBase 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 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):

manifest_checks:
    - name: check_model_names
      include: ^models/intermediate
      model_name_pattern: ^int_
    - name: check_model_names
      include: ^models/staging
      model_name_pattern: ^stg_

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelNames(BaseCheck):
    """Models must have a name that matches the supplied regex.

    Parameters:
        model_name_pattern (str): Regexp the model name must match.

    Receives:
        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_names
              include: ^models/intermediate
              model_name_pattern: ^int_
            - name: check_model_names
              include: ^models/staging
              model_name_pattern: ^stg_
        ```

    """

    model_config = ConfigDict(extra="forbid", protected_namespaces=())

    model: "DbtBouncerModelBase" = Field(default=None)
    name: Literal["check_model_names"]
    model_name_pattern: str

    def execute(self) -> None:
        """Execute the check."""
        assert (
            re.compile(self.model_name_pattern.strip()).match(self.model.name)
            is not None
        ), (
            f"`{get_clean_model_name(self.model.unique_id)}` does not match the supplied regex `{self.model_name_pattern.strip()})`."
        )

`CheckModelNumberOfGrants` #

Model can have the specified number of privileges.

Receives at execution time:

Name	Type	Description
`max_number_of_privileges`	`Optional(int)`	Maximum number of privileges, inclusive.
`min_number_of_privileges`	`Optional(int)`	Minimum number of privileges, inclusive.
`model`	`DbtBouncerModelBase`	The DbtBouncerModelBase 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 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):

manifest_checks:
    - name: check_model_number_of_grants
      include: ^models/marts
      max_number_of_privileges: 1 # Optional
      min_number_of_privileges: 0 # Optional

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelNumberOfGrants(BaseCheck):
    """Model can have the specified number of privileges.

    Receives:
        max_number_of_privileges (Optional(int)): Maximum number of privileges, inclusive.
        min_number_of_privileges (Optional(int)): Minimum number of privileges, inclusive.
        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_number_of_grants
              include: ^models/marts
              max_number_of_privileges: 1 # Optional
              min_number_of_privileges: 0 # Optional
        ```

    """

    model: "DbtBouncerModelBase" = Field(default=None)
    name: Literal["check_model_number_of_grants"]
    max_number_of_privileges: int = Field(default=100)
    min_number_of_privileges: int = Field(default=0)

    def execute(self) -> None:
        """Execute the check."""
        num_grants = len(self.model.config.grants.keys())

        assert num_grants >= self.min_number_of_privileges, (
            f"`{get_clean_model_name(self.model.unique_id)}` has less grants (`{num_grants}`) than the specified minimum ({self.min_number_of_privileges})."
        )
        assert num_grants <= self.max_number_of_privileges, (
            f"`{get_clean_model_name(self.model.unique_id)}` has more grants (`{num_grants}`) than the specified maximum ({self.max_number_of_privileges})."
        )

`CheckModelPropertyFileLocation` #

Model properties files must follow the guidance provided by dbt here.

Parameters:

Name	Type	Description	Default
`model`	`DbtBouncerModelBase`	The DbtBouncerModelBase object to check.	required

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 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):

manifest_checks:
    - name: check_model_property_file_location

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelPropertyFileLocation(BaseCheck):
    """Model properties files must follow the guidance provided by dbt [here](https://docs.getdbt.com/best-practices/how-we-structure/1-guide-overview).

    Parameters:
        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_property_file_location
        ```

    """

    model: "DbtBouncerModelBase" = Field(default=None)
    name: Literal["check_model_property_file_location"]

    def execute(self) -> None:
        """Execute the check."""
        assert (  # noqa: PT018
            hasattr(self.model, "patch_path")
            and clean_path_str(self.model.patch_path) is not None
        ), f"`{get_clean_model_name(self.model.unique_id)}` is not documented."

        expected_substr = (
            "_".join(clean_path_str(self.model.original_file_path).split("/")[1:-1])
            .replace("staging", "stg")
            .replace("intermediate", "int")
            .replace("marts", "")
        )
        properties_yml_name = clean_path_str(self.model.patch_path).split("/")[-1]

        assert properties_yml_name.startswith(
            "_",
        ), (
            f"The properties file for `{get_clean_model_name(self.model.unique_id)}` (`{properties_yml_name}`) does not start with an underscore."
        )
        assert expected_substr in properties_yml_name, (
            f"The properties file for `{get_clean_model_name(self.model.unique_id)}` (`{properties_yml_name}`) does not contain the expected substring (`{expected_substr}`)."
        )
        assert properties_yml_name.endswith(
            "__models.yml",
        ), (
            f"The properties file for `{get_clean_model_name(self.model.unique_id)}` (`{properties_yml_name}`) does not end with `__models.yml`."
        )

`CheckModelSchemaName` #

Models must have a schema name that matches the supplied regex.

Note that most setups will use schema names in development that are prefixed, for example: * dbt_jdoe_stg_payments * mary_stg_payments

Please account for this if you wish to run dbt-bouncer against locally generated manifests.

Parameters:

Name	Type	Description	Default
`schema_name_pattern`	`str`	Regexp the schema name must match.	required

Receives at execution time:

Name	Type	Description
`model`	`DbtBouncerModelBase`	The DbtBouncerModelBase 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 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):

manifest_checks:
    - name: check_model_schema_name
      include: ^models/intermediate
      schema_name_pattern: .*intermediate # Accounting for schemas like `dbt_jdoe_intermediate`.
    - name: check_model_schema_name
      include: ^models/staging
      schema_name_pattern: .*stg_.*

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelSchemaName(BaseCheck):
    """Models must have a schema name that matches the supplied regex.

    Note that most setups will use schema names in development that are prefixed, for example:
        * dbt_jdoe_stg_payments
        * mary_stg_payments

    Please account for this if you wish to run `dbt-bouncer` against locally generated manifests.

    Parameters:
        schema_name_pattern (str): Regexp the schema name must match.

    Receives:
        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_schema_name
              include: ^models/intermediate
              schema_name_pattern: .*intermediate # Accounting for schemas like `dbt_jdoe_intermediate`.
            - name: check_model_schema_name
              include: ^models/staging
              schema_name_pattern: .*stg_.*
        ```

    """

    model_config = ConfigDict(extra="forbid", protected_namespaces=())

    model: "DbtBouncerModelBase" = Field(default=None)
    name: Literal["check_model_schema_name"]
    schema_name_pattern: str

    def execute(self) -> None:
        """Execute the check."""
        assert (
            re.compile(self.schema_name_pattern.strip()).match(self.model.schema_)
            is not None
        ), (
            f"`{self.model.schema_}` does not match the supplied regex `{self.schema_name_pattern.strip()})`."
        )

`CheckModelVersionAllowed` #

Check that the version of the model matches the supplied regex pattern.

Parameters:

Name	Type	Description	Default
`version_pattern`	`str`	Regexp the version must match.	required

Receives at execution time:

Name	Type	Description
`model`	`DbtBouncerModelBase`	The DbtBouncerModelBase 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 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):

manifest_checks:
    - name: check_model_version_allowed
      include: ^models/marts
      version_pattern: >- # Versions must be numeric
        [0-9]\d*
    - name: check_model_version_allowed
      include: ^models/marts
      version_pattern: ^(stable|latest)$ # Version can be "stable" or "latest", nothing else is permitted

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelVersionAllowed(BaseCheck):
    r"""Check that the version of the model matches the supplied regex pattern.

    Parameters:
        version_pattern (str): Regexp the version must match.

    Receives:
        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_version_allowed
              include: ^models/marts
              version_pattern: >- # Versions must be numeric
                [0-9]\d*
            - name: check_model_version_allowed
              include: ^models/marts
              version_pattern: ^(stable|latest)$ # Version can be "stable" or "latest", nothing else is permitted
        ```

    """

    model_config = ConfigDict(extra="forbid", protected_namespaces=())

    model: "DbtBouncerModelBase" = Field(default=None)
    name: Literal["check_model_version_allowed"]
    version_pattern: str

    def execute(self) -> None:
        """Execute the check."""
        if self.model.version:
            assert (
                re.compile(self.version_pattern.strip()).match(str(self.model.version))
                is not None
            ), (
                f"Version `{self.model.version}` in `{self.model.name}` does not match the supplied regex `{self.version_pattern.strip()})`."
            )

`CheckModelVersionPinnedInRef` #

Check that the version of the model is always specified in downstream nodes.

Receives at execution time:

Name	Type	Description
`manifest_obj`	`DbtBouncerManifest`	The DbtBouncerManifest object parsed from `manifest.json`.
`model`	`DbtBouncerModelBase`	The DbtBouncerModelBase 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 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):

manifest_checks:
    - name: check_model_version_pinned_in_ref
      include: ^models/marts

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelVersionPinnedInRef(BaseCheck):
    r"""Check that the version of the model is always specified in downstream nodes.

    Receives:
        manifest_obj (DbtBouncerManifest): The DbtBouncerManifest object 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_version_pinned_in_ref
              include: ^models/marts
        ```

    """

    model_config = ConfigDict(extra="forbid", protected_namespaces=())

    manifest_obj: "DbtBouncerManifest" = Field(default=None)
    model: "DbtBouncerModelBase" = Field(default=None)
    name: Literal["check_model_version_pinned_in_ref"]

    def execute(self) -> None:
        """Execute the check."""
        downstream_models = [
            x
            for x in self.manifest_obj.manifest.child_map[self.model.unique_id]
            if x.startswith("model.")
        ]
        downstream_models_with_unversioned_refs: List[str] = []
        for m in downstream_models:
            downstream_models_with_unversioned_refs.extend(
                m
                for ref in self.manifest_obj.manifest.nodes[m].refs
                if ref.name == self.model.unique_id.split(".")[-1] and not ref.version
            )

        assert not downstream_models_with_unversioned_refs, (
            f"`{self.model.name}` is referenced without a pinned version in downstream models: {downstream_models_with_unversioned_refs}."
        )

`CheckModelsDocumentationCoverage` #

Set the minimum percentage of models that have a populated description.

Parameters:

Name	Type	Description	Default
`min_model_documentation_coverage_pct`	`float`	The minimum percentage of models that must have a populated description.	required

Receives at execution time:

Name	Type	Description
`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.
`severity`	`Optional[Literal['error', 'warn']]`	Severity level of the check. Default: `error`.

Example(s):

manifest_checks:
    - name: check_model_documentation_coverage
      min_model_documentation_coverage_pct: 90

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelsDocumentationCoverage(BaseModel):
    """Set the minimum percentage of models that have a populated description.

    Parameters:
        min_model_documentation_coverage_pct (float): The minimum percentage of models that must have a populated description.

    Receives:
        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.
        severity (Optional[Literal["error", "warn"]]): Severity level of the check. Default: `error`.

    Example(s):
        ```yaml
        manifest_checks:
            - name: check_model_documentation_coverage
              min_model_documentation_coverage_pct: 90
        ```

    """

    model_config = ConfigDict(extra="forbid")

    description: Optional[str] = Field(
        default=None,
        description="Description of what the check does and why it is implemented.",
    )
    index: Optional[int] = Field(
        default=None,
        description="Index to uniquely identify the check, calculated at runtime.",
    )
    min_model_documentation_coverage_pct: int = Field(
        default=100,
        ge=0,
        le=100,
    )
    models: List["DbtBouncerModelBase"] = Field(default=[])
    name: Literal["check_model_documentation_coverage"]
    severity: Optional[Literal["error", "warn"]] = Field(
        default="error",
        description="Severity of the check, one of 'error' or 'warn'.",
    )

    def execute(self) -> None:
        """Execute the check."""
        num_models = len(self.models)
        models_with_description = []
        for model in self.models:
            if len(model.description.strip()) > 4:
                models_with_description.append(model.unique_id)

        num_models_with_descriptions = len(models_with_description)
        model_description_coverage_pct = (
            num_models_with_descriptions / num_models
        ) * 100

        assert (
            model_description_coverage_pct >= self.min_model_documentation_coverage_pct
        ), (
            f"Only {model_description_coverage_pct}% of models have a populated description, this is less than the permitted minimum of {self.min_model_documentation_coverage_pct}%."
        )

`CheckModelsTestCoverage` #

Set the minimum percentage of models that have at least one test.

Parameters:

Name	Type	Description	Default
`min_model_test_coverage_pct`	`float`	The minimum percentage of models that must have at least one test.	required
`models`	`List[DbtBouncerModelBase]`	List of DbtBouncerModelBase objects parsed from `manifest.json`.	required
`tests`	`List[DbtBouncerTestBase]`	List of DbtBouncerTestBase objects parsed from `manifest.json`.	required

Other Parameters (passed via config file):

Name	Type	Description
`description`	`Optional[str]`	Description of what the check does and why it is implemented.
`severity`	`Optional[Literal['error', 'warn']]`	Severity level of the check. Default: `error`.

Example(s):

manifest_checks:
    - name: check_model_test_coverage
      min_model_test_coverage_pct: 90

Source code in src/dbt_bouncer/checks/manifest/check_models.py

class CheckModelsTestCoverage(BaseModel):
    """Set the minimum percentage of models that have at least one test.

    Parameters:
        min_model_test_coverage_pct (float): The minimum percentage of models that must have at least one test.
        models (List[DbtBouncerModelBase]): List of DbtBouncerModelBase objects parsed from `manifest.json`.
        tests (List[DbtBouncerTestBase]): List of DbtBouncerTestBase objects parsed from `manifest.json`.

    Other Parameters:
        description (Optional[str]): Description of what the check does and why it is implemented.
        severity (Optional[Literal["error", "warn"]]): Severity level of the check. Default: `error`.


    Example(s):
        ```yaml
        manifest_checks:
            - name: check_model_test_coverage
              min_model_test_coverage_pct: 90
        ```

    """

    model_config = ConfigDict(extra="forbid")

    description: Optional[str] = Field(
        default=None,
        description="Description of what the check does and why it is implemented.",
    )
    index: Optional[int] = Field(
        default=None,
        description="Index to uniquely identify the check, calculated at runtime.",
    )
    name: Literal["check_model_test_coverage"]
    min_model_test_coverage_pct: float = Field(
        default=100,
        ge=0,
        le=100,
    )
    models: List["DbtBouncerModelBase"] = Field(default=[])
    severity: Optional[Literal["error", "warn"]] = Field(
        default="error",
        description="Severity of the check, one of 'error' or 'warn'.",
    )
    tests: List["DbtBouncerTestBase"] = Field(default=[])

    def execute(self) -> None:
        """Execute the check."""
        num_models = len(self.models)
        models_with_tests = []
        for model in self.models:
            for test in self.tests:
                if model.unique_id in test.depends_on.nodes:
                    models_with_tests.append(model.unique_id)
        num_models_with_tests = len(set(models_with_tests))
        model_test_coverage_pct = (num_models_with_tests / num_models) * 100

        assert model_test_coverage_pct >= self.min_model_test_coverage_pct, (
            f"Only {model_test_coverage_pct}% of models have at least one test, this is less than the permitted minimum of {self.min_model_test_coverage_pct}%."
        )

Manifest Checks: Models#

CheckModelAccess #

CheckModelCodeDoesNotContainRegexpPattern #

CheckModelContractsEnforcedForPublicModel #

CheckModelDependsOnMacros #

CheckModelDependsOnMultipleSources #

CheckModelDescriptionContainsRegexPattern #

CheckModelDescriptionPopulated #

CheckModelDirectories #

CheckModelDocumentedInSameDirectory #

CheckModelGrantPrivilege #

CheckModelGrantPrivilegeRequired #

CheckModelHasContractsEnforced #

CheckModelHasMetaKeys #

CheckModelHasNoUpstreamDependencies #

CheckModelHasSemiColon #

CheckModelHasTags #

CheckModelHasUniqueTest #

CheckModelHasUnitTests #

CheckModelLatestVersionSpecified #

CheckModelMaxChainedViews #

CheckModelMaxFanout #

CheckModelMaxNumberOfLines #

CheckModelMaxUpstreamDependencies #

CheckModelNames #

CheckModelNumberOfGrants #

CheckModelPropertyFileLocation #

CheckModelSchemaName #

CheckModelVersionAllowed #

CheckModelVersionPinnedInRef #

CheckModelsDocumentationCoverage #

CheckModelsTestCoverage #

`CheckModelAccess` #

`CheckModelCodeDoesNotContainRegexpPattern` #

`CheckModelContractsEnforcedForPublicModel` #

`CheckModelDependsOnMacros` #

`CheckModelDependsOnMultipleSources` #

`CheckModelDescriptionContainsRegexPattern` #

`CheckModelDescriptionPopulated` #

`CheckModelDirectories` #

`CheckModelDocumentedInSameDirectory` #

`CheckModelGrantPrivilege` #

`CheckModelGrantPrivilegeRequired` #

`CheckModelHasContractsEnforced` #

`CheckModelHasMetaKeys` #

`CheckModelHasNoUpstreamDependencies` #

`CheckModelHasSemiColon` #

`CheckModelHasTags` #

`CheckModelHasUniqueTest` #

`CheckModelHasUnitTests` #

`CheckModelLatestVersionSpecified` #

`CheckModelMaxChainedViews` #

`CheckModelMaxFanout` #

`CheckModelMaxNumberOfLines` #

`CheckModelMaxUpstreamDependencies` #

`CheckModelNames` #

`CheckModelNumberOfGrants` #

`CheckModelPropertyFileLocation` #

`CheckModelSchemaName` #

`CheckModelVersionAllowed` #

`CheckModelVersionPinnedInRef` #

`CheckModelsDocumentationCoverage` #

`CheckModelsTestCoverage` #