django-cfg 1.3.1__py3-none-any.whl → 1.3.5__py3-none-any.whl

django_cfg/apps/payments/views/serializers/api_keys.py

@@ -23,8 +23,8 @@ class APIKeyListSerializer(serializers.ModelSerializer):
     """
     
     user = serializers.StringRelatedField(read_only=True)
-    is_expired = serializers.BooleanField(source='is_expired', read_only=True)
-    is_valid = serializers.BooleanField(source='is_valid', read_only=True)
+    is_expired = serializers.BooleanField(read_only=True)
+    is_valid = serializers.BooleanField(read_only=True)
     
     class Meta:
         model = APIKey
@@ -51,10 +51,10 @@ class APIKeySerializer(serializers.ModelSerializer):
     """
     
     user = serializers.StringRelatedField(read_only=True)
-    key_preview = serializers.CharField(source='key_preview', read_only=True)
-    is_expired = serializers.BooleanField(source='is_expired', read_only=True)
-    is_valid = serializers.BooleanField(source='is_valid', read_only=True)
-    days_until_expiry = serializers.IntegerField(source='days_until_expiry', read_only=True)
+    key_preview = serializers.CharField(read_only=True)
+    is_expired = serializers.BooleanField(read_only=True)
+    is_valid = serializers.BooleanField(read_only=True)
+    days_until_expiry = serializers.IntegerField(read_only=True)
     
     class Meta:
         model = APIKey
@@ -361,6 +361,20 @@ class APIKeyValidationSerializer(serializers.Serializer):
             }
 
 
+class APIKeyValidationResponseSerializer(serializers.Serializer):
+    """
+    API key validation response serializer.
+    
+    Defines the structure of API key validation response for OpenAPI schema.
+    """
+    success = serializers.BooleanField(help_text="Whether the validation was successful")
+    valid = serializers.BooleanField(help_text="Whether the API key is valid")
+    api_key = APIKeySerializer(allow_null=True, help_text="API key details if valid")
+    message = serializers.CharField(help_text="Validation message")
+    error = serializers.CharField(required=False, help_text="Error message if validation failed")
+    error_code = serializers.CharField(required=False, help_text="Error code if validation failed")
+
+
 class APIKeyStatsSerializer(serializers.Serializer):
     """
     API key statistics serializer.

django_cfg/apps/payments/views/serializers/balances.py

@@ -25,9 +25,6 @@ class UserBalanceSerializer(serializers.ModelSerializer):
     """
     
     user = serializers.StringRelatedField(read_only=True)
-    balance_display = serializers.CharField(source='balance_display', read_only=True)
-    is_empty = serializers.BooleanField(source='is_empty', read_only=True)
-    has_transactions = serializers.BooleanField(source='has_transactions', read_only=True)
     
     class Meta:
         model = UserBalance
@@ -51,17 +48,17 @@ class TransactionSerializer(serializers.ModelSerializer):
     """
     
     user = serializers.StringRelatedField(read_only=True)
-    amount_display = serializers.CharField(source='amount_display', read_only=True)
-    type_color = serializers.CharField(source='type_color', read_only=True)
-    is_credit = serializers.BooleanField(source='is_credit', read_only=True)
-    is_debit = serializers.BooleanField(source='is_debit', read_only=True)
+    amount_display = serializers.CharField(read_only=True)
+    type_color = serializers.CharField(read_only=True)
+    is_credit = serializers.BooleanField(read_only=True)
+    is_debit = serializers.BooleanField(read_only=True)
     
     class Meta:
         model = Transaction
         fields = [
             'id',
             'user',
-            'amount',
+            'amount_usd',
             'amount_display',
             'transaction_type',
             'type_color',

django_cfg/apps/payments/views/serializers/currencies.py

@@ -22,9 +22,6 @@ class CurrencySerializer(serializers.ModelSerializer):
     """
     
     type_display = serializers.CharField(source='get_currency_type_display', read_only=True)
-    is_crypto = serializers.BooleanField(source='is_crypto', read_only=True)
-    is_fiat = serializers.BooleanField(source='is_fiat', read_only=True)
-    is_stable = serializers.BooleanField(source='is_stable', read_only=True)
     
     class Meta:
         model = Currency
@@ -35,11 +32,10 @@ class CurrencySerializer(serializers.ModelSerializer):
             'symbol',
             'currency_type',
             'type_display',
-            'decimals',
+            'decimal_places',
             'is_active',
             'is_crypto',
             'is_fiat',
-            'is_stable',
             'created_at',
             'updated_at',
         ]
@@ -113,7 +109,7 @@ class ProviderCurrencySerializer(serializers.ModelSerializer):
             'min_amount',
             'max_amount',
             'fee_percentage',
-            'is_active',
+            'is_enabled',
             'created_at',
             'updated_at',
         ]

django_cfg/apps/payments/views/serializers/payments.py

@@ -25,21 +25,22 @@ class PaymentListSerializer(serializers.ModelSerializer):
     """
     
     status_display = serializers.CharField(source='get_status_display', read_only=True)
-    amount_display = serializers.CharField(source='amount_display', read_only=True)
-    crypto_amount_display = serializers.CharField(source='crypto_amount_display', read_only=True)
+    amount_display = serializers.SerializerMethodField(read_only=True)
+    
+    def get_amount_display(self, obj):
+        """Get formatted amount display."""
+        return f"${obj.amount_usd:.2f}"
     
     class Meta:
         model = UniversalPayment
         fields = [
             'id',
             'amount_usd',
-            'crypto_amount',
-            'currency_code',
+            'currency',
             'provider',
             'status',
             'status_display',
             'amount_display',
-            'crypto_amount_display',
             'created_at',
             'expires_at',
         ]
@@ -55,17 +56,33 @@ class PaymentSerializer(serializers.ModelSerializer):
     
     user = serializers.StringRelatedField(read_only=True)
     status_display = serializers.CharField(source='get_status_display', read_only=True)
-    status_color = serializers.CharField(source='status_color', read_only=True)
-    amount_display = serializers.CharField(source='amount_display', read_only=True)
-    crypto_amount_display = serializers.CharField(source='crypto_amount_display', read_only=True)
+    amount_display = serializers.SerializerMethodField(read_only=True)
     
     # Status check methods
-    is_pending = serializers.BooleanField(source='is_pending', read_only=True)
-    is_completed = serializers.BooleanField(source='is_completed', read_only=True)
-    is_failed = serializers.BooleanField(source='is_failed', read_only=True)
-    is_expired = serializers.BooleanField(source='is_expired', read_only=True)
-    can_be_cancelled = serializers.BooleanField(source='can_be_cancelled', read_only=True)
-    can_be_refunded = serializers.BooleanField(source='can_be_refunded', read_only=True)
+    is_pending = serializers.SerializerMethodField(read_only=True)
+    is_completed = serializers.SerializerMethodField(read_only=True)
+    is_failed = serializers.SerializerMethodField(read_only=True)
+    is_expired = serializers.SerializerMethodField(read_only=True)
+    
+    def get_amount_display(self, obj):
+        """Get formatted amount display."""
+        return f"${obj.amount_usd:.2f}"
+    
+    def get_is_pending(self, obj):
+        """Check if payment is pending."""
+        return obj.status == obj.PaymentStatus.PENDING
+    
+    def get_is_completed(self, obj):
+        """Check if payment is completed."""
+        return obj.status == obj.PaymentStatus.COMPLETED
+    
+    def get_is_failed(self, obj):
+        """Check if payment is failed."""
+        return obj.status == obj.PaymentStatus.FAILED
+    
+    def get_is_expired(self, obj):
+        """Check if payment is expired."""
+        return obj.status == obj.PaymentStatus.EXPIRED
     
     class Meta:
         model = UniversalPayment
@@ -73,24 +90,20 @@ class PaymentSerializer(serializers.ModelSerializer):
             'id',
             'user',
             'amount_usd',
-            'crypto_amount',
-            'currency_code',
+            'currency',
+            'network',
             'provider',
             'status',
             'status_display',
-            'status_color',
             'amount_display',
-            'crypto_amount_display',
             'provider_payment_id',
             'payment_url',
-            'qr_code_url',
-            'wallet_address',
+            'pay_address',
             'callback_url',
             'cancel_url',
             'description',
-            'metadata',
             'transaction_hash',
-            'confirmation_blocks',
+            'confirmations_count',
             'created_at',
             'updated_at',
             'expires_at',
@@ -100,32 +113,24 @@ class PaymentSerializer(serializers.ModelSerializer):
             'is_completed',
             'is_failed',
             'is_expired',
-            'can_be_cancelled',
-            'can_be_refunded',
         ]
         read_only_fields = [
             'id',
             'user',
-            'crypto_amount',
             'provider_payment_id',
             'payment_url',
-            'qr_code_url',
-            'wallet_address',
+            'pay_address',
             'transaction_hash',
-            'confirmation_blocks',
+            'confirmations_count',
             'created_at',
             'updated_at',
             'completed_at',
             'status_display',
-            'status_color',
             'amount_display',
-            'crypto_amount_display',
             'is_pending',
             'is_completed',
             'is_failed',
             'is_expired',
-            'can_be_cancelled',
-            'can_be_refunded',
         ]
 
 

django_cfg/apps/payments/views/serializers/subscriptions.py

@@ -29,7 +29,7 @@ class EndpointGroupSerializer(serializers.ModelSerializer):
             'id',
             'name',
             'description',
-            'is_active',
+            'is_enabled',
             'created_at',
             'updated_at',
         ]
@@ -52,9 +52,9 @@ class TariffSerializer(serializers.ModelSerializer):
             'id',
             'name',
             'description',
-            'monthly_price',
+            'monthly_price_usd',
             'requests_per_month',
-            'requests_per_minute',
+            'requests_per_hour',
             'is_active',
             'endpoint_groups',
             'endpoint_groups_count',
@@ -74,8 +74,6 @@ class SubscriptionListSerializer(serializers.ModelSerializer):
     user = serializers.StringRelatedField(read_only=True)
     tariff_name = serializers.CharField(source='tariff.name', read_only=True)
     status_display = serializers.CharField(source='get_status_display', read_only=True)
-    is_active = serializers.BooleanField(source='is_active', read_only=True)
-    is_expired = serializers.BooleanField(source='is_expired', read_only=True)
     
     class Meta:
         model = Subscription
@@ -104,18 +102,8 @@ class SubscriptionSerializer(serializers.ModelSerializer):
     tariff = TariffSerializer(read_only=True)
     endpoint_group = EndpointGroupSerializer(read_only=True)
     status_display = serializers.CharField(source='get_status_display', read_only=True)
-    status_color = serializers.CharField(source='status_color', read_only=True)
-    
-    # Status check methods
-    is_active = serializers.BooleanField(source='is_active', read_only=True)
-    is_expired = serializers.BooleanField(source='is_expired', read_only=True)
-    is_trial = serializers.BooleanField(source='is_trial', read_only=True)
-    can_be_renewed = serializers.BooleanField(source='can_be_renewed', read_only=True)
-    can_be_cancelled = serializers.BooleanField(source='can_be_cancelled', read_only=True)
     
-    # Usage statistics
-    usage_percentage = serializers.FloatField(source='usage_percentage', read_only=True)
-    requests_remaining = serializers.IntegerField(source='requests_remaining', read_only=True)
+    # Only keep fields that actually exist or are needed
     
     class Meta:
         model = Subscription
@@ -129,16 +117,11 @@ class SubscriptionSerializer(serializers.ModelSerializer):
             'status_color',
             'tier',
             'total_requests',
-            'requests_used',
-            'requests_remaining',
             'usage_percentage',
             'last_request_at',
             'expires_at',
             'is_active',
             'is_expired',
-            'is_trial',
-            'can_be_renewed',
-            'can_be_cancelled',
             'created_at',
             'updated_at',
         ]
@@ -146,8 +129,6 @@ class SubscriptionSerializer(serializers.ModelSerializer):
             'id',
             'user',
             'total_requests',
-            'requests_used',
-            'requests_remaining',
             'usage_percentage',
             'last_request_at',
             'created_at',
@@ -156,9 +137,6 @@ class SubscriptionSerializer(serializers.ModelSerializer):
             'status_color',
             'is_active',
             'is_expired',
-            'is_trial',
-            'can_be_renewed',
-            'can_be_cancelled',
         ]
 
 

django_cfg/apps/urls.py

@@ -52,7 +52,8 @@ def get_django_cfg_urlpatterns() -> List[URLPattern]:
         # if base_module.is_maintenance_enabled():
         #     patterns.append(path('admin/django_cfg_maintenance/', include('django_cfg.apps.maintenance.urls_admin')))
 
-        if base_module.is_payments_enabled():
+        # if base_module.is_payments_enabled():
+        if True:
             patterns.append(path('admin/django_cfg_payments/admin/', include('django_cfg.apps.payments.urls_admin')))
             
     except Exception:

django_cfg/core/config.py

@@ -336,7 +336,6 @@ class DjangoConfig(BaseModel):
     )
 
     # === Internal State ===
-    _environment: Optional[str] = PrivateAttr(default=None)
     _base_dir: Optional[Path] = PrivateAttr(default=None)
     _django_settings: Optional[Dict[str, Any]] = PrivateAttr(default=None)
 
@@ -353,7 +352,7 @@ class DjangoConfig(BaseModel):
         super().__init__(**data)
 
         # Initialize internal state
-        self._detect_environment()
+        self._auto_detect_env_mode()
         self._resolve_paths()
         self._apply_smart_defaults()
         self._load_environment_config()
@@ -448,14 +447,22 @@ class DjangoConfig(BaseModel):
         """Check if running in test mode."""
         return self.env_mode == EnvironmentMode.TEST
 
-    def _detect_environment(self) -> None:
-        """Detect current environment from various sources."""
-        from django_cfg.core.environment import EnvironmentDetector
-
-        try:
-            self._environment = EnvironmentDetector.detect_environment()
-        except Exception as e:
-            raise EnvironmentError(f"Failed to detect environment: {e}", suggestions=["Set DJANGO_ENV environment variable explicitly"]) from e
+    def _auto_detect_env_mode(self) -> None:
+        """Auto-detect environment mode from various sources."""
+        import os
+        
+        # Check environment variables first
+        env_var = os.getenv("DJANGO_ENV", "").lower()
+        if env_var in ["development", "dev"]:
+            self.env_mode = EnvironmentMode.DEVELOPMENT
+        elif env_var in ["production", "prod"]:
+            self.env_mode = EnvironmentMode.PRODUCTION
+        elif env_var in ["test", "testing"]:
+            self.env_mode = EnvironmentMode.TEST
+        elif hasattr(self, 'debug') and self.debug:
+            # Auto-detect from debug flag if no env var set
+            self.env_mode = EnvironmentMode.DEVELOPMENT
+        # Otherwise keep the default (PRODUCTION)
 
     @property
     def base_dir(self) -> Path:
@@ -509,17 +516,17 @@ class DjangoConfig(BaseModel):
         try:
             # Apply cache defaults
             if self.cache_default:
-                self.cache_default = SmartDefaults.configure_cache_backend(self.cache_default, self._environment, self.debug)
+                self.cache_default = SmartDefaults.configure_cache_backend(self.cache_default, self.env_mode, self.debug)
 
             if self.cache_sessions:
-                self.cache_sessions = SmartDefaults.configure_cache_backend(self.cache_sessions, self._environment, self.debug)
+                self.cache_sessions = SmartDefaults.configure_cache_backend(self.cache_sessions, self.env_mode, self.debug)
 
             # Apply email defaults
             if self.email:
-                self.email = SmartDefaults.configure_email_backend(self.email, self._environment, self.debug)
+                self.email = SmartDefaults.configure_email_backend(self.email, self.env_mode, self.debug)
 
         except Exception as e:
-            raise ConfigurationError(f"Failed to apply smart defaults: {e}", context={"environment": self._environment, "debug": self.debug}) from e
+            raise ConfigurationError(f"Failed to apply smart defaults: {e}", context={"environment": self.env_mode, "debug": self.debug}) from e
 
     def _load_environment_config(self) -> None:
         """Load environment-specific configuration from YAML files."""
@@ -775,6 +782,9 @@ class DjangoConfig(BaseModel):
         if self.enable_accounts:
             middleware.append("django_cfg.middleware.UserActivityMiddleware")
 
+        # Add static no-cache middleware (auto-detects development mode)
+        middleware.append("django_cfg.middleware.StaticNoCacheMiddleware")
+
         # Add payments middleware if enabled
         if self.payments and self.payments.enabled:
             middleware.extend(self.payments.get_middleware_classes())
@@ -854,7 +864,7 @@ class DjangoConfig(BaseModel):
         Returns:
             Model data with internal fields excluded
         """
-        return self.model_dump(exclude={"_environment", "_base_dir", "_django_settings"}, exclude_none=True)
+        return self.model_dump(exclude={"_base_dir", "_django_settings"}, exclude_none=True)
 
 
 # Global config instance for access from other modules

django_cfg/core/generation.py

@@ -179,7 +179,7 @@ class SettingsGenerator:
                 # Apply database defaults for each database based on its engine
                 for alias, db_config in config.databases.items():
                     db_defaults = SmartDefaults.get_database_defaults(
-                        config._environment, 
+                        config.env_mode, 
                         config.debug, 
                         db_config.engine
                     )
@@ -219,17 +219,17 @@ class SettingsGenerator:
 
             # Default cache - always provide one
             if config.cache_default:
-                caches["default"] = config.cache_default.to_django_config(config._environment, config.debug, "default")
+                caches["default"] = config.cache_default.to_django_config(config.env_mode, config.debug, "default")
             else:
                 # Create default cache backend
                 from django_cfg.models.cache import CacheConfig
 
                 default_cache = CacheConfig()
-                caches["default"] = default_cache.to_django_config(config._environment, config.debug, "default")
+                caches["default"] = default_cache.to_django_config(config.env_mode, config.debug, "default")
 
             # Sessions cache
             if config.cache_sessions:
-                caches["sessions"] = config.cache_sessions.to_django_config(config._environment, config.debug, "sessions")
+                caches["sessions"] = config.cache_sessions.to_django_config(config.env_mode, config.debug, "sessions")
 
                 # Configure Django to use cache for sessions (can be overridden)
                 settings["SESSION_ENGINE"] = "django.contrib.sessions.backends.cache"
@@ -241,7 +241,7 @@ class SettingsGenerator:
                     cache_obj = getattr(config, attr_name)
                     if hasattr(cache_obj, "to_django_config"):
                         cache_alias = attr_name.replace("cache_", "")
-                        caches[cache_alias] = cache_obj.to_django_config(config._environment, config.debug, cache_alias)
+                        caches[cache_alias] = cache_obj.to_django_config(config.env_mode, config.debug, cache_alias)
 
             if caches:
                 settings["CACHES"] = caches
@@ -261,7 +261,7 @@ class SettingsGenerator:
             if config.security_domains or config.ssl_redirect is not None:
                 security_defaults = SmartDefaults.get_security_defaults(
                     config.security_domains, 
-                    config._environment, 
+                    config.env_mode, 
                     config.debug,
                     config.ssl_redirect,
                     config.cors_allow_headers
@@ -275,12 +275,12 @@ class SettingsGenerator:
                     pass
 
             # Additional security settings for production
-            if config._environment == "production":
+            if config.env_mode == "production":
                 settings.update(
                     {
-                        "SESSION_COOKIE_AGE": 86400,  # 24 hours
+                        "SESSION_COOKIE_AGE": 2592000,  # 30 days (30 * 24 * 60 * 60)
                         "SESSION_SAVE_EVERY_REQUEST": True,
-                        "SESSION_EXPIRE_AT_BROWSER_CLOSE": True,
+                        "SESSION_EXPIRE_AT_BROWSER_CLOSE": False,  # Allow persistent sessions
                     }
                 )
 
@@ -296,7 +296,7 @@ class SettingsGenerator:
             settings = {}
 
             if config.email:
-                email_settings = config.email.to_django_config(config._environment, config.debug)
+                email_settings = config.email.to_django_config(config.env_mode, config.debug)
                 settings.update(email_settings)
 
             return settings
@@ -311,7 +311,7 @@ class SettingsGenerator:
             settings = {}
 
             # Generate logging defaults
-            logging_defaults = SmartDefaults.get_logging_defaults(config._environment, config.debug)
+            logging_defaults = SmartDefaults.get_logging_defaults(config.env_mode, config.debug)
 
             if logging_defaults:
                 settings["LOGGING"] = logging_defaults
@@ -370,7 +370,7 @@ class SettingsGenerator:
             }
 
             # Adjust for different environments
-            if config._environment == "development":
+            if config.env_mode == "development":
                 settings["USE_L10N"] = True  # Deprecated but sometimes needed
 
             return settings

django_cfg/core/integration/display/startup.py

@@ -122,7 +122,7 @@ class StartupDisplayManager(BaseDisplayManager):
         info_table.add_row("🏗️ Project", self.config.project_name)
         
         # Add environment source
-        env_source = getattr(self.config, '_environment', 'default_fallback')
+        env_source = getattr(self.config, 'env_mode', 'default_fallback')
         info_table.add_row("🔍 Env Source", env_source)
         
         info_table.add_row("🌐 Site", LIB_SITE_URL)

django_cfg/core/validation.py

@@ -81,7 +81,7 @@ class ConfigurationValidator:
             errors.append("SECRET_KEY must be at least 50 characters long")
         else:
             # Check for insecure patterns in production
-            if config._environment == 'production':
+            if config.env_mode == 'production':
                 insecure_patterns = [
                     'django-insecure',
                     'change-me',
@@ -110,7 +110,7 @@ class ConfigurationValidator:
                     errors.append(f"Invalid hostname in ALLOWED_HOSTS[{i}]: '{host}'")
             
             # Production-specific validation
-            if config._environment == 'production' and '*' in allowed_hosts:
+            if config.env_mode == 'production' and '*' in allowed_hosts:
                 errors.append("Wildcard '*' in ALLOWED_HOSTS is not recommended for production")
         
         return errors
@@ -143,7 +143,7 @@ class ConfigurationValidator:
         errors = []
         
         # Environment-specific security validation
-        if config._environment == 'production':
+        if config.env_mode == 'production':
             # Allow DEBUG=True in production for development purposes
             pass
         
@@ -161,7 +161,7 @@ class ConfigurationValidator:
         """Validate environment-specific consistency."""
         errors = []
         
-        environment = config._environment
+        environment = config.env_mode
         
         if environment == 'production':
             # Production requirements - allow DEBUG=True for development

django_cfg/management/commands/show_config.py

@@ -100,7 +100,7 @@ class Command(BaseCommand):
         self.stdout.write(self.style.SUCCESS('\n🌍 Environment'))
         self.stdout.write('-' * 40)
         env_data = [
-            ('Environment', getattr(config, '_environment', 'auto-detected')),
+            ('Environment', getattr(config, 'env_mode', 'auto-detected')),
             ('Debug Mode', config.debug),
             ('Security Domains', ', '.join(config.security_domains) if config.security_domains else 'None'),
         ]
@@ -186,7 +186,7 @@ class Command(BaseCommand):
                 'description': getattr(config, 'project_description', None),
             },
             'environment': {
-                'environment': getattr(config, '_environment', 'auto-detected'),
+                'environment': getattr(config, 'env_mode', 'auto-detected'),
                 'debug': config.debug,
                 'allowed_hosts': config.allowed_hosts,
             },

django_cfg/management/commands/tree.py

@@ -97,9 +97,7 @@ class Command(BaseCommand):
             
             # Try to get environment info
             try:
-                env_info = getattr(config, 'environment', 'unknown')
-                if hasattr(config, '_environment'):
-                    env_info = config._environment or 'unknown'
+                env_info = getattr(config, 'env_mode', 'unknown')
                 self.stdout.write(
                     self.style.HTTP_INFO(f"🔧 Environment: {env_info}")
                 )

django_cfg/middleware/__init__.py

@@ -5,7 +5,9 @@ Provides middleware components for Django CFG applications.
 """
 
 from .user_activity import UserActivityMiddleware
+from .static_nocache import StaticNoCacheMiddleware
 
 __all__ = [
     'UserActivityMiddleware',
+    'StaticNoCacheMiddleware',
 ]

django_cfg/middleware/static_nocache.py

@@ -0,0 +1,55 @@
+"""
+Static files no-cache middleware for django-cfg.
+
+Automatically disables caching for static files in development environments
+to prevent browser caching issues during development.
+"""
+
+from django.conf import settings
+from django_cfg.core.config import EnvironmentMode
+
+
+class StaticNoCacheMiddleware:
+    """
+    Middleware to disable caching for static files in development.
+    
+    This ensures that JavaScript and CSS files are always fresh during development,
+    preventing browser caching issues when files are updated.
+    
+    Automatically detects development mode based on:
+    - DEBUG setting
+    - ENV_MODE environment variable
+    """
+    
+    def __init__(self, get_response):
+        self.get_response = get_response
+        
+        # Determine if we should disable caching
+        self.should_disable_cache = self._should_disable_cache()
+
+    def _should_disable_cache(self):
+        """Determine if caching should be disabled based on environment."""
+        # Always disable in DEBUG mode
+        if settings.DEBUG:
+            return True
+            
+        # Check ENV_MODE if available
+        env_mode = getattr(settings, 'ENV_MODE', None)
+        if env_mode == EnvironmentMode.DEVELOPMENT or env_mode == EnvironmentMode.TEST:
+            return True
+            
+        return False
+
+    def __call__(self, request):
+        response = self.get_response(request)
+        
+        # Apply no-cache headers for static files in development
+        if self.should_disable_cache and request.path.startswith('/static/'):
+            response['Cache-Control'] = 'no-store, no-cache, must-revalidate, max-age=0'
+            response['Pragma'] = 'no-cache'
+            response['Expires'] = '0'
+            # Add ETag removal to prevent conditional requests
+            if 'ETag' in response:
+                del response['ETag']
+        
+        return response