docs(token-store): trim over-verbose docstrings to one-line style

Author: kishore7snehil

src/auth0_api_python/token_store.py

@@ -1,7 +1,4 @@
-"""
-Token storage for tokens the SDK itself mints (e.g. On Behalf Of exchanges),
-distinct from CacheAdapter which only caches OIDC discovery metadata and JWKS.
-"""
+"""Token storage for SDK-minted tokens (OBO, M2M, Token Vault), distinct from CacheAdapter."""
 
 from abc import ABC, abstractmethod
 from collections.abc import Mapping
@@ -24,43 +21,14 @@ class TokenSet(_TokenSetRequired, total=False):
 
 @dataclass(frozen=True)
 class VerifiedToken:
-    """An access token and the claims from verifying it.
-
-    The claims must come from verify_access_token, since they are trusted to build the
-    cache identity.
-    """
+    """Access token with verified claims from verify_access_token, trusted to build the cache key."""
 
     access_token: str
     claims: Mapping[str, Any]
 
 
 class AbstractTokenStore(ABC):
-    """
-    Base class for token stores that persist exchanged tokens outside process memory
-    (e.g. Redis, Memcached, a database). Requires a secret at construction and provides
-    encrypt/decrypt helpers so subclasses can protect tokens at rest without having to
-    implement the encryption themselves.
-
-    Example:
-        class RedisTokenStore(AbstractTokenStore):
-            def __init__(self, redis_client, *, secret: str):
-                super().__init__(secret=secret)
-                self.redis = redis_client
-
-            async def get(self, key: str) -> Optional[TokenSet]:
-                raw = await self.redis.get(key)
-                if raw is None:
-                    return None
-                return self.decrypt(key, raw)
-
-            async def set(self, key: str, value: TokenSet) -> None:
-                encrypted = self.encrypt(key, value)
-                ttl = max(value["expires_at"] - int(time.time()), 0)
-                await self.redis.set(key, encrypted, ex=ttl)
-
-            async def delete(self, key: str) -> None:
-                await self.redis.delete(key)
-    """
+    """Base class for external token stores with built-in JWE encrypt and decrypt helpers."""
 
     def __init__(self, *, secret: str) -> None:
         self._secret = secret
@@ -98,16 +66,7 @@ class TokenIndexMember(TypedDict):
 
 
 class IndexedTokenStore(AbstractTokenStore):
-    """
-    A token store that maintains a token index safely under concurrent writes and prunes it by expiry.
-
-    Needed for any cache layout that keeps several tokens per principal and reuses one whose
-    granted scopes cover a request. A plain AbstractTokenStore can only maintain such an index by
-    reading it, adding to it, and writing it back, which loses a concurrent addition made in
-    between. Implementations back the index with a structure that adds one member atomically and
-    drops members once they expire, for example a Redis sorted set scored by each member's
-    expiry. Adding a short-lived member must not shorten the whole index's lifetime.
-    """
+    """Token store variant that maintains a scope index with atomic member writes to avoid concurrent-add races."""
 
     @abstractmethod
     async def add_index_member(self, index_key: str, member: TokenIndexMember) -> None: