[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

docs/cache_support.rst

@@ -62,4 +62,3 @@ Cache keys follow this format:
 
 - Refresh token: ``sjwt_brt:<jti>``
 - Token family: ``sjwt_btf:<family_id>``
-

rest_framework_simplejwt/cache.py

@@ -1,22 +1,24 @@
 from django.core.cache import caches
+
 from .settings import api_settings
 
+
 class BlacklistCache:
     """
     Cache implementation for Simple JWT blacklist functionalities.
     Provides caching for both blacklisted refresh tokens and token families.
     """
-        
+
     @property
     def cache(self):
         """Get the configured cache backend for Simple JWT."""
         return caches[api_settings.SJWT_CACHE_NAME]
-    
+
     @property
     def is_refresh_tokens_cache_enabled(self):
         """Check if refresh token caching is enabled."""
         return api_settings.CACHE_BLACKLISTED_REFRESH_TOKENS
-    
+
     @property
     def is_families_cache_enabled(self):
         """Check if token family caching is enabled."""
@@ -29,39 +31,33 @@ def _get_refresh_token_key(self, jti: str) -> str:
     def _get_family_key(self, family_id: str) -> str:
         """Generate cache key for a token family ID."""
         return f"{api_settings.CACHE_KEY_PREFIX_BLACKLISTED_FAMILIES}:{family_id}"
-    
+
     def add_refresh_token(self, jti: str) -> None:
         """Stores refresh token JTI in the cache."""
         key = self._get_refresh_token_key(jti)
         self.cache.set(
-            key, 
-            True, 
-            timeout=api_settings.CACHE_TTL_BLACKLISTED_REFRESH_TOKENS
+            key, True, timeout=api_settings.CACHE_TTL_BLACKLISTED_REFRESH_TOKENS
         )
-    
+
     def is_refresh_token_blacklisted(self, jti: str) -> bool:
         """Checks if a refresh token JTI is blacklisted in cache."""
         return self.cache.get(self._get_refresh_token_key(jti), False)
 
     def add_token_family(self, family_id: str) -> None:
         """Stores a token family ID in the cache."""
         key = self._get_family_key(family_id)
-        self.cache.set(
-            key, 
-            True, 
-            timeout=api_settings.CACHE_TTL_BLACKLISTED_FAMILIES
-        )
+        self.cache.set(key, True, timeout=api_settings.CACHE_TTL_BLACKLISTED_FAMILIES)
 
     def is_token_family_blacklisted(self, family_id: str) -> bool:
         """Checks if a token family is blacklisted in cache."""
-        return self.cache.get(self._get_family_key(family_id), False)    
-        
+        return self.cache.get(self._get_family_key(family_id), False)
+
     def delete_refresh_token_from_cache(self, jti: str) -> bool:
         """Returns True if the token jti was successfully deleted, False otherwise."""
         return self.cache.delete(self._get_refresh_token_key(jti))
 
     def delete_family_from_cache(self, family_id: str) -> bool:
-        """Returns True if the family ID was successfully deleted, False otherwise."""        
+        """Returns True if the family ID was successfully deleted, False otherwise."""
         return self.cache.delete(self._get_family_key(family_id))
 
 

rest_framework_simplejwt/exceptions.py

@@ -22,6 +22,7 @@ class TokenBackendExpiredToken(TokenBackendError):
 
 class RefreshTokenBlacklistedError(TokenError):
     """Raised when a refresh token is found in the blacklist."""
+
     pass
 
 
@@ -66,4 +67,4 @@ class TokenFamilyNotConfigured(DetailDictMixin, exceptions.APIException):
     default_detail = _(
         "Token family functionality is not enabled or available. Please check your configuration."
     )
-    default_code = "token_family_not_configured"
+    default_code = "token_family_not_configured"

rest_framework_simplejwt/serializers.py

@@ -7,12 +7,16 @@
 from rest_framework import exceptions, serializers
 from rest_framework.exceptions import AuthenticationFailed, ValidationError
 
-from .exceptions import TokenError, TokenFamilyNotConfigured, RefreshTokenBlacklistedError
+from .cache import blacklist_cache
+from .exceptions import (
+    RefreshTokenBlacklistedError,
+    TokenError,
+    TokenFamilyNotConfigured,
+)
 from .models import TokenUser
 from .settings import api_settings
-from .tokens import RefreshToken, SlidingToken, Token, UntypedToken, FamilyMixin
-from .cache import blacklist_cache
 from .token_blacklist.models import BlacklistedToken
+from .tokens import FamilyMixin, RefreshToken, SlidingToken, Token, UntypedToken
 
 AuthUser = TypeVar("AuthUser", AbstractBaseUser, TokenUser)
 
@@ -143,7 +147,7 @@ def validate(self, attrs: dict[str, Any]) -> dict[str, str]:
             data["refresh"] = str(refresh)
 
         return data
-    
+
     def _get_refresh_token(self, token_str: str) -> RefreshToken:
         """
         Handles refresh token instantiation and family blacklisting if enabled.
@@ -152,9 +156,9 @@ def _get_refresh_token(self, token_str: str) -> RefreshToken:
             return self.token_class(token_str)
         except RefreshTokenBlacklistedError as e:
             if (
-                api_settings.TOKEN_FAMILY_ENABLED and
-                api_settings.TOKEN_FAMILY_BLACKLIST_ON_REUSE and
-                "rest_framework_simplejwt.token_family" in settings.INSTALLED_APPS
+                api_settings.TOKEN_FAMILY_ENABLED
+                and api_settings.TOKEN_FAMILY_BLACKLIST_ON_REUSE
+                and "rest_framework_simplejwt.token_family" in settings.INSTALLED_APPS
             ):
                 refresh = self.token_class(token=token_str, verify=False)
                 family_id = refresh.get_family_id()
@@ -202,13 +206,13 @@ def validate(self, attrs: dict[str, None]) -> dict[Any, Any]:
 
             if BlacklistedToken.objects.filter(token__jti=jti).exists():
                 raise ValidationError(_("Token is blacklisted"))
-            
+
         if (
-            api_settings.TOKEN_FAMILY_ENABLED and
-            "rest_framework_simplejwt.token_family" in settings.INSTALLED_APPS
-        ):  
-            FamilyMixin.check_family_expiration(token= token)
-            FamilyMixin.check_family_blacklist(token= token)
+            api_settings.TOKEN_FAMILY_ENABLED
+            and "rest_framework_simplejwt.token_family" in settings.INSTALLED_APPS
+        ):
+            FamilyMixin.check_family_expiration(token=token)
+            FamilyMixin.check_family_blacklist(token=token)
 
         return {}
 
@@ -224,7 +228,7 @@ def validate(self, attrs: dict[str, Any]) -> dict[Any, Any]:
         except AttributeError:
             pass
         return {}
-    
+
 
 class TokenFamilyBlacklistSerializer(serializers.Serializer):
     refresh = serializers.CharField(write_only=True)
@@ -238,5 +242,5 @@ def validate(self, attrs: dict[str, Any]) -> dict[Any, Any]:
             raise TokenFamilyNotConfigured()
         except TokenError as e:
             raise serializers.ValidationError({"refresh": str(e)})
-        
+
         return {"message": "Token Family blacklisted"}

rest_framework_simplejwt/token_family/__init__.py

@@ -1,6 +1,4 @@
 from django import VERSION
 
 if VERSION < (3, 2):
-    default_app_config = (
-        "rest_framework_simplejwt.token_family.apps.TokenFamilyConfig"
-    )
+    default_app_config = "rest_framework_simplejwt.token_family.apps.TokenFamilyConfig"

rest_framework_simplejwt/token_family/admin.py

@@ -8,7 +8,7 @@
 from rest_framework.request import Request
 
 from ..models import TokenUser
-from .models import TokenFamily, BlacklistedTokenFamily
+from .models import BlacklistedTokenFamily, TokenFamily
 
 AuthUser = TypeVar("AuthUser", AbstractBaseUser, TokenUser)
 
@@ -98,4 +98,4 @@ def family_expires_at(self, obj: BlacklistedTokenFamily) -> datetime:
     family_expires_at.admin_order_field = "family__expires_at"  # type: ignore
 
 
-admin.site.register(BlacklistedTokenFamily, BlacklistedTokenFamilyAdmin)
+admin.site.register(BlacklistedTokenFamily, BlacklistedTokenFamilyAdmin)

rest_framework_simplejwt/token_family/apps.py

@@ -1,8 +1,10 @@
+from datetime import timedelta
+
 from django.apps import AppConfig
-from django.utils.translation import gettext_lazy as _
 from django.core.exceptions import ImproperlyConfigured
 from django.utils.module_loading import import_string
-from datetime import timedelta
+from django.utils.translation import gettext_lazy as _
+
 from rest_framework_simplejwt.settings import api_settings
 
 
@@ -30,31 +32,45 @@ def _validate_family_settings() -> None:
 
         family_exp_claim = api_settings.TOKEN_FAMILY_EXPIRATION_CLAIM
         if not isinstance(family_exp_claim, str) or not family_exp_claim.strip():
-            raise ImproperlyConfigured("TOKEN_FAMILY_EXPIRATION_CLAIM must be a non-empty string")
+            raise ImproperlyConfigured(
+                "TOKEN_FAMILY_EXPIRATION_CLAIM must be a non-empty string"
+            )
 
         family_lifetime = api_settings.TOKEN_FAMILY_LIFETIME
         if family_lifetime is not None and not isinstance(family_lifetime, timedelta):
-            raise ImproperlyConfigured("TOKEN_FAMILY_LIFETIME must be of type timedelta or None")
+            raise ImproperlyConfigured(
+                "TOKEN_FAMILY_LIFETIME must be of type timedelta or None"
+            )
 
         family_enabled = api_settings.TOKEN_FAMILY_ENABLED
         if not isinstance(family_enabled, bool):
             raise ImproperlyConfigured("TOKEN_FAMILY_ENABLED must be of type bool")
 
         check_on_access = api_settings.TOKEN_FAMILY_CHECK_ON_ACCESS
         if not isinstance(check_on_access, bool):
-            raise ImproperlyConfigured("TOKEN_FAMILY_CHECK_ON_ACCESS must be of type bool")
+            raise ImproperlyConfigured(
+                "TOKEN_FAMILY_CHECK_ON_ACCESS must be of type bool"
+            )
 
         blacklist_on_reuse = api_settings.TOKEN_FAMILY_BLACKLIST_ON_REUSE
         if not isinstance(blacklist_on_reuse, bool):
-            raise ImproperlyConfigured("TOKEN_FAMILY_BLACKLIST_ON_REUSE must be of type bool")
-        
+            raise ImproperlyConfigured(
+                "TOKEN_FAMILY_BLACKLIST_ON_REUSE must be of type bool"
+            )
 
         # Validate TOKEN_FAMILY_BLACKLIST_SERIALIZER
         blacklist_serializer_path = api_settings.TOKEN_FAMILY_BLACKLIST_SERIALIZER
-        if not isinstance(blacklist_serializer_path, str) or not blacklist_serializer_path.strip():
-            raise ImproperlyConfigured("TOKEN_FAMILY_BLACKLIST_SERIALIZER must be a non-empty string")
+        if (
+            not isinstance(blacklist_serializer_path, str)
+            or not blacklist_serializer_path.strip()
+        ):
+            raise ImproperlyConfigured(
+                "TOKEN_FAMILY_BLACKLIST_SERIALIZER must be a non-empty string"
+            )
 
         try:
             import_string(blacklist_serializer_path)
         except ImportError as e:
-            raise ImportError(f"Could not import serializer '{blacklist_serializer_path}': {e}") from e
+            raise ImportError(
+                f"Could not import serializer '{blacklist_serializer_path}': {e}"
+            ) from e

rest_framework_simplejwt/token_family/migrations/0001_initial.py

@@ -6,7 +6,6 @@
 
 
 class Migration(migrations.Migration):
-
     initial = True
 
     dependencies = [
@@ -15,29 +14,45 @@ class Migration(migrations.Migration):
 
     operations = [
         migrations.CreateModel(
-            name='TokenFamily',
+            name="TokenFamily",
             fields=[
-                ('id', models.BigAutoField(primary_key=True, serialize=False)),
-                ('family_id', models.CharField(max_length=255, unique=True)),
-                ('created_at', models.DateTimeField(blank=True)),
-                ('expires_at', models.DateTimeField(blank=True, null=True)),
-                ('user', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='token_families', to=settings.AUTH_USER_MODEL)),
+                ("id", models.BigAutoField(primary_key=True, serialize=False)),
+                ("family_id", models.CharField(max_length=255, unique=True)),
+                ("created_at", models.DateTimeField(blank=True)),
+                ("expires_at", models.DateTimeField(blank=True, null=True)),
+                (
+                    "user",
+                    models.ForeignKey(
+                        blank=True,
+                        null=True,
+                        on_delete=django.db.models.deletion.SET_NULL,
+                        related_name="token_families",
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
             ],
             options={
-                'verbose_name': 'Token Family',
-                'verbose_name_plural': 'Token Families',
+                "verbose_name": "Token Family",
+                "verbose_name_plural": "Token Families",
             },
         ),
         migrations.CreateModel(
-            name='TokenFamilyBlacklist',
+            name="TokenFamilyBlacklist",
             fields=[
-                ('id', models.BigAutoField(primary_key=True, serialize=False)),
-                ('blacklisted_at', models.DateTimeField(auto_now_add=True)),
-                ('family', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, related_name='blacklisted', to='token_family.tokenfamily')),
+                ("id", models.BigAutoField(primary_key=True, serialize=False)),
+                ("blacklisted_at", models.DateTimeField(auto_now_add=True)),
+                (
+                    "family",
+                    models.OneToOneField(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="blacklisted",
+                        to="token_family.tokenfamily",
+                    ),
+                ),
             ],
             options={
-                'verbose_name': 'Token Family Blacklist',
-                'verbose_name_plural': 'Blacklisted Token Families',
+                "verbose_name": "Token Family Blacklist",
+                "verbose_name_plural": "Blacklisted Token Families",
             },
         ),
     ]

rest_framework_simplejwt/token_family/migrations/0002_rename_tokenfamilyblacklist_blacklistedtokenfamily.py

@@ -4,14 +4,13 @@
 
 
 class Migration(migrations.Migration):
-
     dependencies = [
-        ('token_family', '0001_initial'),
+        ("token_family", "0001_initial"),
     ]
 
     operations = [
         migrations.RenameModel(
-            old_name='TokenFamilyBlacklist',
-            new_name='BlacklistedTokenFamily',
+            old_name="TokenFamilyBlacklist",
+            new_name="BlacklistedTokenFamily",
         ),
     ]