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

dbt_bouncer/checks/manifest/check_unit_tests.py

@@ -1,7 +1,7 @@
-# mypy: disable-error-code="union-attr"
 import logging
-from typing import TYPE_CHECKING, List, Literal, Optional
+from typing import TYPE_CHECKING, Literal
 
+import pytest
 from pydantic import BaseModel, ConfigDict, Field
 
 from dbt_bouncer.check_base import BaseCheck
@@ -11,16 +11,14 @@ if TYPE_CHECKING:
     from dbt_bouncer.artifact_parsers.dbt_cloud.manifest_latest import (
         UnitTests,
     )
-    from dbt_bouncer.artifact_parsers.parsers_common import DbtBouncerManifest
-
-from dbt_bouncer.utils import object_in_path
-
-if TYPE_CHECKING:
-    from dbt_bouncer.artifact_parsers.parsers_common import (
+    from dbt_bouncer.artifact_parsers.parsers_manifest import (
         DbtBouncerManifest,
         DbtBouncerModelBase,
     )
 
+from dbt_bouncer.checks.common import DbtBouncerFailedCheckError
+from dbt_bouncer.utils import object_in_path
+
 
 class CheckUnitTestCoverage(BaseModel):
     """Set the minimum percentage of models that have a unit test.
@@ -33,13 +31,13 @@ class CheckUnitTestCoverage(BaseModel):
         min_unit_test_coverage_pct (float): The minimum percentage of models that must have a unit test.
 
     Receives:
-        models (List[DbtBouncerModelBase]): List of DbtBouncerModelBase objects parsed from `manifest.json`.
-        unit_tests (List[UnitTests]): List of UnitTests objects parsed from `manifest.json`.
+        models (list[DbtBouncerModelBase]): List of DbtBouncerModelBase 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.
-        include (Optional[str]): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
-        severity (Optional[Literal["error", "warn"]]): Severity level of the check. Default: `error`.
+        description (str | None): Description of what the check does and why it is implemented.
+        include (str | None): Regex pattern to match the model path. Only model paths that match the pattern will be checked.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -51,36 +49,43 @@ class CheckUnitTestCoverage(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.",
     )
-    include: Optional[str] = Field(
+    include: str | None = Field(
         default=None,
         description="Regexp to match which paths to include.",
     )
-    index: Optional[int] = Field(
+    index: int | None = Field(
         default=None,
         description="Index to uniquely identify the check, calculated at runtime.",
     )
-    manifest_obj: "DbtBouncerManifest" = Field(default=None)
+    manifest_obj: "DbtBouncerManifest | None" = Field(default=None)
     min_unit_test_coverage_pct: int = Field(
         default=100,
         ge=0,
         le=100,
     )
-    models: List["DbtBouncerModelBase"] = Field(default=[])
+    models: list["DbtBouncerModelBase"] = Field(default=[])
     name: Literal["check_unit_test_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'.",
     )
-    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 unit test coverage is less than permitted minimum.
+
+        """
+        if self.manifest_obj is None:
+            raise DbtBouncerFailedCheckError("self.manifest_obj 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"):
             relevant_models = [
                 m.unique_id
@@ -89,18 +94,20 @@ class CheckUnitTestCoverage(BaseModel):
             ]
             models_with_unit_test = []
             for unit_test in self.unit_tests:
-                for node in unit_test.depends_on.nodes:
-                    if node in relevant_models:
-                        models_with_unit_test.append(node)
+                if unit_test.depends_on and unit_test.depends_on.nodes:
+                    for node in unit_test.depends_on.nodes:
+                        if node in relevant_models:
+                            models_with_unit_test.append(node)
 
             num_models_with_unit_tests = len(set(models_with_unit_test))
             unit_test_coverage_pct = (
                 num_models_with_unit_tests / len(relevant_models)
             ) * 100
 
-            assert unit_test_coverage_pct >= self.min_unit_test_coverage_pct, (
-                f"Only {unit_test_coverage_pct}% of models have a unit test, this is less than the permitted minimum of {self.min_unit_test_coverage_pct}%."
-            )
+            if unit_test_coverage_pct < self.min_unit_test_coverage_pct:
+                raise DbtBouncerFailedCheckError(
+                    f"Only {unit_test_coverage_pct}% of models have a unit test, this is less than the permitted minimum of {self.min_unit_test_coverage_pct}%."
+                )
         else:
             logging.warning(
                 "The `check_unit_test_expect_format` check is only supported for dbt 1.8.0 and above.",
@@ -115,17 +122,17 @@ class CheckUnitTestExpectFormats(BaseCheck):
         This check is only supported for dbt 1.8.0 and above.
 
     Parameters:
-        permitted_formats (Optional[List[Literal["csv", "dict", "sql"]]]): A list of formats that are allowed to be used for `expect` input in a unit test.
+        permitted_formats (list[Literal["csv", "dict", "sql"]] | None): A list of formats that are allowed to be used for `expect` input in a unit test.
 
     Receives:
         manifest_obj (DbtBouncerManifest): The DbtBouncerManifest object parsed from `manifest.json`.
         unit_test (UnitTests): The UnitTests 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 unit test path (i.e the .yml file where the unit test is configured). Unit test paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the unit test path (i.e the .yml file where the unit test is configured). Only unit test paths that match the pattern will be checked.
-        severity (Optional[Literal["error", "warn"]]): Severity level of the check. Default: `error`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the unit test path (i.e the .yml file where the unit test is configured). Unit test paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the unit test path (i.e the .yml file where the unit test is configured). Only unit test paths that match the pattern will be checked.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -137,21 +144,45 @@ class CheckUnitTestExpectFormats(BaseCheck):
 
     """
 
-    manifest_obj: "DbtBouncerManifest" = Field(default=None)
+    manifest_obj: "DbtBouncerManifest | None" = Field(default=None)
     name: Literal["check_unit_test_expect_format"]
-    permitted_formats: List[Literal["csv", "dict", "sql"]] = Field(
+    permitted_formats: list[Literal["csv", "dict", "sql"]] = Field(
         default=["csv", "dict", "sql"],
     )
-    unit_test: "UnitTests" = Field(default=None)
+    unit_test: "UnitTests | None" = Field(default=None)
 
     def execute(self) -> None:
-        """Execute the check."""
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If unit test expect format is not permitted.
+
+        """
+        if self.manifest_obj is None:
+            raise DbtBouncerFailedCheckError("self.manifest_obj is None")
+        if self.unit_test is None:
+            raise DbtBouncerFailedCheckError("self.unit_test 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"):
-            assert self.unit_test.expect.format.value in self.permitted_formats, (
-                f"Unit test `{self.unit_test.name}` has an `expect` format that is not permitted. Permitted formats are: {self.permitted_formats}."
+            if self.unit_test.expect.format is None:
+                pytest.fail(
+                    f"Unit test `{self.unit_test.name}` does not have an `expect` format defined. "
+                    f"Permitted formats are: {self.permitted_formats}."
+                )
+
+            format_value = (
+                self.unit_test.expect.format.value
+                if self.unit_test.expect.format
+                else None
             )
+
+            if format_value not in self.permitted_formats:
+                raise DbtBouncerFailedCheckError(
+                    f"Unit test `{self.unit_test.name}` has an `expect` format that is not permitted. "
+                    f"Permitted formats are: {self.permitted_formats}. "
+                    f"Found: {format_value}"
+                )
         else:
             logging.warning(
                 "The `check_unit_test_expect_format` check is only supported for dbt 1.8.0 and above.",
@@ -166,17 +197,17 @@ class CheckUnitTestGivenFormats(BaseCheck):
         This check is only supported for dbt 1.8.0 and above.
 
     Parameters:
-        permitted_formats (Optional[List[Literal["csv", "dict", "sql"]]]): A list of formats that are allowed to be used for `expect` input in a unit test.
+        permitted_formats (list[Literal["csv", "dict", "sql"]] | None): A list of formats that are allowed to be used for `expect` input in a unit test.
 
     Receives:
         manifest_obj (DbtBouncerManifest): The DbtBouncerManifest object parsed from `manifest.json`.
         unit_test (UnitTests): The UnitTests 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 unit test path (i.e the .yml file where the unit test is configured). Unit test paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the unit test path (i.e the .yml file where the unit test is configured). Only unit test paths that match the pattern will be checked.
-        severity (Optional[Literal["error", "warn"]]): Severity level of the check. Default: `error`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the unit test path (i.e the .yml file where the unit test is configured). Unit test paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the unit test path (i.e the .yml file where the unit test is configured). Only unit test paths that match the pattern will be checked.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -188,22 +219,34 @@ class CheckUnitTestGivenFormats(BaseCheck):
 
     """
 
-    manifest_obj: "DbtBouncerManifest" = Field(default=None)
+    manifest_obj: "DbtBouncerManifest | None" = Field(default=None)
     name: Literal["check_unit_test_given_formats"]
-    permitted_formats: List[Literal["csv", "dict", "sql"]] = Field(
+    permitted_formats: list[Literal["csv", "dict", "sql"]] = Field(
         default=["csv", "dict", "sql"],
     )
-    unit_test: "UnitTests" = Field(default=None)
+    unit_test: "UnitTests | None" = Field(default=None)
 
     def execute(self) -> None:
-        """Execute the check."""
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If unit test given formats are not permitted.
+
+        """
+        if self.manifest_obj is None:
+            raise DbtBouncerFailedCheckError("self.manifest_obj is None")
+        if self.unit_test is None:
+            raise DbtBouncerFailedCheckError("self.unit_test 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"):
-            given_formats = [i.format.value for i in self.unit_test.given]
-            assert all(e in self.permitted_formats for e in given_formats), (
-                f"Unit test `{self.unit_test.name}` has given formats which are not permitted. Permitted formats are: {self.permitted_formats}."
-            )
+            given_formats = [
+                i.format.value for i in self.unit_test.given if i.format is not None
+            ]
+            if not all(e in self.permitted_formats for e in given_formats):
+                raise DbtBouncerFailedCheckError(
+                    f"Unit test `{self.unit_test.name}` has given formats which are not permitted. Permitted formats are: {self.permitted_formats}."
+                )
         else:
             logging.warning(
                 "The `check_unit_test_given_formats` check is only supported for dbt 1.8.0 and above.",

dbt_bouncer/checks/run_results/check_run_results.py

@@ -1,6 +1,4 @@
-# mypy: disable-error-code="union-attr"
-
-from typing import TYPE_CHECKING, Literal, Optional
+from typing import TYPE_CHECKING, Literal
 
 from pydantic import Field
 
@@ -9,6 +7,8 @@ from dbt_bouncer.check_base import BaseCheck
 if TYPE_CHECKING:
     from dbt_bouncer.artifact_parsers.parsers_run_results import DbtBouncerRunResultBase
 
+from dbt_bouncer.checks.common import DbtBouncerFailedCheckError
+
 
 class CheckRunResultsMaxExecutionTime(BaseCheck):
     """Each result can take a maximum duration (seconds).
@@ -20,10 +20,10 @@ class CheckRunResultsMaxExecutionTime(BaseCheck):
         run_result (DbtBouncerRunResult): The DbtBouncerRunResult 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 resource path. Resource paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the resource path. Only resource paths that match the pattern will be checked.
-        severity (Optional[Literal["error", "warn"]]): Severity level of the check. Default: `error`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the resource path. Resource paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the resource path. Only resource paths that match the pattern will be checked.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Example(s):
         ```yaml
@@ -42,13 +42,22 @@ class CheckRunResultsMaxExecutionTime(BaseCheck):
 
     max_execution_time_seconds: float
     name: Literal["check_run_results_max_execution_time"]
-    run_result: Optional["DbtBouncerRunResultBase"] = Field(default=None)
+    run_result: "DbtBouncerRunResultBase | None" = Field(default=None)
 
     def execute(self) -> None:
-        """Execute the check."""
-        assert self.run_result.execution_time <= self.max_execution_time_seconds, (
-            f"`{self.run_result.unique_id.split('.')[-1]}` has an execution time ({self.run_result.execution_time} greater than permitted ({self.max_execution_time_seconds}s)."
-        )
+        """Execute the check.
+
+        Raises:
+            DbtBouncerFailedCheckError: If execution time is greater than permitted.
+
+        """
+        if self.run_result is None:
+            raise DbtBouncerFailedCheckError("self.run_result is None")
+
+        if self.run_result.execution_time > self.max_execution_time_seconds:
+            raise DbtBouncerFailedCheckError(
+                f"`{self.run_result.unique_id.split('.')[-1]}` has an execution time ({self.run_result.execution_time} greater than permitted ({self.max_execution_time_seconds}s)."
+            )
 
 
 class CheckRunResultsMaxGigabytesBilled(BaseCheck):
@@ -63,10 +72,10 @@ class CheckRunResultsMaxGigabytesBilled(BaseCheck):
         run_result (DbtBouncerRunResult): The DbtBouncerRunResult 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 resource path. Resource paths that match the pattern will not be checked.
-        include (Optional[str]): Regex pattern to match the resource path. Only resource paths that match the pattern will be checked.
-        severity (Optional[Literal["error", "warn"]]): Severity level of the check. Default: `error`.
+        description (str | None): Description of what the check does and why it is implemented.
+        exclude (str | None): Regex pattern to match the resource path. Resource paths that match the pattern will not be checked.
+        include (str | None): Regex pattern to match the resource path. Only resource paths that match the pattern will be checked.
+        severity (Literal["error", "warn"] | None): Severity level of the check. Default: `error`.
 
     Raises: # noqa:DOC502
         KeyError: If the `dbt-bigquery` adapter is not used.
@@ -83,15 +92,19 @@ class CheckRunResultsMaxGigabytesBilled(BaseCheck):
 
     max_gigabytes_billed: float
     name: Literal["check_run_results_max_gigabytes_billed"]
-    run_result: Optional["DbtBouncerRunResultBase"] = Field(default=None)
+    run_result: "DbtBouncerRunResultBase | None" = Field(default=None)
 
     def execute(self) -> None:
         """Execute the check.
 
         Raises:
+            DbtBouncerFailedCheckError: If gigabytes billed is greater than permitted.
             RuntimeError: If running with adapter other than `dbt-bigquery`.
 
         """
+        if self.run_result is None:
+            raise DbtBouncerFailedCheckError("self.run_result is None")
+
         try:
             gigabytes_billed = self.run_result.adapter_response["bytes_billed"] / (
                 1000**3
@@ -101,6 +114,7 @@ class CheckRunResultsMaxGigabytesBilled(BaseCheck):
                 "`bytes_billed` not found in adapter response. Are you using the `dbt-bigquery` adapter?",
             ) from e
 
-        assert gigabytes_billed < self.max_gigabytes_billed, (
-            f"`{self.run_result.unique_id.split('.')[-2]}` results in ({gigabytes_billed} billed bytes, this is greater than permitted ({self.max_gigabytes_billed})."
-        )
+        if gigabytes_billed > self.max_gigabytes_billed:
+            raise DbtBouncerFailedCheckError(
+                f"`{self.run_result.unique_id.split('.')[-2]}` results in ({gigabytes_billed} billed bytes, this is greater than permitted ({self.max_gigabytes_billed})."
+            )

dbt_bouncer/config_file_parser.py

@@ -1,46 +1,65 @@
+import inspect
+import operator
 import os
+from functools import reduce
 from pathlib import Path
-from typing import Any, Dict, List, Literal, Optional, Union
+from typing import Any, Literal
 
+import click
 from pydantic import BaseModel, ConfigDict, Field
 from typing_extensions import Annotated
 
-from dbt_bouncer.utils import clean_path_str
+from dbt_bouncer.global_context import get_context
+from dbt_bouncer.utils import clean_path_str, get_check_objects
 
 
 def get_check_types(
-    check_type: List[
+    check_type: list[
         Literal["catalog_checks", "manifest_checks", "run_results_checks"]
     ],
-) -> List[Any]:
+) -> list[Any]:
     """Get the check types from the check categories.
 
     Args:
-        check_type: List[Literal["catalog_checks", "manifest_checks", "run_results_checks"]]
+        check_type: list[Literal["catalog_checks", "manifest_checks", "run_results_checks"]]
 
     Returns:
-        List[str]: The check types.
+        list[str]: The check types.
 
     """
-    from dbt_bouncer.utils import get_check_objects
-
-    check_classes: List[Dict[str, Union[Any, Path]]] = [
+    try:
+        ctx = get_context()
+        if ctx:
+            config_file_path = ctx.config_file_path
+            custom_checks_dir = ctx.custom_checks_dir
+        else:
+            click_ctx = click.get_current_context()
+            config_file_path = click_ctx.obj.get("config_file_path")
+            custom_checks_dir = click_ctx.obj.get("custom_checks_dir")
+
+        if custom_checks_dir:
+            custom_checks_dir = config_file_path.parent / custom_checks_dir
+    except (RuntimeError, AttributeError, KeyError):
+        custom_checks_dir = None
+
+    check_classes: list[dict[str, Any | Path]] = [
         {
-            "class": getattr(x, x.__name__),
-            "source_file": Path(clean_path_str(x.__file__)),
+            "class": x,
+            "source_file": Path(clean_path_str(inspect.getfile(x))),
         }
-        for x in get_check_objects()
+        for x in get_check_objects(custom_checks_dir)
+    ]
+
+    filtered_classes = [
+        x["class"] for x in check_classes if x["source_file"].parts[-2] == check_type
     ]
-    return List[  # type: ignore[misc, return-value]
+    if not filtered_classes:
+        return list[Any]  # type: ignore[return-value]
+
+    return list[  # type: ignore[misc, return-value]
         Annotated[
             Annotated[
-                Union[
-                    tuple(
-                        x["class"]
-                        for x in check_classes
-                        if x["source_file"].parts[-2] == check_type
-                    )
-                ],
+                reduce(operator.or_, filtered_classes),  # type: ignore
                 Field(discriminator="name"),
             ],
             Field(discriminator="name"),
@@ -53,29 +72,29 @@ class DbtBouncerConfBase(BaseModel):
 
     model_config = ConfigDict(extra="forbid")
 
-    custom_checks_dir: Optional[str] = Field(
+    custom_checks_dir: str | None = Field(
         default=None,
         description="Path to a directory containing custom checks.",
     )
-    dbt_artifacts_dir: Optional[str] = Field(
-        default=(
+    dbt_artifacts_dir: str | None = Field(
+        default_factory=lambda: (
             f"{os.getenv('DBT_PROJECT_DIR')}/target"
             if os.getenv("DBT_PROJECT_DIR")
             else "./target"
         )
     )
-    exclude: Optional[str] = Field(
+    exclude: str | None = Field(
         default=None,
         description="Regexp to match which paths to exclude.",
     )
-    include: Optional[str] = Field(
+    include: str | None = Field(
         default=None,
         description="Regexp to match which paths to include.",
     )
-    package_name: Optional[str] = Field(
+    package_name: str | None = Field(
         default=None, description="If you want to run `dbt-bouncer` against a package."
     )
-    severity: Union[Literal["error", "warn"], None] = Field(
+    severity: Literal["error", "warn"] | None = Field(
         default=None,
         description="Severity of the check, one of 'error' or 'warn'.",
     )
@@ -90,7 +109,7 @@ class DbtBouncerConfAllCategories(DbtBouncerConfBase):
     manifest_checks: get_check_types(check_type="manifest") = Field(default=[])  # type: ignore[valid-type]
     run_results_checks: get_check_types(check_type="run_results") = Field(default=[])  # type: ignore[valid-type]
 
-    custom_checks_dir: Optional[str] = Field(
+    custom_checks_dir: str | None = Field(
         default=None,
         description="Path to a directory containing custom checks.",
     )

dbt_bouncer/config_file_validator.py

@@ -1,8 +1,9 @@
 import logging
 import os
 import re
+from collections.abc import Mapping
 from pathlib import Path, PurePath
-from typing import TYPE_CHECKING, Any, Dict, List, Literal, Mapping, Optional
+from typing import TYPE_CHECKING, Any, Literal
 
 import click
 import toml
@@ -29,14 +30,14 @@ DEFAULT_DBT_BOUNCER_CONFIG = """manifest_checks:
 
 
 def conf_cls_factory(
-    check_categories: List[
+    check_categories: list[
         Literal["catalog_checks", "manifest_checks", "run_results_checks"]
     ],
 ):
     """Return the appropriate configuration class based on the check categories.
 
     Args:
-        check_categories: List[Literal["catalog_checks", "manifest_checks", "run_results_checks"]]
+        check_categories: list[Literal["catalog_checks", "manifest_checks", "run_results_checks"]]
 
     Raises:
         ValueError: If the check categories are not valid.
@@ -144,7 +145,7 @@ def get_config_file_path(
 
 def load_config_file_contents(
     config_file_path: PurePath,
-    allow_default_config_file_creation: Optional[bool] = None,
+    allow_default_config_file_creation: bool | None = None,
 ) -> Mapping[str, Any]:
     """Load the contents of the config file.
 
@@ -160,7 +161,7 @@ def load_config_file_contents(
 
     """
     if config_file_path.suffix in [".yml", ".yaml"]:
-        return load_config_from_yaml(config_file_path)
+        return load_config_from_yaml(Path(config_file_path))
     elif config_file_path.suffix in [".toml"]:
         toml_cfg = toml.load(config_file_path)
         if "dbt-bouncer" in toml_cfg["tool"]:
@@ -200,8 +201,8 @@ def load_config_file_contents(
 
 
 def validate_conf(
-    check_categories,  #: List[Literal["catalog_checks"], Literal["manifest_checks"], Literal["run_results_checks"]],
-    config_file_contents: Dict[str, Any],
+    check_categories,  #: list[Literal["catalog_checks"], Literal["manifest_checks"], Literal["run_results_checks"]],
+    config_file_contents: dict[str, Any],
 ) -> "DbtBouncerConf":
     """Validate the configuration and return the Pydantic model.
 
@@ -249,6 +250,8 @@ def validate_conf(
             DbtBouncerManifest,
             DbtBouncerModel,
             DbtBouncerModelBase,
+            DbtBouncerSeed,
+            DbtBouncerSeedBase,
             DbtBouncerSemanticModel,
             DbtBouncerSemanticModelBase,
             DbtBouncerSnapshot,
@@ -273,7 +276,7 @@ def validate_conf(
     except ValidationError as e:
         import jellyfish
 
-        error_message: List[str] = []
+        error_message: list[str] = []
         for error in e.errors():
             if (
                 re.compile(

dbt_bouncer/global_context.py

@@ -0,0 +1,31 @@
+from pathlib import PurePath
+
+
+class BouncerContext:
+    """Context object for dbt-bouncer."""
+
+    def __init__(
+        self, config_file_path: PurePath, custom_checks_dir: str | None
+    ) -> None:
+        """Initialize the context."""
+        self.config_file_path = config_file_path
+        self.custom_checks_dir = custom_checks_dir
+
+
+_context: BouncerContext | None = None
+
+
+def set_context(ctx: BouncerContext) -> None:
+    """Set the global context."""
+    global _context
+    _context = ctx
+
+
+def get_context() -> BouncerContext | None:
+    """Get the global context.
+
+    Returns:
+        BouncerContext | None: The global context if set, else None.
+
+    """
+    return _context