style: clean up unused parameters and imports in examples

examples/basic_usage.py

@@ -3,21 +3,24 @@
 from __future__ import annotations
 
 from contextlib import asynccontextmanager
-from typing import AsyncIterator
+from typing import TYPE_CHECKING
 
 from fastapi import Depends, FastAPI, Request
 from fastapi.responses import JSONResponse
 
 from fastapi_traffic import (
     Algorithm,
-    RateLimitExceeded,
     RateLimiter,
+    RateLimitExceeded,
     SQLiteBackend,
     rate_limit,
 )
 from fastapi_traffic.core.decorator import RateLimitDependency
 from fastapi_traffic.core.limiter import set_limiter
 
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator
+
 # Configure global rate limiter with SQLite backend for persistence
 backend = SQLiteBackend("rate_limits.db")
 limiter = RateLimiter(backend)
@@ -25,7 +28,7 @@ set_limiter(limiter)
 
 
 @asynccontextmanager
-async def lifespan(app: FastAPI) -> AsyncIterator[None]:
+async def lifespan(_: FastAPI) -> AsyncIterator[None]:
     """Manage application lifespan - startup and shutdown."""
     # Startup: Initialize the rate limiter
     await limiter.initialize()
@@ -39,7 +42,7 @@ app = FastAPI(title="FastAPI Traffic Example", lifespan=lifespan)
 
 # Exception handler for rate limit exceeded
 @app.exception_handler(RateLimitExceeded)
-async def rate_limit_handler(request: Request, exc: RateLimitExceeded) -> JSONResponse:
+async def rate_limit_handler(_: Request, exc: RateLimitExceeded) -> JSONResponse:
     """Handle rate limit exceeded exceptions."""
     headers = exc.limit_info.to_headers() if exc.limit_info else {}
     return JSONResponse(
@@ -56,7 +59,7 @@ async def rate_limit_handler(request: Request, exc: RateLimitExceeded) -> JSONRe
 # Example 1: Basic decorator usage
 @app.get("/api/basic")
 @rate_limit(100, 60)  # 100 requests per minute
-async def basic_endpoint(request: Request) -> dict[str, str]:
+async def basic_endpoint(_: Request) -> dict[str, str]:
     """Basic rate-limited endpoint."""
     return {"message": "Hello, World!"}
 
@@ -69,7 +72,7 @@ async def basic_endpoint(request: Request) -> dict[str, str]:
     algorithm=Algorithm.TOKEN_BUCKET,
     burst_size=10,  # Allow bursts of up to 10 requests
 )
-async def token_bucket_endpoint(request: Request) -> dict[str, str]:
+async def token_bucket_endpoint(_: Request) -> dict[str, str]:
     """Endpoint using token bucket algorithm."""
     return {"message": "Token bucket rate limiting"}
 
@@ -81,7 +84,7 @@ async def token_bucket_endpoint(request: Request) -> dict[str, str]:
     window_size=60,
     algorithm=Algorithm.SLIDING_WINDOW,
 )
-async def sliding_window_endpoint(request: Request) -> dict[str, str]:
+async def sliding_window_endpoint(_: Request) -> dict[str, str]:
     """Endpoint using sliding window algorithm."""
     return {"message": "Sliding window rate limiting"}
 
@@ -99,7 +102,7 @@ def api_key_extractor(request: Request) -> str:
     window_size=3600,  # 1000 requests per hour
     key_extractor=api_key_extractor,
 )
-async def api_key_endpoint(request: Request) -> dict[str, str]:
+async def api_key_endpoint(_: Request) -> dict[str, str]:
     """Endpoint rate limited by API key."""
     return {"message": "Rate limited by API key"}
 
@@ -110,7 +113,7 @@ rate_limit_dep = RateLimitDependency(limit=20, window_size=60)
 
 @app.get("/api/dependency")
 async def dependency_endpoint(
-    request: Request,
+    _: Request,
     rate_info: dict[str, object] = Depends(rate_limit_dep),
 ) -> dict[str, object]:
     """Endpoint using rate limit as dependency."""
@@ -132,7 +135,7 @@ def is_admin(request: Request) -> bool:
     window_size=60,
     exempt_when=is_admin,
 )
-async def admin_exempt_endpoint(request: Request) -> dict[str, str]:
+async def admin_exempt_endpoint(_: Request) -> dict[str, str]:
     """Endpoint with admin exemption."""
     return {"message": "Admins are exempt from rate limiting"}
 
@@ -144,7 +147,7 @@ async def admin_exempt_endpoint(request: Request) -> dict[str, str]:
     window_size=60,
     cost=10,  # This endpoint costs 10 tokens per request
 )
-async def expensive_endpoint(request: Request) -> dict[str, str]:
+async def expensive_endpoint(_: Request) -> dict[str, str]:
     """Expensive operation that costs more tokens."""
     return {"message": "Expensive operation completed"}