DataDiff prefix

Author: dlawin

data_diff/dbt_parser.py

@@ -12,18 +12,18 @@
 from dbt.config.renderer import ProfileRenderer
 
 from data_diff.errors import (
-    DbtBigQueryOauthOnlyError,
-    DbtConnectionNotImplementedError,
-    DbtCoreNoRunnerError,
-    DbtNoSuccessfulModelsInRunError,
-    DbtProfileNotFoundError,
-    DbtProjectVarsNotFoundError,
-    DbtRedshiftPasswordOnlyError,
-    DbtRunResultsVersionError,
-    DbtSelectNoMatchingModelsError,
-    DbtSelectUnexpectedError,
-    DbtSelectVersionTooLowError,
-    DbtSnowflakeSetConnectionError,
+    DataDiffDbtBigQueryOauthOnlyError,
+    DataDiffDbtConnectionNotImplementedError,
+    DataDiffDbtCoreNoRunnerError,
+    DataDiffDbtNoSuccessfulModelsInRunError,
+    DataDiffDbtProfileNotFoundError,
+    DataDiffDbtProjectVarsNotFoundError,
+    DataDiffDbtRedshiftPasswordOnlyError,
+    DataDiffDbtRunResultsVersionError,
+    DataDiffDbtSelectNoMatchingModelsError,
+    DataDiffDbtSelectUnexpectedError,
+    DataDiffDbtSelectVersionTooLowError,
+    DataDiffDbtSnowflakeSetConnectionError,
 )
 
 from .utils import getLogger, get_from_dict_with_raise
@@ -108,7 +108,7 @@ def __init__(self, profiles_dir_override: str, project_dir_override: str) -> Non
 
     def get_datadiff_variables(self) -> dict:
         doc_url = "https://docs.datafold.com/development_testing/open_source#configure-your-dbt-project"
-        exception = DbtProjectVarsNotFoundError(
+        exception = DataDiffDbtProjectVarsNotFoundError(
             f"vars: data_diff: section not found in dbt_project.yml.\n\nTo solve this, please configure your dbt project: \n{doc_url}\n"
         )
         vars_dict = get_from_dict_with_raise(self.project_dict, "vars", exception)
@@ -137,11 +137,11 @@ def get_models(self, dbt_selection: Optional[str] = None):
                     return self.get_dbt_selection_models(dbt_selection)
                 # edge case if running data-diff from a separate env than dbt (likely local development)
                 else:
-                    raise DbtCoreNoRunnerError(
+                    raise DataDiffDbtCoreNoRunnerError(
                         "data-diff is using a dbt-core version < 1.5, update the environment's dbt-core version via pip install 'dbt-core>=1.5' in order to use `--select`"
                     )
             else:
-                raise DbtSelectVersionTooLowError(
+                raise DataDiffDbtSelectVersionTooLowError(
                     f"The `--select` feature requires dbt >= 1.5, but your project's manifest.json is from dbt v{dbt_version}. Please follow these steps to use the `--select` feature: \n 1. Update your dbt-core version via pip install 'dbt-core>=1.5'. Details: https://docs.getdbt.com/docs/core/pip-install#change-dbt-core-versions \n 2. Execute any `dbt` command (`run`, `compile`, `build`) to create a new manifest.json."
                 )
         else:
@@ -178,10 +178,10 @@ def get_dbt_selection_models(self, dbt_selection: str) -> List[str]:
             return models
 
         if not results.result:
-            raise DbtSelectNoMatchingModelsError(f"No dbt models found for `--select {dbt_selection}`")
+            raise DataDiffDbtSelectNoMatchingModelsError(f"No dbt models found for `--select {dbt_selection}`")
 
         logger.debug(str(results))
-        raise DbtSelectUnexpectedError("Encountered an unexpected error while finding `--select` models")
+        raise DataDiffDbtSelectUnexpectedError("Encountered an unexpected error while finding `--select` models")
 
     def get_run_results_models(self):
         with open(self.project_dir / RUN_RESULTS_PATH) as run_results:
@@ -195,7 +195,7 @@ def get_run_results_models(self):
             self.profiles_dir = legacy_profiles_dir()
 
         if dbt_version < parse_version(LOWER_DBT_V):
-            raise DbtRunResultsVersionError(
+            raise DataDiffDbtRunResultsVersionError(
                 f"Found dbt: v{dbt_version} Expected the dbt project's version to be >= {LOWER_DBT_V}"
             )
         if dbt_version >= parse_version(UPPER_DBT_V):
@@ -206,7 +206,7 @@ def get_run_results_models(self):
         success_models = [x.unique_id for x in run_results_obj.results if x.status.name == "success"]
         models = [self.manifest_obj.nodes.get(x) for x in success_models]
         if not models:
-            raise DbtNoSuccessfulModelsInRunError("Expected > 0 successful models runs from the last dbt command.")
+            raise DataDiffDbtNoSuccessfulModelsInRunError("Expected > 0 successful models runs from the last dbt command.")
 
         print(f"Running with data-diff={__version__}\n")
         return models
@@ -235,31 +235,31 @@ def get_connection_creds(self) -> Tuple[Dict[str, str], str]:
         profile = get_from_dict_with_raise(
             profiles,
             dbt_profile_var,
-            DbtProfileNotFoundError(f"No profile '{dbt_profile_var}' found in '{profiles_path}'."),
+            DataDiffDbtProfileNotFoundError(f"No profile '{dbt_profile_var}' found in '{profiles_path}'."),
         )
         # values can contain env_vars
         rendered_profile = ProfileRenderer().render_data(profile)
         profile_target = get_from_dict_with_raise(
             rendered_profile,
             "target",
-            DbtProfileNotFoundError(f"No target found in profile '{dbt_profile_var}' in '{profiles_path}'."),
+            DataDiffDbtProfileNotFoundError(f"No target found in profile '{dbt_profile_var}' in '{profiles_path}'."),
         )
         outputs = get_from_dict_with_raise(
             rendered_profile,
             "outputs",
-            DbtProfileNotFoundError(f"No outputs found in profile '{dbt_profile_var}' in '{profiles_path}'."),
+            DataDiffDbtProfileNotFoundError(f"No outputs found in profile '{dbt_profile_var}' in '{profiles_path}'."),
         )
         credentials = get_from_dict_with_raise(
             outputs,
             profile_target,
-            DbtProfileNotFoundError(
+            DataDiffDbtProfileNotFoundError(
                 f"No credentials found for target '{profile_target}' in profile '{dbt_profile_var}' in '{profiles_path}'."
             ),
         )
         conn_type = get_from_dict_with_raise(
             credentials,
             "type",
-            DbtProfileNotFoundError(
+            DataDiffDbtProfileNotFoundError(
                 f"No type found for target '{profile_target}' in profile '{dbt_profile_var}' in '{profiles_path}'."
             ),
         )
@@ -287,7 +287,7 @@ def set_connection(self):
 
             if credentials.get("private_key_path") is not None:
                 if credentials.get("password") is not None:
-                    raise DbtSnowflakeSetConnectionError("Cannot use password and key at the same time")
+                    raise DataDiffDbtSnowflakeSetConnectionError("Cannot use password and key at the same time")
                 conn_info["key"] = credentials.get("private_key_path")
                 conn_info["private_key_passphrase"] = credentials.get("private_key_passphrase")
             elif credentials.get("authenticator") is not None:
@@ -296,13 +296,13 @@ def set_connection(self):
             elif credentials.get("password") is not None:
                 conn_info["password"] = credentials.get("password")
             else:
-                raise DbtSnowflakeSetConnectionError("Snowflake: unsupported auth method")
+                raise DataDiffDbtSnowflakeSetConnectionError("Snowflake: unsupported auth method")
         elif conn_type == "bigquery":
             method = credentials.get("method")
             # there are many connection types https://docs.getdbt.com/reference/warehouse-setups/bigquery-setup#oauth-via-gcloud
             # this assumes that the user is auth'd via `gcloud auth application-default login`
             if method is None or method != "oauth":
-                raise DbtBigQueryOauthOnlyError("Oauth is the current method supported for Big Query.")
+                raise DataDiffDbtBigQueryOauthOnlyError("Oauth is the current method supported for Big Query.")
             conn_info = {
                 "driver": conn_type,
                 "project": credentials.get("project"),
@@ -318,7 +318,7 @@ def set_connection(self):
             if (credentials.get("pass") is None and credentials.get("password") is None) or credentials.get(
                 "method"
             ) == "iam":
-                raise DbtRedshiftPasswordOnlyError("Only password authentication is currently supported for Redshift.")
+                raise DataDiffDbtRedshiftPasswordOnlyError("Only password authentication is currently supported for Redshift.")
             conn_info = {
                 "driver": conn_type,
                 "host": credentials.get("host"),
@@ -349,7 +349,7 @@ def set_connection(self):
             }
             self.threads = credentials.get("threads")
         else:
-            raise DbtConnectionNotImplementedError(f"Provider {conn_type} is not yet supported for dbt diffs")
+            raise DataDiffDbtConnectionNotImplementedError(f"Provider {conn_type} is not yet supported for dbt diffs")
 
         self.connection = conn_info
 

data_diff/errors.py

@@ -1,46 +1,46 @@
-class DbtProjectVarsNotFoundError(Exception):
+class DataDiffDbtProjectVarsNotFoundError(Exception):
     "Raised when an expected dbt_project.yml section is missing."
 
 
-class DbtProfileNotFoundError(Exception):
+class DataDiffDbtProfileNotFoundError(Exception):
     "Raised when an expected profiles.yml section is missing."
 
 
-class DbtNoSuccessfulModelsInRunError(Exception):
+class DataDiffDbtNoSuccessfulModelsInRunError(Exception):
     "Raised when there are no successful model runs in the run_results.json"
 
 
-class DbtRunResultsVersionError(Exception):
+class DataDiffDbtRunResultsVersionError(Exception):
     "Raised when the dbt version in run_results.json is lower than the minimum version."
 
 
-class DbtSelectNoMatchingModelsError(Exception):
+class DataDiffDbtSelectNoMatchingModelsError(Exception):
     "Raised when the `--select` flag returns no models."
 
 
-class DbtSelectUnexpectedError(Exception):
+class DataDiffDbtSelectUnexpectedError(Exception):
     "Catch all for unexpected dbt list --select results."
 
 
-class DbtSnowflakeSetConnectionError(Exception):
+class DataDiffDbtSnowflakeSetConnectionError(Exception):
     "Raised when a dbt snowflake profile has unexpected values."
 
 
-class DbtBigQueryOauthOnlyError(Exception):
+class DataDiffDbtBigQueryOauthOnlyError(Exception):
     "Raised when trying to use a method other than oauth with BigQuery."
 
 
-class DbtRedshiftPasswordOnlyError(Exception):
+class DataDiffDbtRedshiftPasswordOnlyError(Exception):
     "Raised when using a non-password connection method with Redshift."
 
 
-class DbtConnectionNotImplementedError(Exception):
+class DataDiffDbtConnectionNotImplementedError(Exception):
     "Raised when trying to use an unsupported dbt connection method."
 
 
-class DbtCoreNoRunnerError(Exception):
+class DataDiffDbtCoreNoRunnerError(Exception):
     "Raised when the manifest version >= 1.5, but the dbt-core package is < 1.5. This is an edge case most likely to occur in development."
 
 
-class DbtSelectVersionTooLowError(Exception):
+class DataDiffDbtSelectVersionTooLowError(Exception):
     "Raised when attempting to use `--select` with a dbt-core version < 1.5."