scriptoriumadmin/litellm
1
0
Fork 0
mirror of https://github.com/BerriAI/litellm.git synced 2026-08-28 05:25:59 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 36

merge: litellm_internal_staging into litellm_vertex_batch_embeddings_translation
Some checks failed
LiteLLM Rust / rustfmt, clippy, test (push) Has been cancelled
Details

Browse source 
Co-Authored-By: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
This commit is contained in:
milan 2026-08-03 19:25:41 +00:00
commit 2558d145f5
265 changed files with 1320 additions and 1087 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
litellm/_lazy_imports.py
View file

@ -23,6 +23,7 @@ from typing import Any, cast
# Import all the data structures that define what can be lazy-loaded
# These are just lists of names and maps of where to find them
from ._lazy_imports_registry import (
# Import maps
_BEDROCK_TYPES_IMPORT_MAP,
_CACHING_IMPORT_MAP,
_COST_CALCULATOR_IMPORT_MAP,
@ -33,12 +34,11 @@ from ._lazy_imports_registry import (
_TOKEN_COUNTER_IMPORT_MAP,
_TYPES_IMPORT_MAP,
_TYPES_UTILS_IMPORT_MAP,
# Import maps
_UTILS_IMPORT_MAP,
_UTILS_MODULE_IMPORT_MAP,
# Name tuples
BEDROCK_TYPES_NAMES,
CACHING_NAMES,
# Name tuples
COST_CALCULATOR_NAMES,
DOTPROMPT_NAMES,
HTTP_HANDLER_NAMES,

2
litellm/batch_completion/main.py
View file

@ -249,7 +249,7 @@ def batch_completion_models_all_responses(*args, **kwargs):
if result is not None:
responses.append(result)
except Exception as e:
print_verbose(f"batch_completion_models_all_responses: model request failed: {e!s}")
print_verbose(f"batch_completion_models_all_responses: model request failed: {e}")
continue
return responses

4
litellm/batches/main.py
View file

@ -182,7 +182,7 @@ def create_batch(
)
except Exception as e:
verbose_logger.exception(
f"litellm.batches.main.py::create_batch() - Error inferring custom_llm_provider - {e!s}"
f"litellm.batches.main.py::create_batch() - Error inferring custom_llm_provider - {e}"
)
_is_async = kwargs.pop("acreate_batch", False) is True
@ -890,7 +890,7 @@ def cancel_batch(
)
except Exception as e:
verbose_logger.exception(
f"litellm.batches.main.py::cancel_batch() - Error inferring custom_llm_provider - {e!s}"
f"litellm.batches.main.py::cancel_batch() - Error inferring custom_llm_provider - {e}"
)
optional_params = GenericLiteLLMParams(**kwargs)
litellm_params = get_litellm_params(

10
litellm/caching/caching.py
View file

@ -353,13 +353,13 @@ class Cache:
if param in combined_kwargs:
param_value: str | None = self._get_param_value(param, kwargs)
if param_value is not None:
cache_key += f"{param!s}: {param_value!s}"
cache_key += f"{param}: {param_value}"
elif param not in litellm_param_kwargs: # check if user passed in optional param - e.g. top_k
if litellm.enable_caching_on_provider_specific_optional_params is True: # feature flagged for now
if kwargs[param] is None:
continue # ignore None params
param_value = kwargs[param]
cache_key += f"{param!s}: {param_value!s}"
cache_key += f"{param}: {param_value}"
if is_semantic_cache:
cache_key += self._get_semantic_cache_tenant_scope(kwargs)
@ -676,7 +676,7 @@ class Cache:
cache_key, cached_data, kwargs = self._add_cache_logic(result=result, **kwargs)
self.cache.set_cache(cache_key, cached_data, **kwargs)
except Exception as e:
verbose_logger.exception(f"LiteLLM Cache: Excepton add_cache: {e!s}")
verbose_logger.exception(f"LiteLLM Cache: Excepton add_cache: {e}")
async def async_add_cache(self, result, dynamic_cache_object: BaseCache | None = None, **kwargs):
"""
@ -695,7 +695,7 @@ class Cache:
else:
await self.cache.async_set_cache(cache_key, cached_data, **kwargs)
except Exception as e:
verbose_logger.exception(f"LiteLLM Cache: Excepton add_cache: {e!s}")
verbose_logger.exception(f"LiteLLM Cache: Excepton add_cache: {e}")
def _convert_to_cached_embedding(
self,
@ -874,7 +874,7 @@ class Cache:
else:
await self.cache.async_set_cache_pipeline(cache_list=cache_list, **kwargs)
except Exception as e:
verbose_logger.exception(f"LiteLLM Cache: Excepton add_cache: {e!s}")
verbose_logger.exception(f"LiteLLM Cache: Excepton add_cache: {e}")
def should_use_cache(self, **kwargs):
"""

6
litellm/caching/dual_cache.py
View file

@ -147,7 +147,7 @@ class DualCache(BaseCache):
return result
except Exception as e:
verbose_logger.error(f"LiteLLM Cache: Excepton async add_cache: {e!s}")
verbose_logger.error(f"LiteLLM Cache: Excepton async add_cache: {e}")
raise e
def get_cache(
@ -347,7 +347,7 @@ class DualCache(BaseCache):
if self.redis_cache is not None and local_only is False:
await self.redis_cache.async_set_cache(key, value, **kwargs)
except Exception as e:
verbose_logger.exception(f"LiteLLM Cache: Excepton async add_cache: {e!s}")
verbose_logger.exception(f"LiteLLM Cache: Excepton async add_cache: {e}")
# async_batch_set_cache
async def async_set_cache_pipeline(self, cache_list: list, local_only: bool = False, **kwargs):
@ -366,7 +366,7 @@ class DualCache(BaseCache):
cache_list=cache_list, ttl=kwargs.pop("ttl", None), **kwargs
)
except Exception as e:
verbose_logger.exception(f"LiteLLM Cache: Excepton async add_cache: {e!s}")
verbose_logger.exception(f"LiteLLM Cache: Excepton async add_cache: {e}")
async def async_increment_cache(
self,

2
litellm/caching/qdrant_semantic_cache.py
View file

@ -178,7 +178,7 @@ class QdrantSemanticCache(BaseCache):
if response.status_code not in (200, 201):
print_verbose(f"Qdrant semantic-cache could not create cache-key payload index: {response.text}")
except Exception as exc:
print_verbose(f"Qdrant semantic-cache could not create cache-key payload index: {exc!s}")
print_verbose(f"Qdrant semantic-cache could not create cache-key payload index: {exc}")
def _payload_matches_cache_key(self, payload: dict, key: str) -> bool:
# Pre-isolation points stored only prompt + response with no cache-key

22
litellm/caching/redis_cache.py
View file

@ -346,7 +346,7 @@ class RedisCache(BaseCache):
verbose_logger.debug("Ignoring async redis ping. No running event loop.")
else:
verbose_logger.error(
f"Error connecting to Async Redis client - {e!s}",
f"Error connecting to Async Redis client - {e}",
extra={"error": str(e)},
)
self._handle_async_ping_error(e)
@ -483,7 +483,7 @@ class RedisCache(BaseCache):
)
except Exception as e:
# NON blocking - notify users Redis is throwing an exception
print_verbose(f"litellm.caching.caching: set() - Got exception from REDIS : {e!s}")
print_verbose(f"litellm.caching.caching: set() - Got exception from REDIS : {e}")
def increment_cache(self, key, value: int, ttl: float | None = None, **kwargs) -> int:
_redis_client = self.redis_client
@ -1139,7 +1139,7 @@ class RedisCache(BaseCache):
return decoded_results
except Exception as e:
verbose_logger.error(f"Error occurred in batch get cache - {e!s}")
verbose_logger.error(f"Error occurred in batch get cache - {e}")
return key_value_dict
@_redis_circuit_breaker_guard
@ -1185,7 +1185,7 @@ class RedisCache(BaseCache):
event_metadata={"key": key},
)
)
print_verbose(f"litellm.caching.caching: async get() - Got exception from REDIS: {e!s}")
print_verbose(f"litellm.caching.caching: async get() - Got exception from REDIS: {e}")
_record_swallowed_redis_failure(self._circuit_breaker, e)
@_redis_circuit_breaker_guard
@ -1257,7 +1257,7 @@ class RedisCache(BaseCache):
parent_otel_span=parent_otel_span,
)
)
verbose_logger.error(f"Error occurred in async batch get cache - {e!s}")
verbose_logger.error(f"Error occurred in async batch get cache - {e}")
_record_swallowed_redis_failure(self._circuit_breaker, e)
return key_value_dict
@ -1292,7 +1292,7 @@ class RedisCache(BaseCache):
error=e,
call_type=f"sync_ping <- {_get_call_stack_info()}",
)
verbose_logger.error(f"LiteLLM Redis Cache PING: - Got exception from REDIS : {e!s}")
verbose_logger.error(f"LiteLLM Redis Cache PING: - Got exception from REDIS : {e}")
raise e
async def ping(self) -> bool:
@ -1326,7 +1326,7 @@ class RedisCache(BaseCache):
call_type=f"async_ping <- {_get_call_stack_info()}",
)
)
verbose_logger.error(f"LiteLLM Redis Cache PING: - Got exception from REDIS : {e!s}")
verbose_logger.error(f"LiteLLM Redis Cache PING: - Got exception from REDIS : {e}")
raise e
@_redis_circuit_breaker_guard
@ -1388,10 +1388,10 @@ class RedisCache(BaseCache):
else:
return {"status": "failed", "message": "Redis ping returned False"}
except Exception as e:
verbose_logger.error(f"Redis connection test failed: {e!s}")
verbose_logger.error(f"Redis connection test failed: {e}")
return {
"status": "failed",
"message": f"Redis connection failed: {e!s}",
"message": f"Redis connection failed: {e}",
"error": str(e),
}
@ -1565,7 +1565,7 @@ class RedisCache(BaseCache):
call_type=f"async_rpush <- {_get_call_stack_info()}",
)
)
verbose_logger.error(f"LiteLLM Redis Cache RPUSH: - Got exception from REDIS : {e!s}")
verbose_logger.error(f"LiteLLM Redis Cache RPUSH: - Got exception from REDIS : {e}")
raise e
async def _pipeline_rpush_helper(
@ -1711,7 +1711,7 @@ class RedisCache(BaseCache):
call_type=f"async_lpop <- {_get_call_stack_info()}",
)
)
verbose_logger.error(f"LiteLLM Redis Cache LPOP: - Got exception from REDIS : {e!s}")
verbose_logger.error(f"LiteLLM Redis Cache LPOP: - Got exception from REDIS : {e}")
raise e
async def _pipeline_lpop_helper(

4
litellm/caching/redis_cluster_cache.py
View file

@ -100,9 +100,9 @@ class RedisClusterCache(RedisCache):
except Exception as e:
from litellm._logging import verbose_logger
verbose_logger.error(f"Redis Cluster connection test failed: {e!s}")
verbose_logger.error(f"Redis Cluster connection test failed: {e}")
return {
"status": "failed",
"message": f"Redis Cluster connection failed: {e!s}",
"message": f"Redis Cluster connection failed: {e}",
"error": str(e),
}

16
litellm/caching/redis_semantic_cache.py
View file

@ -364,7 +364,7 @@ class RedisSemanticCache(BaseCache):
try:
cached_response = ast.literal_eval(cached_response)
except (ValueError, SyntaxError) as e:
print_verbose(f"Error parsing cached response: {e!s}")
print_verbose(f"Error parsing cached response: {e}")
return None
return cached_response
@ -403,7 +403,7 @@ class RedisSemanticCache(BaseCache):
store_kwargs["ttl"] = int(ttl)
self.llmcache.store(prompt, value_str, **store_kwargs)
except Exception as e:
print_verbose(f"Error setting {value_str or value} in the Redis semantic cache: {e!s}")
print_verbose(f"Error setting {value_str or value} in the Redis semantic cache: {e}")
def get_cache(self, key: str, **kwargs) -> Any:
"""
@ -468,7 +468,7 @@ class RedisSemanticCache(BaseCache):
return self._get_cache_logic(cached_response=cached_response)
except Exception as e:
print_verbose(f"Error retrieving from Redis semantic cache: {e!s}")
print_verbose(f"Error retrieving from Redis semantic cache: {e}")
kwargs.setdefault("metadata", {})["semantic-similarity"] = 0.0
async def _get_async_embedding(self, prompt: str, metadata: dict[str, Any] | None = None) -> list[float]:
@ -505,8 +505,8 @@ class RedisSemanticCache(BaseCache):
)
return embedding_response["data"][0]["embedding"]
except Exception as e:
print_verbose(f"Error generating async embedding: {e!s}")
raise ValueError(f"Failed to generate embedding: {e!s}") from e
print_verbose(f"Error generating async embedding: {e}")
raise ValueError(f"Failed to generate embedding: {e}") from e
async def async_set_cache(self, key: str, value: Any, **kwargs) -> None:
"""
@ -546,7 +546,7 @@ class RedisSemanticCache(BaseCache):
**store_kwargs,
)
except Exception as e:
print_verbose(f"Error in async_set_cache: {e!s}")
print_verbose(f"Error in async_set_cache: {e}")
async def async_get_cache(self, key: str, **kwargs) -> Any:
"""
@ -612,7 +612,7 @@ class RedisSemanticCache(BaseCache):
return self._get_cache_logic(cached_response=cached_response)
except Exception as e:
print_verbose(f"Error in async_get_cache: {e!s}")
print_verbose(f"Error in async_get_cache: {e}")
kwargs.setdefault("metadata", {})["semantic-similarity"] = 0.0
async def _index_info(self) -> dict[str, Any]:
@ -639,4 +639,4 @@ class RedisSemanticCache(BaseCache):
tasks.append(self.async_set_cache(val[0], val[1], **kwargs))
await asyncio.gather(*tasks)
except Exception as e:
print_verbose(f"Error in async_set_cache_pipeline: {e!s}")
print_verbose(f"Error in async_set_cache_pipeline: {e}")

10
litellm/caching/valkey_semantic_cache.py
View file

@ -249,7 +249,7 @@ class ValkeySemanticCache(RedisSemanticCache):
if ttl is not None:
self.sync_client.expire(doc_key, ttl)
except Exception as e:
print_verbose(f"Error in Valkey semantic-cache set_cache: {e!s}")
print_verbose(f"Error in Valkey semantic-cache set_cache: {e}")
def get_cache(self, key: str, **kwargs: Any) -> Any:
print_verbose(f"Valkey semantic-cache get_cache, kwargs: {kwargs}")
@ -268,7 +268,7 @@ class ValkeySemanticCache(RedisSemanticCache):
)
return self._resolve_hit(self._first_hit(search_result), key, **kwargs)
except Exception as e:
print_verbose(f"Error in Valkey semantic-cache get_cache: {e!s}")
print_verbose(f"Error in Valkey semantic-cache get_cache: {e}")
kwargs.setdefault("metadata", {})["semantic-similarity"] = 0.0
async def async_set_cache(self, key: str, value: Any, **kwargs: Any) -> None:
@ -288,7 +288,7 @@ class ValkeySemanticCache(RedisSemanticCache):
if ttl is not None:
await self.async_client.expire(doc_key, ttl)
except Exception as e:
print_verbose(f"Error in async Valkey semantic-cache set_cache: {e!s}")
print_verbose(f"Error in async Valkey semantic-cache set_cache: {e}")
async def async_get_cache(self, key: str, **kwargs: Any) -> Any:
print_verbose(f"Async Valkey semantic-cache get_cache, kwargs: {kwargs}")
@ -307,14 +307,14 @@ class ValkeySemanticCache(RedisSemanticCache):
)
return self._resolve_hit(self._first_hit(search_result), key, **kwargs)
except Exception as e:
print_verbose(f"Error in async Valkey semantic-cache get_cache: {e!s}")
print_verbose(f"Error in async Valkey semantic-cache get_cache: {e}")
kwargs.setdefault("metadata", {})["semantic-similarity"] = 0.0
async def async_set_cache_pipeline(self, cache_list: list[tuple[str, Any]], **kwargs: Any) -> None:
try:
await asyncio.gather(*[self.async_set_cache(key, value, **kwargs) for key, value in cache_list])
except Exception as e:
print_verbose(f"Error in Valkey semantic-cache async_set_cache_pipeline: {e!s}")
print_verbose(f"Error in Valkey semantic-cache async_set_cache_pipeline: {e}")
async def _index_info(self) -> dict:
return await self.async_client.ft(self.index_name).info()

8
litellm/cost_calculator.py
View file

@ -715,7 +715,7 @@ def _get_provider_for_cost_calc(
_, custom_llm_provider, _, _ = litellm.get_llm_provider(model=model)
except Exception as e:
verbose_logger.debug(
f"litellm.cost_calculator.py::_get_provider_for_cost_calc() - Error inferring custom_llm_provider - {e!s}"
f"litellm.cost_calculator.py::_get_provider_for_cost_calc() - Error inferring custom_llm_provider - {e}"
)
return None
@ -1092,7 +1092,7 @@ def _store_cost_breakdown_in_logging_obj(
)
except Exception as breakdown_error:
verbose_logger.debug(f"Error storing cost breakdown: {breakdown_error!s}")
verbose_logger.debug(f"Error storing cost breakdown: {breakdown_error}")
# Don't fail the main cost calculation if breakdown storage fails
@ -1315,7 +1315,7 @@ def completion_cost(
) # strip the llm provider from the model name -> for image gen cost calculation
except Exception as e:
verbose_logger.debug(
f"litellm.cost_calculator.py::completion_cost() - Error inferring custom_llm_provider - {e!s}"
f"litellm.cost_calculator.py::completion_cost() - Error inferring custom_llm_provider - {e}"
)
if CostCalculatorUtils._call_type_has_image_response(call_type) and isinstance(
completion_response, ImageResponse
@ -1662,7 +1662,7 @@ def completion_cost(
return _final_cost
except Exception as e:
verbose_logger.debug(
f"litellm.cost_calculator.py::completion_cost() - Error calculating cost for model={model} - {e!s}"
f"litellm.cost_calculator.py::completion_cost() - Error calculating cost for model={model} - {e}"
)
if idx == len(potential_model_names) - 1:
raise e

2
litellm/exceptions.py
View file

@ -1140,7 +1140,7 @@ class MidStreamFallbackError(ServiceUnavailableError): # type: ignore
if self.max_retries:
_message += f", LiteLLM Max Retries: {self.max_retries}"
if self.original_exception:
_message += f" Original exception: {type(self.original_exception).__name__}: {self.original_exception!s}"
_message += f" Original exception: {type(self.original_exception).__name__}: {self.original_exception}"
return _message
def __repr__(self):

16
litellm/experimental_mcp_client/client.py
View file

@ -515,7 +515,7 @@ class MCPClient:
_log(
f"MCP client list_tools failed - "
f"Error Type: {error_type}, "
f"Error: {e!s}, "
f"Error: {e}, "
f"Server: {self.server_url or 'stdio'}, "
f"Transport: {self.transport_type}"
)
@ -536,7 +536,7 @@ class MCPClient:
def error_tool_result(exc: Exception) -> MCPCallToolResult:
"""The error result ``call_tool`` returns when it swallows a failure (no re-execution)."""
return MCPCallToolResult(
content=[TextContent(type="text", text=f"{type(exc).__name__}: {exc!s}")],
content=[TextContent(type="text", text=f"{type(exc).__name__}: {exc}")],
isError=True,
)
@ -601,7 +601,7 @@ class MCPClient:
_log(
f"MCP client call_tool failed - "
f"Error Type: {error_type}, "
f"Error: {e!s}, "
f"Error: {e}, "
f"Tool: {call_tool_request_params.name}, "
f"Server: {self.server_url or 'stdio'}, "
f"Transport: {self.transport_type}"
@ -640,7 +640,7 @@ class MCPClient:
verbose_logger.error(
f"MCP client list_prompts failed - "
f"Error Type: {error_type}, "
f"Error: {e!s}, "
f"Error: {e}, "
f"Server: {self.server_url or 'stdio'}, "
f"Transport: {self.transport_type}"
)
@ -681,7 +681,7 @@ class MCPClient:
verbose_logger.error(
f"MCP client get_prompt failed - "
f"Error Type: {error_type}, "
f"Error: {e!s}, "
f"Error: {e}, "
f"Prompt: {get_prompt_request_params.name}, "
f"Server: {self.server_url or 'stdio'}, "
f"Transport: {self.transport_type}"
@ -717,7 +717,7 @@ class MCPClient:
verbose_logger.error(
f"MCP client list_resources failed - "
f"Error Type: {error_type}, "
f"Error: {e!s}, "
f"Error: {e}, "
f"Server: {self.server_url or 'stdio'}, "
f"Transport: {self.transport_type}"
)
@ -753,7 +753,7 @@ class MCPClient:
verbose_logger.error(
f"MCP client list_resource_templates failed - "
f"Error Type: {error_type}, "
f"Error: {e!s}, "
f"Error: {e}, "
f"Server: {self.server_url or 'stdio'}, "
f"Transport: {self.transport_type}"
)
@ -791,7 +791,7 @@ class MCPClient:
verbose_logger.error(
f"MCP client read_resource failed - "
f"Error Type: {error_type}, "
f"Error: {e!s}, "
f"Error: {e}, "
f"Url: {url}, "
f"Server: {self.server_url or 'stdio'}, "
f"Transport: {self.transport_type}"

4
litellm/google_genai/adapters/handler.py
View file

@ -98,7 +98,7 @@ class GenerateContentToCompletionHandler:
return generate_content_response
except Exception as e:
raise ValueError(f"Error calling litellm.acompletion for generate_content: {e!s}")
raise ValueError(f"Error calling litellm.acompletion for generate_content: {e}")
@staticmethod
def generate_content_handler(
@ -159,4 +159,4 @@ class GenerateContentToCompletionHandler:
return generate_content_response
except Exception as e:
raise ValueError(f"Error calling litellm.completion for generate_content: {e!s}")
raise ValueError(f"Error calling litellm.completion for generate_content: {e}")

2
litellm/integrations/SlackAlerting/batching_handler.py
View file

@ -70,6 +70,6 @@ async def send_to_webhook(slackAlertingInstance: SlackAlertingType, item, count)
if response.status_code != 200:
verbose_proxy_logger.debug(f"Error sending slack alert to url={item['url']}. Error={response.text}")
except Exception as e:
verbose_proxy_logger.debug(f"Error sending slack alert: {e!s}")
verbose_proxy_logger.debug(f"Error sending slack alert: {e}")
finally:
_print_alerting_payload_warning(payload, slackAlertingInstance=slackAlertingInstance)

6
litellm/integrations/SlackAlerting/slack_alerting.py
View file

@ -1467,7 +1467,7 @@ Model Info:
try:
await self._flush_digest_buckets()
except Exception as e:
verbose_proxy_logger.debug(f"Error flushing digest buckets: {e!s}")
verbose_proxy_logger.debug(f"Error flushing digest buckets: {e}")
await self.flush_queue()
async def async_log_success_event(self, kwargs, response_obj, start_time, end_time):
@ -1502,7 +1502,7 @@ Model Info:
)
except Exception as e:
verbose_proxy_logger.error(
f"[Non-Blocking Error] Slack Alerting: Got error in logging LLM deployment latency: {e!s}"
f"[Non-Blocking Error] Slack Alerting: Got error in logging LLM deployment latency: {e}"
)
async def async_log_failure_event(self, kwargs, response_obj, start_time, end_time):
@ -1522,7 +1522,7 @@ Model Info:
)
)
except Exception as e:
verbose_logger.debug(f"Exception raises -{e!s}")
verbose_logger.debug(f"Exception raises -{e}")
if isinstance(kwargs.get("exception", ""), APIError):
if "outage_alerts" in self.alert_types:

2
litellm/integrations/arize/arize.py
View file

@ -169,7 +169,7 @@ class ArizeLogger(OpenTelemetry):
except Exception as e:
return {
"status": "unhealthy",
"error_message": f"Arize health check failed: {e!s}",
"error_message": f"Arize health check failed: {e}",
}
def construct_dynamic_otel_headers(

8
litellm/integrations/azure_sentinel/azure_sentinel.py
View file

@ -203,7 +203,7 @@ class AzureSentinelLogger(CustomBatchLogger):
await self.async_send_batch()
except Exception as e:
verbose_logger.exception(f"Azure Sentinel Layer Error - {e!s}\n{traceback.format_exc()}")
verbose_logger.exception(f"Azure Sentinel Layer Error - {e}\n{traceback.format_exc()}")
async def async_log_failure_event(self, kwargs, response_obj, start_time, end_time):
"""
@ -233,7 +233,7 @@ class AzureSentinelLogger(CustomBatchLogger):
await self.async_send_batch()
except Exception as e:
verbose_logger.exception(f"Azure Sentinel Layer Error - {e!s}\n{traceback.format_exc()}")
verbose_logger.exception(f"Azure Sentinel Layer Error - {e}\n{traceback.format_exc()}")
async def async_log_audit_log_event(self, audit_log: StandardAuditLogPayload) -> None:
"""
@ -256,7 +256,7 @@ class AzureSentinelLogger(CustomBatchLogger):
await self.async_send_audit_batch()
except Exception as e:
verbose_logger.exception(f"Azure Sentinel Audit Log Layer Error - {e!s}\n{traceback.format_exc()}")
verbose_logger.exception(f"Azure Sentinel Audit Log Layer Error - {e}\n{traceback.format_exc()}")
async def async_send_batch(self):
"""
@ -323,7 +323,7 @@ class AzureSentinelLogger(CustomBatchLogger):
)
except Exception as e:
verbose_logger.exception(f"Azure Sentinel Error sending batch API - {e!s}\n{traceback.format_exc()}")
verbose_logger.exception(f"Azure Sentinel Error sending batch API - {e}\n{traceback.format_exc()}")
finally:
log_queue.clear()

20
litellm/integrations/azure_storage/azure_storage.py
View file

@ -53,9 +53,7 @@ class AzureBlobStorageLogger(CustomBatchLogger):
self.log_queue: list[StandardLoggingPayload] = []
super().__init__(**kwargs, flush_lock=self.flush_lock)
except Exception as e:
verbose_logger.exception(
f"AzureBlobStorageLogger: Got exception on init AzureBlobStorageLogger client {e!s}"
)
verbose_logger.exception(f"AzureBlobStorageLogger: Got exception on init AzureBlobStorageLogger client {e}")
raise e
async def async_log_success_event(self, kwargs, response_obj, start_time, end_time):
@ -79,7 +77,7 @@ class AzureBlobStorageLogger(CustomBatchLogger):
self.log_queue.append(standard_logging_payload)
except Exception as e:
verbose_logger.exception(f"AzureBlobStorageLogger Layer Error - {e!s}")
verbose_logger.exception(f"AzureBlobStorageLogger Layer Error - {e}")
async def async_log_failure_event(self, kwargs, response_obj, start_time, end_time):
"""
@ -101,7 +99,7 @@ class AzureBlobStorageLogger(CustomBatchLogger):
self.log_queue.append(standard_logging_payload)
except Exception as e:
verbose_logger.exception(f"AzureBlobStorageLogger Layer Error - {e!s}")
verbose_logger.exception(f"AzureBlobStorageLogger Layer Error - {e}")
async def async_send_batch(self):
"""
@ -124,7 +122,7 @@ class AzureBlobStorageLogger(CustomBatchLogger):
await self.async_upload_payload_to_azure_blob_storage(payload=payload)
except Exception as e:
verbose_logger.exception(f"AzureBlobStorageLogger Error sending batch API - {e!s}")
verbose_logger.exception(f"AzureBlobStorageLogger Error sending batch API - {e}")
async def async_upload_payload_to_azure_blob_storage(self, payload: StandardLoggingPayload):
"""
@ -153,7 +151,7 @@ class AzureBlobStorageLogger(CustomBatchLogger):
verbose_logger.debug(f"Successfully uploaded log to Azure Blob Storage: {filename}")
except Exception as e:
verbose_logger.exception(f"Error uploading to Azure Blob Storage: {e!s}")
verbose_logger.exception(f"Error uploading to Azure Blob Storage: {e}")
raise e
async def _create_file(self, client: AsyncHTTPHandler, base_url: str):
@ -169,7 +167,7 @@ class AzureBlobStorageLogger(CustomBatchLogger):
response.raise_for_status()
verbose_logger.debug("Successfully created file resource")
except Exception as e:
verbose_logger.exception(f"Error creating file resource: {e!s}")
verbose_logger.exception(f"Error creating file resource: {e}")
raise
async def _append_data(self, client: AsyncHTTPHandler, base_url: str, json_payload: str):
@ -189,7 +187,7 @@ class AzureBlobStorageLogger(CustomBatchLogger):
response.raise_for_status()
verbose_logger.debug("Successfully appended data")
except Exception as e:
verbose_logger.exception(f"Error appending data: {e!s}")
verbose_logger.exception(f"Error appending data: {e}")
raise
async def _flush_data(self, client: AsyncHTTPHandler, base_url: str, position: int):
@ -205,7 +203,7 @@ class AzureBlobStorageLogger(CustomBatchLogger):
response.raise_for_status()
verbose_logger.debug("Successfully flushed data")
except Exception as e:
verbose_logger.exception(f"Error flushing data: {e!s}")
verbose_logger.exception(f"Error flushing data: {e}")
raise
####### Helper methods to managing Authentication to Azure Storage #######
@ -345,4 +343,4 @@ class AzureBlobStorageLogger(CustomBatchLogger):
verbose_logger.debug(f"Successfully uploaded and wrote to {today}/{file_name}")
except Exception as e:
verbose_logger.exception(f"Error occurred: {e!s}")
verbose_logger.exception(f"Error occurred: {e}")

6
litellm/integrations/cloudzero/cloudzero.py
View file

@ -153,7 +153,7 @@ class CloudZeroLogger(CustomLogger):
verbose_logger.debug(f"CloudZero Logger: Successfully exported {len(cbf_data)} records to CloudZero")
except Exception as e:
verbose_logger.error(f"CloudZero Logger: Error exporting usage data: {e!s}")
verbose_logger.error(f"CloudZero Logger: Error exporting usage data: {e}")
raise
async def dry_run_export_usage_data(self, limit: int | None = 10000):
@ -244,8 +244,8 @@ class CloudZeroLogger(CustomLogger):
}
except Exception as e:
verbose_logger.error(f"CloudZero Logger: Error in dry run export: {e!s}")
verbose_logger.error(f"CloudZero Dry Run Error: {e!s}")
verbose_logger.error(f"CloudZero Logger: Error in dry run export: {e}")
verbose_logger.error(f"CloudZero Dry Run Error: {e}")
raise
def _display_cbf_data_on_screen(self, cbf_data):

2
litellm/integrations/cloudzero/database.py
View file

@ -98,4 +98,4 @@ class LiteLLMDatabase:
# This prevents schema mismatch errors when data types vary across rows
return pl.DataFrame(db_response, infer_schema_length=None)
except Exception as e:
raise Exception(f"Error retrieving usage data: {e!s}")
raise Exception(f"Error retrieving usage data: {e}")

2
litellm/integrations/custom_logger.py
View file

@ -927,7 +927,7 @@ class CustomLogger: # https://docs.litellm.ai/docs/observability/custom_callbac
except Exception as e:
from litellm._logging import verbose_logger
verbose_logger.debug(f"Error in handle_callback_failure for {callback_name}: {e!s}")
verbose_logger.debug(f"Error in handle_callback_failure for {callback_name}: {e}")
async def _strip_base64_from_messages(
self,

14
litellm/integrations/datadog/datadog.py
View file

@ -171,7 +171,7 @@ class DataDogLogger(
batch_size=_resolve_dd_batch_size(),
)
except Exception as e:
verbose_logger.exception(f"Datadog: Got exception on init Datadog client {e!s}")
verbose_logger.exception(f"Datadog: Got exception on init Datadog client {e}")
raise e
def _get_datadog_params(self) -> dict:
@ -257,7 +257,7 @@ class DataDogLogger(
await self._log_async_event(kwargs, response_obj, start_time, end_time)
except Exception as e:
verbose_logger.exception(f"Datadog Layer Error - {e!s}\n{traceback.format_exc()}")
verbose_logger.exception(f"Datadog Layer Error - {e}\n{traceback.format_exc()}")
async def async_log_failure_event(self, kwargs, response_obj, start_time, end_time):
try:
@ -265,7 +265,7 @@ class DataDogLogger(
await self._log_async_event(kwargs, response_obj, start_time, end_time)
except Exception as e:
verbose_logger.exception(f"Datadog Layer Error - {e!s}\n{traceback.format_exc()}")
verbose_logger.exception(f"Datadog Layer Error - {e}\n{traceback.format_exc()}")
async def async_post_call_failure_hook(
self,
@ -340,7 +340,7 @@ class DataDogLogger(
if len(self.log_queue) >= self.batch_size:
await self.flush_queue()
except Exception as e:
verbose_logger.exception(f"Datadog: async_post_call_failure_hook - {e!s}\n{traceback.format_exc()}")
verbose_logger.exception(f"Datadog: async_post_call_failure_hook - {e}\n{traceback.format_exc()}")
return None
async def async_send_batch(self):
@ -380,7 +380,7 @@ class DataDogLogger(
except Exception as e:
self.log_queue = batch_to_send + self.log_queue
verbose_logger.exception(f"Datadog Error sending batch API - {e!s}\n{traceback.format_exc()}")
verbose_logger.exception(f"Datadog Error sending batch API - {e}\n{traceback.format_exc()}")
async def _send_with_413_split(self, batch: list) -> list:
"""
@ -411,7 +411,7 @@ class DataDogLogger(
if isinstance(e, MaskedHTTPStatusError) and e.status_code == 413:
response = e.response
else:
verbose_logger.exception(f"Datadog Error sending batch API - {e!s}")
verbose_logger.exception(f"Datadog Error sending batch API - {e}")
return self._undelivered(chunk, pending)
if response.status_code == 413:
@ -515,7 +515,7 @@ class DataDogLogger(
)
except Exception as e:
verbose_logger.exception(f"Datadog Layer Error - {e!s}\n{traceback.format_exc()}")
verbose_logger.exception(f"Datadog Layer Error - {e}\n{traceback.format_exc()}")
async def _log_async_event(self, kwargs, response_obj, start_time, end_time):
dd_payload = self.create_datadog_logging_payload(

4
litellm/integrations/datadog/datadog_cost_management.py
View file

@ -84,7 +84,7 @@ class DatadogCostManagementLogger(CustomBatchLogger):
await self.async_send_batch()
except Exception as e:
verbose_logger.exception(f"Datadog Cost Management: Error in async_log_success_event: {e!s}")
verbose_logger.exception(f"Datadog Cost Management: Error in async_log_success_event: {e}")
async def async_send_batch(self):
if not self.log_queue:
@ -104,7 +104,7 @@ class DatadogCostManagementLogger(CustomBatchLogger):
await self._upload_to_datadog(aggregated_entries)
except Exception as e:
self.log_queue = batch_to_send + self.log_queue
verbose_logger.exception(f"Datadog Cost Management: Error in async_send_batch: {e!s}")
verbose_logger.exception(f"Datadog Cost Management: Error in async_send_batch: {e}")
def _aggregate_costs(self, logs: list[StandardLoggingPayload]) -> list[DatadogFOCUSCostEntry]:
"""

12
litellm/integrations/datadog/datadog_llm_obs.py
View file

@ -89,7 +89,7 @@ class DataDogLLMObsLogger(CustomBatchLogger):
kwargs.update(dict_datadog_llm_obs_params)
CustomBatchLogger.__init__(self, **kwargs, flush_lock=self.flush_lock)
except Exception as e:
verbose_logger.exception(f"DataDogLLMObs: Error initializing - {e!s}")
verbose_logger.exception(f"DataDogLLMObs: Error initializing - {e}")
raise e
def _configure_dd_agent(self, dd_agent_host: str):
@ -145,7 +145,7 @@ class DataDogLLMObsLogger(CustomBatchLogger):
if len(self.log_queue) >= self.batch_size:
await self.async_send_batch()
except Exception as e:
verbose_logger.exception(f"DataDogLLMObs: Error logging success event - {e!s}")
verbose_logger.exception(f"DataDogLLMObs: Error logging success event - {e}")
async def async_log_failure_event(self, kwargs, response_obj, start_time, end_time):
try:
@ -157,7 +157,7 @@ class DataDogLLMObsLogger(CustomBatchLogger):
if len(self.log_queue) >= self.batch_size:
await self.async_send_batch()
except Exception as e:
verbose_logger.exception(f"DataDogLLMObs: Error logging failure event - {e!s}")
verbose_logger.exception(f"DataDogLLMObs: Error logging failure event - {e}")
async def async_send_batch(self):
try:
@ -214,7 +214,7 @@ class DataDogLLMObsLogger(CustomBatchLogger):
except httpx.HTTPStatusError as e:
verbose_logger.exception(f"DataDogLLMObs: Error sending batch - {e.response.text}")
except Exception as e:
verbose_logger.exception(f"DataDogLLMObs: Error sending batch - {e!s}")
verbose_logger.exception(f"DataDogLLMObs: Error sending batch - {e}")
def create_llm_obs_payload(self, kwargs: dict, start_time: datetime, end_time: datetime) -> LLMObsPayload:
standard_logging_payload: StandardLoggingPayload | None = kwargs.get("standard_logging_object")
@ -707,7 +707,7 @@ class DataDogLLMObsLogger(CustomBatchLogger):
kv_pairs[f"tool_calls.{idx}.function.arguments"] = json.dumps(function_arguments)
except (KeyError, TypeError, ValueError) as e:
verbose_logger.debug(f"DataDogLLMObs: Error processing tool call {idx}: {e!s}")
verbose_logger.debug(f"DataDogLLMObs: Error processing tool call {idx}: {e}")
continue
return kv_pairs
@ -747,6 +747,6 @@ class DataDogLLMObsLogger(CustomBatchLogger):
tool_call_metadata[f"output_{key}"] = value
except Exception as e:
verbose_logger.debug(f"DataDogLLMObs: Error extracting tool call metadata: {e!s}")
verbose_logger.debug(f"DataDogLLMObs: Error extracting tool call metadata: {e}")
return tool_call_metadata

6
litellm/integrations/datadog/datadog_metrics.py
View file

@ -180,7 +180,7 @@ class DatadogMetricsLogger(CustomBatchLogger):
await self.flush_queue()
except Exception as e:
verbose_logger.exception(f"Datadog Metrics: Error in async_log_success_event: {e!s}")
verbose_logger.exception(f"Datadog Metrics: Error in async_log_success_event: {e}")
async def async_log_failure_event(self, kwargs, response_obj, start_time, end_time):
try:
@ -202,7 +202,7 @@ class DatadogMetricsLogger(CustomBatchLogger):
await self.flush_queue()
except Exception as e:
verbose_logger.exception(f"Datadog Metrics: Error in async_log_failure_event: {e!s}")
verbose_logger.exception(f"Datadog Metrics: Error in async_log_failure_event: {e}")
async def async_send_batch(self):
if not self.log_queue:
@ -214,7 +214,7 @@ class DatadogMetricsLogger(CustomBatchLogger):
try:
await self._upload_to_datadog(payload_data)
except Exception as e:
verbose_logger.exception(f"Datadog Metrics: Error in async_send_batch: {e!s}")
verbose_logger.exception(f"Datadog Metrics: Error in async_send_batch: {e}")
raise
async def _upload_to_datadog(self, payload: DatadogMetricsPayload):

2
litellm/integrations/dynamodb.py
View file

@ -70,7 +70,7 @@ class DyanmoDBLogger:
# Assuming log_data is a dictionary with log information
response = table.put_item(Item=payload)
print_verbose(f"Response from DynamoDB:{response!s}")
print_verbose(f"Response from DynamoDB:{response}")
print_verbose(f"DynamoDB Layer Logging - final response object: {response_obj}")
return response

2
litellm/integrations/galileo.py
View file

@ -128,7 +128,7 @@ class GalileoObserve(CustomLogger):
except Exception as e:
return IntegrationHealthCheckStatus(
status="unhealthy",
error_message=f"Galileo health check failed: {e!s}",
error_message=f"Galileo health check failed: {e}",
)
async def async_set_galileo_headers(self) -> None:

10
litellm/integrations/gcs_bucket/gcs_bucket.py
View file

@ -76,7 +76,7 @@ class GCSBucketLogger(GCSBucketBase, AdditionalLoggingUtils):
await self.log_queue.put(GCSLogQueueItem(payload=logging_payload, kwargs=kwargs, response_obj=response_obj))
except Exception as e:
verbose_logger.exception(f"GCS Bucket logging error: {e!s}")
verbose_logger.exception(f"GCS Bucket logging error: {e}")
async def async_log_failure_event(self, kwargs, response_obj, start_time, end_time):
try:
@ -95,7 +95,7 @@ class GCSBucketLogger(GCSBucketBase, AdditionalLoggingUtils):
await self.log_queue.put(GCSLogQueueItem(payload=logging_payload, kwargs=kwargs, response_obj=response_obj))
except Exception as e:
verbose_logger.exception(f"GCS Bucket logging error: {e!s}")
verbose_logger.exception(f"GCS Bucket logging error: {e}")
def _drain_queue_batch(self) -> list[GCSLogQueueItem]:
"""
@ -218,7 +218,7 @@ class GCSBucketLogger(GCSBucketBase, AdditionalLoggingUtils):
except Exception as e:
success_count = 0
error_count = len(items)
verbose_logger.exception(f"GCS Bucket error logging batch payload to GCS bucket: {e!s}")
verbose_logger.exception(f"GCS Bucket error logging batch payload to GCS bucket: {e}")
return (success_count, error_count)
async def _send_individual_logs(self, items: list[GCSLogQueueItem]) -> None:
@ -255,7 +255,7 @@ class GCSBucketLogger(GCSBucketBase, AdditionalLoggingUtils):
logging_payload=item["payload"],
)
except Exception as e:
verbose_logger.exception(f"GCS Bucket error logging individual payload to GCS bucket: {e!s}")
verbose_logger.exception(f"GCS Bucket error logging individual payload to GCS bucket: {e}")
async def async_send_batch(self):
"""
@ -336,7 +336,7 @@ class GCSBucketLogger(GCSBucketBase, AdditionalLoggingUtils):
loaded_response = json.loads(response)
return loaded_response
except Exception as e:
verbose_logger.debug(f"Failed to fetch payload for date {date_str}: {e!s}")
verbose_logger.debug(f"Failed to fetch payload for date {date_str}: {e}")
continue
return None

4
litellm/integrations/gcs_pubsub/pub_sub.py
View file

@ -132,7 +132,7 @@ class GcsPubSubLogger(CustomBatchLogger):
await self.async_send_batch()
except Exception as e:
verbose_logger.exception(f"PubSub Layer Error - {e!s}\n{traceback.format_exc()}")
verbose_logger.exception(f"PubSub Layer Error - {e}\n{traceback.format_exc()}")
async def async_send_batch(self):
"""
@ -148,7 +148,7 @@ class GcsPubSubLogger(CustomBatchLogger):
await self.publish_message(message)
except Exception as e:
verbose_logger.exception(f"PubSub Error sending batch - {e!s}\n{traceback.format_exc()}")
verbose_logger.exception(f"PubSub Error sending batch - {e}\n{traceback.format_exc()}")
finally:
self.log_queue.clear()

10
litellm/integrations/generic_api/generic_api_callback.py
View file

@ -42,7 +42,7 @@ def load_compatible_callbacks() -> dict:
with open(json_path, "r") as f:
return json.load(f)
except Exception as e:
verbose_logger.warning(f"Error loading generic_api_compatible_callbacks.json: {e!s}")
verbose_logger.warning(f"Error loading generic_api_compatible_callbacks.json: {e}")
return {}
@ -214,7 +214,7 @@ class GenericAPILogger(CustomBatchLogger):
key, value = item.split("=", 1)
headers_dict[key.strip()] = value.strip()
except Exception as e:
verbose_logger.warning(f"Error parsing headers from environment variables: {e!s}")
verbose_logger.warning(f"Error parsing headers from environment variables: {e}")
# 2. Update with litellm generic headers if available
if litellm.generic_logger_headers:
@ -308,7 +308,7 @@ class GenericAPILogger(CustomBatchLogger):
await self.async_send_batch()
except Exception as e:
verbose_logger.exception(f"Generic API Logger Error - {e!s}\n{traceback.format_exc()}")
verbose_logger.exception(f"Generic API Logger Error - {e}\n{traceback.format_exc()}")
async def async_log_failure_event(self, kwargs, response_obj, start_time, end_time):
"""
@ -339,7 +339,7 @@ class GenericAPILogger(CustomBatchLogger):
await self.async_send_batch()
except Exception as e:
verbose_logger.exception(f"Generic API Logger Error - {e!s}\n{traceback.format_exc()}")
verbose_logger.exception(f"Generic API Logger Error - {e}\n{traceback.format_exc()}")
async def async_send_batch(self):
"""
@ -395,7 +395,7 @@ class GenericAPILogger(CustomBatchLogger):
)
except Exception as e:
verbose_logger.exception(f"Generic API Logger Error sending batch - {e!s}\n{traceback.format_exc()}")
verbose_logger.exception(f"Generic API Logger Error sending batch - {e}\n{traceback.format_exc()}")
finally:
self.log_queue.clear()

2
litellm/integrations/langfuse/langfuse.py
View file

@ -330,7 +330,7 @@ class LangFuseLogger:
return {"trace_id": trace_id, "generation_id": generation_id}
except Exception as e:
verbose_logger.exception(f"Langfuse Layer Error(): Exception occured - {e!s}")
verbose_logger.exception(f"Langfuse Layer Error(): Exception occured - {e}")
return {"trace_id": None, "generation_id": None}
def _get_langfuse_input_output_content(

4
litellm/integrations/langfuse/langfuse_prompt_management.py
View file

@ -317,7 +317,7 @@ class LangfusePromptManagement(LangFuseLogger, PromptManagementBase, CustomLogge
except Exception as e:
from litellm._logging import verbose_logger
verbose_logger.exception(f"Langfuse Layer Error - Exception occurred while logging success event: {e!s}")
verbose_logger.exception(f"Langfuse Layer Error - Exception occurred while logging success event: {e}")
self.handle_callback_failure(callback_name="langfuse")
async def async_log_failure_event(self, kwargs, response_obj, start_time, end_time):
@ -347,5 +347,5 @@ class LangfusePromptManagement(LangFuseLogger, PromptManagementBase, CustomLogge
except Exception as e:
from litellm._logging import verbose_logger
verbose_logger.exception(f"Langfuse Layer Error - Exception occurred while logging failure event: {e!s}")
verbose_logger.exception(f"Langfuse Layer Error - Exception occurred while logging failure event: {e}")
self.handle_callback_failure(callback_name="langfuse")

4
litellm/integrations/logfire_logger.py
View file

@ -35,7 +35,7 @@ class LogfireLogger:
if logfire.DEFAULT_LOGFIRE_INSTANCE.config.send_to_logfire:
logfire.configure(token=os.getenv("LOGFIRE_TOKEN"))
except Exception as e:
print_verbose(f"Got exception on init logfire client {e!s}")
print_verbose(f"Got exception on init logfire client {e}")
raise e
def _get_span_config(self, payload) -> SpanConfig:
@ -159,4 +159,4 @@ class LogfireLogger:
print_verbose(f"Logfire Layer Logging - final response object: {response_obj}")
except Exception as e:
verbose_logger.debug(f"Logfire Layer Error - {e!s}\n{traceback.format_exc()}")
verbose_logger.debug(f"Logfire Layer Error - {e}\n{traceback.format_exc()}")

10
litellm/integrations/opik/opik.py
View file

@ -81,7 +81,7 @@ class OpikLogger(CustomBatchLogger):
self.flush_lock: asyncio.Lock | None = asyncio.Lock()
except Exception as e:
verbose_logger.exception(
f"OpikLogger - Asynchronous processing not initialized as we are not running in an async context {e!s}"
f"OpikLogger - Asynchronous processing not initialized as we are not running in an async context {e}"
)
self.flush_lock = None
@ -161,7 +161,7 @@ class OpikLogger(CustomBatchLogger):
verbose_logger.debug("OpikLogger - Flushing batch")
await self.flush_queue()
except Exception as e:
verbose_logger.exception(f"OpikLogger failed to log success event - {e!s}\n{traceback.format_exc()}")
verbose_logger.exception(f"OpikLogger failed to log success event - {e}\n{traceback.format_exc()}")
def _sync_send(self, url: str, headers: dict[str, str], batch: dict[str, Any]) -> None:
try:
@ -174,7 +174,7 @@ class OpikLogger(CustomBatchLogger):
if response.status_code != 204:
raise Exception(f"Response from opik API status_code: {response.status_code}, text: {response.text}")
except Exception as e:
verbose_logger.exception(f"OpikLogger failed to send batch - {e!s}\n{traceback.format_exc()}")
verbose_logger.exception(f"OpikLogger failed to send batch - {e}\n{traceback.format_exc()}")
def log_success_event(
self,
@ -245,7 +245,7 @@ class OpikLogger(CustomBatchLogger):
batch={"spans": [span_payload.__dict__]},
)
except Exception as e:
verbose_logger.exception(f"OpikLogger failed to log success event - {e!s}\n{traceback.format_exc()}")
verbose_logger.exception(f"OpikLogger failed to log success event - {e}\n{traceback.format_exc()}")
async def _submit_batch(self, url: str, headers: dict[str, str], batch: dict[str, Any]) -> None:
try:
@ -261,7 +261,7 @@ class OpikLogger(CustomBatchLogger):
else:
verbose_logger.info(f"OpikLogger - {len(self.log_queue)} Opik events submitted")
except Exception as e:
verbose_logger.exception(f"OpikLogger failed to send batch - {e!s}")
verbose_logger.exception(f"OpikLogger failed to send batch - {e}")
def _create_opik_headers(self) -> dict[str, str]:
headers: dict[str, str] = {}

14
litellm/integrations/posthog.py
View file

@ -72,7 +72,7 @@ class PostHogLogger(CustomBatchLogger):
super().__init__(**kwargs, flush_lock=None, batch_size=POSTHOG_MAX_BATCH_SIZE)
except Exception as e:
verbose_logger.exception(f"PostHog: Got exception on init PostHog client {e!s}")
verbose_logger.exception(f"PostHog: Got exception on init PostHog client {e}")
raise e
def log_success_event(self, kwargs, response_obj, start_time, end_time):
@ -107,7 +107,7 @@ class PostHogLogger(CustomBatchLogger):
verbose_logger.debug("PostHog: Sync event successfully sent")
except Exception as e:
verbose_logger.exception(f"PostHog Sync Layer Error - {e!s}")
verbose_logger.exception(f"PostHog Sync Layer Error - {e}")
async def async_log_success_event(self, kwargs, response_obj, start_time, end_time):
try:
@ -115,7 +115,7 @@ class PostHogLogger(CustomBatchLogger):
self._ensure_async_setup() # Lazy initialization
await self._log_async_event(kwargs, response_obj, start_time, end_time)
except Exception as e:
verbose_logger.exception(f"PostHog Layer Error - {e!s}")
verbose_logger.exception(f"PostHog Layer Error - {e}")
async def async_log_failure_event(self, kwargs, response_obj, start_time, end_time):
try:
@ -123,7 +123,7 @@ class PostHogLogger(CustomBatchLogger):
self._ensure_async_setup() # Lazy initialization
await self._log_async_event(kwargs, response_obj, start_time, end_time)
except Exception as e:
verbose_logger.exception(f"PostHog Layer Error - {e!s}")
verbose_logger.exception(f"PostHog Layer Error - {e}")
async def _log_async_event(self, kwargs, response_obj=None, start_time=0.0, end_time=0.0):
# Note: response_obj, start_time, end_time not used - all data comes from kwargs
@ -367,7 +367,7 @@ class PostHogLogger(CustomBatchLogger):
else:
verbose_logger.debug(f"PostHog: Batch of {len(self.log_queue)} events successfully sent")
except Exception as e:
verbose_logger.exception(f"PostHog Error sending batch API - {e!s}")
verbose_logger.exception(f"PostHog Error sending batch API - {e}")
def _ensure_async_setup(self):
if not self._async_initialized:
@ -377,7 +377,7 @@ class PostHogLogger(CustomBatchLogger):
self._async_initialized = True
verbose_logger.debug("PostHog: Async components initialized")
except Exception as e:
verbose_logger.error(f"PostHog: Failed to initialize async components: {e!s}")
verbose_logger.error(f"PostHog: Failed to initialize async components: {e}")
raise
def _extract_metadata(self, kwargs: dict[str, Any]) -> dict[str, Any]:
@ -445,4 +445,4 @@ class PostHogLogger(CustomBatchLogger):
self.log_queue.clear()
except Exception as e:
verbose_logger.error(f"PostHog: Error flushing events on exit: {e!s}")
verbose_logger.error(f"PostHog: Error flushing events on exit: {e}")

28
litellm/integrations/prometheus.py
View file

@ -683,7 +683,7 @@ class PrometheusLogger(CustomLogger):
)
except Exception as e:
print_verbose(f"Got exception on init prometheus client {e!s}")
print_verbose(f"Got exception on init prometheus client {e}")
raise e
def _parse_prometheus_config(self) -> dict[str, list[str]]:
@ -2132,7 +2132,7 @@ class PrometheusLogger(CustomLogger):
response_cost=0,
)
except Exception as e:
verbose_logger.exception(f"prometheus Layer Error(): Exception occured - {e!s}")
verbose_logger.exception(f"prometheus Layer Error(): Exception occured - {e}")
def _extract_status_code(
self,
@ -2383,7 +2383,7 @@ class PrometheusLogger(CustomLogger):
)
except Exception as e:
verbose_logger.exception(f"prometheus Layer Error(): Exception occured - {e!s}")
verbose_logger.exception(f"prometheus Layer Error(): Exception occured - {e}")
async def async_post_call_success_hook(self, data: dict, user_api_key_dict: UserAPIKeyAuth, response):
"""
@ -2608,7 +2608,7 @@ class PrometheusLogger(CustomLogger):
)
except Exception as e:
verbose_logger.debug(f"Prometheus Error: set_llm_deployment_failure_metrics. Exception occured - {e!s}")
verbose_logger.debug(f"Prometheus Error: set_llm_deployment_failure_metrics. Exception occured - {e}")
def _set_deployment_tpm_rpm_limit_metrics(
self,
@ -2722,9 +2722,7 @@ class PrometheusLogger(CustomLogger):
)
self.litellm_remaining_requests_metric.labels(**_labels).set(remaining_requests)
except Exception as e:
verbose_logger.exception(
f"Prometheus Error: _async_set_router_remaining_metrics. Exception occured - {e!s}"
)
verbose_logger.exception(f"Prometheus Error: _async_set_router_remaining_metrics. Exception occured - {e}")
def set_llm_deployment_success_metrics(
self,
@ -2867,7 +2865,7 @@ class PrometheusLogger(CustomLogger):
self.litellm_deployment_latency_per_output_token.labels(**_labels).observe(latency_per_token)
except Exception as e:
verbose_logger.exception(f"Prometheus Error: set_llm_deployment_success_metrics. Exception occured - {e!s}")
verbose_logger.exception(f"Prometheus Error: set_llm_deployment_success_metrics. Exception occured - {e}")
return
def _record_guardrail_metrics(
@ -2912,7 +2910,7 @@ class PrometheusLogger(CustomLogger):
hook_type=hook_type,
).inc()
except Exception as e:
verbose_logger.debug(f"Error recording guardrail metrics: {e!s}")
verbose_logger.debug(f"Error recording guardrail metrics: {e}")
########################################
# Managed Batch Metric Recording Methods
@ -3315,7 +3313,7 @@ class PrometheusLogger(CustomLogger):
await set_metrics_function(data)
except Exception as e:
verbose_logger.exception(f"Error initializing {data_type} budget metrics: {e!s}")
verbose_logger.exception(f"Error initializing {data_type} budget metrics: {e}")
async def _initialize_team_budget_metrics(self):
"""
@ -3506,7 +3504,7 @@ class PrometheusLogger(CustomLogger):
self.litellm_teams_count_metric.set(total_teams)
verbose_logger.debug(f"Prometheus: set litellm_teams_count to {total_teams}")
except Exception as e:
verbose_logger.exception(f"Error initializing user/team count metrics: {e!s}")
verbose_logger.exception(f"Error initializing user/team count metrics: {e}")
async def _set_key_list_budget_metrics(self, keys: list[str | UserAPIKeyAuth]):
"""Helper function to set budget metrics for a list of keys"""
@ -3597,7 +3595,7 @@ class PrometheusLogger(CustomLogger):
user_api_key_cache=user_api_key_cache,
)
except Exception as e:
verbose_logger.debug(f"[Non-Blocking] Prometheus: Error getting team info: {e!s}")
verbose_logger.debug(f"[Non-Blocking] Prometheus: Error getting team info: {e}")
return team_object
if team_info:
@ -3695,7 +3693,7 @@ class PrometheusLogger(CustomLogger):
include_budget_table=True,
)
except Exception as e:
verbose_logger.debug(f"[Non-Blocking] Prometheus: Error getting org info: {e!s}")
verbose_logger.debug(f"[Non-Blocking] Prometheus: Error getting org info: {e}")
return
if org_info is None:
@ -3852,7 +3850,7 @@ class PrometheusLogger(CustomLogger):
if key_object:
user_api_key_dict.budget_reset_at = key_object.budget_reset_at
except Exception as e:
verbose_logger.debug(f"[Non-Blocking] Prometheus: Error getting key info: {e!s}")
verbose_logger.debug(f"[Non-Blocking] Prometheus: Error getting key info: {e}")
return user_api_key_dict
@ -3917,7 +3915,7 @@ class PrometheusLogger(CustomLogger):
check_db_only=False,
)
except Exception as e:
verbose_logger.debug(f"[Non-Blocking] Prometheus: Error getting user info: {e!s}")
verbose_logger.debug(f"[Non-Blocking] Prometheus: Error getting user info: {e}")
return user_object
if user_info:

2
litellm/integrations/prometheus_services.py
View file

@ -82,7 +82,7 @@ class PrometheusServicesLogger:
self.mock_testing_failure_calls = 0
except Exception as e:
print_verbose(f"Got exception on init prometheus client {e!s}")
print_verbose(f"Got exception on init prometheus client {e}")
raise e
def _get_service_metrics_initialize(self, service: ServiceTypes) -> list[ServiceMetrics]:

6
litellm/integrations/s3.py
View file

@ -78,7 +78,7 @@ class S3Logger:
**kwargs,
)
except Exception as e:
print_verbose(f"Got exception on init s3 client {e!s}")
print_verbose(f"Got exception on init s3 client {e}")
raise e
async def _async_log_event(self, kwargs, response_obj, start_time, end_time, print_verbose):
@ -163,12 +163,12 @@ class S3Logger:
**sse_params,
)
print_verbose(f"Response from s3:{response!s}")
print_verbose(f"Response from s3:{response}")
print_verbose(f"s3 Layer Logging - final response object: {response_obj}")
return response
except Exception as e:
verbose_logger.exception(f"s3 Layer Error - {e!s}")
verbose_logger.exception(f"s3 Layer Error - {e}")
def _validated_sse_value(name: str, value: str | None) -> str | None:

12
litellm/integrations/s3_v2.py
View file

@ -125,7 +125,7 @@ class S3Logger(CustomBatchLogger, BaseAWSLLM):
BaseAWSLLM.__init__(self)
except Exception as e:
print_verbose(f"Got exception on init s3 client {e!s}")
print_verbose(f"Got exception on init s3 client {e}")
raise e
def _init_s3_params(
@ -284,7 +284,7 @@ class S3Logger(CustomBatchLogger, BaseAWSLLM):
self.batch_size,
)
except Exception as e:
verbose_logger.exception(f"s3 Layer Error - {e!s}")
verbose_logger.exception(f"s3 Layer Error - {e}")
self.handle_callback_failure(callback_name="S3Logger")
async def async_upload_data_to_s3(self, batch_logging_element: s3BatchLoggingElement):
@ -383,7 +383,7 @@ class S3Logger(CustomBatchLogger, BaseAWSLLM):
response.raise_for_status()
break
except Exception as e:
verbose_logger.exception(f"Error uploading to s3: {e!s}")
verbose_logger.exception(f"Error uploading to s3: {e}")
self.handle_callback_failure(callback_name="S3Logger")
async def async_send_batch(self):
@ -557,7 +557,7 @@ class S3Logger(CustomBatchLogger, BaseAWSLLM):
response.raise_for_status()
break
except Exception as e:
verbose_logger.exception(f"Error uploading to s3: {e!s}")
verbose_logger.exception(f"Error uploading to s3: {e}")
self.handle_callback_failure(callback_name="S3Logger")
async def _download_object_from_s3(self, s3_object_key: str) -> dict | None:
@ -642,7 +642,7 @@ class S3Logger(CustomBatchLogger, BaseAWSLLM):
return response.json()
except Exception as e:
verbose_logger.exception(f"Error downloading from S3: {e!s}")
verbose_logger.exception(f"Error downloading from S3: {e}")
return None
async def get_proxy_server_request_from_cold_storage_with_object_key(
@ -666,5 +666,5 @@ class S3Logger(CustomBatchLogger, BaseAWSLLM):
downloaded_object = await self._download_object_from_s3(object_key)
return downloaded_object
except Exception as e:
verbose_logger.exception(f"Error retrieving object {object_key} from cold storage: {e!s}")
verbose_logger.exception(f"Error retrieving object {object_key} from cold storage: {e}")
return None

8
litellm/integrations/sqs.py
View file

@ -113,7 +113,7 @@ class SQSLogger(CustomBatchLogger, BaseAWSLLM):
BaseAWSLLM.__init__(self)
except Exception as e:
print_verbose(f"Got exception on init sqs client {e!s}")
print_verbose(f"Got exception on init sqs client {e}")
raise e
def _init_sqs_params(
@ -215,7 +215,7 @@ class SQSLogger(CustomBatchLogger, BaseAWSLLM):
self.batch_size,
)
except Exception as e:
verbose_logger.exception(f"sqs Layer Error - {e!s}")
verbose_logger.exception(f"sqs Layer Error - {e}")
async def async_log_failure_event(self, kwargs, response_obj, start_time, end_time):
try:
@ -233,7 +233,7 @@ class SQSLogger(CustomBatchLogger, BaseAWSLLM):
)
except Exception as e:
verbose_logger.exception(f"Datadog Layer Error - {e!s}\n{traceback.format_exc()}")
verbose_logger.exception(f"Datadog Layer Error - {e}\n{traceback.format_exc()}")
async def async_send_batch(self) -> None:
verbose_logger.debug(f"sqs logger - sending batch of {len(self.log_queue)}")
@ -305,7 +305,7 @@ class SQSLogger(CustomBatchLogger, BaseAWSLLM):
)
response.raise_for_status()
except Exception as e:
verbose_logger.exception(f"Error sending to SQS: {e!s}")
verbose_logger.exception(f"Error sending to SQS: {e}")
async def async_health_check(self) -> IntegrationHealthCheckStatus:
"""

6
litellm/integrations/vector_store_integrations/vector_store_pre_call_hook.py
View file

@ -146,7 +146,7 @@ class VectorStorePreCallHook(CustomLogger):
return model, modified_messages, non_default_params
except Exception as e:
verbose_logger.exception(f"Error in VectorStorePreCallHook: {e!s}")
verbose_logger.exception(f"Error in VectorStorePreCallHook: {e}")
# Return original parameters on error
return model, messages, non_default_params
@ -275,7 +275,7 @@ class VectorStorePreCallHook(CustomLogger):
return response
except Exception as e:
verbose_logger.exception(f"Error adding search results to response: {e!s}")
verbose_logger.exception(f"Error adding search results to response: {e}")
# Don't fail the request if search results fail to be added
return None
@ -322,6 +322,6 @@ class VectorStorePreCallHook(CustomLogger):
return response_chunk
except Exception as e:
verbose_logger.exception(f"Error adding search results to streaming chunk: {e!s}")
verbose_logger.exception(f"Error adding search results to streaming chunk: {e}")
# Don't fail the request if search results fail to be added
return response_chunk

16
litellm/integrations/websearch_interception/handler.py
View file

@ -224,7 +224,7 @@ class WebSearchInterceptionLogger(CustomLogger):
content.append({"type": "text", "text": search_result_text})
response: dict[str, object] = {
"id": f"msg_{uuid.uuid4()!s}",
"id": f"msg_{uuid.uuid4()}",
"type": "message",
"role": "assistant",
"model": model,
@ -1038,8 +1038,8 @@ class WebSearchInterceptionLogger(CustomLogger):
@staticmethod
def _extract_search_text(result: object) -> str:
if isinstance(result, Exception):
verbose_logger.error(f"WebSearchInterception: Responses search failed with error: {result!s}")
return f"Search failed: {result!s}"
verbose_logger.error(f"WebSearchInterception: Responses search failed with error: {result}")
return f"Search failed: {result}"
if isinstance(result, tuple) and len(result) == 2:
text_value, _ = result
return text_value if isinstance(text_value, str) else str(text_value)
@ -1194,8 +1194,8 @@ class WebSearchInterceptionLogger(CustomLogger):
structured_results: list[SearchResponse | None] = []
for i, result in enumerate(search_results):
if isinstance(result, Exception):
verbose_logger.error(f"WebSearchInterception: Search {i} failed with error: {result!s}")
final_search_results.append(f"Search failed: {result!s}")
verbose_logger.error(f"WebSearchInterception: Search {i} failed with error: {result}")
final_search_results.append(f"Search failed: {result}")
structured_results.append(None)
elif isinstance(result, tuple) and len(result) == 2:
text_value, structured_value = result
@ -1308,7 +1308,7 @@ class WebSearchInterceptionLogger(CustomLogger):
)
return search_result_text, result
except Exception as e:
verbose_logger.error(f"WebSearchInterception: Search failed for '{query}': {e!s}")
verbose_logger.error(f"WebSearchInterception: Search failed for '{query}': {e}")
raise
async def _authorize_search_tool(
@ -1486,8 +1486,8 @@ class WebSearchInterceptionLogger(CustomLogger):
final_search_results: list[str] = []
for i, result in enumerate(search_results):
if isinstance(result, Exception):
verbose_logger.error(f"WebSearchInterception: Search {i} failed with error: {result!s}")
final_search_results.append(f"Search failed: {result!s}")
verbose_logger.error(f"WebSearchInterception: Search {i} failed with error: {result}")
final_search_results.append(f"Search failed: {result}")
elif isinstance(result, tuple) and len(result) == 2:
text_value, _ = result
final_search_results.append(cast(str, text_value) if isinstance(text_value, str) else str(text_value))

6
litellm/litellm_core_utils/exception_mapping_utils.py
View file

@ -679,7 +679,7 @@ def _map_replicate_exception(
)
raise APIError(
status_code=500,
message=f"ReplicateException - {original_exception!s}",
message=f"ReplicateException - {original_exception}",
llm_provider="replicate",
model=model,
request=httpx.Request(
@ -2459,7 +2459,7 @@ def exception_type( # type: ignore
): # deal with edge-case invalid request error bug in openai-python sdk
exception_mapping_worked = True
raise BadRequestError(
message=f"{exception_provider} BadRequestError : This can happen due to missing AZURE_API_VERSION: {original_exception!s}",
message=f"{exception_provider} BadRequestError : This can happen due to missing AZURE_API_VERSION: {original_exception}",
model=model,
llm_provider=custom_llm_provider,
response=getattr(original_exception, "response", None),
@ -2478,7 +2478,7 @@ def exception_type( # type: ignore
)
else:
raise APIConnectionError(
message=f"{original_exception!s}\n{_redact_string(traceback.format_exc())}",
message=f"{original_exception}\n{_redact_string(traceback.format_exc())}",
llm_provider=custom_llm_provider,
model=model,
request=httpx.Request(method="POST", url="https://api.openai.com/v1/"), # stub the request

2
litellm/litellm_core_utils/fallback_utils.py
View file

@ -70,7 +70,7 @@ async def async_completion_with_fallbacks(**kwargs):
)
except Exception as e:
verbose_logger.exception(f"Fallback attempt failed for model {model}: {e!s}")
verbose_logger.exception(f"Fallback attempt failed for model {model}: {e}")
most_recent_exception_str = str(e)
continue

4
litellm/litellm_core_utils/get_llm_provider_logic.py
View file

@ -501,9 +501,9 @@ def get_llm_provider(
if isinstance(e, litellm.exceptions.BadRequestError):
raise e
else:
error_str = f"GetLLMProvider Exception - {e!s}\n\noriginal model: {model}"
error_str = f"GetLLMProvider Exception - {e}\n\noriginal model: {model}"
raise litellm.exceptions.BadRequestError( # type: ignore
message=f"GetLLMProvider Exception - {e!s}\n\noriginal model: {model}",
message=f"GetLLMProvider Exception - {e}\n\noriginal model: {model}",
model=model,
response=None,
llm_provider="",

2
litellm/litellm_core_utils/get_model_cost_map.py
View file

@ -292,7 +292,7 @@ def get_model_cost_map(url: str) -> dict:
str(e),
)
_cost_map_source_info.source = "local"
_cost_map_source_info.fallback_reason = f"Remote fetch failed: {e!s}"
_cost_map_source_info.fallback_reason = f"Remote fetch failed: {e}"
return _finalize_model_cost_map(GetModelCostMap.load_local_model_cost_map())
# Validate using cached count (cheap int comparison, no file I/O)

32
litellm/litellm_core_utils/litellm_logging.py
View file

@ -199,7 +199,7 @@ try:
EnterpriseStandardLoggingPayloadSetup
)
except Exception as e:
verbose_logger.debug(f"[Non-Blocking] Unable to import GenericAPILogger - LiteLLM Enterprise Feature - {e!s}")
verbose_logger.debug(f"[Non-Blocking] Unable to import GenericAPILogger - LiteLLM Enterprise Feature - {e}")
GenericAPILogger = CustomLogger # type: ignore
ResendEmailLogger = CustomLogger # type: ignore
SendGridEmailLogger = CustomLogger # type: ignore
@ -968,7 +968,7 @@ class Logging(LiteLLMLoggingBaseClass):
error=str(e),
)
_metadata["raw_request"] = f"Unable to Log \
raw request: {e!s}"
raw request: {e}"
if getattr(self, "logger_fn", None) and callable(self.logger_fn):
try:
self.logger_fn(
@ -976,7 +976,7 @@ class Logging(LiteLLMLoggingBaseClass):
) # Expectation: any logger function passed in by the user should accept a dict object
except Exception as e:
verbose_logger.exception(
f"LiteLLM.LoggingError: [Non-Blocking] Exception occurred while logging {e!s}"
f"LiteLLM.LoggingError: [Non-Blocking] Exception occurred while logging {e}"
)
self.model_call_details["api_call_start_time"] = datetime.datetime.now()
@ -1036,14 +1036,14 @@ class Logging(LiteLLMLoggingBaseClass):
callback_func=callback,
)
except Exception as e:
verbose_logger.exception(f"litellm.Logging.pre_call(): Exception occured - {e!s}")
verbose_logger.exception(f"litellm.Logging.pre_call(): Exception occured - {e}")
verbose_logger.debug(
f"LiteLLM.Logging: is sentry capture exception initialized {capture_exception}"
)
if capture_exception: # log this error to sentry for debugging
capture_exception(e)
except Exception as e:
verbose_logger.exception(f"LiteLLM.LoggingError: [Non-Blocking] Exception occurred while logging {e!s}")
verbose_logger.exception(f"LiteLLM.LoggingError: [Non-Blocking] Exception occurred while logging {e}")
verbose_logger.error(f"LiteLLM.Logging: is sentry capture exception initialized {capture_exception}")
if capture_exception: # log this error to sentry for debugging
capture_exception(e)
@ -1159,7 +1159,7 @@ class Logging(LiteLLMLoggingBaseClass):
) # Expectation: any logger function passed in by the user should accept a dict object
except Exception as e:
verbose_logger.exception(
f"LiteLLM.LoggingError: [Non-Blocking] Exception occurred while logging {e!s}"
f"LiteLLM.LoggingError: [Non-Blocking] Exception occurred while logging {e}"
)
original_response = redact_message_input_output_from_logging(
model_call_details=(self.model_call_details if hasattr(self, "model_call_details") else {}),
@ -1196,7 +1196,7 @@ class Logging(LiteLLMLoggingBaseClass):
)
except Exception as e:
verbose_logger.exception(
f"LiteLLM.LoggingError: [Non-Blocking] Exception occurred while post-call logging with integrations {e!s}"
f"LiteLLM.LoggingError: [Non-Blocking] Exception occurred while post-call logging with integrations {e}"
)
verbose_logger.debug(
f"LiteLLM.Logging: is sentry capture exception initialized {capture_exception}"
@ -1204,7 +1204,7 @@ class Logging(LiteLLMLoggingBaseClass):
if capture_exception: # log this error to sentry for debugging
capture_exception(e)
except Exception as e:
verbose_logger.exception(f"LiteLLM.LoggingError: [Non-Blocking] Exception occurred while logging {e!s}")
verbose_logger.exception(f"LiteLLM.LoggingError: [Non-Blocking] Exception occurred while logging {e}")
async def async_post_mcp_tool_call_hook(
self,
@ -1244,7 +1244,7 @@ class Logging(LiteLLMLoggingBaseClass):
if response is not None:
response_obj = self._parse_post_mcp_call_hook_response(response=response)
except Exception as e:
verbose_logger.exception(f"LiteLLM.LoggingError: [Non-Blocking] Exception occurred while logging {e!s}")
verbose_logger.exception(f"LiteLLM.LoggingError: [Non-Blocking] Exception occurred while logging {e}")
return response_obj
def _parse_post_mcp_call_hook_response(self, response: MCPPostCallResponseObject | None) -> Any:
@ -1889,7 +1889,7 @@ class Logging(LiteLLMLoggingBaseClass):
return start_time, end_time, result
except Exception as e:
raise Exception(f"[Non-Blocking] LiteLLM.Success_Call Error: {e!s}")
raise Exception(f"[Non-Blocking] LiteLLM.Success_Call Error: {e}")
def _is_recognized_call_type_for_logging(
self,
@ -2378,7 +2378,7 @@ class Logging(LiteLLMLoggingBaseClass):
pass
except Exception as e:
verbose_logger.exception(
f"LiteLLM.LoggingError: [Non-Blocking] Exception occurred while success logging {e!s}",
f"LiteLLM.LoggingError: [Non-Blocking] Exception occurred while success logging {e}",
)
async def async_success_handler(self, result=None, start_time=None, end_time=None, cache_hit=None, **kwargs):
@ -2694,7 +2694,7 @@ class Logging(LiteLLMLoggingBaseClass):
break # Only increment once
except Exception as e:
verbose_logger.debug(f"Error in _handle_callback_failure: {e!s}")
verbose_logger.debug(f"Error in _handle_callback_failure: {e}")
def _failure_handler_helper_fn(self, exception, traceback_exception, start_time=None, end_time=None):
if start_time is None:
@ -2931,14 +2931,14 @@ class Logging(LiteLLMLoggingBaseClass):
except Exception as e:
print_verbose(
f"LiteLLM.LoggingError: [Non-Blocking] Exception occurred while failure logging with integrations {e!s}"
f"LiteLLM.LoggingError: [Non-Blocking] Exception occurred while failure logging with integrations {e}"
)
print_verbose(f"LiteLLM.Logging: is sentry capture exception initialized {capture_exception}")
if capture_exception: # log this error to sentry for debugging
capture_exception(e)
except Exception as e:
verbose_logger.exception(
f"LiteLLM.LoggingError: [Non-Blocking] Exception occurred while failure logging {e!s}"
f"LiteLLM.LoggingError: [Non-Blocking] Exception occurred while failure logging {e}"
)
async def async_failure_handler(self, exception, traceback_exception, start_time=None, end_time=None):
@ -2995,7 +2995,7 @@ class Logging(LiteLLMLoggingBaseClass):
except Exception as e:
verbose_logger.exception(
f"LiteLLM.LoggingError: [Non-Blocking] Exception occurred while failure \
logging {e!s}\nCallback={callback}"
logging {e}\nCallback={callback}"
)
# Track callback logging failures in Prometheus
self._handle_callback_failure(callback=callback)
@ -5426,7 +5426,7 @@ def get_standard_logging_object_payload(
return payload
except Exception as e:
verbose_logger.exception(f"Error creating standard logging object - {e!s}")
verbose_logger.exception(f"Error creating standard logging object - {e}")
return None

4
litellm/litellm_core_utils/llm_cost_calc/utils.py
View file

@ -150,7 +150,7 @@ def _generic_cost_per_character(
prompt_cost = prompt_characters * custom_prompt_cost
except Exception as e:
verbose_logger.exception(
f"litellm.litellm_core_utils.llm_cost_calc.utils.py::cost_per_character(): Exception occured - {e!s}\nDefaulting to None"
f"litellm.litellm_core_utils.llm_cost_calc.utils.py::cost_per_character(): Exception occured - {e}\nDefaulting to None"
)
prompt_cost = None
@ -165,7 +165,7 @@ def _generic_cost_per_character(
completion_cost = completion_characters * custom_completion_cost
except Exception as e:
verbose_logger.exception(
f"litellm.litellm_core_utils.llm_cost_calc.utils.py::cost_per_character(): Exception occured - {e!s}\nDefaulting to None"
f"litellm.litellm_core_utils.llm_cost_calc.utils.py::cost_per_character(): Exception occured - {e}\nDefaulting to None"
)
completion_cost = None

2
litellm/litellm_core_utils/llm_response_utils/get_api_base.py
View file

@ -53,7 +53,7 @@ def get_api_base(model: str, optional_params: dict | LiteLLM_Params) -> str | No
api_key=_optional_params.api_key,
)
except Exception as e:
verbose_logger.debug(f"Error occurred in getting api base - {e!s}")
verbose_logger.debug(f"Error occurred in getting api base - {e}")
custom_llm_provider = None
dynamic_api_base = None

8
litellm/litellm_core_utils/logging_utils.py
View file

@ -178,7 +178,7 @@ def _get_parent_otel_span_from_logging_obj(
return _get_parent_otel_span_from_kwargs(logging_obj.model_call_details)
except Exception as e:
verbose_logger.exception(f"Error in _get_parent_otel_span_from_logging_obj: {e!s}")
verbose_logger.exception(f"Error in _get_parent_otel_span_from_logging_obj: {e}")
return None
@ -265,7 +265,7 @@ def _set_duration_in_model_call_details(
else:
verbose_logger.debug("`logging_obj` not found - unable to track `llm_api_duration_ms")
except Exception as e:
verbose_logger.warning(f"Error setting `llm_api_duration_ms`: {e!s}")
verbose_logger.warning(f"Error setting `llm_api_duration_ms`: {e}")
def track_llm_api_timing():
@ -321,7 +321,7 @@ def track_llm_api_timing():
)
)
except Exception as e:
verbose_logger.debug(f"Error in service logging: {e!s}")
verbose_logger.debug(f"Error in service logging: {e}")
@functools.wraps(func)
def sync_wrapper(*args, **kwargs):
@ -366,7 +366,7 @@ def track_llm_api_timing():
parent_otel_span=parent_otel_span,
)
except Exception as e:
verbose_logger.debug(f"Error in service logging: {e!s}")
verbose_logger.debug(f"Error in service logging: {e}")
# Check if the function is async or sync
if inspect.iscoroutinefunction(func):

2
litellm/litellm_core_utils/prompt_templates/common_utils.py
View file

@ -1683,7 +1683,7 @@ def parse_tool_call_arguments(
if context:
error_parts.append(f"({context})")
error_message = " ".join(error_parts) + f". Error: {original_error!s}. Arguments: {arguments}"
error_message = " ".join(error_parts) + f". Error: {original_error}. Arguments: {arguments}"
raise ValueError(error_message) from original_error

10
litellm/litellm_core_utils/prompt_templates/factory.py
View file

@ -438,9 +438,7 @@ def _render_chat_template(env, chat_template: str, bos_token: str, eos_token: st
return rendered_text
except Exception as e:
raise Exception(
f"Error rendering template - {e!s}"
) # don't use verbose_logger.exception, if exception is raised
raise Exception(f"Error rendering template - {e}") # don't use verbose_logger.exception, if exception is raised
async def _afetch_and_extract_template(
@ -858,7 +856,7 @@ def convert_to_anthropic_image_obj(openai_image_url: str, format: str | None) ->
raise
except Exception as e:
raise Exception(
f"""Image url not in expected format. Example Expected input - "image_url": "data:image/jpeg;base64,{{base64_image}}". Supported formats - ['image/jpeg', 'image/png', 'image/gif', 'image/webp']. Error: {e!s}"""
f"""Image url not in expected format. Example Expected input - "image_url": "data:image/jpeg;base64,{{base64_image}}". Supported formats - ['image/jpeg', 'image/png', 'image/gif', 'image/webp']. Error: {e}"""
)
@ -1361,7 +1359,7 @@ def convert_to_gemini_tool_call_invoke(
)
return _parts_list
except Exception as e:
raise Exception(f"Unable to convert openai tool calls={message} to gemini tool calls. Received error={e!s}")
raise Exception(f"Unable to convert openai tool calls={message} to gemini tool calls. Received error={e}")
def convert_to_gemini_tool_call_result(
@ -3713,7 +3711,7 @@ def _convert_to_bedrock_tool_call_invoke(
_parts_list.append(cache_point_block)
return _parts_list
except Exception as e:
raise Exception(f"Unable to convert openai tool calls={tool_calls} to bedrock tool calls. Received error={e!s}")
raise Exception(f"Unable to convert openai tool calls={tool_calls} to bedrock tool calls. Received error={e}")
def _append_bedrock_tool_result_media_block(

14
litellm/litellm_core_utils/streaming_handler.py
View file

@ -618,7 +618,7 @@ class CustomStreamWrapper:
else:
return ""
except Exception as e:
verbose_logger.exception(f"litellm.CustomStreamWrapper.handle_baseten_chunk(): Exception occured - {e!s}")
verbose_logger.exception(f"litellm.CustomStreamWrapper.handle_baseten_chunk(): Exception occured - {e}")
return ""
def handle_triton_stream(self, chunk):
@ -1179,7 +1179,7 @@ class CustomStreamWrapper:
content=None,
tool_calls=[
{
"id": f"call_{uuid.uuid4()!s}",
"id": f"call_{uuid.uuid4()}",
"function": {
"arguments": args_str,
"name": function_call.name,
@ -1204,7 +1204,7 @@ class CustomStreamWrapper:
)
except Exception:
if chunk.candidates[0].finish_reason.name == "SAFETY": # type: ignore
raise Exception(f"The response was blocked by VertexAI. {chunk!s}")
raise Exception(f"The response was blocked by VertexAI. {chunk}")
else:
completion_obj["content"] = str(chunk)
elif self.custom_llm_provider == "petals":
@ -1430,7 +1430,7 @@ class CustomStreamWrapper:
model_response.choices[0].delta = Delta(**_json_delta)
except Exception as e:
verbose_logger.exception(
f"litellm.CustomStreamWrapper.chunk_creator(): Exception occured - {e!s}"
f"litellm.CustomStreamWrapper.chunk_creator(): Exception occured - {e}"
)
model_response.choices[0].delta = Delta()
elif self._has_any_special_delta_attributes(delta):
@ -1538,7 +1538,7 @@ class CustomStreamWrapper:
except Exception as e:
from litellm._logging import verbose_logger
verbose_logger.exception(f"Error in post-call streaming deployment hook: {e!s}")
verbose_logger.exception(f"Error in post-call streaming deployment hook: {e}")
return chunk
def _add_mcp_list_tools_to_first_chunk(self, chunk: ModelResponseStream) -> ModelResponseStream:
@ -1578,7 +1578,7 @@ class CustomStreamWrapper:
except Exception as e:
from litellm._logging import verbose_logger
verbose_logger.exception(f"Error adding MCP list tools to first chunk: {e!s}")
verbose_logger.exception(f"Error adding MCP list tools to first chunk: {e}")
return chunk
@ -1615,7 +1615,7 @@ class CustomStreamWrapper:
except Exception as e:
from litellm._logging import verbose_logger
verbose_logger.exception(f"Error adding MCP metadata to final chunk: {e!s}")
verbose_logger.exception(f"Error adding MCP metadata to final chunk: {e}")
return chunk

2
litellm/litellm_core_utils/token_counter.py
View file

@ -104,7 +104,7 @@ def get_modified_max_tokens(
return user_max_tokens
except Exception as e:
verbose_logger.debug(
f"litellm.litellm_core_utils.token_counter.py::get_modified_max_tokens() - Error while checking max token limit: {e!s}\nmodel={model}, base_model={base_model}"
f"litellm.litellm_core_utils.token_counter.py::get_modified_max_tokens() - Error while checking max token limit: {e}\nmodel={model}, base_model={base_model}"
)
return user_max_tokens

2
litellm/llms/a2a/chat/transformation.py
View file

@ -279,7 +279,7 @@ class A2AConfig(BaseConfig):
except Exception as e:
raise A2AError(
status_code=raw_response.status_code,
message=f"Failed to parse A2A response: {e!s}",
message=f"Failed to parse A2A response: {e}",
headers=dict(raw_response.headers),
)

4
litellm/llms/anthropic/chat/transformation.py
View file

@ -1875,7 +1875,7 @@ class AnthropicConfig(AnthropicModelInfo, BaseConfig):
except Exception as e:
raise AnthropicError(
status_code=400,
message=f"{e!s}\nReceived Messages={messages}",
message=f"{e}\nReceived Messages={messages}",
) # don't use verbose_logger.exception, if exception is raised
## Auto-strip advisor blocks from history if advisor tool is absent.
@ -2454,7 +2454,7 @@ class AnthropicConfig(AnthropicModelInfo, BaseConfig):
except Exception as e:
response_headers = getattr(raw_response, "headers", None)
raise AnthropicError(
message=f"Unable to get json response - {e!s}, Original Response: {raw_response.text}",
message=f"Unable to get json response - {e}, Original Response: {raw_response.text}",
status_code=raw_response.status_code,
headers=response_headers,
)

6
litellm/llms/anthropic/count_tokens/handler.py
View file

@ -109,14 +109,14 @@ class AnthropicCountTokensHandler(AnthropicCountTokensConfig):
raise
except httpx.HTTPStatusError as e:
# HTTP errors - preserve the actual status code
verbose_logger.error(f"HTTP error in CountTokens handler: {e!s}")
verbose_logger.error(f"HTTP error in CountTokens handler: {e}")
raise AnthropicError(
status_code=e.response.status_code,
message=e.response.text,
)
except Exception as e:
verbose_logger.error(f"Error in CountTokens handler: {e!s}")
verbose_logger.error(f"Error in CountTokens handler: {e}")
raise AnthropicError(
status_code=500,
message=f"CountTokens processing error: {e!s}",
message=f"CountTokens processing error: {e}",
)

2
litellm/llms/azure/azure.py
View file

@ -684,7 +684,7 @@ class AzureChatCompletion(BaseAzureLLM, BaseLLM):
except json.JSONDecodeError as json_error:
raise AzureOpenAIError(
status_code=raw_response.status_code or 500,
message=f"Failed to parse raw Azure embedding response: {json_error!s}",
message=f"Failed to parse raw Azure embedding response: {json_error}",
) from json_error
if isinstance(response, str):
raise AzureOpenAIError(

10
litellm/llms/azure/common_utils.py
View file

@ -333,7 +333,7 @@ def get_azure_ad_token(
verbose_logger.debug("Azure AD Token Provider could not be used.")
except Exception as e:
verbose_logger.error(
f"Error calling Azure AD token provider: {e!s}. Follow docs - https://docs.litellm.ai/docs/providers/azure/#azure-ad-token-refresh---defaultazurecredential"
f"Error calling Azure AD token provider: {e}. Follow docs - https://docs.litellm.ai/docs/providers/azure/#azure-ad-token-refresh---defaultazurecredential"
)
raise e
@ -359,8 +359,8 @@ def get_azure_ad_token(
# Re-raise TypeError directly
raise
except Exception as e:
verbose_logger.error(f"Error calling Azure AD token provider: {e!s}")
raise RuntimeError(f"Failed to get Azure AD token: {e!s}") from e
verbose_logger.error(f"Error calling Azure AD token provider: {e}")
raise RuntimeError(f"Failed to get Azure AD token: {e}") from e
return azure_ad_token
@ -393,7 +393,7 @@ class BaseAzureLLM(BaseOpenAILLM):
verbose_logger.debug("Successfully obtained Azure AD token provider using DefaultAzureCredential")
return azure_ad_token_provider
except Exception as e:
verbose_logger.debug(f"DefaultAzureCredential failed: {e!s}")
verbose_logger.debug(f"DefaultAzureCredential failed: {e}")
return None
def get_azure_openai_client(
@ -580,7 +580,7 @@ class BaseAzureLLM(BaseOpenAILLM):
# only show first 5 chars of api_key
_api_key = _api_key[:8] + "*" * 15
verbose_logger.debug(
f"Initializing Azure OpenAI Client for {model_name}, Api Base: {api_base!s}, Api Key:{_api_key}"
f"Initializing Azure OpenAI Client for {model_name}, Api Base: {api_base}, Api Key:{_api_key}"
)
azure_client_params = {
"api_key": api_key,

2
litellm/llms/azure_ai/agents/handler.py
View file

@ -193,7 +193,7 @@ class AzureAIAgentsHandler:
),
)
except Exception as e:
verbose_logger.warning(f"Failed to calculate token usage: {e!s}")
verbose_logger.warning(f"Failed to calculate token usage: {e}")
return model_response

6
litellm/llms/azure_ai/anthropic/count_tokens/handler.py
View file

@ -114,14 +114,14 @@ class AzureAIAnthropicCountTokensHandler(AzureAIAnthropicCountTokensConfig):
raise
except httpx.HTTPStatusError as e:
# HTTP errors - preserve the actual status code
verbose_logger.error(f"HTTP error in CountTokens handler: {e!s}")
verbose_logger.error(f"HTTP error in CountTokens handler: {e}")
raise AnthropicError(
status_code=e.response.status_code,
message=e.response.text,
)
except Exception as e:
verbose_logger.error(f"Error in CountTokens handler: {e!s}")
verbose_logger.error(f"Error in CountTokens handler: {e}")
raise AnthropicError(
status_code=500,
message=f"CountTokens processing error: {e!s}",
message=f"CountTokens processing error: {e}",
)

2
litellm/llms/azure_ai/vector_stores/transformation.py
View file

@ -132,7 +132,7 @@ class AzureAIVectorStoreConfig(BaseVectorStoreConfig, BaseAzureLLM):
)
query_vector = embedding_response.data[0]["embedding"]
except Exception as e:
raise Exception(f"Failed to generate embedding for query: {e!s}")
raise Exception(f"Failed to generate embedding for query: {e}")
# Azure AI Search endpoint for search
index_name = vector_store_id # vector_store_id is the index name

4
litellm/llms/base_llm/files/azure_blob_storage_backend.py
View file

@ -133,7 +133,7 @@ class AzureBlobStorageBackend(BaseFileStorageBackend, AzureBlobStorageLogger):
return storage_url
except Exception as e:
verbose_logger.exception(f"Error uploading file to Azure Blob Storage: {e!s}")
verbose_logger.exception(f"Error uploading file to Azure Blob Storage: {e}")
raise
async def _upload_file_with_account_key(self, file_content: bytes, full_path: str) -> str:
@ -247,7 +247,7 @@ class AzureBlobStorageBackend(BaseFileStorageBackend, AzureBlobStorageLogger):
return await self._download_file_with_azure_ad(file_path)
except Exception as e:
verbose_logger.exception(f"Error downloading file from Azure Blob Storage: {e!s}")
verbose_logger.exception(f"Error downloading file from Azure Blob Storage: {e}")
raise
async def _download_file_with_account_key(self, file_path: str) -> bytes:

8
litellm/llms/bedrock/chat/agentcore/transformation.py
View file

@ -186,7 +186,7 @@ class AmazonAgentCoreConfig(BaseConfig, BaseAWSLLM):
return session_id
# Generate a session ID with 33+ characters
generated_id = f"litellm-session-{uuid.uuid4()!s}"
generated_id = f"litellm-session-{uuid.uuid4()}"
verbose_logger.debug(f"Generated new session ID: {generated_id}")
return generated_id
@ -370,7 +370,7 @@ class AmazonAgentCoreConfig(BaseConfig, BaseAWSLLM):
total_tokens=total_tokens,
)
except Exception as e:
verbose_logger.warning(f"Failed to calculate token usage: {e!s}")
verbose_logger.warning(f"Failed to calculate token usage: {e}")
return None
def _parse_json_response(self, response_json: dict) -> AgentCoreParsedResponse:
@ -1023,9 +1023,9 @@ class AmazonAgentCoreConfig(BaseConfig, BaseAWSLLM):
return model_response
except Exception as e:
verbose_logger.error(f"Error processing Bedrock AgentCore response: {e!s}")
verbose_logger.error(f"Error processing Bedrock AgentCore response: {e}")
raise BedrockError(
message=f"Error processing response: {e!s}",
message=f"Error processing response: {e}",
status_code=raw_response.status_code,
)

2
litellm/llms/bedrock/chat/converse_transformation.py
View file

@ -2073,7 +2073,7 @@ class AmazonConverseConfig(BaseConfig):
completion_response = ConverseResponseBlock(**response.json()) # type: ignore
except Exception as e:
raise BedrockError(
message=f"Error converting to valid response block={e!s}. File an issue if litellm error - https://github.com/BerriAI/litellm/issues",
message=f"Error converting to valid response block={e}. File an issue if litellm error - https://github.com/BerriAI/litellm/issues",
status_code=422,
)

4
litellm/llms/bedrock/chat/invoke_agent/transformation.py
View file

@ -464,9 +464,9 @@ class AmazonInvokeAgentConfig(BaseConfig, BaseAWSLLM):
)
except Exception as e:
verbose_logger.error(f"Error processing Bedrock Invoke Agent response: {e!s}")
verbose_logger.error(f"Error processing Bedrock Invoke Agent response: {e}")
raise BedrockError(
message=f"Error processing response: {e!s}",
message=f"Error processing response: {e}",
status_code=raw_response.status_code,
)

2
litellm/llms/bedrock/chat/invoke_handler.py
View file

@ -590,7 +590,7 @@ class AWSEventStreamDecoder:
return response
except Exception as e:
raise Exception(f"Received streaming error - {e!s}")
raise Exception(f"Received streaming error - {e}")
def _chunk_parser(self, chunk_data: dict) -> Union[GChunk, ModelResponseStream, dict]:
text = ""

4
litellm/llms/bedrock/chat/invoke_transformations/amazon_twelvelabs_pegasus_transformation.py
View file

@ -208,7 +208,7 @@ class AmazonTwelveLabsPegasusConfig(AmazonInvokeConfig, BaseConfig):
completion_response = raw_response.json()
except Exception as e:
raise BedrockError(
message=f"Error parsing response: {raw_response.text}, error: {e!s}",
message=f"Error parsing response: {raw_response.text}, error: {e}",
status_code=raw_response.status_code,
)
@ -237,7 +237,7 @@ class AmazonTwelveLabsPegasusConfig(AmazonInvokeConfig, BaseConfig):
raise Exception("Unable to set message content")
except Exception as e:
raise BedrockError(
message=f"Error setting response content: {e!s}. Response: {completion_response}",
message=f"Error setting response content: {e}. Response: {completion_response}",
status_code=raw_response.status_code,
)

4
litellm/llms/bedrock/chat/invoke_transformations/base_invoke_transformation.py
View file

@ -356,7 +356,7 @@ class AmazonInvokeConfig(BaseConfig, BaseAWSLLM):
outputText = completion_response.get("results")[0].get("outputText")
except Exception as e:
raise BedrockError(
message=f"Error processing={raw_response.text}, Received error={e!s}",
message=f"Error processing={raw_response.text}, Received error={e}",
status_code=422,
)
@ -379,7 +379,7 @@ class AmazonInvokeConfig(BaseConfig, BaseAWSLLM):
raise Exception()
except Exception as e:
raise BedrockError(
message=f"Error parsing received text={outputText}.\nError-{e!s}",
message=f"Error parsing received text={outputText}.\nError-{e}",
status_code=raw_response.status_code,
)

6
litellm/llms/bedrock/count_tokens/handler.py
View file

@ -120,14 +120,14 @@ class BedrockCountTokensHandler(BedrockCountTokensConfig):
raise
except httpx.HTTPStatusError as e:
# HTTP errors - preserve the actual status code
verbose_logger.error(f"HTTP error in CountTokens handler: {e!s}")
verbose_logger.error(f"HTTP error in CountTokens handler: {e}")
raise BedrockError(
status_code=e.response.status_code,
message=e.response.text,
)
except Exception as e:
verbose_logger.error(f"Error in CountTokens handler: {e!s}")
verbose_logger.error(f"Error in CountTokens handler: {e}")
raise BedrockError(
status_code=500,
message=f"CountTokens processing error: {e!s}",
message=f"CountTokens processing error: {e}",
)

2
litellm/llms/bedrock/files/handler.py
View file

@ -130,7 +130,7 @@ class BedrockFilesHandler(BaseAWSLLM):
response = s3_client.get_object(Bucket=bucket_name, Key=object_key)
file_content = response["Body"].read()
except Exception as e:
raise ValueError(f"Failed to download file from S3: {s3_uri}. Error: {e!s}")
raise ValueError(f"Failed to download file from S3: {s3_uri}. Error: {e}")
# Create mock HTTP response
mock_response = httpx.Response(

2
litellm/llms/bedrock/files/transformation.py
View file

@ -652,7 +652,7 @@ class BedrockFilesConfig(BaseAWSLLM, BaseFilesConfig):
)
except Exception as e:
verbose_logger.exception(
f"litellm.llms.bedrock.files.transformation.py::_transform_openai_jsonl_content_to_bedrock_jsonl_content() - Error inferring custom_llm_provider - {e!s}"
f"litellm.llms.bedrock.files.transformation.py::_transform_openai_jsonl_content_to_bedrock_jsonl_content() - Error inferring custom_llm_provider - {e}"
)
# Determine provider from model name

2
litellm/llms/bedrock/realtime/handler.py
View file

@ -175,7 +175,7 @@ class BedrockRealtime(BaseAWSLLM):
except Exception as e:
verbose_proxy_logger.exception(f"Error in BedrockRealtime.async_realtime: {e}")
try:
await websocket.close(code=1011, reason=_redact_string(f"Internal error: {e!s}"))
await websocket.close(code=1011, reason=_redact_string(f"Internal error: {e}"))
except Exception:
pass
raise

4
litellm/llms/black_forest_labs/image_edit/handler.py
View file

@ -159,7 +159,7 @@ class BlackForestLabsImageEdit:
except Exception as e:
raise BlackForestLabsError(
status_code=500,
message=f"Request failed: {e!s}",
message=f"Request failed: {e}",
)
# Poll for result
@ -262,7 +262,7 @@ class BlackForestLabsImageEdit:
except Exception as e:
raise BlackForestLabsError(
status_code=500,
message=f"Request failed: {e!s}",
message=f"Request failed: {e}",
)
# Poll for result

4
litellm/llms/black_forest_labs/image_generation/handler.py
View file

@ -156,7 +156,7 @@ class BlackForestLabsImageGeneration:
except Exception as e:
raise BlackForestLabsError(
status_code=500,
message=f"Request failed: {e!s}",
message=f"Request failed: {e}",
)
# Poll for result
@ -262,7 +262,7 @@ class BlackForestLabsImageGeneration:
except Exception as e:
raise BlackForestLabsError(
status_code=500,
message=f"Request failed: {e!s}",
message=f"Request failed: {e}",
)
# Poll for result

2
litellm/llms/clarifai/chat/transformation.py
View file

@ -106,7 +106,7 @@ class ClarifaiConfig(OpenAIGPTConfig):
except Exception as e:
raise OpenAIError(
status_code=raw_response.status_code,
message=f"Failed to parse Clarifai response: {e!s}",
message=f"Failed to parse Clarifai response: {e}",
headers=raw_response.headers,
) from e

2
litellm/llms/codestral/completion/handler.py
View file

@ -356,7 +356,7 @@ class CodestralTextCompletion:
)
except Exception as e:
raise TextCompletionCodestralError(
status_code=500, message=f"{e!s}"
status_code=500, message=f"{e}"
) # don't use verbose_logger.exception, if exception is raised
return self.process_text_completion_response(
model=model,

6
litellm/llms/custom_httpx/llm_http_handler.py
View file

@ -5659,7 +5659,7 @@ class BaseLLMHTTPHandler:
fingerprint=fingerprint,
)
except Exception as e:
verbose_logger.exception(f"LiteLLM.AgenticHookError: Exception in chat completion agentic hooks: {e!s}")
verbose_logger.exception(f"LiteLLM.AgenticHookError: Exception in chat completion agentic hooks: {e}")
# Check if we need to convert response to fake stream for chat completions
# This happens when:
@ -5906,7 +5906,7 @@ class BaseLLMHTTPHandler:
except Exception as e:
verbose_logger.exception(f"Error connecting to backend: {e}")
try:
await websocket.close(code=1011, reason=_redact_string(f"Internal server error: {e!s}"))
await websocket.close(code=1011, reason=_redact_string(f"Internal server error: {e}"))
except RuntimeError as close_error:
if "already completed" in str(close_error) or "websocket.close" in str(close_error):
# The WebSocket is already closed or the response is completed, so we can ignore this error
@ -6303,7 +6303,7 @@ class BaseLLMHTTPHandler:
except Exception as e:
verbose_logger.exception(f"Error in responses WS: {e}")
try:
await websocket.close(code=1011, reason=_redact_string(f"Internal server error: {e!s}"))
await websocket.close(code=1011, reason=_redact_string(f"Internal server error: {e}"))
except RuntimeError as close_error:
if "already completed" in str(close_error) or "websocket.close" in str(close_error):
pass

2
litellm/llms/dashscope/embed/transformation.py
View file

@ -130,7 +130,7 @@ class DashScopeEmbeddingConfig(BaseEmbeddingConfig):
except Exception as e:
raise DashScopeError(
status_code=raw_response.status_code,
message=f"Failed to parse DashScope response as JSON: {e!s}",
message=f"Failed to parse DashScope response as JSON: {e}",
)
logging_obj.post_call(

2
litellm/llms/databricks/chat/transformation.py
View file

@ -630,7 +630,7 @@ class DatabricksConfig(DatabricksBase, OpenAILikeChatConfig, AnthropicConfig):
except Exception as e:
response_headers = getattr(raw_response, "headers", None)
raise DatabricksException(
message=f"Unable to get json response - {e!s}, Original Response: {raw_response.text}",
message=f"Unable to get json response - {e}, Original Response: {raw_response.text}",
status_code=raw_response.status_code,
headers=response_headers,
)

2
litellm/llms/databricks/common_utils.py
View file

@ -245,7 +245,7 @@ class DatabricksBase:
except requests.RequestException as e:
raise DatabricksException(
status_code=500,
message=f"OAuth M2M token request failed: {e!s}",
message=f"OAuth M2M token request failed: {e}",
)
if response.status_code != 200:

2
litellm/llms/deepgram/audio_transcription/transformation.py
View file

@ -122,7 +122,7 @@ class DeepgramAudioTranscriptionConfig(BaseAudioTranscriptionConfig):
return response
except Exception as e:
raise ValueError(f"Error transforming Deepgram response: {e!s}\nResponse: {raw_response.text}")
raise ValueError(f"Error transforming Deepgram response: {e}\nResponse: {raw_response.text}")
def _reconstruct_diarized_transcript(self, words: list) -> str:
"""

2
litellm/llms/elevenlabs/audio_transcription/transformation.py
View file

@ -144,7 +144,7 @@ class ElevenLabsAudioTranscriptionConfig(BaseAudioTranscriptionConfig):
return response
except Exception as e:
raise ValueError(f"Error transforming ElevenLabs response: {e!s}\nResponse: {raw_response.text}")
raise ValueError(f"Error transforming ElevenLabs response: {e}\nResponse: {raw_response.text}")
def get_complete_url(
self,

2
litellm/llms/fireworks_ai/chat/transformation.py
View file

@ -542,7 +542,7 @@ class FireworksAIConfig(FireworksAIMixin, OpenAIGPTConfig):
except Exception as e:
response_headers = getattr(raw_response, "headers", None)
raise FireworksAIException(
message=f"Unable to get json response - {e!s}, Original Response: {raw_response.text}",
message=f"Unable to get json response - {e}, Original Response: {raw_response.text}",
status_code=raw_response.status_code,
headers=response_headers,
)

2
litellm/llms/fireworks_ai/rerank/transformation.py
View file

@ -178,7 +178,7 @@ class FireworksAIRerankConfig(FireworksAIMixin, BaseRerankConfig):
raw_response_json = raw_response.json()
except Exception as e:
raise self.get_error_class(
error_message=f"Failed to parse response: {e!s}",
error_message=f"Failed to parse response: {e}",
status_code=raw_response.status_code,
headers=raw_response.headers,
)

2
litellm/llms/gdc/chat/transformation.py
View file

@ -220,7 +220,7 @@ class GDCGeminiConfig(OpenAILikeChatConfig):
AttributeError,
) as e:
raise litellm.utils.AuthenticationError(
message=f"Failed to load service account credentials from api_key: {e!s}",
message=f"Failed to load service account credentials from api_key: {e}",
llm_provider="gdc",
model=model,
) from e

4
litellm/llms/gemini/count_tokens/handler.py
View file

@ -155,8 +155,8 @@ class GoogleAIStudioTokenCounter:
status_code=e.response.status_code,
) from e
except httpx.RequestError as e:
error_msg = f"Request to Google Gen AI Studio failed: {e!s}"
error_msg = f"Request to Google Gen AI Studio failed: {e}"
raise litellm.APIConnectionError(message=error_msg, llm_provider="gemini", model=model) from e
except Exception as e:
error_msg = f"Unexpected error during token counting: {e!s}"
error_msg = f"Unexpected error during token counting: {e}"
raise Exception(error_msg) from e

12
litellm/llms/gemini/files/transformation.py
View file

@ -190,8 +190,8 @@ class GoogleAIStudioFilesHandler(GeminiModelInfo, BaseFilesConfig):
status_details=None,
)
except Exception as e:
verbose_logger.exception(f"Error parsing file upload response: {e!s}")
raise ValueError(f"Error parsing file upload response: {e!s}")
verbose_logger.exception(f"Error parsing file upload response: {e}")
raise ValueError(f"Error parsing file upload response: {e}")
def transform_retrieve_file_request(
self,
@ -294,8 +294,8 @@ class GoogleAIStudioFilesHandler(GeminiModelInfo, BaseFilesConfig):
status_details=(str(response_json.get("error", "")) if gemini_state == "FAILED" else None),
)
except Exception as e:
verbose_logger.exception(f"Error parsing file retrieve response: {e!s}")
raise ValueError(f"Error parsing file retrieve response: {e!s}")
verbose_logger.exception(f"Error parsing file retrieve response: {e}")
raise ValueError(f"Error parsing file retrieve response: {e}")
def transform_delete_file_request(
self,
@ -362,8 +362,8 @@ class GoogleAIStudioFilesHandler(GeminiModelInfo, BaseFilesConfig):
else:
raise ValueError(f"Failed to delete file: {raw_response.text}")
except Exception as e:
verbose_logger.exception(f"Error parsing file delete response: {e!s}")
raise ValueError(f"Error parsing file delete response: {e!s}")
verbose_logger.exception(f"Error parsing file delete response: {e}")
raise ValueError(f"Error parsing file delete response: {e}")
def transform_list_files_request(
self,

4
litellm/llms/gemini/vector_stores/transformation.py
View file

@ -256,7 +256,7 @@ class GeminiVectorStoreConfig(BaseVectorStoreConfig):
except Exception as e:
raise self.get_error_class(
error_message=f"Failed to parse Gemini response: {e!s}",
error_message=f"Failed to parse Gemini response: {e}",
status_code=response.status_code,
headers=response.headers,
)
@ -327,7 +327,7 @@ class GeminiVectorStoreConfig(BaseVectorStoreConfig):
except Exception as e:
raise self.get_error_class(
error_message=f"Failed to parse Gemini create response: {e!s}",
error_message=f"Failed to parse Gemini create response: {e}",
status_code=response.status_code,
headers=response.headers,
)

4
litellm/llms/gigachat/authenticator.py
View file

@ -177,7 +177,7 @@ def _request_token_sync(
except httpx.RequestError as e:
raise GigaChatAuthError(
status_code=500,
message=f"GigaChat authentication request failed: {e!s}",
message=f"GigaChat authentication request failed: {e}",
)
@ -212,7 +212,7 @@ async def _request_token_async(
except httpx.RequestError as e:
raise GigaChatAuthError(
status_code=500,
message=f"GigaChat authentication request failed: {e!s}",
message=f"GigaChat authentication request failed: {e}",
)

40
litellm/llms/github_copilot/authenticator.py
View file

@ -68,7 +68,7 @@ class Authenticator:
verbose_logger.error("Error saving access token to file")
return access_token
except (GetDeviceCodeError, GetAccessTokenError, RefreshAPIKeyError) as e:
verbose_logger.warning(f"Failed attempt {attempt + 1}: {e!s}")
verbose_logger.warning(f"Failed attempt {attempt + 1}: {e}")
continue
raise GetAccessTokenError(
@ -100,7 +100,7 @@ class Authenticator:
except OSError:
verbose_logger.warning("No API key file found or error opening file")
except (json.JSONDecodeError, KeyError) as e:
verbose_logger.warning(f"Error reading API key from file: {e!s}")
verbose_logger.warning(f"Error reading API key from file: {e}")
except APIKeyExpiredError:
pass # Already logged in the try block
@ -117,14 +117,14 @@ class Authenticator:
status_code=401,
)
except OSError as e:
verbose_logger.error(f"Error saving API key to file: {e!s}")
verbose_logger.error(f"Error saving API key to file: {e}")
raise GetAPIKeyError(
message=f"Failed to save API key: {e!s}",
message=f"Failed to save API key: {e}",
status_code=500,
)
except RefreshAPIKeyError as e:
raise GetAPIKeyError(
message=f"Failed to refresh API key: {e!s}",
message=f"Failed to refresh API key: {e}",
status_code=401,
)
@ -142,7 +142,7 @@ class Authenticator:
api_endpoint = endpoints.get("api")
return api_endpoint
except (OSError, json.JSONDecodeError, KeyError) as e:
verbose_logger.warning(f"Error reading API endpoint from file: {e!s}")
verbose_logger.warning(f"Error reading API endpoint from file: {e}")
return None
def _refresh_api_key(self) -> dict[str, Any]:
@ -173,9 +173,9 @@ class Authenticator:
else:
verbose_logger.warning(f"API key response missing token: {response_json}")
except httpx.HTTPStatusError as e:
verbose_logger.error(f"HTTP error refreshing API key (attempt {attempt + 1}/{max_retries}): {e!s}")
verbose_logger.error(f"HTTP error refreshing API key (attempt {attempt + 1}/{max_retries}): {e}")
except Exception as e:
verbose_logger.error(f"Unexpected error refreshing API key: {e!s}")
verbose_logger.error(f"Unexpected error refreshing API key: {e}")
raise RefreshAPIKeyError(
message="Failed to refresh API key after maximum retries",
@ -245,21 +245,21 @@ class Authenticator:
return resp_json
except httpx.HTTPStatusError as e:
verbose_logger.error(f"HTTP error getting device code: {e!s}")
verbose_logger.error(f"HTTP error getting device code: {e}")
raise GetDeviceCodeError(
message=f"Failed to get device code: {e!s}",
message=f"Failed to get device code: {e}",
status_code=400,
)
except json.JSONDecodeError as e:
verbose_logger.error(f"Error decoding JSON response: {e!s}")
verbose_logger.error(f"Error decoding JSON response: {e}")
raise GetDeviceCodeError(
message=f"Failed to decode device code response: {e!s}",
message=f"Failed to decode device code response: {e}",
status_code=400,
)
except Exception as e:
verbose_logger.error(f"Unexpected error getting device code: {e!s}")
verbose_logger.error(f"Unexpected error getting device code: {e}")
raise GetDeviceCodeError(
message=f"Failed to get device code: {e!s}",
message=f"Failed to get device code: {e}",
status_code=400,
)
@ -304,21 +304,21 @@ class Authenticator:
else:
verbose_logger.warning(f"Unexpected response: {resp_json}")
except httpx.HTTPStatusError as e:
verbose_logger.error(f"HTTP error polling for access token: {e!s}")
verbose_logger.error(f"HTTP error polling for access token: {e}")
raise GetAccessTokenError(
message=f"Failed to get access token: {e!s}",
message=f"Failed to get access token: {e}",
status_code=400,
)
except json.JSONDecodeError as e:
verbose_logger.error(f"Error decoding JSON response: {e!s}")
verbose_logger.error(f"Error decoding JSON response: {e}")
raise GetAccessTokenError(
message=f"Failed to decode access token response: {e!s}",
message=f"Failed to decode access token response: {e}",
status_code=400,
)
except Exception as e:
verbose_logger.error(f"Unexpected error polling for access token: {e!s}")
verbose_logger.error(f"Unexpected error polling for access token: {e}")
raise GetAccessTokenError(
message=f"Failed to get access token: {e!s}",
message=f"Failed to get access token: {e}",
status_code=400,
)

2
litellm/llms/huggingface/common_utils.py
View file

@ -96,7 +96,7 @@ def _fetch_inference_provider_mapping(model: str) -> dict:
status_code = 500
headers = {}
raise HuggingFaceError(
message=f"Failed to fetch provider mapping: {e!s}",
message=f"Failed to fetch provider mapping: {e}",
status_code=status_code,
headers=headers,
)

4
litellm/llms/langgraph/chat/sse_iterator.py
View file

@ -196,7 +196,7 @@ class LangGraphSSEStreamIterator:
except httpx.StreamClosed:
raise StopIteration
except Exception as e:
verbose_logger.error(f"Error in LangGraph SSE stream: {e!s}")
verbose_logger.error(f"Error in LangGraph SSE stream: {e}")
raise StopIteration
async def __anext__(self) -> ModelResponseStream:
@ -224,5 +224,5 @@ class LangGraphSSEStreamIterator:
except httpx.StreamClosed:
raise StopAsyncIteration
except Exception as e:
verbose_logger.error(f"Error in LangGraph SSE stream: {e!s}")
verbose_logger.error(f"Error in LangGraph SSE stream: {e}")
raise StopAsyncIteration

6
litellm/llms/langgraph/chat/transformation.py
View file

@ -451,14 +451,14 @@ class LangGraphConfig(BaseConfig):
)
setattr(model_response, "usage", usage)
except Exception as e:
verbose_logger.warning(f"Failed to calculate token usage: {e!s}")
verbose_logger.warning(f"Failed to calculate token usage: {e}")
return model_response
except Exception as e:
verbose_logger.error(f"Error processing LangGraph response: {e!s}")
verbose_logger.error(f"Error processing LangGraph response: {e}")
raise LangGraphError(
message=f"Error processing response: {e!s}",
message=f"Error processing response: {e}",
status_code=raw_response.status_code,
)

2
litellm/llms/litellm_proxy/skills/code_execution.py
View file

@ -239,7 +239,7 @@ class CodeExecutionHandler:
tool_result += f"\n\nError:\n{exec_result['error']}"
except Exception as e:
tool_result = f"Code execution failed: {e!s}"
tool_result = f"Code execution failed: {e}"
execution_results.append(
{
"iteration": iteration,

4
litellm/llms/manus/files/transformation.py
View file

@ -279,8 +279,8 @@ class ManusFilesConfig(BaseFilesConfig):
status_details=response_json.get("status_details"),
)
except Exception as e:
verbose_logger.exception(f"Error parsing Manus file response: {e!s}")
raise ValueError(f"Error parsing Manus file response: {e!s}")
verbose_logger.exception(f"Error parsing Manus file response: {e}")
raise ValueError(f"Error parsing Manus file response: {e}")
def transform_retrieve_file_request(
self,

2
litellm/llms/milvus/vector_stores/transformation.py
View file

@ -158,7 +158,7 @@ class MilvusVectorStoreConfig(BaseVectorStoreConfig):
)
query_vector = embedding_response.data[0]["embedding"]
except Exception as e:
raise Exception(f"Failed to generate embedding for query: {e!s}")
raise Exception(f"Failed to generate embedding for query: {e}")
# Azure AI Search endpoint for search
index_name = vector_store_id # vector_store_id is the index name

6
litellm/llms/minimax/text_to_speech/transformation.py
View file

@ -353,7 +353,7 @@ class MinimaxTextToSpeechConfig(BaseTextToSpeechConfig):
except Exception as e:
raise MinimaxException(
status_code=500,
message=f"Failed to decode audio data: {e!s}",
message=f"Failed to decode audio data: {e}",
headers=dict(raw_response.headers),
)
@ -378,7 +378,7 @@ class MinimaxTextToSpeechConfig(BaseTextToSpeechConfig):
except json.JSONDecodeError as e:
raise MinimaxException(
status_code=500,
message=f"Failed to parse MiniMax response: {e!s}",
message=f"Failed to parse MiniMax response: {e}",
headers=dict(raw_response.headers),
)
except Exception as e:
@ -386,7 +386,7 @@ class MinimaxTextToSpeechConfig(BaseTextToSpeechConfig):
raise
raise MinimaxException(
status_code=500,
message=f"Error processing MiniMax response: {e!s}",
message=f"Error processing MiniMax response: {e}",
headers=dict(raw_response.headers),
)

2
litellm/llms/mistral/chat/transformation.py
View file

@ -330,7 +330,7 @@ class MistralConfig(OpenAIGPTConfig):
new_content = [{"type": "text", "text": reasoning_prompt + "\n\n"}] + existing_content
else:
# Fallback for any other type - convert to string
new_content = f"{reasoning_prompt}\n\n{existing_content!s}"
new_content = f"{reasoning_prompt}\n\n{existing_content}"
messages[i] = cast(AllMessageValues, {**msg, "content": new_content})
break

Some files were not shown because too many files have changed in this diff Show more