lint fixes

Author: arbiv

elementary/clients/dbt/command_line_dbt_runner.py

@@ -51,10 +51,10 @@ def __init__(
         )
         self.raise_on_failure = raise_on_failure
         self.env_vars = env_vars
-        
+
         # Apply databricks compatibility patch for version 1.10.2
         self._apply_databricks_compatibility_patch()
-        
+
         if force_dbt_deps:
             self.deps()
         elif run_deps_if_needed:
@@ -322,83 +322,93 @@ def _run_deps_if_needed(self):
 
         if should_run_deps:
             self.deps()
-    
+
     def _apply_databricks_compatibility_patch(self):
         """Apply monkey patch to fix dbt-databricks 1.10.2 compatibility issues"""
         try:
-            from dbt.adapters.databricks import parse_model
-            import logging
-            
-            # Define safe wrapper functions
-            def is_unsupported_object(model):
+            from typing import Any, Optional
+
+            from dbt.adapters.databricks import parse_model  # type: ignore
+
+            def is_unsupported_object(model: Any) -> bool:
                 """Check if the object is a Macro or other unsupported type"""
-                return hasattr(model, '__class__') and 'Macro' in str(model.__class__)
-            
-            def safe_catalog_name(model):
+                return hasattr(model, "__class__") and "Macro" in str(model.__class__)
+
+            def safe_catalog_name(model: Any) -> str:
                 try:
                     if is_unsupported_object(model):
-                        logger.debug(f"Received unsupported object type for catalog_name, using unity as default")
-                        return 'unity'
+                        logger.debug(
+                            "Received unsupported object type for catalog_name, using unity as default"
+                        )
+                        return "unity"
                     # Handle RelationConfig objects
-                    if hasattr(model, 'config') and model.config and hasattr(model.config, 'get'):
-                        catalog = model.config.get('catalog')
+                    if (
+                        hasattr(model, "config")
+                        and model.config
+                        and hasattr(model.config, "get")
+                    ):
+                        catalog = model.config.get("catalog")
                         if catalog:
                             return catalog
                     # Fallback to unity catalog
-                    return 'unity'
+                    return "unity"
                 except Exception as e:
-                    logger.debug(f"Failed to parse catalog name from model: {e}. Using unity as default.")
-                    return 'unity'
-            
-            def safe_file_format(model):
+                    logger.debug(
+                        f"Failed to parse catalog name from model: {e}. Using unity as default."
+                    )
+                    return "unity"
+
+            def safe_file_format(model: Any) -> Optional[str]:
                 try:
                     if is_unsupported_object(model):
                         return None
-                    return safe_get(model, 'file_format')
+                    return safe_get(model, "file_format")
                 except Exception as e:
                     logger.debug(f"Failed to get file_format from model: {e}")
                     return None
-            
-            def safe_location_path(model):
+
+            def safe_location_path(model: Any) -> Optional[str]:
                 try:
                     if is_unsupported_object(model):
                         return None
-                    if not hasattr(model, 'config') or not model.config:
+                    if not hasattr(model, "config") or not model.config:
                         return None
-                    if model.config.get('include_full_name_in_path'):
+                    if model.config.get("include_full_name_in_path"):
                         return f"{model.database}/{model.schema}/{model.identifier}"
-                    return model.identifier if hasattr(model, 'identifier') else None
+                    return model.identifier if hasattr(model, "identifier") else None
                 except Exception as e:
                     logger.debug(f"Failed to get location_path from model: {e}")
                     return None
-            
-            def safe_location_root(model):
+
+            def safe_location_root(model: Any) -> Optional[str]:
                 try:
                     if is_unsupported_object(model):
                         return None
-                    return safe_get(model, 'location_root')
+                    return safe_get(model, "location_root")
                 except Exception as e:
                     logger.debug(f"Failed to get location_root from model: {e}")
                     return None
-            
-            def safe_table_format(model):
+
+            def safe_table_format(model: Any) -> Optional[str]:
                 try:
                     if is_unsupported_object(model):
                         return None
-                    return safe_get(model, 'table_format')
+                    return safe_get(model, "table_format")
                 except Exception as e:
                     logger.debug(f"Failed to get table_format from model: {e}")
                     return None
-            
-            def safe_get(model, setting: str, case_sensitive=False):
+
+            def safe_get(
+                model: Any, setting: str, case_sensitive: bool | None = False
+            ) -> str | None:
                 try:
                     if is_unsupported_object(model):
                         return None
                     # Check if model has config attribute
-                    if not hasattr(model, 'config') or not model.config:
+                    if not hasattr(model, "config") or not model.config:
                         return None
                     # Check if config has get method
-                    if not hasattr(model.config, 'get'):
+                    if not hasattr(model.config, "get"):
                         return None
                     value = model.config.get(setting)
                     if value:
@@ -407,17 +417,17 @@ def safe_get(model, setting: str, case_sensitive=False):
                 except Exception as e:
                     logger.debug(f"Failed to get {setting} from model config: {e}")
                     return None
-            
+
             # Replace problematic functions with safe versions
             parse_model.catalog_name = safe_catalog_name
             parse_model.file_format = safe_file_format
             parse_model.location_path = safe_location_path
             parse_model.location_root = safe_location_root
             parse_model.table_format = safe_table_format
             parse_model._get = safe_get
-                
+
             logger.debug("Applied dbt-databricks 1.10.2 compatibility patch")
-            
+
         except ImportError:
             # parse_model module doesn't exist in older versions
             pass