fix: updated for pre-commitfixes and PR's copilot autofixes

Author: rupali-atlan

application_sdk/clients/azure/__init__.py

@@ -15,25 +15,22 @@
 from .azure_auth import AzureAuthProvider
 from .azure_services import AzureStorageClient
 from .azure_utils import (
-    parse_azure_url,
-    validate_azure_credentials,
     build_azure_connection_string,
     extract_azure_resource_info,
-    validate_azure_permissions,
-    get_azure_service_endpoint,
     format_azure_error_message,
+    get_azure_service_endpoint,
+    parse_azure_url,
+    validate_azure_credentials,
+    validate_azure_permissions,
 )
 
 __all__ = [
     # Main client
     "AzureClient",
-    
     # Authentication
     "AzureAuthProvider",
-    
     # Service-specific clients
     "AzureStorageClient",
-    
     # Utilities
     "parse_azure_url",
     "validate_azure_credentials",
@@ -44,4 +41,4 @@
     "format_azure_error_message",
 ]
 
-__version__ = "0.1.0" 
+__version__ = "0.1.0"

application_sdk/clients/azure/azure.py

@@ -8,16 +8,16 @@
 
 import asyncio
 from concurrent.futures import ThreadPoolExecutor
-from typing import Any, Dict, Optional, Type
+from typing import Any, Dict, Optional
 
+from azure.core.credentials import TokenCredential
 from azure.core.exceptions import AzureError, ClientAuthenticationError
-from azure.identity import DefaultAzureCredential
 
 from application_sdk.clients import ClientInterface
 from application_sdk.clients.azure.azure_auth import AzureAuthProvider
 from application_sdk.clients.azure.azure_services import AzureStorageClient
-from application_sdk.common.error_codes import ClientError, CommonError
 from application_sdk.common.credential_utils import resolve_credentials
+from application_sdk.common.error_codes import ClientError
 from application_sdk.observability.logger_adaptor import get_logger
 
 logger = get_logger(__name__)
@@ -26,11 +26,11 @@
 class AzureClient(ClientInterface):
     """
     Main Azure client for the application-sdk framework.
-    
+
     This client provides a unified interface for connecting to and interacting
     with Azure Storage services. It supports Service Principal authentication
     and provides service-specific subclients for different Azure services.
-    
+
     Attributes:
         credentials (Dict[str, Any]): Azure connection credentials
         resolved_credentials (Dict[str, Any]): Resolved credentials after processing
@@ -58,7 +58,7 @@ def __init__(
         """
         self.credentials = credentials or {}
         self.resolved_credentials: Dict[str, Any] = {}
-        self.credential: Optional[DefaultAzureCredential] = None
+        self.credential: Optional[TokenCredential] = None
         self.auth_provider = AzureAuthProvider()
         self._services: Dict[str, Any] = {}
         self._executor = ThreadPoolExecutor(max_workers=max_workers)
@@ -82,22 +82,21 @@ async def load(self, credentials: Optional[Dict[str, Any]] = None) -> None:
 
         try:
             logger.info("Loading Azure client...")
-            
+
             # Resolve credentials using framework's credential resolution
             self.resolved_credentials = await resolve_credentials(self.credentials)
-            
+
             # Create Azure credential using Service Principal authentication
             self.credential = await self.auth_provider.create_credential(
-                auth_type="service_principal",
-                credentials=self.resolved_credentials
+                auth_type="service_principal", credentials=self.resolved_credentials
             )
-            
+
             # Test the connection
             await self._test_connection()
-            
+
             self._connection_health = True
             logger.info("Azure client loaded successfully")
-            
+
         except ClientAuthenticationError as e:
             logger.error(f"Azure authentication failed: {str(e)}")
             raise ClientError(f"{ClientError.CLIENT_AUTH_ERROR}: {str(e)}")
@@ -112,28 +111,28 @@ async def close(self) -> None:
         """Close Azure connections and clean up resources."""
         try:
             logger.info("Closing Azure client...")
-            
+
             # Close all service clients
             for service_name, service_client in self._services.items():
                 try:
-                    if hasattr(service_client, 'close'):
+                    if hasattr(service_client, "close"):
                         await service_client.close()
-                    elif hasattr(service_client, 'disconnect'):
+                    elif hasattr(service_client, "disconnect"):
                         await service_client.disconnect()
                 except Exception as e:
                     logger.warning(f"Error closing {service_name} client: {str(e)}")
-            
+
             # Clear service cache
             self._services.clear()
-            
+
             # Shutdown executor
             self._executor.shutdown(wait=True)
-            
+
             # Reset connection health
             self._connection_health = False
-            
+
             logger.info("Azure client closed successfully")
-            
+
         except Exception as e:
             logger.error(f"Error closing Azure client: {str(e)}")
 
@@ -149,18 +148,17 @@ async def get_storage_client(self) -> AzureStorageClient:
         """
         if not self._connection_health:
             raise ClientError(f"{ClientError.CLIENT_AUTH_ERROR}: Client not loaded")
-        
+
         if "storage" not in self._services:
             try:
                 self._services["storage"] = AzureStorageClient(
-                    credential=self.credential,
-                    **self._kwargs
+                    credential=self.credential, **self._kwargs
                 )
                 await self._services["storage"].load(self.resolved_credentials)
             except Exception as e:
                 logger.error(f"Failed to create storage client: {str(e)}")
                 raise ClientError(f"{ClientError.CLIENT_AUTH_ERROR}: {str(e)}")
-        
+
         return self._services["storage"]
 
     async def get_service_client(self, service_type: str) -> Any:
@@ -181,10 +179,10 @@ async def get_service_client(self, service_type: str) -> Any:
         service_mapping = {
             "storage": self.get_storage_client,
         }
-        
+
         if service_type not in service_mapping:
             raise ValueError(f"Unsupported service type: {service_type}")
-        
+
         return await service_mapping[service_type]()
 
     async def health_check(self) -> Dict[str, Any]:
@@ -197,33 +195,32 @@ async def health_check(self) -> Dict[str, Any]:
         health_status = {
             "connection_health": self._connection_health,
             "services": {},
-            "overall_health": False
+            "overall_health": False,
         }
-        
+
         if not self._connection_health:
             return health_status
-        
+
         # Check each service
         for service_name, service_client in self._services.items():
             try:
-                if hasattr(service_client, 'health_check'):
+                if hasattr(service_client, "health_check"):
                     service_health = await service_client.health_check()
                 else:
                     service_health = {"status": "unknown"}
-                
+
                 health_status["services"][service_name] = service_health
             except Exception as e:
                 health_status["services"][service_name] = {
                     "status": "error",
-                    "error": str(e)
+                    "error": str(e),
                 }
-        
+
         # Overall health is True if connection is healthy and at least one service is available
         health_status["overall_health"] = (
-            self._connection_health and 
-            len(health_status["services"]) > 0
+            self._connection_health and len(health_status["services"]) > 0
         )
-        
+
         return health_status
 
     async def _test_connection(self) -> None:
@@ -233,12 +230,17 @@ async def _test_connection(self) -> None:
         Raises:
             ClientAuthenticationError: If connection test fails.
         """
+        if not self.credential:
+            raise ClientAuthenticationError(
+                "No credential available for connection test"
+            )
+
         try:
             # Test the credential by getting a token
             await asyncio.get_event_loop().run_in_executor(
                 self._executor,
                 self.credential.get_token,
-                "https://management.azure.com/.default"
+                "https://management.azure.com/.default",
             )
         except Exception as e:
             raise ClientAuthenticationError(f"Connection test failed: {str(e)}")
@@ -249,4 +251,26 @@ def __enter__(self):
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         """Context manager exit."""
-        asyncio.create_task(self.close()) 
+        # Note: This is a synchronous context manager.
+        # For proper async cleanup, use the async context manager instead.
+        # This method is kept for backward compatibility but doesn't guarantee cleanup.
+        logger.warning(
+            "Using synchronous context manager. For proper async cleanup, "
+            "use 'async with AzureClient() as client:' instead."
+        )
+        # Schedule cleanup but don't wait for it
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                loop.create_task(self.close())
+        except RuntimeError:
+            # No event loop running, can't schedule async cleanup
+            logger.warning("No event loop running, async cleanup not possible")
+
+    async def __aenter__(self):
+        """Async context manager entry."""
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        await self.close()

application_sdk/clients/azure/azure_auth.py

@@ -9,8 +9,8 @@
 from typing import Any, Dict, Optional
 
 from azure.core.credentials import TokenCredential
-from azure.identity import ClientSecretCredential
 from azure.core.exceptions import ClientAuthenticationError
+from azure.identity import ClientSecretCredential
 
 from application_sdk.common.error_codes import CommonError
 from application_sdk.observability.logger_adaptor import get_logger
@@ -21,10 +21,10 @@
 class AzureAuthProvider:
     """
     Azure authentication provider for handling Service Principal authentication.
-    
+
     This class provides a unified interface for creating Azure credentials
     using Service Principal authentication with Azure SDK.
-    
+
     Supported authentication method:
     - service_principal: Using client ID, client secret, and tenant ID
     """
@@ -56,23 +56,21 @@ async def create_credential(
         """
         try:
             logger.debug(f"Creating Azure credential with auth type: {auth_type}")
-            
+
             if auth_type.lower() != "service_principal":
                 raise CommonError(
                     f"{CommonError.CREDENTIALS_PARSE_ERROR}: "
                     f"Only 'service_principal' authentication is supported. "
                     f"Received: {auth_type}"
                 )
-            
+
             return await self._create_service_principal_credential(credentials)
-                    
+
         except ClientAuthenticationError:
             raise
         except Exception as e:
             logger.error(f"Failed to create Azure credential: {str(e)}")
-            raise CommonError(
-                f"{CommonError.CREDENTIALS_PARSE_ERROR}: {str(e)}"
-            )
+            raise CommonError(f"{CommonError.CREDENTIALS_PARSE_ERROR}: {str(e)}")
 
     async def _create_service_principal_credential(
         self, credentials: Optional[Dict[str, Any]]
@@ -97,7 +95,9 @@ async def _create_service_principal_credential(
 
         tenant_id = credentials.get("tenant_id") or credentials.get("tenantId")
         client_id = credentials.get("client_id") or credentials.get("clientId")
-        client_secret = credentials.get("client_secret") or credentials.get("clientSecret")
+        client_secret = credentials.get("client_secret") or credentials.get(
+            "clientSecret"
+        )
 
         if not all([tenant_id, client_id, client_secret]):
             raise CommonError(
@@ -107,13 +107,18 @@ async def _create_service_principal_credential(
             )
 
         logger.debug(f"Creating service principal credential for tenant: {tenant_id}")
-        
+
+        # Ensure all values are strings
+        tenant_id_str = str(tenant_id) if tenant_id else ""
+        client_id_str = str(client_id) if client_id else ""
+        client_secret_str = str(client_secret) if client_secret else ""
+
         return await asyncio.get_event_loop().run_in_executor(
             None,
             ClientSecretCredential,
-            tenant_id,
-            client_id,
-            client_secret
+            tenant_id_str,
+            client_id_str,
+            client_secret_str,
         )
 
     async def validate_credential(self, credential: TokenCredential) -> bool:
@@ -128,21 +133,19 @@ async def validate_credential(self, credential: TokenCredential) -> bool:
         """
         try:
             logger.debug("Validating Azure credential")
-            
+
             # Try to get a token for Azure Management API
             token = await asyncio.get_event_loop().run_in_executor(
-                None,
-                credential.get_token,
-                "https://management.azure.com/.default"
+                None, credential.get_token, "https://management.azure.com/.default"
             )
-            
+
             if token and token.token:
                 logger.debug("Azure credential validation successful")
                 return True
             else:
                 logger.warning("Azure credential validation failed: No token received")
                 return False
-                
+
         except Exception as e:
             logger.error(f"Azure credential validation failed: {str(e)}")
             return False
@@ -154,4 +157,4 @@ def get_supported_auth_types(self) -> list[str]:
         Returns:
             list[str]: List of supported authentication types.
         """
-        return ["service_principal"] 
+        return ["service_principal"]

application_sdk/clients/azure/azure_services/__init__.py

@@ -9,4 +9,4 @@
 
 __all__ = [
     "AzureStorageClient",
-] 
+]