o i:9 @sNdZddlmZddlmZddlmZmZmZm Z m Z m Z m Z zddl mZmZmZmZWney?ZzededZ[wwddlmZmZdd lmZmZdd lmZdd lmZmZmZdd lm Z erdd l!m"Z"dd l#m"Z$ddl%m&Z&ddl'm(Z(gdZ)Gddde ddZ*GdddeZ+GdddeZ, d"d#d d!Z-dS)$auRetries utilities based on tenacity, especially for HTTP requests. This module provides HTTP transport wrappers and wait strategies that integrate with the tenacity library to add retry capabilities to HTTP requests. The transports can be used with HTTP clients that support custom transports (such as httpx), while the wait strategies can be used with any tenacity retry decorator. The module includes: - TenacityTransport: Synchronous HTTP transport with retry capabilities - AsyncTenacityTransport: Asynchronous HTTP transport with retry capabilities - wait_retry_after: Wait strategy that respects HTTP Retry-After headers ) annotations) TracebackType)AsyncBaseTransportAsyncHTTPTransport BaseTransportHTTPStatusError HTTPTransportRequestResponse)RetryCallState RetryErrorretrywait_exponentialuPlease install `tenacity` to use the retries utilities, you can use the `retries` optional group — `pip install "pydantic-ai-slim[retries]"`N) AwaitableCallable)datetimetimezone)parsedate_to_datetime) TYPE_CHECKINGAnycast) TypedDict) RetryBaseT) StopBaseT) WaitBaseT) RetryConfigTenacityTransportAsyncTenacityTransportwait_retry_afterc@steZdZUdZded< ded< ded< ded < d ed < d ed < d ed< ded< ded< ded<dS)raeThe configuration for tenacity-based retrying. These are precisely the arguments to the tenacity `retry` decorator, and they are generally used internally by passing them to that decorator via `@retry(**config)` or similar. All fields are optional, and if not provided, the default values from the `tenacity.retry` decorator will be used. z/Callable[[int | float], None | Awaitable[None]]sleeprstoprwaitzSyncRetryBaseT | RetryBaseTr z2Callable[[RetryCallState], None | Awaitable[None]]beforeafterz9Callable[[RetryCallState], None | Awaitable[None]] | None before_sleepboolreraiseztype[RetryError]retry_error_clsz7Callable[[RetryCallState], Any | Awaitable[Any]] | Noneretry_error_callbackN)__name__ __module__ __qualname____doc____annotations__r.r.Y/var/www/html/karishye-ai-python/venv/lib/python3.10/site-packages/pydantic_ai/retries.pyr4s, rF)totalc@PeZdZdZ  ddd d Zd ddZd!ddZ   d"d#ddZd$ddZdS)%racSynchronous HTTP transport with tenacity-based retry functionality. This transport wraps another BaseTransport and adds retry capabilities using the tenacity library. It can be configured to retry requests based on various conditions such as specific exception types, response status codes, or custom validation logic. The transport works by intercepting HTTP requests and responses, allowing the tenacity controller to determine when and how to retry failed requests. The validate_response function can be used to convert HTTP responses into exceptions that trigger retries. Args: wrapped: The underlying transport to wrap and add retry functionality to. config: The arguments to use for the tenacity `retry` decorator, including retry conditions, wait strategy, stop conditions, etc. See the tenacity docs for more info. validate_response: Optional callable that takes a Response and can raise an exception to be handled by the controller if the response should trigger a retry. Common use case is to raise exceptions for certain HTTP status codes. If None, no response validation is performed. Example: ```python from httpx import Client, HTTPStatusError, HTTPTransport from tenacity import retry_if_exception_type, stop_after_attempt from pydantic_ai.retries import RetryConfig, TenacityTransport, wait_retry_after transport = TenacityTransport( RetryConfig( retry=retry_if_exception_type(HTTPStatusError), wait=wait_retry_after(max_wait=300), stop=stop_after_attempt(5), reraise=True ), HTTPTransport(), validate_response=lambda r: r.raise_for_status() ) client = Client(transport=transport) ``` NconfigrwrappedBaseTransport | Nonevalidate_response Callable[[Response], Any] | NonecC||_|pt|_||_dSN)r2rr3r5selfr2r3r5r.r.r/__init__  zTenacityTransport.__init__requestr returnr cs&tdijd fdd }||S) a]Handle an HTTP request with retry logic. Args: request: The HTTP request to handle. Returns: The HTTP response. Raises: RuntimeError: If the retry controller did not make any attempts. Exception: Any exception raised by the wrapped transport or validation function. reqr r>r csFj|}||_jr!z|W|Sty |w|Sr8)r3handle_requestr=r5 Exceptioncloser?responser:r.r/r@s   z8TenacityTransport.handle_request..handle_requestNr.r?r r>r r r2)r:r=r@r.rEr/r@sz TenacityTransport.handle_requestcCs|j|Sr8)r3 __enter__rEr.r.r/rHs zTenacityTransport.__enter__exc_typetype[BaseException] | None exc_valueBaseException | None tracebackTracebackType | NoneNonecCs|j|||dSr8)r3__exit__r:rIrKrMr.r.r/rPszTenacityTransport.__exit__cCs|jdSr8)r3rBrEr.r.r/rBszTenacityTransport.closeNN)r2rr3r4r5r6r=r r>r )r>rNNNrIrJrKrLrMrNr>rOr>rO) r)r*r+r,r;r@rHrPrBr.r.r.r/rus+  rc@r1)%raWAsynchronous HTTP transport with tenacity-based retry functionality. This transport wraps another AsyncBaseTransport and adds retry capabilities using the tenacity library. It can be configured to retry requests based on various conditions such as specific exception types, response status codes, or custom validation logic. The transport works by intercepting HTTP requests and responses, allowing the tenacity controller to determine when and how to retry failed requests. The validate_response function can be used to convert HTTP responses into exceptions that trigger retries. Args: wrapped: The underlying async transport to wrap and add retry functionality to. config: The arguments to use for the tenacity `retry` decorator, including retry conditions, wait strategy, stop conditions, etc. See the tenacity docs for more info. validate_response: Optional callable that takes a Response and can raise an exception to be handled by the controller if the response should trigger a retry. Common use case is to raise exceptions for certain HTTP status codes. If None, no response validation is performed. Example: ```python from httpx import AsyncClient, HTTPStatusError from tenacity import retry_if_exception_type, stop_after_attempt from pydantic_ai.retries import AsyncTenacityTransport, RetryConfig, wait_retry_after transport = AsyncTenacityTransport( RetryConfig( retry=retry_if_exception_type(HTTPStatusError), wait=wait_retry_after(max_wait=300), stop=stop_after_attempt(5), reraise=True ), validate_response=lambda r: r.raise_for_status() ) client = AsyncClient(transport=transport) ``` Nr2rr3AsyncBaseTransport | Noner5r6cCr7r8)r2rr3r5r9r.r.r/r;r<zAsyncTenacityTransport.__init__r=r r>r cs.tdijd fdd }||IdHS) acHandle an async HTTP request with retry logic. Args: request: The HTTP request to handle. Returns: The HTTP response. Raises: RuntimeError: If the retry controller did not make any attempts. Exception: Any exception raised by the wrapped transport or validation function. r?r r>r csTj|IdH}||_jr(z|W|Sty'|IdHw|Sr8)r3handle_async_requestr=r5rAacloserCrEr.r/rXs  zIAsyncTenacityTransport.handle_async_request..handle_async_requestNr.rFrG)r:r=rXr.rEr/rX sz+AsyncTenacityTransport.handle_async_requestcs|jIdH|Sr8)r3 __aenter__rEr.r.r/rZ(sz!AsyncTenacityTransport.__aenter__rIrJrKrLrMrNrOcs|j|||IdHdSr8)r3 __aexit__rQr.r.r/r[,sz AsyncTenacityTransport.__aexit__cs|jIdHdSr8)r3rYrEr.r.r/rY4szAsyncTenacityTransport.acloserR)r2rr3rWr5r6rS)r>rrTrUrV) r)r*r+r,r;rXrZr[rYr.r.r.r/rs*  r,fallback_strategy(Callable[[RetryCallState], float] | Nonemax_waitfloatr>!Callable[[RetryCallState], float]cs(dur tdddd fd d }|S) a Create a tenacity-compatible wait strategy that respects HTTP Retry-After headers. This wait strategy checks if the exception contains an HTTPStatusError with a Retry-After header, and if so, waits for the time specified in the header. If no header is present or parsing fails, it falls back to the provided strategy. The Retry-After header can be in two formats: - An integer representing seconds to wait - An HTTP date string representing when to retry Args: fallback_strategy: Wait strategy to use when no Retry-After header is present or parsing fails. Defaults to exponential backoff with max 60s. max_wait: Maximum time to wait in seconds, regardless of header value. Defaults to 300 (5 minutes). Returns: A wait function that can be used with tenacity retry decorators. Example: ```python from httpx import AsyncClient, HTTPStatusError from tenacity import retry_if_exception_type, stop_after_attempt from pydantic_ai.retries import AsyncTenacityTransport, RetryConfig, wait_retry_after transport = AsyncTenacityTransport( RetryConfig( retry=retry_if_exception_type(HTTPStatusError), wait=wait_retry_after(max_wait=120), stop=stop_after_attempt(5), reraise=True ), validate_response=lambda r: r.raise_for_status() ) client = AsyncClient(transport=transport) ``` N<) multipliermaxstater r>r`c s|jr|jnd}t|trk|jjd}|rkz t|}tt |WSt yjz(t t t |}t|t s:Jt tj}||}|dkrRt|WYSWn t ttfy_YnwY|SY|Sw|S)Nz retry-afterr)outcome exception isinstancerrDheadersgetintminr` ValueErrorrrrnowrutc total_seconds TypeErrorAssertionError)rfexc retry_after wait_seconds retry_timeror]r_r.r/ wait_funcds2    z#wait_retry_after..wait_func)rfr r>r`)r)r]r_ryr.rxr/r8s) r)Nr\)r]r^r_r`r>ra).r, __future__rtypesrhttpxrrrrrr r tenacityr r r r ImportError _import_errorcollections.abcrrrr email.utilsrtypingrrrtyping_extensionsrtenacity.asyncio.retryrtenacity.retrySyncRetryBaseT tenacity.stopr tenacity.waitr__all__rrrrr.r.r.r/s< $       Abb