Incorporate PR feedback: improve examples

- Replace CompressionWrapper with LoggingWrapper in trading_data example
  (disk cache is already compressed, so logging is more useful)
- Move logging.basicConfig() from module-level to main() in all examples
  (prevents side effects on import)
- Fix fragile wrapper attribute chains by using explicit variable references
  (improves maintainability and removes type: ignore comments)
- Update README documentation to match code changes

Addresses feedback from @strawgate and CodeRabbit review.

Co-authored-by: William Easton <strawgate@users.noreply.github.com>

Author: github-actions[bot]

examples/chat_app/chat_app.py

@@ -19,9 +19,6 @@
 from key_value.aio.wrappers.ttl_clamp.wrapper import TTLClampWrapper
 from pydantic import BaseModel
 
-# Configure logging
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
-
 
 class ChatMessage(BaseModel):
     """A chat message with sender, content, and timestamp."""
@@ -47,12 +44,9 @@ def __init__(self):
         # 1. StatisticsWrapper - Track operation metrics
         # 2. TTLClampWrapper - Enforce max TTL of 24 hours (86400 seconds)
         # 3. LoggingWrapper - Log all operations for debugging
-        wrapped_store = LoggingWrapper(
-            key_value=TTLClampWrapper(
-                key_value=StatisticsWrapper(key_value=base_store),
-                max_ttl=86400,  # 24 hours in seconds
-            )
-        )
+        stats = StatisticsWrapper(key_value=base_store)
+        ttl_clamped = TTLClampWrapper(key_value=stats, max_ttl=86400)  # 24 hours
+        wrapped_store = LoggingWrapper(key_value=ttl_clamped)
 
         # PydanticAdapter for type-safe message storage/retrieval
         self.adapter: PydanticAdapter[ChatMessage] = PydanticAdapter[ChatMessage](
@@ -61,7 +55,7 @@ def __init__(self):
         )
 
         # Store reference to statistics wrapper for metrics
-        self.stats_wrapper = wrapped_store.key_value.key_value  # type: ignore[attr-defined]
+        self.stats_wrapper = stats
 
     async def send_message(self, conversation_id: str, sender: str, content: str) -> str:
         """
@@ -136,6 +130,9 @@ def get_statistics(self) -> dict[str, int]:
 
 async def main():
     """Demonstrate the chat application."""
+    # Configure logging for the demo
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+
     chat = ChatApp()
 
     # Send some messages

examples/trading_data/README.md

@@ -1,20 +1,19 @@
 # Trading Data Cache Example
 
 A trading data caching application demonstrating advanced py-key-value patterns
-including compression, multi-tier caching, and retry logic.
+including logging, multi-tier caching, and retry logic.
 
 ## Overview
 
 This example shows how to build an efficient trading data cache using
 py-key-value. The implementation features a two-tier caching strategy
-(memory + disk) with compression for optimal storage efficiency and fast access
-to recent data.
+(memory + disk) with logging for observability and fast access to recent data.
 
 ## Features
 
 - **Type-safe price data storage** using PydanticAdapter
 - **Multi-tier caching** with PassthroughCacheWrapper (memory → disk)
-- **Data compression** with CompressionWrapper for efficient storage
+- **Operation logging** with LoggingWrapper for debugging and observability
 - **Automatic retry** with RetryWrapper for transient failure handling
 - **Cache metrics** tracking with StatisticsWrapper
 - **Symbol-based isolation** using collection-based storage
@@ -26,15 +25,14 @@ The wrapper stack (applied inside-out):
 1. **StatisticsWrapper** - Tracks cache hit/miss metrics and operation counts
 2. **RetryWrapper** - Handles transient failures with exponential backoff (3
    retries)
-3. **CompressionWrapper** - Compresses data before writing to disk
+3. **LoggingWrapper** - Logs all operations for debugging and monitoring
 4. **PassthroughCacheWrapper** - Two-tier caching: fast memory cache with disk
    persistence
 
 Data flow:
 
-- **Write**: Data → Memory cache → Compressed → Disk storage
-- **Read**: Check memory cache → If miss, load from disk → Decompress → Cache in
-  memory
+- **Write**: Data → Memory cache → Logged → Disk storage
+- **Read**: Check memory cache → If miss, load from disk → Log → Cache in memory
 
 ## Requirements
 
@@ -224,9 +222,14 @@ from key_value.aio.stores.redis.store import RedisStore
 memory_cache = RedisStore(url="redis://localhost:6379/0")
 disk_cache = DiskStore(root_directory="historical_data")
 
+# Build wrapper stack with logging
+stats = StatisticsWrapper(key_value=disk_cache)
+retry_wrapper = RetryWrapper(key_value=stats, max_retries=3, base_delay=0.1)
+disk_with_logging = LoggingWrapper(key_value=retry_wrapper)
+
 cache_store = PassthroughCacheWrapper(
     cache=memory_cache,
-    key_value=CompressionWrapper(key_value=disk_cache)
+    key_value=disk_with_logging
 )
 ```
 
@@ -235,8 +238,12 @@ Example with encryption:
 ```python
 from key_value.aio.wrappers.encryption.wrapper import FernetEncryptionWrapper
 
-encrypted_disk = FernetEncryptionWrapper(
-    key_value=disk_cache,
+# Add encryption to the wrapper stack
+stats = StatisticsWrapper(key_value=disk_cache)
+encrypted_stats = FernetEncryptionWrapper(
+    key_value=stats,
     key=b"your-32-byte-encryption-key-here"
 )
+retry_wrapper = RetryWrapper(key_value=encrypted_stats, max_retries=3, base_delay=0.1)
+disk_with_logging = LoggingWrapper(key_value=retry_wrapper)
 ```

examples/trading_data/trading_app.py

@@ -3,7 +3,7 @@
 
 This example shows how to:
 - Use PydanticAdapter for type-safe price data storage
-- Apply CompressionWrapper for efficient historical data storage
+- Use LoggingWrapper for observability and debugging
 - Use PassthroughCacheWrapper for multi-tier caching (memory + disk)
 - Use RetryWrapper for handling transient failures
 - Use StatisticsWrapper to track cache hit/miss metrics
@@ -17,15 +17,12 @@
 from key_value.aio.adapters.pydantic import PydanticAdapter
 from key_value.aio.stores.disk.store import DiskStore
 from key_value.aio.stores.memory.store import MemoryStore
-from key_value.aio.wrappers.compression.wrapper import CompressionWrapper
+from key_value.aio.wrappers.logging.wrapper import LoggingWrapper
 from key_value.aio.wrappers.passthrough_cache.wrapper import PassthroughCacheWrapper
 from key_value.aio.wrappers.retry.wrapper import RetryWrapper
 from key_value.aio.wrappers.statistics.wrapper import StatisticsWrapper
 from pydantic import BaseModel
 
-# Configure logging
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
-
 
 class PriceData(BaseModel):
     """Trading price data for a symbol."""
@@ -38,11 +35,11 @@ class PriceData(BaseModel):
 
 class TradingDataCache:
     """
-    Trading data cache with multi-tier caching and compression.
+    Trading data cache with multi-tier caching and logging.
 
     Uses a memory cache for fast access to recent data, with disk-backed
-    persistence for historical data. Compression reduces storage requirements
-    for large datasets.
+    persistence for historical data. Logging provides observability into
+    cache operations.
     """
 
     def __init__(self, cache_dir: str = ".trading_cache"):
@@ -52,19 +49,19 @@ def __init__(self, cache_dir: str = ".trading_cache"):
         # Tier 1: Memory cache for fast access
         memory_cache = MemoryStore()
 
-        # Tier 2: Disk cache with compression for historical data
+        # Tier 2: Disk cache for historical data
         disk_cache = DiskStore(root_directory=cache_dir)
 
         # Wrapper stack (applied inside-out):
         # 1. StatisticsWrapper - Track cache metrics
         # 2. RetryWrapper - Handle transient failures (3 retries with exponential backoff)
-        # 3. CompressionWrapper - Compress data before storage
+        # 3. LoggingWrapper - Log operations for debugging
         # 4. PassthroughCacheWrapper - Two-tier caching (memory → disk)
-        disk_with_compression = CompressionWrapper(
-            key_value=RetryWrapper(key_value=StatisticsWrapper(key_value=disk_cache), max_retries=3, base_delay=0.1)
-        )
+        stats = StatisticsWrapper(key_value=disk_cache)
+        retry_wrapper = RetryWrapper(key_value=stats, max_retries=3, base_delay=0.1)
+        disk_with_logging = LoggingWrapper(key_value=retry_wrapper)
 
-        cache_store = PassthroughCacheWrapper(cache=memory_cache, key_value=disk_with_compression)
+        cache_store = PassthroughCacheWrapper(cache=memory_cache, key_value=disk_with_logging)
 
         # PydanticAdapter for type-safe price data storage/retrieval
         self.adapter: PydanticAdapter[PriceData] = PydanticAdapter[PriceData](
@@ -73,7 +70,7 @@ def __init__(self, cache_dir: str = ".trading_cache"):
         )
 
         # Store reference to statistics wrapper for metrics
-        self.stats_wrapper = disk_with_compression.key_value.key_value  # type: ignore[attr-defined]
+        self.stats_wrapper = stats
         self.cache_dir = cache_dir
 
     async def store_price(self, symbol: str, price: float, volume: int, ttl: int | None = None) -> str:
@@ -170,6 +167,9 @@ async def cleanup(self):
 
 async def main():
     """Demonstrate the trading data cache."""
+    # Configure logging for the demo
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+
     cache = TradingDataCache(cache_dir=".demo_trading_cache")
 
     try:

examples/web_scraper_cache/scraper.py

@@ -25,8 +25,6 @@
 from key_value.aio.wrappers.ttl_clamp.wrapper import TTLClampWrapper
 from pydantic import BaseModel
 
-# Configure logging
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
 logger = logging.getLogger(__name__)
 
 
@@ -199,6 +197,9 @@ async def simulate_scrape(url: str) -> tuple[str, dict[str, str]]:
 
 async def main():
     """Demonstrate the web scraper cache."""
+    # Configure logging for the demo
+    logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
+
     # Generate a key for this demo (in production, load from secure storage)
     encryption_key = Fernet.generate_key()
     # Only show fingerprint, never the actual key