perf: convert GCacheKey and RedisValue from Pydantic to dataclass

Replace Pydantic BaseModel with frozen dataclasses for hot-path objects
to reduce object creation overhead. Benchmarks show ~1.5x faster creation.

- GCacheKey: @DataClass(frozen=True, slots=True) with field(default_factory=list)
- RedisValue: @DataClass(frozen=True, slots=True)
- Fix payload mutation in redis_cache.py to work with frozen dataclass

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: lan17

src/gcache/_internal/redis_cache.py

@@ -4,9 +4,9 @@
 import time
 from collections.abc import Callable
 from concurrent.futures.thread import ThreadPoolExecutor
+from dataclasses import dataclass
 from typing import Any
 
-from pydantic import BaseModel
 from redis.asyncio import Redis, RedisCluster
 
 from gcache._internal.cache_interface import CacheInterface, Fallback
@@ -17,7 +17,8 @@
 from gcache.exceptions import MissingKeyConfig
 
 
-class RedisValue(BaseModel):
+@dataclass(frozen=True, slots=True)
+class RedisValue:
     """
     Wrap actual payload with created timestamp.
     """
@@ -133,8 +134,9 @@ async def get(self, key: GCacheKey, fallback: Fallback) -> Any:
             )
 
             # Load payload using custom serializer if present.
+            payload = deserialized_value.payload
             if key.serializer is not None:
-                deserialized_value.payload = await key.serializer.load(deserialized_value.payload)
+                payload = await key.serializer.load(payload)
 
             (
                 GCacheMetrics.SERIALIZATION_TIMER.labels(key.use_case, key.key_type, self.layer().name, "load").observe(
@@ -147,7 +149,7 @@ async def get(self, key: GCacheKey, fallback: Fallback) -> Any:
                 watermark_ms = int(watermark_ms)
                 if watermark_ms >= deserialized_value.created_at_ms:
                     return await self._exec_fallback(key, watermark_ms, fallback)
-            return deserialized_value.payload
+            return payload
         else:
             return await self._exec_fallback(key, watermark_ms, fallback)
 

src/gcache/config.py

@@ -1,6 +1,7 @@
 import json
 from abc import ABC, abstractmethod
 from collections.abc import Awaitable, Callable
+from dataclasses import dataclass, field
 from enum import Enum
 from logging import Logger, LoggerAdapter
 from typing import Any, Union
@@ -115,17 +116,16 @@ async def load(self, data: bytes | str) -> Any:
         pass
 
 
-class GCacheKey(BaseModel):
+@dataclass(frozen=True, slots=True)
+class GCacheKey:
     key_type: str
     id: str
     use_case: str
-    args: list[tuple[str, str]] = []
+    args: list[tuple[str, str]] = field(default_factory=list)
     invalidation_tracking: bool = False
     default_config: GCacheKeyConfig | None = None
     serializer: Serializer | None = None
 
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
     def __hash__(self) -> int:
         # Tuple hashing is fast (C implementation) and avoids string allocation
         return hash((self.key_type, self.id, self.use_case, tuple(self.args)))