django-cfg 1.4.20__py3-none-any.whl → 1.4.23__py3-none-any.whl

django_cfg/modules/django_twilio/twilio_service.py

@@ -8,20 +8,16 @@ Handles all Twilio-specific functionality including:
 """
 
 import logging
-import random
-import string
-from typing import Optional, Dict, Any, Tuple
-from datetime import datetime, timedelta
-
-from ._imports import Client, TwilioException
-from asgiref.sync import sync_to_async
+from typing import Any, Dict, Optional, Tuple
 
 from django_cfg.modules.base import BaseCfgModule
-from django_cfg.modules.django_twilio.models import TwilioConfig, TwilioVerifyConfig
 from django_cfg.modules.django_twilio.exceptions import (
     TwilioConfigurationError,
     TwilioSendError,
 )
+from django_cfg.modules.django_twilio.models import TwilioConfig
+
+from ._imports import Client, TwilioException
 
 logger = logging.getLogger(__name__)
 
@@ -32,13 +28,13 @@ class TwilioService(BaseCfgModule):
     
     Handles all Twilio operations with auto-configuration from DjangoConfig.
     """
-    
+
     def __init__(self):
         """Initialize with auto-discovered configuration."""
         super().__init__()
         self._config: Optional[TwilioConfig] = None
         self._client: Optional[Client] = None
-    
+
     def get_config(self) -> TwilioConfig:
         """Get Twilio configuration from DjangoConfig."""
         if self._config is None:
@@ -48,7 +44,7 @@ class TwilioService(BaseCfgModule):
                     "DjangoConfig instance not found",
                     suggestions=["Ensure DjangoConfig is properly initialized"]
                 )
-            
+
             twilio_config = getattr(django_config, 'twilio', None)
             if not twilio_config:
                 raise TwilioConfigurationError(
@@ -56,11 +52,11 @@ class TwilioService(BaseCfgModule):
                     missing_fields=["twilio"],
                     suggestions=["Add TwilioConfig to your DjangoConfig class"]
                 )
-            
+
             self._config = twilio_config
-        
+
         return self._config
-    
+
     def get_client(self) -> Client:
         """Get or create Twilio client."""
         if self._client is None:
@@ -70,25 +66,25 @@ class TwilioService(BaseCfgModule):
                     config.account_sid,
                     config.auth_token.get_secret_value()
                 )
-                
+
                 if config.debug_logging:
                     logger.info(f"Twilio client initialized for account: {config.account_sid[:8]}...")
-                    
+
             except Exception as e:
                 raise TwilioConfigurationError(
                     f"Failed to initialize Twilio client: {str(e)}",
                     context={"account_sid": config.account_sid[:8] + "..."},
                     suggestions=["Verify your Twilio credentials"]
                 )
-        
+
         return self._client
-    
+
     # === WhatsApp Methods ===
-    
+
     def send_whatsapp_message(
-        self, 
-        to: str, 
-        body: str, 
+        self,
+        to: str,
+        body: str,
         from_number: Optional[str] = None
     ) -> Dict[str, Any]:
         """
@@ -105,11 +101,11 @@ class TwilioService(BaseCfgModule):
         try:
             client = self.get_client()
             config = self.get_config()
-            
+
             # Ensure to number has whatsapp prefix
             if not to.startswith('whatsapp:'):
                 to = f'whatsapp:{to}'
-            
+
             # Use default from number if not provided
             if not from_number:
                 if config.whatsapp_from:
@@ -118,17 +114,17 @@ class TwilioService(BaseCfgModule):
                     from_number = 'whatsapp:+14155238886'  # Twilio sandbox fallback
             elif not from_number.startswith('whatsapp:'):
                 from_number = f'whatsapp:{from_number}'
-            
+
             if config.debug_logging:
                 logger.info(f"Sending WhatsApp message to {to[:15]}...")
-            
+
             # Send message
             message = client.messages.create(
                 to=to,
                 from_=from_number,
                 body=body
             )
-            
+
             result = {
                 'sid': message.sid,
                 'status': message.status,
@@ -139,12 +135,12 @@ class TwilioService(BaseCfgModule):
                 'price': message.price,
                 'price_unit': message.price_unit,
             }
-            
+
             if config.debug_logging:
                 logger.info(f"WhatsApp message sent successfully: {message.sid}")
-            
+
             return result
-            
+
         except TwilioException as e:
             logger.error(f"Twilio API error: {e}")
             raise TwilioSendError(
@@ -159,13 +155,13 @@ class TwilioService(BaseCfgModule):
         except Exception as e:
             logger.error(f"Unexpected error sending WhatsApp message: {e}")
             raise TwilioSendError(f"Unexpected error: {str(e)}")
-    
+
     # === SMS Methods ===
-    
+
     def send_sms_message(
-        self, 
-        to: str, 
-        body: str, 
+        self,
+        to: str,
+        body: str,
         from_number: Optional[str] = None
     ) -> Dict[str, Any]:
         """
@@ -182,7 +178,7 @@ class TwilioService(BaseCfgModule):
         try:
             client = self.get_client()
             config = self.get_config()
-            
+
             # Use default from number if not provided
             if not from_number:
                 if config.sms_from:
@@ -193,17 +189,17 @@ class TwilioService(BaseCfgModule):
                         missing_fields=["sms_from"],
                         suggestions=["Set sms_from in your TwilioConfig"]
                     )
-            
+
             if config.debug_logging:
                 logger.info(f"Sending SMS to {to[:10]}...")
-            
+
             # Send message
             message = client.messages.create(
                 to=to,
                 from_=from_number,
                 body=body
             )
-            
+
             result = {
                 'sid': message.sid,
                 'status': message.status,
@@ -214,12 +210,12 @@ class TwilioService(BaseCfgModule):
                 'price': message.price,
                 'price_unit': message.price_unit,
             }
-            
+
             if config.debug_logging:
                 logger.info(f"SMS sent successfully: {message.sid}")
-            
+
             return result
-            
+
         except TwilioException as e:
             logger.error(f"Twilio API error: {e}")
             raise TwilioSendError(
@@ -234,9 +230,9 @@ class TwilioService(BaseCfgModule):
         except Exception as e:
             logger.error(f"Unexpected error sending SMS: {e}")
             raise TwilioSendError(f"Unexpected error: {str(e)}")
-    
+
     # === OTP Methods (Twilio Verify API) ===
-    
+
     def send_whatsapp_otp_hybrid(self, phone_number: str, otp_code: str, fallback_to_sms: bool = True) -> Tuple[bool, str]:
         """
         HYBRID APPROACH: Send OTP via Direct WhatsApp first, then fallback to Verify API.
@@ -252,13 +248,13 @@ class TwilioService(BaseCfgModule):
         success = False
         final_message = ""
         method_used = ""
-        
+
         # STEP 1: Try Direct WhatsApp with custom OTP
         try:
             from django_cfg.core.state import get_current_config
             django_config = get_current_config()
             site_name = django_config.project_name if django_config else "Django CFG"
-            
+
             # Create beautiful WhatsApp message
             whatsapp_message = f"""🔐 *{site_name} Verification*
 
@@ -268,43 +264,43 @@ Your verification code: *{otp_code}*
 🔒 Keep this code secure
 
 _Powered by {site_name}_"""
-            
+
             logger.info(f"🎯 Attempting Direct WhatsApp OTP to {self._mask_phone(phone_number)}...")
             result = self.send_whatsapp_message(phone_number, whatsapp_message)
-            
+
             if result.get('sid'):  # If we got a message SID, it was sent successfully
                 success = True
                 method_used = "Direct WhatsApp"
                 final_message = f"OTP sent via WhatsApp to {self._mask_phone(phone_number)}"
                 logger.info(f"✅ Direct WhatsApp OTP sent successfully: {result.get('sid', 'N/A')}")
             else:
-                logger.warning(f"❌ Direct WhatsApp failed: No SID returned")
-                
+                logger.warning("❌ Direct WhatsApp failed: No SID returned")
+
         except Exception as e:
             logger.warning(f"❌ Direct WhatsApp error: {e}")
-        
+
         # STEP 2: Fallback to Verify API if Direct WhatsApp failed
         if not success:
             try:
                 logger.info(f"🔄 Fallback: Trying Verify API for {self._mask_phone(phone_number)}...")
                 verify_success, verify_message = self.send_whatsapp_otp_verify(phone_number, fallback_to_sms)
-                
+
                 if verify_success:
                     success = True
                     method_used = "Verify API"
                     final_message = verify_message
-                    logger.info(f"✅ Verify API fallback successful")
+                    logger.info("✅ Verify API fallback successful")
                 else:
                     logger.error(f"❌ Verify API fallback failed: {verify_message}")
-                    
+
             except Exception as e:
                 logger.error(f"❌ Verify API fallback error: {e}")
-        
+
         # STEP 3: Final check
         if not success:
             logger.error(f"❌ All WhatsApp methods failed for {self._mask_phone(phone_number)}")
             return False, "All WhatsApp delivery methods failed"
-        
+
         logger.info(f"🎉 Phone OTP sent via {method_used} to {self._mask_phone(phone_number)}")
         return True, f"{final_message} ({method_used})"
 
@@ -320,16 +316,16 @@ _Powered by {site_name}_"""
             Tuple[bool, str]: (success, message)
         """
         config = self.get_config()
-        
+
         if not config.verify:
             raise TwilioConfigurationError(
                 "Twilio Verify service not configured",
                 missing_fields=["verify"],
                 suggestions=["Configure TwilioVerifyConfig in your Twilio settings"]
             )
-        
+
         client = self.get_client()
-        
+
         try:
             # Try WhatsApp first
             logger.info(f"🚀 Sending WhatsApp OTP to {self._mask_phone(phone_number)} via Verify API")
@@ -339,29 +335,29 @@ _Powered by {site_name}_"""
                 to=phone_number,
                 channel='whatsapp'
             )
-            
+
             # Log detailed Twilio response
             logger.info(f"📱 Twilio Verify Response: status={verification.status}, sid={verification.sid}, channel={verification.channel}, to={verification.to}")
-            
+
             if verification.status == 'pending':
                 logger.info(f"✅ WhatsApp OTP sent successfully to {self._mask_phone(phone_number)}")
                 return True, f"OTP sent via WhatsApp to {self._mask_phone(phone_number)}"
-            
+
             # If WhatsApp failed and fallback is enabled, try SMS
             if fallback_to_sms and verification.status != 'pending':
                 logger.warning(f"WhatsApp failed for {self._mask_phone(phone_number)}, trying SMS fallback")
                 return self.send_sms_otp(phone_number)
-            
+
             raise TwilioSendError(
                 f"WhatsApp OTP failed with status: {verification.status}",
                 context={'phone': phone_number, 'status': verification.status}
             )
-            
+
         except TwilioException as e:
             if fallback_to_sms:
                 logger.warning(f"WhatsApp error for {self._mask_phone(phone_number)}: {e}, trying SMS")
                 return self.send_sms_otp(phone_number)
-            
+
             raise TwilioSendError(
                 f"WhatsApp OTP failed: {e}",
                 context={
@@ -370,7 +366,7 @@ _Powered by {site_name}_"""
                     'error_message': str(e)
                 }
             ) from e
-    
+
     def send_sms_otp(self, phone_number: str) -> Tuple[bool, str]:
         """
         Send OTP via SMS using Twilio Verify API.
@@ -382,16 +378,16 @@ _Powered by {site_name}_"""
             Tuple[bool, str]: (success, message)
         """
         config = self.get_config()
-        
+
         if not config.verify:
             raise TwilioConfigurationError(
                 "Twilio Verify service not configured",
                 missing_fields=["verify"],
                 suggestions=["Configure TwilioVerifyConfig in your Twilio settings"]
             )
-        
+
         client = self.get_client()
-        
+
         try:
             logger.info(f"📱 Sending SMS OTP to {self._mask_phone(phone_number)} via Verify API")
             verification = client.verify.v2.services(
@@ -400,10 +396,10 @@ _Powered by {site_name}_"""
                 to=phone_number,
                 channel='sms'
             )
-            
+
             # Log detailed Twilio response
             logger.info(f"📱 Twilio SMS Response: status={verification.status}, sid={verification.sid}, channel={verification.channel}, to={verification.to}")
-            
+
             if verification.status == 'pending':
                 logger.info(f"✅ SMS OTP sent successfully to {self._mask_phone(phone_number)}")
                 return True, f"OTP sent via SMS to {self._mask_phone(phone_number)}"
@@ -412,7 +408,7 @@ _Powered by {site_name}_"""
                     f"SMS OTP failed with status: {verification.status}",
                     context={'phone': phone_number, 'status': verification.status}
                 )
-                
+
         except TwilioException as e:
             raise TwilioSendError(
                 f"SMS OTP failed: {e}",
@@ -422,7 +418,7 @@ _Powered by {site_name}_"""
                     'error_message': str(e)
                 }
             ) from e
-    
+
     def verify_otp(self, phone_number: str, code: str) -> Tuple[bool, str]:
         """
         Verify OTP code using Twilio Verify API.
@@ -435,26 +431,26 @@ _Powered by {site_name}_"""
             Tuple[bool, str]: (is_valid, message)
         """
         config = self.get_config()
-        
+
         if not config.verify:
             raise TwilioConfigurationError("Twilio Verify service not configured")
-        
+
         try:
             client = self.get_client()
-            
+
             verification_check = client.verify.v2.services(
                 config.verify.service_sid
             ).verification_checks.create(
                 to=phone_number,
                 code=code
             )
-            
+
             if verification_check.status == 'approved':
                 logger.info(f"OTP verified successfully for {self._mask_phone(phone_number)}")
                 return True, "OTP verified successfully"
             else:
                 return False, f"Invalid OTP code: {verification_check.status}"
-                
+
         except TwilioException as e:
             raise TwilioSendError(
                 f"OTP verification failed: {e}",
@@ -464,13 +460,13 @@ _Powered by {site_name}_"""
                     'error_message': str(e)
                 }
             ) from e
-    
+
     # === Utility Methods ===
-    
+
     def _mask_phone(self, phone: str) -> str:
         """Mask phone number for security in logs."""
         return f"***{phone[-4:]}" if len(phone) > 4 else "***"
-    
+
     def get_message_status(self, message_sid: str) -> Dict[str, Any]:
         """
         Get status of a sent message.
@@ -484,7 +480,7 @@ _Powered by {site_name}_"""
         try:
             client = self.get_client()
             message = client.messages(message_sid).fetch()
-            
+
             return {
                 'sid': message.sid,
                 'status': message.status,
@@ -499,7 +495,7 @@ _Powered by {site_name}_"""
                 'error_code': message.error_code,
                 'error_message': message.error_message,
             }
-            
+
         except TwilioException as e:
             raise TwilioSendError(f"Failed to get message status: {str(e)}")
 

django_cfg/modules/django_twilio/unified.py

@@ -6,20 +6,21 @@ configuration and delivery success rates.
 """
 
 import logging
-from typing import Tuple, Optional, List, Dict, Any
 from datetime import datetime
+from typing import Any, Dict, List, Optional, Tuple
+
 from asgiref.sync import sync_to_async
 
 from .base import BaseTwilioService
-from .whatsapp import WhatsAppOTPService
 from .email_otp import EmailOTPService
-from .sms import SMSOTPService
-from .models import TwilioConfig, TwilioChannelType
 from .exceptions import (
     TwilioConfigurationError,
     TwilioSendError,
     TwilioVerificationError,
 )
+from .models import TwilioChannelType, TwilioConfig
+from .sms import SMSOTPService
+from .whatsapp import WhatsAppOTPService
 
 logger = logging.getLogger(__name__)
 
@@ -120,7 +121,7 @@ class UnifiedOTPService(BaseTwilioService):
         config = self.get_twilio_config()
 
         # For Twilio Verify channels (WhatsApp, SMS), use Twilio verification
-        if not "@" in identifier and config.verify:
+        if "@" not in identifier and config.verify:
             return self._verify_twilio_otp(identifier, code, config)
 
         # For email or custom verification, use stored OTP

django_cfg/modules/django_twilio/utils.py

@@ -5,13 +5,12 @@ Provides simple function-based API for sending and verifying OTPs
 without manually instantiating service classes.
 """
 
-from typing import Tuple, Optional
+from typing import Optional, Tuple
 
-from .whatsapp import WhatsAppOTPService
 from .email_otp import EmailOTPService
 from .sms import SMSOTPService
 from .unified import UnifiedOTPService
-
+from .whatsapp import WhatsAppOTPService
 
 # Sync convenience functions
 

django_cfg/modules/django_twilio/whatsapp.py

@@ -7,15 +7,16 @@ Supports both sync and async operations.
 
 import logging
 from typing import Tuple
-from ._imports import Client, TwilioException
+
 from asgiref.sync import sync_to_async
 
+from ._imports import Client, TwilioException
 from .base import BaseTwilioService
-from .models import TwilioVerifyConfig
 from .exceptions import (
     TwilioConfigurationError,
     TwilioSendError,
 )
+from .models import TwilioVerifyConfig
 
 logger = logging.getLogger(__name__)
 

django_cfg/modules/django_unfold/__init__.py

@@ -5,11 +5,12 @@ Provides complete Unfold admin interface integration with dashboard,
 navigation, theming, and callback support.
 """
 
-from .dashboard import DashboardManager, get_dashboard_manager
 from .callbacks import UnfoldCallbacks
-from .system_monitor import SystemMonitor
-from .tailwind import get_unfold_colors, get_css_variables
+from .dashboard import DashboardManager, get_dashboard_manager
 from .models import *
+from .system_monitor import SystemMonitor
+from .tailwind import get_css_variables, get_unfold_colors
+
 
 # Lazy initialization functions to avoid circular imports
 def get_system_monitor() -> SystemMonitor:
@@ -30,7 +31,7 @@ def get_unfold_callbacks() -> UnfoldCallbacks:
 __all__ = [
     'DashboardManager',
     'get_dashboard_manager',
-    'UnfoldCallbacks', 
+    'UnfoldCallbacks',
     'get_unfold_callbacks',
     'SystemMonitor',
     'get_system_monitor',
@@ -38,7 +39,7 @@ __all__ = [
     'get_css_variables',
     # Models
     'UnfoldConfig',
-    'UnfoldTheme', 
+    'UnfoldTheme',
     'UnfoldColors',
     'UnfoldSidebar',
     'UnfoldThemeConfig',
@@ -66,4 +67,4 @@ __email__ = 'team@djangocfg.com'
 # Module metadata
 __title__ = 'Django CFG Unfold'
 __description__ = 'Complete Unfold admin interface integration'
-__url__ = 'https://github.com/djangocfg/django-cfg'
+__url__ = 'https://github.com/djangocfg/django-cfg'

django_cfg/modules/django_unfold/callbacks/actions.py

@@ -5,8 +5,9 @@ Quick actions callbacks.
 import logging
 from typing import List
 
-from ..models.dashboard import QuickAction
 from django_cfg.modules.django_admin.icons import Icons
+
+from ..models.dashboard import QuickAction
 from .base import get_user_admin_urls
 
 logger = logging.getLogger(__name__)
@@ -14,12 +15,12 @@ logger = logging.getLogger(__name__)
 
 class ActionsCallbacks:
     """Quick actions callbacks."""
-    
+
     def get_quick_actions(self) -> List[QuickAction]:
         """Get quick action buttons as Pydantic models."""
         # Get user admin URLs dynamically based on AUTH_USER_MODEL
         user_admin_urls = get_user_admin_urls()
-        
+
         actions = [
             QuickAction(
                 title="Add User",
@@ -45,6 +46,6 @@ class ActionsCallbacks:
                 color="success",
                 category="system",
             ),
-        ] 
-        
+        ]
+
         return actions