Apply code formatting and linting fixes

- Apply Black formatting to all Bedrock CountTokens files
- Clean up imports and remove unused variables in tests
- Fix indentation and simplify test structure
- Fix pyright type error with type ignore annotation
- All tests continue to pass after cleanup

Author: timelfrink

litellm/llms/bedrock/count_tokens/handler.py

@@ -40,7 +40,9 @@ async def handle_count_tokens_request(
             # Validate the request
             self.validate_count_tokens_request(request_data)
 
-            verbose_logger.debug(f"Processing CountTokens request for resolved model: {resolved_model}")
+            verbose_logger.debug(
+                f"Processing CountTokens request for resolved model: {resolved_model}"
+            )
 
             # Get AWS region using existing LiteLLM function
             aws_region_name = self._get_aws_region_name(
@@ -59,7 +61,9 @@ async def handle_count_tokens_request(
             verbose_logger.debug(f"Transformed request: {bedrock_request}")
 
             # Get endpoint URL using simplified function
-            endpoint_url = self.get_bedrock_count_tokens_endpoint(resolved_model, aws_region_name)
+            endpoint_url = self.get_bedrock_count_tokens_endpoint(
+                resolved_model, aws_region_name
+            )
 
             verbose_logger.debug(f"Making request to: {endpoint_url}")
 
@@ -76,6 +80,7 @@ async def handle_count_tokens_request(
 
             # Make HTTP request
             import httpx
+
             async with httpx.AsyncClient() as client:
                 response = await client.post(
                     endpoint_url,
@@ -91,15 +96,17 @@ async def handle_count_tokens_request(
                     verbose_logger.error(f"AWS Bedrock error: {error_text}")
                     raise HTTPException(
                         status_code=400,
-                        detail={"error": f"AWS Bedrock error: {error_text}"}
+                        detail={"error": f"AWS Bedrock error: {error_text}"},
                     )
 
                 bedrock_response = response.json()
 
             verbose_logger.debug(f"Bedrock response: {bedrock_response}")
 
             # Transform response back to expected format
-            final_response = self.transform_bedrock_response_to_anthropic(bedrock_response)
+            final_response = self.transform_bedrock_response_to_anthropic(
+                bedrock_response
+            )
 
             verbose_logger.debug(f"Final response: {final_response}")
 
@@ -112,5 +119,5 @@ async def handle_count_tokens_request(
             verbose_logger.error(f"Error in CountTokens handler: {str(e)}")
             raise HTTPException(
                 status_code=500,
-                detail={"error": f"CountTokens processing error: {str(e)}"}
-            )
+                detail={"error": f"CountTokens processing error: {str(e)}"},
+            )

litellm/llms/bedrock/count_tokens/transformation.py

@@ -79,7 +79,9 @@ def transform_anthropic_to_bedrock_count_tokens(
         else:
             return self._transform_to_invoke_model_format(request_data)
 
-    def _transform_to_converse_format(self, messages: List[Dict[str, Any]]) -> Dict[str, Any]:
+    def _transform_to_converse_format(
+        self, messages: List[Dict[str, Any]]
+    ) -> Dict[str, Any]:
         """Transform to Converse input format."""
         # Extract system messages if present
         system_messages = []
@@ -90,10 +92,7 @@ def _transform_to_converse_format(self, messages: List[Dict[str, Any]]) -> Dict[
                 system_messages.append({"text": message.get("content", "")})
             else:
                 # Transform message content to Bedrock format
-                transformed_message = {
-                    "role": message.get("role"),
-                    "content": []
-                }
+                transformed_message = {"role": message.get("role"), "content": []}
 
                 # Handle content - ensure it's in the correct array format
                 content = message.get("content", "")
@@ -107,38 +106,30 @@ def _transform_to_converse_format(self, messages: List[Dict[str, Any]]) -> Dict[
                 user_messages.append(transformed_message)
 
         # Build the converse input format
-        converse_input = {
-            "messages": user_messages
-        }
+        converse_input = {"messages": user_messages}
 
         # Add system messages if present
         if system_messages:
             converse_input["system"] = system_messages
 
         # Build the complete request
-        return {
-            "input": {
-                "converse": converse_input
-            }
-        }
+        return {"input": {"converse": converse_input}}
 
-    def _transform_to_invoke_model_format(self, request_data: Dict[str, Any]) -> Dict[str, Any]:
+    def _transform_to_invoke_model_format(
+        self, request_data: Dict[str, Any]
+    ) -> Dict[str, Any]:
         """Transform to InvokeModel input format."""
         import json
 
         # For InvokeModel, we need to provide the raw body that would be sent to the model
         # Remove the 'model' field from the body as it's not part of the model input
         body_data = {k: v for k, v in request_data.items() if k != "model"}
 
-        return {
-            "input": {
-                "invokeModel": {
-                    "body": json.dumps(body_data)
-                }
-            }
-        }
+        return {"input": {"invokeModel": {"body": json.dumps(body_data)}}}
 
-    def get_bedrock_count_tokens_endpoint(self, model: str, aws_region_name: str) -> str:
+    def get_bedrock_count_tokens_endpoint(
+        self, model: str, aws_region_name: str
+    ) -> str:
         """
         Construct the AWS Bedrock CountTokens API endpoint using existing LiteLLM functions.
 
@@ -161,8 +152,9 @@ def get_bedrock_count_tokens_endpoint(self, model: str, aws_region_name: str) ->
 
         return endpoint
 
-
-    def transform_bedrock_response_to_anthropic(self, bedrock_response: Dict[str, Any]) -> Dict[str, Any]:
+    def transform_bedrock_response_to_anthropic(
+        self, bedrock_response: Dict[str, Any]
+    ) -> Dict[str, Any]:
         """
         Transform Bedrock CountTokens response to Anthropic format.
 
@@ -178,9 +170,7 @@ def transform_bedrock_response_to_anthropic(self, bedrock_response: Dict[str, An
         """
         input_tokens = bedrock_response.get("inputTokens", 0)
 
-        return {
-            "input_tokens": input_tokens
-        }
+        return {"input_tokens": input_tokens}
 
     def validate_count_tokens_request(self, request_data: Dict[str, Any]) -> None:
         """
@@ -220,4 +210,4 @@ def validate_count_tokens_request(self, request_data: Dict[str, Any]) -> None:
             # For InvokeModel format, we need at least some content to count tokens
             # The content structure varies by model, so we do minimal validation
             if len(request_data) <= 1:  # Only has 'model' field
-                raise ValueError("Request must contain content to count tokens")
+                raise ValueError("Request must contain content to count tokens")

litellm/proxy/pass_through_endpoints/llm_passthrough_endpoints.py

@@ -172,7 +172,9 @@ async def gemini_proxy_route(
         request=request, api_key=f"Bearer {google_ai_studio_api_key}"
     )
 
-    base_target_url = os.getenv("GEMINI_API_BASE") or "https://generativelanguage.googleapis.com"
+    base_target_url = (
+        os.getenv("GEMINI_API_BASE") or "https://generativelanguage.googleapis.com"
+    )
     encoded_endpoint = httpx.URL(endpoint).path
 
     # Ensure endpoint starts with '/' for proper URL construction
@@ -489,8 +491,7 @@ async def handle_bedrock_count_tokens(
         model = request_body.get("model")
         if not model:
             raise HTTPException(
-                status_code=400,
-                detail={"error": "Model is required in request body"}
+                status_code=400, detail={"error": "Model is required in request body"}
             )
 
         # Get model parameters from router
@@ -511,7 +512,7 @@ async def handle_bedrock_count_tokens(
                 # Copy all litellm_params - BaseAWSLLM will handle AWS credential discovery
                 for key, value in model_litellm_params.items():
                     if key != "user_api_key_dict":  # Don't overwrite user_api_key_dict
-                        litellm_params[key] = value
+                        litellm_params[key] = value  # type: ignore
 
         verbose_proxy_logger.debug(f"Count tokens litellm_params: {litellm_params}")
         verbose_proxy_logger.debug(f"Resolved model: {resolved_model}")
@@ -531,8 +532,7 @@ async def handle_bedrock_count_tokens(
     except Exception as e:
         verbose_proxy_logger.error(f"Error in handle_bedrock_count_tokens: {str(e)}")
         raise HTTPException(
-            status_code=500,
-            detail={"error": f"CountTokens processing error: {str(e)}"}
+            status_code=500, detail={"error": f"CountTokens processing error: {str(e)}"}
         )
 
 
@@ -588,13 +588,13 @@ async def bedrock_llm_proxy_route(
                 "error": "Model missing from endpoint. Expected format: /model/<Model>/<endpoint>. Got: "
                 + endpoint,
             },
-        ) 
+        )
 
     data["method"] = request.method
     data["endpoint"] = endpoint
     data["data"] = request_body
     data["custom_llm_provider"] = "bedrock"
-    
+
     try:
         result = await base_llm_response_processor.base_passthrough_process_llm_request(
             request=request,