o ưi@s^dZddlZddlZddlZddlZddlZddlZddlmZddl m Z m Z m Z m Z mZmZmZddlZddlmZmZddlmZddlmZddlmZdd lmZmZmZdd lm Z d d l!m"Z"e rdd l#m$Z%ddl&m'Z'm(Z(ddl)m*Z*ddl+m,Z,e*Z-e,Z.e'Z/e(Z0ee%e fZ$n e Z-e Z.e Z/e Z0e Z$dde1de2fddZ3Gddde"Z4dS)z Redis Cache implementation Has 4 primary methods: - set_cache - get_cache - async_set_cache - async_get_cache N) timedelta) TYPE_CHECKINGAnyListOptionalTupleUnioncast) print_verboseverbose_logger)DEFAULT_REDIS_MAJOR_VERSION)!_get_parent_otel_span_from_kwargs)coroutine_checker)RedisPipelineIncrementOperationRedisPipelineLpopOperationRedisPipelineRpushOperation) ServiceTypes) BaseCache)Span)Redis RedisCluster)Pipeline)ClusterPipeline num_framesreturncCszEt}|dur WdS|j}|durWdS|j}|dur WdSg}t|D]}|dur.n |jj}|||j}q&|s@WdSd|WStyOYdSw)a Get the function names from the previous 1-2 functions in the call stack. Args: num_frames: Number of previous frames to include (default: 2) Returns: A string with format "current_function <- caller_function [<- grandparent_function]" Nunknownz <- ) inspect currentframef_backrangef_codeco_nameappendjoin Exception)r current_framer frameZfunction_names_ func_namer+R/home/app/Keep/.python/lib/python3.10/site-packages/litellm/caching/redis_cache.py_get_call_stack_info5s.     r-c sjeZdZ       d{deedeedeedeeffdd Zd d Z d e fd dZ d e fddZ defddZ deeeffddZdedefddZdefddZddZ d|dedeedefdd Zd}d!ed"edefd#d$Zd%edefd&d'Zd(d)Zd*eeefd+eeeefdeedefd,d-Z d|d+eeeefdeefd.d/Zd0edededeeddf d1d2Z dedeefd3d4Z!d5d6Z"  d~dedeed7ee#defd8d9Z$d:d;Z%dZ&d|d7ee#fd?d@Z'dAeedeefdBdCZ(dAeedeefdDdEZ) d|dFeeeeeefd7ee#de*fdGdHZ+ d|d7ee#fdIdJZ, d|dFeeeeeefd7ee#de*fdKdLZ-de.fdMdNZ/de.fdOdPZ0dQdRZ1defdSdTZ2dUdVZ3dWdXZ4dYdZZ5d[d\Z6de*fd]d^Z7defd_d`Z8dadbZ9d*edcee:deeefdddeZ;dcee:deeefdfdgZd*edmee?deefdndoZ@dmee?deefdpdqZAd*eded"edeeBfdrdsZC  d~ded"eed7ee#deeeeffdtduZDd*edveeEdeeeefdwdxZFdveeEdeeeefdydzZGZHS) RedisCacheNd@redis_flush_size namespace startup_nodessocket_timeoutc  snddlm} ddlm} m} i} |dur|| d<|dur || d<|dur(|| d<|dur0|| d<|dur8|| d <|d ddurNt|d | rN|d |_n| |_| || di| |_ d|_ | |_ | di| |_ ||_g|_|dur{d |_n||_d |_zt|j s|j d |_Wn tyYnw|tjdurtjttjddStdS)Nr)ServiceLoggingr)get_redis_clientget_redis_connection_poolhostportpasswordr3r4service_logger_objr/Unknown redis_version)Z default_ttlr+)Zlitellm._service_loggerr5_redisr6r7get isinstancepopr;update redis_clientredis_async_client redis_kwargsasync_redis_conn_poolr2redis_batch_writing_bufferr1r=rZis_async_callableinfor&_setup_health_pingslitellmZdefault_redis_ttlsuper__init__int) selfr8r9r:r1r2r3r4kwargsr5r6r7rE __class__r+r,rL_sR     zRedisCache.__init__c Csz t|}Wn3ty>}z'dt|vrtdntjd t|dt|id| |WYd}~nd}~wwzt |j drN|j WdSWdStys}ztjddt|id| |WYd}~dSd}~ww) z,Setup async and sync health pings for Redis.zno running event loopz1Ignoring async redis ping. No running event loop.z+Error connecting to Async Redis client - {}error)extraNpingz%Error connecting to Sync Redis client)asyncioget_running_loop create_taskrTr&strr debugrRformat_handle_async_ping_errorhasattrrC_handle_sync_ping_error)rNr)er+r+r,rIs2      zRedisCache._setup_health_pingsr^cCPzt}t}|}||jjtj|||ddWdSty'YdSw)z2Handle async ping error with service failure hook.Zredis_async_pingservicedurationrR call_typeN rUrVtimerWr;async_service_failure_hookrREDISr&rNr^loop start_timeend_timer+r+r,r[ z#RedisCache._handle_async_ping_errorcCr_)z1Handle sync ping error with service failure hook.Zredis_sync_pingr`Nrdrhr+r+r,r]rlz"RedisCache._handle_sync_ping_errorrcCs@t|j}tj|dd}t|dd}d|S)z Generate a cache key for the async Redis client based on connection parameters. This ensures different Redis configurations use different cached clients. T) sort_keysNzasync-redis-client-) sortedrEitemsjsondumpshashlibsha256encode hexdigest)rNZ sorted_kwargsZ kwargs_strZ kwargs_hashr+r+r,_get_async_client_cache_keys z&RedisCache._get_async_client_cache_keycCsddlm}ddlm}m}|}|j|d}|dur&ttt t f|}n|di|j |_ |dd|j i|j }|j ||d||_|S) Nr)in_memory_llm_clients_cacher)get_redis_async_clientr7keyZconnection_pool)r{valuer+)rJrxr>ryr7rw get_cacher rasync_redis_clientasync_redis_cluster_clientrErF set_cacherD)rNrxryr7 cache_keyZ cached_clientrDr+r+r,init_async_clients&   zRedisCache.init_async_clientr{cCs(|jdur||js|jd|}|S)zD Make sure each key starts with the given namespace N:)r2 startswithrNr{r+r+r,check_and_fix_namespacesz"RedisCache.check_and_fix_namespacec Csj|jdkrtSz t|j}d|vrt|dd}|WStt|}|WSttfy4tYSw)a Parse Redis version to extract the major version number. Handles multiple version formats: - Strings: "7.0.0", "6", "7.0.0-rc1", " 7.0.0 " - Floats: 7.0 (e.g., from AWS ElastiCache Valkey) - Integers: 7 - Malformed: "latest", "", "Unknown" (defaults to DEFAULT_REDIS_MAJOR_VERSION) Returns: int: The major version number (defaults to DEFAULT_REDIS_MAJOR_VERSION if unparseable) r<.r) r=r rXstriprMsplitfloat ValueErrorAttributeError)rN version_str major_versionr+r+r,_parse_redis_major_version s  z%RedisCache._parse_redis_major_versionc Ks|jd i|}td|d|d|d|j|j|d}z*t}|jj|t||dt}||}|jj t j |dt ||dWdSt ye}ztd t|WYd}~dSd}~ww) NzSet Redis Cache: key:  Value  ttl=, redis_version=rznamer|exz set_cache <- rarbrcrjrkz.script_callablez Error registering Redis script: N) rr\rrrrXrr&r rR)rNrrr^r+rr,async_register_scripts     $ z RedisCache.async_register_scriptc sddlm}t}z|}Wn6tyG}z*t}||} t|jjt j | |||t |dt dt dt|||d}~ww|j|d}|jdi|} |dd} td |d |d | zIt|d sstd |j|t|| | dIdH} td|d |d | t}||} t|jjt j | dt ||t |d|id| WSty}z2t}||} t|jjt j | |dt ||t |d|idt dt||WYd}~dSd}~ww)Nrrzasync_set_cache <- rarbrRrjrkparent_otel_spanrcRLiteLLM Redis Caching: async set() - Got exception from REDIS %s, Writing value=%srznxFSet ASYNC Redis Cache: key: rrrz3Redis client cannot set cache. Attribute not found.)rr|rrz)Successfully Set ASYNC Redis Cache: key: r{rarbrcrjrkrevent_metadatararbrRrcrjrkrrr+) redis.asynciorrerr&rUrWr;rfrrgr r-r rRrXrrr?r r\rrqrrr) rNr{r|rOrrjrr^rkrrrrr+r+r,async_set_caches            zRedisCache.async_set_cachepipe cache_listc s|j|d}|D]/\}}|j|d}td|d|d|t|}d}|dur0t|d}|j|||dq |IdH}|S) zU Helper function for executing a pipeline of set operations on Redis rrzz%Set ASYNC Redis Cache PIPELINE: key: rrNsecondsr)rrr rqrrrrexecute) rNrrrr cache_valueZjson_cache_value_tdresultsr+r+r,_pipeline_helpers$    zRedisCache._pipeline_helperc s^t|dkr dS|}t}td|d|d|jd}zR|jdd4IdH}||||IdH}WdIdHn 1IdHsGwYtd|t} | |} t|j j t j | d t || t|d WdSty} z/t} | |} t|j jt j | | d t || t|d td t| |WYd} ~ dSd} ~ ww) z? Use Redis Pipelines for bulk write operations rNz!Set Async Redis Cache: key list: rrFZ transactionzpipeline results: zasync_set_cache_pipeline <- rarbrcrjrkrrarbrRrcrjrkrzaLiteLLM Redis Caching: async set_cache_pipeline() - Got exception from REDIS %s, Writing value=%s)rrrer r=pipelinerrUrWr;rrrgr-r r&rfr rRrX) rNrrrOrrjrrrrkrr^r+r+r,async_set_cache_pipeline3s` (    z#RedisCache.async_set_cache_pipelinerCcsh|j|d}z$|j|g|RIdH|dur)t|d}|||IdHWdSWdSty3w)z@Helper function for async_set_cache_sadd. Separated for testing.rNr)rZsaddrrr&)rNrCr{r|rrr+r+r,_set_cache_sadd_helperns   z!RedisCache._set_cache_sadd_helperc sddlm}t}z|}Wn6tyG}z*t} | |} t|jjt j | ||| t |dt dt dt|||d}~ww|j|d}td|d|d |z:|j||||d IdHtd |d|d |t} | |} t|jjt j | dt || t |d WdSty}z/t} | |} t|jjt j | |dt || t |d t dt||WYd}~dSd}~ww)Nrrzasync_set_cache_sadd <- rrrzrrr)rCr{r|rz.Successfully Set ASYNC Redis Cache SADD: key: rrz]LiteLLM Redis Caching: async set_cache_sadd() - Got exception from REDIS %s, Writing value=%s)rrrerr&rUrWr;rfrrgr r-r rRrXrr rr) rNr{r|rrOrrjrr^rkrr+r+r,async_set_cache_sadds           zRedisCache.async_set_cache_saddcsXtdt|j|j|d}|j||ft|j|jkr*|IdHdSdS)Nz-in batch cache writing for redis buffer size=rz)r rrGrr$r1flush_cache_buffer)rNr{r|rOr+r+r,batch_cache_writes zRedisCache.batch_cache_writercs$ddlm}|}t}|j|d}|j|d}zB|j||dIdH} |dur?||IdH} | dkr?|||IdHt} | |} t |j j t j| dt|| |d| WSty} z(t} | |} t |j jt j| | dt|| |d td t| || d} ~ ww) Nrrrrzrrzasync_increment <- rrz^LiteLLM Redis Caching: async async_increment() - Got exception from REDIS %s, Writing value=%s)rrrrerr incrbyfloatrrrUrWr;rrrgr-r&rfr rRrX)rNr{r|rrrrrjZ _used_ttlrrrkrr^r+r+r,async_increments^       zRedisCache.async_incrementcs2tdt|j||jIdHg|_dS)Nz,flushing to redis....reached size of buffer )r rrGrrNr+r+r,r s  zRedisCache.flush_cache_buffercached_responsecCsF|dur|S|d}zt|}W|Sty"t|}Y|Sw)z[ Common 'get_cache_logic' across sync + async redis client implementations Nutf-8)decoderqloadsr&ast literal_eval)rNrr+r+r,_get_cache_logics  zRedisCache._get_cache_logicc KszA|j|d}td|t}|j|}t}||}|jjtj|dt |||dtd|d||j |dWSt yZ}z t d|WYd}~dSd}~ww) NrzzGet Redis Cache: key: z get_cache <- rzGot Redis Cache: key: , cached_response rz;litellm.caching.caching: get() - Got exception from REDIS: )rr rerCr?r;rrrgr-rr&r rR) rNr{rrOrjrrkrr^r+r+r,r}"s2   zRedisCache.get_cachercCs|jj|dS) Wrapper to call `mget` on the redis client We use a wrapper so RedisCluster can override this method r)rCmget)rNrr+r+r,_run_redis_mget_operation<sz$RedisCache._run_redis_mget_operationcs|}|j|dIdHS)rrN)rr)rNrr~r+r+r,_async_run_redis_mget_operationDsz*RedisCache._async_run_redis_mget_operationkey_listc Csi}dd|D}z_g}|D]}|j|pdd}||qt}|j|d}t} | |} |jjtj| dt|| |dt t ||}i} | D]\} } t | t r\| d} || } | | | <qN| WSty}ztd t||WYd }~Sd }~ww) a Use Redis for bulk read operations Args: key_list: List of keys to get from Redis parent_otel_span: Optional parent OpenTelemetry span Returns: dict: A dictionary mapping keys to their cached values cSg|]}|dur|qSrr+.0r{r+r+r, ]z.RedisCache.batch_get_cache..rzrzbatch_get_cache <- rrz$Error occurred in batch get cache - N)rr$rerr;rrrgr-dictziprpr@bytesrrr&r rRrX)rNrrkey_value_dict _key_list_keysrrjrrkrdecoded_resultskvr^r+r+r,batch_get_cacheMs@        zRedisCache.batch_get_cachec s&ddlm}|}|j|d}t}zAtd|||IdH}td|d||j|d}t} | |} t |j j t j | dt|| |d |id |WSty} z0t} | |} t |j jt j | | dt|| |d |id td t| WYd} ~ dSd} ~ ww) NrrrzzGet Async Redis Cache: key: zGot Async Redis Cache: key: rrzasync_get_cache <- r{rrzAlitellm.caching.caching: async get() - Got exception from REDIS: )rrrrrer r?rrUrWr;rrrgr-r&rfrX) rNr{rrOrrrjrresponserkrr^r+r+r,async_get_caches\       zRedisCache.async_get_cachecsRi}t}dd|D}z_g}|D] }|j|d}||q|j|dIdH}t} | |} t|jjtj | dt || |dt t ||}i} | D]\} } t| tra| d} || } | | | <qS| WSty}z/t} | |} t|jjtj | |dt || |d td t||WYd}~Sd}~ww) a[ Use Redis for bulk read operations Args: key_list: List of keys to get from Redis parent_otel_span: Optional parent OpenTelemetry span Returns: dict: A dictionary mapping keys to their cached values `.mget` does not support None keys. This will filter out None keys. cSrrr+rr+r+r,rrz4RedisCache.async_batch_get_cache..rzrNzasync_batch_get_cache <- rrrz*Error occurred in async batch get cache - )rerr$rrUrWr;rrrgr-rrrpr@rrrr&rfr rRrX)rNrrrrjrrrrrkrrrrr^r+r+r,async_batch_get_caches`          z RedisCache.async_batch_get_cachec Cstdt}z'|j}td|t}||}|jjtj|dt||d|WSt y^}z#t}||}|jj tj||dtdt dt ||d}~ww)zD Tests if the sync redis client is correctly setup. zPinging Sync Redis CachezRedis Cache PING: z sync_ping <- rr`7LiteLLM Redis Cache PING: - Got exception from REDIS : N)r rerCrTr;rrrgr-r&Zservice_failure_hookr rRrX)rNrjrrkrr^r+r+r, sync_pings<    zRedisCache.sync_pingc s|}t}tdz#|IdH}t}||}t|jjtj |dt d|WSt yb}z&t}||}t|jj tj ||dt dt dt||d}~ww)NzPinging Async Redis Cachezasync_ping <- rarbrcr`r)rrer rTrUrWr;rrrgr-r&rfr rRrX)rNrrjrrkrr^r+r+r,rTsB   zRedisCache.pingcs|}|j|IdHdSrrdelete)rNrrr+r+r,delete_cache_keysBszRedisCache.delete_cache_keyscC|j}|Sr)rC client_list)rNrr+r+r,rH zRedisCache.client_listcCrr)rCrH)rNrHr+r+r,rHLrzRedisCache.infocC|jdSrrCflushallrr+r+r, flush_cachePzRedisCache.flush_cachecCrrrrr+r+r,rSrzRedisCache.flushallc sZ|jjddIdHz|jWdSty,}z td|WYd}~dSd}~ww)NT)Zinuse_connectionsz#Error closing sync Redis client: %s)rF disconnectrCcloser&r rY)rNr^r+r+r,rVszRedisCache.disconnectc sz+ddlm}|jd i|j}|IdH}|IdH|r'dddWSdddWStyU}ztdt |dd t |t |d WYd}~Sd}~ww) aa Test the Redis connection by creating a new client and pinging it. This creates a fresh connection without using cached clients or connection pools to ensure the credentials are actually valid. Returns: dict: {"status": "success" | "failed", "message": str, "error": Optional[str]} rNsuccessz Redis connection test successful)statusmessagefailedzRedis ping returned FalsezRedis connection test failed: zRedis connection failed: )r r rRr+) rrUrrErTacloser&r rRrX)rNZ redis_asyncrCZ ping_resultr^r+r+r,test_connection]s*  zRedisCache.test_connectioncs|}||IdHSrr)rNr{rr+r+r,async_delete_cacheszRedisCache.async_delete_cachecCs|j|dSr)rCrrr+r+r, delete_cacheszRedisCache.delete_cacheincrement_listc s|D]6}|j|dd}td|d|dd|d|||d|ddur9t|dd }|||q|IdH}td |d d |DS) z1Helper function for pipeline increment operationsr{rzz+Increment ASYNC Redis Cache PIPELINE: key: rZincrement_valuerrNrz/Increment ASYNC Redis Cache PIPELINE: results: cSsg|] }t|tr|qSr+)r@rrrr+r+r,rsz9RedisCache._pipeline_increment_helper..)rr rrrrr rY)rNrrZ increment_oprrrr+r+r,_pipeline_increment_helpers   z%RedisCache._pipeline_increment_helperc s<t|dkr dSddlm}|}t}td|zJ|jdd4IdH}|||IdH}WdIdHn 1IdHsCwYt}||} t |j j t j | dt||t|d|WSty} z)t}||} t |j jt j | | dt||t|d td t| | d} ~ ww) a Use Redis Pipelines for bulk increment operations Args: increment_list: List of RedisPipelineIncrementOperation dicts containing: - key: str - increment_value: float - ttl_seconds: int rNrz6Increment Async Redis Cache Pipeline: increment list: Frzasync_increment_pipeline <- rrzOLiteLLM Redis Caching: async increment_pipeline() - Got exception from REDIS %s)rrrrrer rrrUrWr;rrrgr-r r&rfr rRrX) rNrrOrrrjrrrkrr^r+r+r,async_increment_pipelines^  (    z#RedisCache.async_increment_pipelinec sfz|}||IdH}|dkrWdS|WSty2}ztd|WYd}~dSd}~ww)a Get the remaining TTL of a key in Redis Args: key (str): The key to get TTL for Returns: Optional[int]: The remaining TTL in seconds, or None if key doesn't exist Redis ref: https://redis.io/docs/latest/commands/ttl/ NrzRedis TTL Error: )rrr&r rY)rNr{rrr^r+r+r, async_get_ttls zRedisCache.async_get_ttlvaluesc s|}t}z(|j|g|RIdH}t}||} t|jjtj| dt d|WSt yc} z&t}||} t|jj tj| | dt dt dt| | d} ~ ww)aR Append one or multiple values to a list stored at key Args: key: The Redis key of the list values: One or more values to append to the list parent_otel_span: Optional parent OpenTelemetry span Returns: int: The length of the list after the push operation Nzasync_rpush <- rr`z8LiteLLM Redis Cache RPUSH: - Got exception from REDIS : )rrerpushrUrWr;rrrgr-r&rfr rRrX) rNr{rrrOrrjrrkrr^r+r+r, async_rpushs@   zRedisCache.async_rpush rpush_listcsP|D]}|j|dg|dRq|IdH}|D] }t|tr%|q|S)z-Helper function for pipeline rpush operationsr{rN)rrr@r&)rNrrZrpush_oprrr+r+r,_pipeline_rpush_helper/s z!RedisCache._pipeline_rpush_helperc t|dkr gS|}t}zE|jdd4IdH}|||IdH}WdIdHn 1IdHs6wYt}||}t|jjt j |dt d|WSt y}z$t}||}t|jj t j ||dt dtdt||d}~ww) a! Use Redis Pipelines for bulk RPUSH operations Args: rpush_list: List of RedisPipelineRpushOperation dicts containing: - key: str - values: List[Any] Returns: List[int]: List lengths after each push rFrNzasync_rpush_pipeline <- rr`zKLiteLLM Redis Caching: async_rpush_pipeline() - Got exception from REDIS %s)rrrerrrUrWr;rrrgr-r&rfr rRrX) rNrrrjrrrkrr^r+r+r,async_rpush_pipeline>J (  zRedisCache.async_rpush_pipelinecsLg}t|D]}|||IdH}|D] }|dur"||qq|Sr)r!lpoprr$)rNrr{rrr)rrr+r+r,*handle_lpop_count_for_older_redis_versionsts   z5RedisCache.handle_lpop_count_for_older_redis_versionsc s|}t}td|d|z|}|durK|dkrK|jdd4IdH}||||IdH} WdIdHn 1IdHsEwYn |||IdH} t} | |} t|j j t j | dt dt| trz| dWWSty| YWSwt| trtd d | Drz d d | DWWSty| YWSw| WSty} z&t} | |} t|j jt j | | dt d tdt| | d} ~ ww)NzLPOP from Redis list: key: z , count: Frzasync_lpop <- rrcss|]}t|tVqdSr)r@rritemr+r+r, s  z(RedisCache.async_lpop..cSsg|]}|dqS)r)rr"r+r+r,rsz)RedisCache.async_lpop..r`z7LiteLLM Redis Cache LPOP: - Got exception from REDIS : )rrer rrr rrUrWr;rrrgr-r@rrr&listallrfr rRrX) rNr{rrrOrrjrrrrkrr^r+r+r, async_lpopsn (        zRedisCache.async_lpop lpop_listc s`|}|dkr |D] }||d|dq |IdH}nJg}|D]}|dp+d}||t|D] }||dq5q$|IdH} g}d} |D]}dd| | | |D} || rb| nd| |7} qM|D] } t| tru| qlg} |D]3} | dur| dqzt| trz| d d| DpdWqzty| | Yqzw| dqz| S) zHelper function for pipeline lpop operations. For Redis >= 7, queues one LPOP(key, count) per operation. For Redis < 7, queues `count` individual LPOP(key) commands per operation. r!r{rNrrcSrrr+rr+r+r,rsz4RedisCache._pipeline_lpop_helper..cSs,g|]}|durt|tr|dn|qS)Nr)r@rrr"r+r+r,rs )rrrr$r!r@r&r%)rNrr(rZlpop_opZ raw_resultscountsrr)Z flat_resultsoffsetZ key_resultsrrr+r+r,_pipeline_lpop_helpersV          z RedisCache._pipeline_lpop_helperc r) aC Use Redis Pipelines for bulk LPOP operations Args: lpop_list: List of RedisPipelineLpopOperation dicts containing: - key: str - count: Optional[int] Returns: List[Optional[List[str]]]: Decoded results per key, None if key was empty rFrNzasync_lpop_pipeline <- rr`zJLiteLLM Redis Caching: async_lpop_pipeline() - Got exception from REDIS %s)rrrerr+rUrWr;rrrgr-r&rfr rRrX) rNr(rrjrrrkrr^r+r+r,async_lpop_pipelinerzRedisCache.async_lpop_pipeline)NNNr/NNr0r)r/)NN)I__name__ __module__ __qualname__rrMrXrrrLrIr&r[r]rwrr~rrrrrrr%rrrrrcluster_pipelinerrrrrrrrrrr}rrrrrrboolrrTrrrHrrrrrrrrrrrrrrrr r'rr+r, __classcell__r+r+rPr,r.\spA    9.O   ;  H  ;  5 5 G$$(    ? 3  6  B ?r.)r)5__doc__rrUrsrrqredatetimertypingrrrrrrr rJZlitellm._loggingr r Zlitellm.constantsr Z'litellm.litellm_core_utils.core_helpersr Z,litellm.litellm_core_utils.coroutine_checkerrZlitellm.types.cachingrrrZlitellm.types.servicesrZ base_cacherZopentelemetry.tracer_SpanrrrZredis.asyncio.clientrZredis.asyncio.clusterrrr0r~rrMrXr-r.r+r+r+r,sD  $        '