refactor(client): 🔨 centralize request execution setup logic

This commit extracts the initialization, credential filtering, and validation steps into a reusable `_prepare_execution` helper method within `RequestExecutor`. This ensures consistency and reduces code duplication between streaming and non-streaming request handlers.

Also in this commit:
- refactor(usage): remove unused `release` method from `TrackingEngine

Author: Mirrowel

src/rotator_library/client/executor.py

@@ -17,7 +17,17 @@
 import logging
 import random
 import time
-from typing import Any, AsyncGenerator, Dict, List, Optional, Set, TYPE_CHECKING, Union
+from typing import (
+    Any,
+    AsyncGenerator,
+    Dict,
+    List,
+    Optional,
+    Set,
+    TYPE_CHECKING,
+    Tuple,
+    Union,
+)
 
 import httpx
 import litellm
@@ -143,34 +153,21 @@ async def execute(
         else:
             return await self._execute_non_streaming(context)
 
-    async def _execute_non_streaming(
+    async def _prepare_execution(
         self,
         context: RequestContext,
-    ) -> Any:
-        """
-        Execute non-streaming request with retry/rotation.
-
-        Args:
-            context: RequestContext with all request details
-
-        Returns:
-            Response object
-        """
+    ) -> Tuple["UsageManager", Any, List[str], Optional[str], Dict[str, Any]]:
         provider = context.provider
         model = context.model
-        deadline = context.deadline
 
-        # Get the UsageManager for this provider
         usage_manager = self._usage_managers.get(provider)
         if not usage_manager:
             raise NoAvailableKeysError(f"No UsageManager for provider {provider}")
 
-        # Filter credentials by tier
         filter_result = self._filter.filter_by_tier(
             context.credentials, model, provider
         )
         credentials = filter_result.all_usable
-
         quota_group = usage_manager.get_model_quota_group(model)
 
         await self._ensure_initialized(usage_manager, context, filter_result)
@@ -179,13 +176,41 @@ async def _execute_non_streaming(
         if not credentials:
             raise NoAvailableKeysError(f"No compatible credentials for model {model}")
 
-        error_accumulator = RequestErrorAccumulator()
-        error_accumulator.model = model
-        error_accumulator.provider = provider
         request_headers = (
             dict(context.request.headers) if context.request is not None else {}
         )
 
+        return usage_manager, filter_result, credentials, quota_group, request_headers
+
+    async def _execute_non_streaming(
+        self,
+        context: RequestContext,
+    ) -> Any:
+        """
+        Execute non-streaming request with retry/rotation.
+
+        Args:
+            context: RequestContext with all request details
+
+        Returns:
+            Response object
+        """
+        provider = context.provider
+        model = context.model
+        deadline = context.deadline
+
+        (
+            usage_manager,
+            filter_result,
+            credentials,
+            quota_group,
+            request_headers,
+        ) = await self._prepare_execution(context)
+
+        error_accumulator = RequestErrorAccumulator()
+        error_accumulator.model = model
+        error_accumulator.provider = provider
+
         retry_state = RetryState()
         last_exception: Optional[Exception] = None
 
@@ -430,37 +455,18 @@ async def _execute_streaming(
         model = context.model
         deadline = context.deadline
 
-        # Get the UsageManager for this provider
-        usage_manager = self._usage_managers.get(provider)
-        if not usage_manager:
-            error_data = {
-                "error": {
-                    "message": f"No UsageManager for provider {provider}",
-                    "type": "proxy_error",
-                }
-            }
-            yield f"data: {json.dumps(error_data)}\n\n"
-            yield "data: [DONE]\n\n"
-            return
-
-        # Filter credentials by tier
-        filter_result = self._filter.filter_by_tier(
-            context.credentials, model, provider
-        )
-        credentials = filter_result.all_usable
-        quota_group = usage_manager.get_model_quota_group(model)
-
-        await self._ensure_initialized(usage_manager, context, filter_result)
-        await self._validate_request(provider, model, context.kwargs)
-
-        request_headers = (
-            dict(context.request.headers) if context.request is not None else {}
-        )
-
-        if not credentials:
+        try:
+            (
+                usage_manager,
+                filter_result,
+                credentials,
+                quota_group,
+                request_headers,
+            ) = await self._prepare_execution(context)
+        except NoAvailableKeysError as exc:
             error_data = {
                 "error": {
-                    "message": f"No compatible credentials for {model}",
+                    "message": str(exc),
                     "type": "proxy_error",
                 }
             }

src/rotator_library/usage/tracking/engine.py

@@ -354,21 +354,6 @@ async def acquire(
             state.active_requests += 1
             return True
 
-    async def release(
-        self,
-        state: CredentialState,
-        model: str,
-    ) -> None:
-        """
-        Release a credential after request completes.
-
-        Args:
-            state: Credential state
-            model: Model that was used
-        """
-        async with self._lock:
-            return
-
     async def apply_cooldown(
         self,
         state: CredentialState,