o 6Wj @sUddlmZddlZddlZddlZddlmZmZddlZddl m Z m Z ddl m Z ddlmZmZdd lmZd gZeeZd ed <d ZGdd d ZdS)) annotationsN)CallableOptional) AccessTokenAccessTokenProvider)WorkloadIdentityError)ADVISORY_REFRESH_SECONDSMANDATORY_REFRESH_SECONDS)AnthropicError TokenCachezlogging.Loggerlogc@sNeZdZdZeeejddd d ZdddZdddZ dddZ dddZ dS) r u2Thread-safe cache wrapping an :class:`AccessTokenProvider` with two-tier proactive refresh and single-flight semantics. Refresh policy on each :meth:`get_token` call: * No cached token → call provider (blocking), cache, return. * Cached with ``expires_at=None`` → return cached forever (never refresh). * More than ``advisory_refresh_seconds`` remaining → return cached. * Between ``mandatory_refresh_seconds`` and ``advisory_refresh_seconds`` remaining (advisory window) → try provider; on success swap cache; on failure log a warning and return the stale cached token. If another caller is already refreshing, the advisory caller just returns the cached token — no second refresh, no waiting. * Less than ``mandatory_refresh_seconds`` remaining or already expired (mandatory window) → call provider; on failure RAISE. Concurrent mandatory callers wait on a shared ``Event`` so exactly one provider call is in flight. The lock is released before the provider call so a 30-second HTTP POST doesn't serialize unrelated callers through a single thread. This matters under async: ``asyncify(get_token)`` runs on the thread pool, and holding the lock across the network call would pin an async worker for the whole exchange. )advisory_refresh_secondsmandatory_refresh_seconds time_sourceproviderrrintrrCallable[[], float]returnNonecCs>||_||_||_||_t|_d|_d|_d|_ d|_ dS)NFg) _provider _advisory _mandatory _time_source threadingLock_lock_cached_refresh_event _next_force_last_advisory_failure_time)selfrrrrr$o/home/esfera/Documents/content_generation/venv/lib/python3.10/site-packages/anthropic/lib/credentials/_cache.py__init__3s  zTokenCache.__init__forceboolrc CsJz|j|dWSty$}zdt|vr|WYd}~Sd}~ww)z@Invoke ``self._provider``, tolerating legacy zero-arg callables.) force_refreshr)N)r TypeErrorstr)r#r'errr$r$r%_invoke_providerLs zTokenCache._invoke_providerc Cs|j |j}Wdn1swYz|j|d}Wn#tyA}z|jdkr,td|jdd}WYd}~nd}~ww|j d|_Wd|S1sTwY|S)zBCall the provider, retrying once on a 401 from the token endpoint.N)r'iz*Token provider returned 401; retrying onceTF)rr!r-r status_coderdebug)r#r'resultr,r$r$r%_call_providerXs$   zTokenCache._call_providerr+c Cs@ d}d}|jq|j}|durb|jdur|jWdS|j|}||jkr5|jWdS||jkrb|jdurI|jWdS||jt kr\|jWdS|}t |}|jdurk|j}nt |_d}Wdn1s|wY|dur| qz|}Wndty}zX|j|j}d|_Wdn1swY|dusJ||durt|ttjfrtd|||j ||_Wdn1swY|jWYd}~Sd}~ww|j||_|j}d|_Wdn 1s wY|dusJ||jS)z5Return a valid bearer token, refreshing if necessary.TNrzGAdvisory token refresh failed (%ds remaining); serving cached token: %s)rr expires_attokenrrrr r" ADVISORY_REFRESH_BACKOFF_SECONDSrrEventwaitr1 BaseExceptionset isinstancer httpx HTTPErrorrwarning) r#advisory_fallbackremaining_secondscached remaining waiter_eventfreshr,releasedr$r$r% get_tokenisz         zTokenCache.get_tokencCs8|jd|_d|_WddS1swYdS)zClear the cached token so the next :meth:`get_token` re-invokes the provider. Also sets a one-shot ``force_refresh`` flag so on-disk providers skip their freshness short-circuit instead of re-serving the revoked token. NT)rrr!)r#r$r$r% invalidates"zTokenCache.invalidateN) rrrrrrrrrr)r'r(rr)rr)rr+)rr) __name__ __module__ __qualname____doc__r r timer&r-r1rDrEr$r$r$r%r s  H) __future__rrJloggingrtypingrrr:_typesrr _workloadr _constantsr r _exceptionsr __all__ getLoggerrFr__annotations__r4r r$r$r$r%s