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

dbt_bouncer/checks/manifest/check_models.py

@@ -1,25 +1,30 @@
-# mypy: disable-error-code="union-attr"
 import logging
 import re
-from typing import TYPE_CHECKING, List, Literal, Optional
+from pathlib import Path
+from typing import TYPE_CHECKING, Literal
 
 from pydantic import BaseModel, ConfigDict, Field
 
 from dbt_bouncer.check_base import BaseCheck
 from dbt_bouncer.checks.common import NestedDict
-from dbt_bouncer.utils import find_missing_meta_keys, get_package_version_number
+from dbt_bouncer.utils import (
+    find_missing_meta_keys,
+    get_package_version_number,
+    is_description_populated,
+)
 
 if TYPE_CHECKING:
     from dbt_bouncer.artifact_parsers.dbt_cloud.manifest_latest import (
         UnitTests,
     )
-    from dbt_bouncer.artifact_parsers.parsers_common import (
+    from dbt_bouncer.artifact_parsers.parsers_manifest import (
         DbtBouncerExposureBase,
         DbtBouncerManifest,
         DbtBouncerModelBase,
         DbtBouncerTestBase,
     )
 
+from dbt_bouncer.checks.common import DbtBouncerFailedCheckError
 from dbt_bouncer.utils import clean_path_str, get_clean_model_name
 
 
@@ -33,11 +38,11 @@ class CheckModelAccess(BaseCheck):
         model (DbtBouncerModelBase): The DbtBouncerModelBase object to check.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
-        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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -57,14 +62,22 @@ class CheckModelAccess(BaseCheck):
     """
 
     access: Literal["private", "protected", "public"]
-    model: "DbtBouncerModelBase" = Field(default=None)
+    model: "DbtBouncerModelBase | None" = 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}`."
-        )
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If access is incorrect.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
+        if self.model.access and self.model.access.value != self.access:
+            raise DbtBouncerFailedCheckError(
+                f"`{get_clean_model_name(self.model.unique_id)}` has `{self.model.access.value}` access, it should have access `{self.access}`."
+            )
 
 
 class CheckModelCodeDoesNotContainRegexpPattern(BaseCheck):
@@ -77,11 +90,11 @@ class CheckModelCodeDoesNotContainRegexpPattern(BaseCheck):
         model (DbtBouncerModelBase): The DbtBouncerModelBase object to check.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
-        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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -93,20 +106,28 @@ class CheckModelCodeDoesNotContainRegexpPattern(BaseCheck):
 
     """
 
-    model: "DbtBouncerModelBase" = Field(default=None)
+    model: "DbtBouncerModelBase | None" = Field(default=None)
     name: Literal["check_model_code_does_not_contain_regexp_pattern"]
     regexp_pattern: str
 
     def execute(self) -> None:
-        """Execute the check."""
-        assert (
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If code contains banned string.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
+        if (
             re.compile(self.regexp_pattern.strip(), flags=re.DOTALL).match(
-                self.model.raw_code
+                str(self.model.raw_code)
+            )
+            is not None
+        ):
+            raise DbtBouncerFailedCheckError(
+                f"`{get_clean_model_name(self.model.unique_id)}` contains a banned string: `{self.regexp_pattern.strip()}`."
             )
-            is None
-        ), (
-            f"`{get_clean_model_name(self.model.unique_id)}` contains a banned string: `{self.regexp_pattern.strip()}`."
-        )
 
 
 class CheckModelContractsEnforcedForPublicModel(BaseCheck):
@@ -116,11 +137,11 @@ class CheckModelContractsEnforcedForPublicModel(BaseCheck):
         model (DbtBouncerModelBase): The DbtBouncerModelBase object to check.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
-        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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -130,13 +151,24 @@ class CheckModelContractsEnforcedForPublicModel(BaseCheck):
 
     """
 
-    model: "DbtBouncerModelBase" = Field(default=None)
+    model: "DbtBouncerModelBase | None" = 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, (
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If contracts are not enforced for public model.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
+        if (
+            self.model.access
+            and self.model.access.value == "public"
+            and (not self.model.contract or self.model.contract.enforced is not True)
+        ):
+            raise DbtBouncerFailedCheckError(
                 f"`{get_clean_model_name(self.model.unique_id)}` is a public model but does not have contracts enforced."
             )
 
@@ -145,18 +177,18 @@ 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`.
+        criteria: (Literal["any", "all", "one"] | None): 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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -174,30 +206,41 @@ class CheckModelDependsOnMacros(BaseCheck):
     """
 
     criteria: Literal["any", "all", "one"] = Field(default="all")
-    model: "DbtBouncerModelBase" = Field(default=None)
+    model: "DbtBouncerModelBase | None" = Field(default=None)
     name: Literal["check_model_depends_on_macros"]
-    required_macros: List[str]
+    required_macros: list[str]
 
     def execute(self) -> None:
-        """Execute the check."""
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If model does not depend on required macros.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
         upstream_macros = [
-            (".").join(m.split(".")[1:]) for m in self.model.depends_on.macros
+            (".").join(m.split(".")[1:])
+            for m in getattr(self.model.depends_on, "macros", []) or []
         ]
         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}."
-            )
+            if not any(macro in upstream_macros for macro in self.required_macros):
+                raise DbtBouncerFailedCheckError(
+                    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
-            ), (
+            if missing_macros:
+                raise DbtBouncerFailedCheckError(
+                    f"`{get_clean_model_name(self.model.unique_id)}` is missing required macros: {missing_macros}."
+                )
+        elif (
+            self.criteria == "one"
+            and sum(macro in upstream_macros for macro in self.required_macros) != 1
+        ):
+            raise DbtBouncerFailedCheckError(
                 f"`{get_clean_model_name(self.model.unique_id)}` must depend on exactly one of the required macros: {self.required_macros}."
             )
 
@@ -209,11 +252,11 @@ class CheckModelDependsOnMultipleSources(BaseCheck):
         model (DbtBouncerModelBase): The DbtBouncerModelBase object to check.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
-        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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -223,17 +266,26 @@ class CheckModelDependsOnMultipleSources(BaseCheck):
 
     """
 
-    model: "DbtBouncerModelBase" = Field(default=None)
+    model: "DbtBouncerModelBase | None" = Field(default=None)
     name: Literal["check_model_depends_on_multiple_sources"]
 
     def execute(self) -> None:
-        """Execute the check."""
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If model references more than one source.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
         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."
+            x.split(".")[0] == "source"
+            for x in getattr(self.model.depends_on, "nodes", []) or []
         )
+        if num_reffed_sources > 1:
+            raise DbtBouncerFailedCheckError(
+                f"`{get_clean_model_name(self.model.unique_id)}` references more than one source."
+            )
 
 
 class CheckModelDescriptionContainsRegexPattern(BaseCheck):
@@ -244,11 +296,11 @@ class CheckModelDescriptionContainsRegexPattern(BaseCheck):
         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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -259,48 +311,75 @@ class CheckModelDescriptionContainsRegexPattern(BaseCheck):
 
     """
 
-    model: "DbtBouncerModelBase" = Field(default=None)
+    model: "DbtBouncerModelBase | None" = 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}."""
-        )
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If description does not match regex.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
+        if not re.compile(self.regexp_pattern.strip(), flags=re.DOTALL).match(
+            str(self.model.description)
+        ):
+            raise DbtBouncerFailedCheckError(
+                f"""`{get_clean_model_name(self.model.unique_id)}`'s description "{self.model.description}" doesn't match the supplied regex: {self.regexp_pattern}."""
+            )
 
 
 class CheckModelDescriptionPopulated(BaseCheck):
     """Models must have a populated description.
 
+    Parameters:
+        min_description_length (int | None): Minimum length required for the description to be considered populated.
+
     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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
         manifest_checks:
             - name: check_model_description_populated
         ```
+        ```yaml
+        manifest_checks:
+            - name: check_model_description_populated
+              min_description_length: 25 # Setting a stricter requirement for description length
+        ```
 
     """
 
-    model: "DbtBouncerModelBase" = Field(default=None)
+    min_description_length: int | None = Field(default=None)
+    model: "DbtBouncerModelBase | None" = 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."
-        )
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If description is not populated.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
+        if not self._is_description_populated(
+            self.model.description or "", self.min_description_length
+        ):
+            raise DbtBouncerFailedCheckError(
+                f"`{get_clean_model_name(self.model.unique_id)}` does not have a populated description."
+            )
 
 
 class CheckModelDirectories(BaseCheck):
@@ -308,17 +387,17 @@ class CheckModelDirectories(BaseCheck):
 
     Parameters:
         include (str): Regex pattern to the directory to check.
-        permitted_sub_directories (List[str]): List of permitted sub-directories.
+        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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -342,33 +421,35 @@ class CheckModelDirectories(BaseCheck):
     """
 
     include: str
-    model: "DbtBouncerModelBase" = Field(default=None)
+    model: "DbtBouncerModelBase | None" = Field(default=None)
     name: Literal["check_model_directories"]
-    permitted_sub_directories: List[str]
+    permitted_sub_directories: list[str]
 
     def execute(self) -> None:
         """Execute the check.
 
         Raises:
-            AssertionError: If model located in `./models`.
+            DbtBouncerFailedCheckError: If model located in `./models` or invalid subdirectory.
 
         """
-        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 self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
+        clean_path = clean_path_str(self.model.original_file_path)
+        matched_path = re.compile(self.include.strip().rstrip("/")).match(clean_path)
+        if matched_path is None:
+            raise DbtBouncerFailedCheckError("matched_path is None")
+        path_after_match = clean_path[matched_path.end() + 1 :]
+        directory_to_check = Path(path_after_match).parts[0]
 
         if directory_to_check.replace(".sql", "") == self.model.name:
-            raise AssertionError(
+            raise DbtBouncerFailedCheckError(
                 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})."
-            )
+            if directory_to_check not in self.permitted_sub_directories:
+                raise DbtBouncerFailedCheckError(
+                    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})."
+                )
 
 
 class CheckModelDocumentedInSameDirectory(BaseCheck):
@@ -378,11 +459,11 @@ class CheckModelDocumentedInSameDirectory(BaseCheck):
         model (DbtBouncerModelBase): The DbtBouncerModelBase object to check.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
-        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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -392,26 +473,41 @@ class CheckModelDocumentedInSameDirectory(BaseCheck):
 
     """
 
-    model: "DbtBouncerModelBase" = Field(default=None)
+    model: "DbtBouncerModelBase | None" = 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
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If model is not documented in same directory.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
+        model_sql_path = Path(clean_path_str(self.model.original_file_path))
+        model_sql_dir = model_sql_path.parent.parts
+
+        if not (
             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."
+            and clean_path_str(self.model.patch_path or "") is not None
+        ):
+            raise DbtBouncerFailedCheckError(
+                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]
+        patch_path_str = clean_path_str(self.model.patch_path or "")
+        start_idx = patch_path_str.find("models")
+        if start_idx != -1:
+            patch_path_str = patch_path_str[start_idx:]
 
-        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)}`."
-        )
+        model_doc_path = Path(patch_path_str)
+        model_doc_dir = model_doc_path.parent.parts
+
+        if model_doc_dir != model_sql_dir:
+            raise DbtBouncerFailedCheckError(
+                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)}`."
+            )
 
 
 class CheckModelFileName(BaseCheck):
@@ -424,11 +520,11 @@ class CheckModelFileName(BaseCheck):
         model (DbtBouncerModelBase): The DbtBouncerModelBase object to check.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
-        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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -442,17 +538,23 @@ class CheckModelFileName(BaseCheck):
     """
 
     file_name_pattern: str
-    model: "DbtBouncerModelBase" = Field(default=None)
+    model: "DbtBouncerModelBase | None" = Field(default=None)
     name: Literal["check_model_file_name"]
 
     def execute(self) -> None:
-        """Execute the check."""
-        file_name = self.model.original_file_path.split("/")[-1]
-        assert (
-            re.compile(self.file_name_pattern.strip()).match(file_name) is not None
-        ), (
-            f"`{get_clean_model_name(self.model.unique_id)}` is in a file that does not match the supplied regex `{self.file_name_pattern.strip()}`."
-        )
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If file name does not match regex.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
+        file_name = Path(clean_path_str(self.model.original_file_path)).name
+        if re.compile(self.file_name_pattern.strip()).match(file_name) is None:
+            raise DbtBouncerFailedCheckError(
+                f"`{get_clean_model_name(self.model.unique_id)}` is in a file that does not match the supplied regex `{self.file_name_pattern.strip()}`."
+            )
 
 
 class CheckModelGrantPrivilege(BaseCheck):
@@ -463,11 +565,11 @@ class CheckModelGrantPrivilege(BaseCheck):
         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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -479,21 +581,31 @@ class CheckModelGrantPrivilege(BaseCheck):
 
     """
 
-    model: "DbtBouncerModelBase" = Field(default=None)
+    model: "DbtBouncerModelBase | None" = Field(default=None)
     name: Literal["check_model_grant_privilege"]
     privilege_pattern: str
 
     def execute(self) -> None:
-        """Execute the check."""
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If grant privileges do not match regex.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
+        config = self.model.config
+        grants = config.grants if config else {}
         non_complying_grants = [
             i
-            for i in self.model.config.grants
-            if re.compile(self.privilege_pattern.strip()).match(i) is None
+            for i in (grants or {})
+            if re.compile(self.privilege_pattern.strip()).match(str(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})."
-        )
+        if non_complying_grants:
+            raise DbtBouncerFailedCheckError(
+                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})."
+            )
 
 
 class CheckModelGrantPrivilegeRequired(BaseCheck):
@@ -504,11 +616,11 @@ class CheckModelGrantPrivilegeRequired(BaseCheck):
         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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -520,15 +632,25 @@ class CheckModelGrantPrivilegeRequired(BaseCheck):
 
     """
 
-    model: "DbtBouncerModelBase" = Field(default=None)
+    model: "DbtBouncerModelBase | None" = 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}`)."
-        )
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If required grant privilege is missing.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
+        config = self.model.config
+        grants = config.grants if config else {}
+        if self.privilege not in (grants or {}):
+            raise DbtBouncerFailedCheckError(
+                f"`{get_clean_model_name(self.model.unique_id)}` does not have the required grant privilege (`{self.privilege}`)."
+            )
 
 
 class CheckModelHasContractsEnforced(BaseCheck):
@@ -538,11 +660,11 @@ class CheckModelHasContractsEnforced(BaseCheck):
         model (DbtBouncerModelBase): The DbtBouncerModelBase object to check.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
-        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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -553,29 +675,37 @@ class CheckModelHasContractsEnforced(BaseCheck):
 
     """
 
-    model: "DbtBouncerModelBase" = Field(default=None)
+    model: "DbtBouncerModelBase | None" = 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."
-        )
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If contracts are not enforced.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
+        if not self.model.contract or self.model.contract.enforced is not True:
+            raise DbtBouncerFailedCheckError(
+                f"`{get_clean_model_name(self.model.unique_id)}` does not have contracts enforced."
+            )
 
 
 class CheckModelHasExposure(BaseCheck):
     """Models must have an exposure.
 
     Receives:
-        exposures (List[DbtBouncerExposureBase]):  List of DbtBouncerExposureBase objects parsed from `manifest.json`.
+        exposures (list[DbtBouncerExposureBase]):  List of DbtBouncerExposureBase objects parsed from `manifest.json`.
         model (DbtBouncerModelBase): The DbtBouncerModelBase object to check.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
-        materialization (Optional[Literal["ephemeral", "incremental", "table", "view"]]): Limit check to models with the specified materialization.
-        severity (Optional[Literal["error", "warn"]]): Severity level of the check. Default: `error`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -589,21 +719,29 @@ class CheckModelHasExposure(BaseCheck):
 
     model_config = ConfigDict(extra="forbid", protected_namespaces=())
 
-    exposures: List["DbtBouncerExposureBase"] = Field(default=[])
-    model: "DbtBouncerModelBase" = Field(default=None)
+    exposures: list["DbtBouncerExposureBase"] = Field(default=[])
+    model: "DbtBouncerModelBase | None" = Field(default=None)
     name: Literal["check_model_has_exposure"]
 
     def execute(self) -> None:
-        """Execute the check."""
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If model does not have an exposure.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
         has_exposure = False
         for e in self.exposures:
-            for m in e.depends_on.nodes:
+            for m in getattr(e.depends_on, "nodes", []) or []:
                 if m == self.model.unique_id:
                     has_exposure = True
 
-        assert has_exposure, (
-            f"`{get_clean_model_name(self.model.unique_id)}` does not have an associated exposure."
-        )
+        if not has_exposure:
+            raise DbtBouncerFailedCheckError(
+                f"`{get_clean_model_name(self.model.unique_id)}` does not have an associated exposure."
+            )
 
 
 class CheckModelHasMetaKeys(BaseCheck):
@@ -614,11 +752,11 @@ class CheckModelHasMetaKeys(BaseCheck):
         model (DbtBouncerModelBase): The DbtBouncerModelBase object to check.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
-        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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -632,18 +770,26 @@ class CheckModelHasMetaKeys(BaseCheck):
     """
 
     keys: NestedDict
-    model: "DbtBouncerModelBase" = Field(default=None)
+    model: "DbtBouncerModelBase | None" = Field(default=None)
     name: Literal["check_model_has_meta_keys"]
 
     def execute(self) -> None:
-        """Execute the check."""
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If required meta keys are missing.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
         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]}"
-        )
+        if missing_keys != []:
+            raise DbtBouncerFailedCheckError(
+                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]}"
+            )
 
 
 class CheckModelHasNoUpstreamDependencies(BaseCheck):
@@ -653,11 +799,11 @@ class CheckModelHasNoUpstreamDependencies(BaseCheck):
         model (DbtBouncerModelBase): The DbtBouncerModelBase object to check.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
-        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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -667,14 +813,26 @@ class CheckModelHasNoUpstreamDependencies(BaseCheck):
 
     """
 
-    model: "DbtBouncerModelBase" = Field(default=None)
+    model: "DbtBouncerModelBase | None" = 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."
-        )
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If model has no upstream dependencies.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
+        if (
+            not self.model.depends_on
+            or not self.model.depends_on.nodes
+            or len(self.model.depends_on.nodes) <= 0
+        ):
+            raise DbtBouncerFailedCheckError(
+                f"`{get_clean_model_name(self.model.unique_id)}` has no upstream dependencies, this likely indicates hard-coded tables references."
+            )
 
 
 class CheckModelHasSemiColon(BaseCheck):
@@ -684,11 +842,11 @@ class CheckModelHasSemiColon(BaseCheck):
         model (DbtBouncerModelBase): The DbtBouncerModelBase object to check.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
-        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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -699,30 +857,38 @@ class CheckModelHasSemiColon(BaseCheck):
 
     """
 
-    model: "DbtBouncerModelBase" = Field(default=None)
+    model: "DbtBouncerModelBase | None" = 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."
-        )
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If model ends with a semi-colon.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
+        if (self.model.raw_code or "").strip()[-1] == ";":
+            raise DbtBouncerFailedCheckError(
+                f"`{get_clean_model_name(self.model.unique_id)}` ends with a semi-colon, this is not permitted."
+            )
 
 
 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`.
+        criteria: (Literal["any", "all", "one"] | None): 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.
+        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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -736,23 +902,35 @@ class CheckModelHasTags(BaseCheck):
     """
 
     criteria: Literal["any", "all", "one"] = Field(default="all")
-    model: "DbtBouncerModelBase" = Field(default=None)
+    model: "DbtBouncerModelBase | None" = Field(default=None)
     name: Literal["check_model_has_tags"]
-    tags: List[str]
+    tags: list[str]
 
     def execute(self) -> None:
-        """Execute the check."""
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If model does not have required tags.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
+        model_tags = self.model.tags or []
         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}."
-            )
+            if not any(tag in model_tags for tag in self.tags):
+                raise DbtBouncerFailedCheckError(
+                    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, (
+            missing_tags = [tag for tag in self.tags if tag not in model_tags]
+            if missing_tags:
+                raise DbtBouncerFailedCheckError(
+                    f"`{get_clean_model_name(self.model.unique_id)}` is missing required tags: {missing_tags}."
+                )
+        elif (
+            self.criteria == "one" and sum(tag in model_tags for tag in self.tags) != 1
+        ):
+            raise DbtBouncerFailedCheckError(
                 f"`{get_clean_model_name(self.model.unique_id)}` must have exactly one of the required tags: {self.tags}."
             )
 
@@ -761,16 +939,16 @@ 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.
+        accepted_uniqueness_tests (list[str] | None): 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`.
+        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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -790,56 +968,69 @@ class CheckModelHasUniqueTest(BaseCheck):
 
     """
 
-    accepted_uniqueness_tests: Optional[List[str]] = Field(
+    accepted_uniqueness_tests: list[str] | None = Field(
         default=[
             "dbt_expectations.expect_compound_columns_to_be_unique",
             "dbt_utils.unique_combination_of_columns",
             "unique",
         ],
     )
-    model: "DbtBouncerModelBase" = Field(default=None)
+    model: "DbtBouncerModelBase | None" = Field(default=None)
     name: Literal["check_model_has_unique_test"]
-    tests: List["DbtBouncerTestBase"] = Field(default=[])
+    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
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If model does not have a unique test.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
+        num_unique_tests = 0
+        for test in self.tests:
+            test_metadata = getattr(test, "test_metadata", None)
+            attached_node = getattr(test, "attached_node", None)
+            if (
+                test_metadata
+                and attached_node == self.model.unique_id
+                and (
+                    (
+                        f"{getattr(test_metadata, 'namespace', '')}.{getattr(test_metadata, 'name', '')}"
+                        in (self.accepted_uniqueness_tests or [])
+                    )
+                    or (
+                        getattr(test_metadata, "namespace", None) is None
+                        and getattr(test_metadata, "name", "")
+                        in (self.accepted_uniqueness_tests or [])
+                    )
+                )
+            ):
+                num_unique_tests += 1
+        if num_unique_tests < 1:
+            raise DbtBouncerFailedCheckError(
+                f"`{get_clean_model_name(self.model.unique_id)}` does not have a test for uniqueness of a column."
             )
-            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."
-        )
 
 
 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.
+        min_number_of_unit_tests (int | None): 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`.
+        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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     !!! warning
 
@@ -859,27 +1050,39 @@ class CheckModelHasUnitTests(BaseCheck):
 
     """
 
-    manifest_obj: "DbtBouncerManifest" = Field(default=None)
+    manifest_obj: "DbtBouncerManifest | None" = Field(default=None)
     min_number_of_unit_tests: int = Field(default=1)
-    model: "DbtBouncerModelBase" = Field(default=None)
+    model: "DbtBouncerModelBase | None" = Field(default=None)
     name: Literal["check_model_has_unit_tests"]
-    unit_tests: List["UnitTests"] = Field(default=[])
+    unit_tests: list["UnitTests"] = Field(default=[])
 
     def execute(self) -> None:
-        """Execute the check."""
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If model does not have enough unit tests.
+
+        """
+        if self.manifest_obj is None:
+            raise DbtBouncerFailedCheckError("self.manifest_obj is None")
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
         if get_package_version_number(
-            self.manifest_obj.manifest.metadata.dbt_version
+            self.manifest_obj.manifest.metadata.dbt_version or "0.0.0"
         ) >= 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
+                    if t.depends_on
+                    and t.depends_on.nodes
+                    and 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}."
-            )
+            if num_unit_tests < self.min_number_of_unit_tests:
+                raise DbtBouncerFailedCheckError(
+                    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.",
@@ -893,11 +1096,11 @@ class CheckModelLatestVersionSpecified(BaseCheck):
         model (DbtBouncerModelBase): The DbtBouncerModelBase object to check.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
-        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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -910,33 +1113,41 @@ class CheckModelLatestVersionSpecified(BaseCheck):
 
     model_config = ConfigDict(extra="forbid", protected_namespaces=())
 
-    model: "DbtBouncerModelBase" = Field(default=None)
+    model: "DbtBouncerModelBase | None" = 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`."
-        )
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If latest version is not specified.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
+        if self.model.latest_version is None:
+            raise DbtBouncerFailedCheckError(
+                f"`{self.model.name}` does not have a specified `latest_version`."
+            )
 
 
 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.
+        materializations_to_include (list[str] | None): List of materializations to include in the check.
+        max_chained_views (int | None): 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`.
+        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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -955,20 +1166,29 @@ class CheckModelMaxChainedViews(BaseCheck):
 
     """
 
-    manifest_obj: "DbtBouncerManifest" = Field(default=None)
-    materializations_to_include: List[str] = Field(
+    manifest_obj: "DbtBouncerManifest | None" = 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=[])
+    model: "DbtBouncerModelBase | None" = Field(default=None)
+    models: list["DbtBouncerModelBase"] = Field(default=[])
     name: Literal["check_model_max_chained_views"]
-    package_name: Optional[str] = Field(default=None)
+    package_name: str | None = Field(default=None)
 
     def execute(self) -> None:
-        """Execute the check."""
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If max chained views exceeded.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
+        if self.manifest_obj is None:
+            raise DbtBouncerFailedCheckError("self.manifest_obj is None")
 
         def return_upstream_view_models(
             materializations,
@@ -982,7 +1202,7 @@ class CheckModelMaxChainedViews(BaseCheck):
 
             Returns
             -
-                List[str]: List of model unique_id's of upstream models that are views.
+                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 == []:
@@ -1019,7 +1239,7 @@ class CheckModelMaxChainedViews(BaseCheck):
                 depth=depth,
             )
 
-        assert (
+        if (
             len(
                 return_upstream_view_models(
                     materializations=self.materializations_to_include,
@@ -1032,28 +1252,29 @@ class CheckModelMaxChainedViews(BaseCheck):
                     ),
                 ),
             )
-            == 0
-        ), (
-            f"`{get_clean_model_name(self.model.unique_id)}` has more than {self.max_chained_views} upstream dependents that are not tables."
-        )
+            != 0
+        ):
+            raise DbtBouncerFailedCheckError(
+                f"`{get_clean_model_name(self.model.unique_id)}` has more than {self.max_chained_views} upstream dependents that are not tables."
+            )
 
 
 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.
+        max_downstream_models (int | None): 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`.
+        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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -1065,19 +1286,29 @@ class CheckModelMaxFanout(BaseCheck):
     """
 
     max_downstream_models: int = Field(default=3)
-    model: "DbtBouncerModelBase" = Field(default=None)
-    models: List["DbtBouncerModelBase"] = Field(default=[])
+    model: "DbtBouncerModelBase | None" = Field(default=None)
+    models: list["DbtBouncerModelBase"] = Field(default=[])
     name: Literal["check_model_max_fanout"]
 
     def execute(self) -> None:
-        """Execute the check."""
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If max fanout exceeded.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
         num_downstream_models = sum(
-            self.model.unique_id in m.depends_on.nodes for m in self.models
+            self.model.unique_id
+            in (getattr(m.depends_on, "nodes", []) if m.depends_on else [])
+            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}."
-        )
+        if num_downstream_models > self.max_downstream_models:
+            raise DbtBouncerFailedCheckError(
+                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}."
+            )
 
 
 class CheckModelMaxNumberOfLines(BaseCheck):
@@ -1089,11 +1320,11 @@ class CheckModelMaxNumberOfLines(BaseCheck):
         model (DbtBouncerModelBase): The DbtBouncerModelBase object to check.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
-        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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -1108,36 +1339,44 @@ class CheckModelMaxNumberOfLines(BaseCheck):
 
     """
 
-    model: "DbtBouncerModelBase" = Field(default=None)
+    model: "DbtBouncerModelBase | None" = 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
+        """Execute the check.
 
-        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})."
-        )
+        Raises:
+            DbtBouncerFailedCheckError: If max lines exceeded.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
+        actual_number_of_lines = (self.model.raw_code or "").count("\n") + 1
+
+        if actual_number_of_lines > self.max_number_of_lines:
+            raise DbtBouncerFailedCheckError(
+                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})."
+            )
 
 
 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.
+        max_upstream_macros (int | None): The maximum number of permitted upstream macros.
+        max_upstream_models (int | None): The maximum number of permitted upstream models.
+        max_upstream_sources (int | None): 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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -1157,28 +1396,45 @@ class CheckModelMaxUpstreamDependencies(BaseCheck):
     max_upstream_sources: int = Field(
         default=1,
     )
-    model: "DbtBouncerModelBase" = Field(default=None)
+    model: "DbtBouncerModelBase | None" = 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"],
-        )
+        """Execute the check.
 
-        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}."
-        )
+        Raises:
+            DbtBouncerFailedCheckError: If max upstream dependencies exceeded.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
+        depends_on = self.model.depends_on
+        if depends_on:
+            num_upstream_macros = len(list(getattr(depends_on, "macros", []) or []))
+            nodes = getattr(depends_on, "nodes", []) or []
+            num_upstream_models = len(
+                [m for m in nodes if m.split(".")[0] == "model"],
+            )
+            num_upstream_sources = len(
+                [m for m in nodes if m.split(".")[0] == "source"],
+            )
+        else:
+            num_upstream_macros = 0
+            num_upstream_models = 0
+            num_upstream_sources = 0
+
+        if num_upstream_macros > self.max_upstream_macros:
+            raise DbtBouncerFailedCheckError(
+                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}."
+            )
+        if num_upstream_models > self.max_upstream_models:
+            raise DbtBouncerFailedCheckError(
+                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}."
+            )
+        if num_upstream_sources > self.max_upstream_sources:
+            raise DbtBouncerFailedCheckError(
+                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}."
+            )
 
 
 class CheckModelNames(BaseCheck):
@@ -1191,11 +1447,11 @@ class CheckModelNames(BaseCheck):
         model (DbtBouncerModelBase): The DbtBouncerModelBase object to check.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
-        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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -1212,34 +1468,42 @@ class CheckModelNames(BaseCheck):
 
     model_config = ConfigDict(extra="forbid", protected_namespaces=())
 
-    model: "DbtBouncerModelBase" = Field(default=None)
+    model: "DbtBouncerModelBase | None" = 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()}`."
-        )
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If model name does not match regex.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
+        if (
+            re.compile(self.model_name_pattern.strip()).match(str(self.model.name))
+            is None
+        ):
+            raise DbtBouncerFailedCheckError(
+                f"`{get_clean_model_name(self.model.unique_id)}` does not match the supplied regex `{self.model_name_pattern.strip()}`."
+            )
 
 
 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.
+        max_number_of_privileges (int | None): Maximum number of privileges, inclusive.
+        min_number_of_privileges (int | None): 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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -1252,21 +1516,32 @@ class CheckModelNumberOfGrants(BaseCheck):
 
     """
 
-    model: "DbtBouncerModelBase" = Field(default=None)
+    model: "DbtBouncerModelBase | None" = 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())
+        """Execute the check.
 
-        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})."
-        )
+        Raises:
+            DbtBouncerFailedCheckError: If number of grants is not within limits.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
+        config = self.model.config
+        grants = config.grants if config else {}
+        num_grants = len((grants or {}).keys())
+
+        if num_grants < self.min_number_of_privileges:
+            raise DbtBouncerFailedCheckError(
+                f"`{get_clean_model_name(self.model.unique_id)}` has less grants (`{num_grants}`) than the specified minimum ({self.min_number_of_privileges})."
+            )
+        if num_grants > self.max_number_of_privileges:
+            raise DbtBouncerFailedCheckError(
+                f"`{get_clean_model_name(self.model.unique_id)}` has more grants (`{num_grants}`) than the specified maximum ({self.max_number_of_privileges})."
+            )
 
 
 class CheckModelPropertyFileLocation(BaseCheck):
@@ -1276,11 +1551,11 @@ class CheckModelPropertyFileLocation(BaseCheck):
         model (DbtBouncerModelBase): The DbtBouncerModelBase object to check.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
-        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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -1290,37 +1565,56 @@ class CheckModelPropertyFileLocation(BaseCheck):
 
     """
 
-    model: "DbtBouncerModelBase" = Field(default=None)
+    model: "DbtBouncerModelBase | None" = Field(default=None)
     name: Literal["check_model_property_file_location"]
 
     def execute(self) -> None:
-        """Execute the check."""
-        assert (  # noqa: PT018
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If property file location is incorrect.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
+        if not (
             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]
+            and self.model.patch_path
+            and clean_path_str(self.model.patch_path or "") is not None
+        ):
+            raise DbtBouncerFailedCheckError(
+                f"`{get_clean_model_name(self.model.unique_id)}` is not documented."
+            )
 
-        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`."
-        )
+        original_path = Path(clean_path_str(self.model.original_file_path))
+        relevant_parts = original_path.parts[1:-1]
+
+        mapped_parts = []
+        for part in relevant_parts:
+            if part == "staging":
+                mapped_parts.append("stg")
+            elif part == "intermediate":
+                mapped_parts.append("int")
+            elif part == "marts":
+                continue
+            else:
+                mapped_parts.append(part)
+
+        expected_substr = "_".join(mapped_parts)
+        properties_yml_name = Path(clean_path_str(self.model.patch_path or "")).name
+
+        if not properties_yml_name.startswith("_"):
+            raise DbtBouncerFailedCheckError(
+                f"The properties file for `{get_clean_model_name(self.model.unique_id)}` (`{properties_yml_name}`) does not start with an underscore."
+            )
+        if expected_substr not in properties_yml_name:
+            raise DbtBouncerFailedCheckError(
+                f"The properties file for `{get_clean_model_name(self.model.unique_id)}` (`{properties_yml_name}`) does not contain the expected substring (`{expected_substr}`)."
+            )
+        if not properties_yml_name.endswith("__models.yml"):
+            raise DbtBouncerFailedCheckError(
+                f"The properties file for `{get_clean_model_name(self.model.unique_id)}` (`{properties_yml_name}`) does not end with `__models.yml`."
+            )
 
 
 class CheckModelSchemaName(BaseCheck):
@@ -1339,11 +1633,11 @@ class CheckModelSchemaName(BaseCheck):
         model (DbtBouncerModelBase): The DbtBouncerModelBase object to check.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
-        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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -1360,18 +1654,26 @@ class CheckModelSchemaName(BaseCheck):
 
     model_config = ConfigDict(extra="forbid", protected_namespaces=())
 
-    model: "DbtBouncerModelBase" = Field(default=None)
+    model: "DbtBouncerModelBase | None" = 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()})`."
-        )
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If schema name does not match regex.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
+        if (
+            re.compile(self.schema_name_pattern.strip()).match(str(self.model.schema_))
+            is None
+        ):
+            raise DbtBouncerFailedCheckError(
+                f"`{self.model.schema_}` does not match the supplied regex `{self.schema_name_pattern.strip()})`."
+            )
 
 
 class CheckModelVersionAllowed(BaseCheck):
@@ -1384,11 +1686,11 @@ class CheckModelVersionAllowed(BaseCheck):
         model (DbtBouncerModelBase): The DbtBouncerModelBase object to check.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
-        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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -1406,17 +1708,24 @@ class CheckModelVersionAllowed(BaseCheck):
 
     model_config = ConfigDict(extra="forbid", protected_namespaces=())
 
-    model: "DbtBouncerModelBase" = Field(default=None)
+    model: "DbtBouncerModelBase | None" = 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
-            ), (
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If version is not allowed.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
+        if self.model.version and (
+            re.compile(self.version_pattern.strip()).match(str(self.model.version))
+            is None
+        ):
+            raise DbtBouncerFailedCheckError(
                 f"Version `{self.model.version}` in `{self.model.name}` does not match the supplied regex `{self.version_pattern.strip()})`."
             )
 
@@ -1429,11 +1738,11 @@ class CheckModelVersionPinnedInRef(BaseCheck):
         model (DbtBouncerModelBase): The DbtBouncerModelBase object to check.
 
     Other Parameters:
-        description (Optional[str]): Description of what the check does and why it is implemented.
-        exclude (Optional[str]): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
-        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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the model path. Model paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        materialization (Literal["ephemeral", "incremental", "table", "view"] | None): Limit check to models with the specified materialization.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -1446,42 +1755,60 @@ class CheckModelVersionPinnedInRef(BaseCheck):
 
     model_config = ConfigDict(extra="forbid", protected_namespaces=())
 
-    manifest_obj: "DbtBouncerManifest" = Field(default=None)
-    model: "DbtBouncerModelBase" = Field(default=None)
+    manifest_obj: "DbtBouncerManifest | None" = Field(default=None)
+    model: "DbtBouncerModelBase | None" = 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] = []
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If version is not pinned in ref.
+
+        """
+        if self.model is None:
+            raise DbtBouncerFailedCheckError("self.model is None")
+        if self.manifest_obj is None:
+            raise DbtBouncerFailedCheckError("self.manifest_obj is None")
+        child_map = self.manifest_obj.manifest.child_map
+        if child_map and self.model.unique_id in child_map:
+            downstream_models = [
+                x for x in child_map[self.model.unique_id] if x.startswith("model.")
+            ]
+        else:
+            downstream_models = []
+
+        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
-            )
+            node = self.manifest_obj.manifest.nodes.get(m)
+            refs = getattr(node, "refs", None)
+            if node and refs and isinstance(refs, list):
+                downstream_models_with_unversioned_refs.extend(
+                    m
+                    for ref in refs
+                    if getattr(ref, "name", None) == self.model.unique_id.split(".")[-1]
+                    and not getattr(ref, "version", None)
+                )
 
-        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}."
-        )
+        if downstream_models_with_unversioned_refs:
+            raise DbtBouncerFailedCheckError(
+                f"`{self.model.name}` is referenced without a pinned version in downstream models: {downstream_models_with_unversioned_refs}."
+            )
 
 
 class CheckModelsDocumentationCoverage(BaseModel):
     """Set the minimum percentage of models that have a populated description.
 
     Parameters:
+        min_description_length (int | None): Minimum length required for the description to be considered populated.
         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`.
+        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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -1489,16 +1816,21 @@ class CheckModelsDocumentationCoverage(BaseModel):
             - name: check_model_documentation_coverage
               min_model_documentation_coverage_pct: 90
         ```
+        ```yaml
+        manifest_checks:
+            - name: check_model_documentation_coverage
+              min_description_length: 25 # Setting a stricter requirement for description length
+        ```
 
     """
 
     model_config = ConfigDict(extra="forbid")
 
-    description: Optional[str] = Field(
+    description: str | None = Field(
         default=None,
         description="Description of what the check does and why it is implemented.",
     )
-    index: Optional[int] = Field(
+    index: int | None = Field(
         default=None,
         description="Index to uniquely identify the check, calculated at runtime.",
     )
@@ -1507,19 +1839,26 @@ class CheckModelsDocumentationCoverage(BaseModel):
         ge=0,
         le=100,
     )
-    models: List["DbtBouncerModelBase"] = Field(default=[])
+    models: list["DbtBouncerModelBase"] = Field(default=[])
     name: Literal["check_model_documentation_coverage"]
-    severity: Optional[Literal["error", "warn"]] = Field(
+    severity: Literal["error", "warn"] | None = Field(
         default="error",
         description="Severity of the check, one of 'error' or 'warn'.",
     )
 
     def execute(self) -> None:
-        """Execute the check."""
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If documentation coverage is less than minimum.
+
+        """
         num_models = len(self.models)
         models_with_description = []
         for model in self.models:
-            if len(model.description.strip()) > 4:
+            if is_description_populated(
+                description=model.description or "", min_description_length=4
+            ):
                 models_with_description.append(model.unique_id)
 
         num_models_with_descriptions = len(models_with_description)
@@ -1527,11 +1866,10 @@ class CheckModelsDocumentationCoverage(BaseModel):
             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}%."
-        )
+        if model_description_coverage_pct < self.min_model_documentation_coverage_pct:
+            raise DbtBouncerFailedCheckError(
+                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}%."
+            )
 
 
 class CheckModelsTestCoverage(BaseModel):
@@ -1539,12 +1877,12 @@ class CheckModelsTestCoverage(BaseModel):
 
     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`.
+        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`.
+        description (str | None): Description of what the check does and why it is implemented.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
 
     Example(s):
@@ -1558,11 +1896,11 @@ class CheckModelsTestCoverage(BaseModel):
 
     model_config = ConfigDict(extra="forbid")
 
-    description: Optional[str] = Field(
+    description: str | None = Field(
         default=None,
         description="Description of what the check does and why it is implemented.",
     )
-    index: Optional[int] = Field(
+    index: int | None = Field(
         default=None,
         description="Index to uniquely identify the check, calculated at runtime.",
     )
@@ -1572,24 +1910,32 @@ class CheckModelsTestCoverage(BaseModel):
         ge=0,
         le=100,
     )
-    models: List["DbtBouncerModelBase"] = Field(default=[])
-    severity: Optional[Literal["error", "warn"]] = Field(
+    models: list["DbtBouncerModelBase"] = Field(default=[])
+    severity: Literal["error", "warn"] | None = Field(
         default="error",
         description="Severity of the check, one of 'error' or 'warn'.",
     )
-    tests: List["DbtBouncerTestBase"] = Field(default=[])
+    tests: list["DbtBouncerTestBase"] = Field(default=[])
 
     def execute(self) -> None:
-        """Execute the check."""
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If test coverage is less than minimum.
+
+        """
         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:
+                if test.depends_on and model.unique_id in getattr(
+                    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}%."
-        )
+        if model_test_coverage_pct < self.min_model_test_coverage_pct:
+            raise DbtBouncerFailedCheckError(
+                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}%."
+            )