o i{?@s*ddlmZddlZddlmZddlmZmZddlmZm Z ddl m Z ddl m Z mZmZddlmZmZd d lmZd d lmZd Zed ddGdddZed ddGdddeZed ddGdddeZd"ddZed ddedGdddeZed ddGd d!d!ZdS)#) annotationsN)copy) dataclassfields) AnnotatedAny) get_snapshot) AliasChoicesBeforeValidatorField) deprecatedoverload)_utils)UsageLimitExceeded) RequestUsageRunUsageUsage UsageLimitsFT)reprkw_onlyc@seZdZUdZded< dZded< dZded< dZded< dZded < dZ ded < dZ ded < e j e d Zd ed< eedd!ddZeedd!ddZed!ddZd"ddZddZd#ddZd S)$ UsageBaserzVAnnotated[int, Field(validation_alias=AliasChoices('input_tokens', 'request_tokens'))] input_tokensintcache_write_tokenscache_read_tokenszXAnnotated[int, Field(validation_alias=AliasChoices('output_tokens', 'response_tokens'))] output_tokensinput_audio_tokenscache_audio_read_tokensoutput_audio_tokensdefault_factoryz=Annotated[dict[str, int], BeforeValidator(lambda d: d or {})]detailsz:`request_tokens` is deprecated, use `input_tokens` insteadreturncC|jSN)rselfr(W/var/www/html/karishye-ai-python/venv/lib/python3.10/site-packages/pydantic_ai/usage.pyrequest_tokens5zUsageBase.request_tokensz<`response_tokens` is deprecated, use `output_tokens` insteadcCr$r%)rr&r(r(r)response_tokens:r+zUsageBase.response_tokenscCs |j|jS)z&Sum of `input_tokens + output_tokens`.)rrr&r(r(r) total_tokens?s zUsageBase.total_tokensdict[str, int]cCsi}|jr |j|d<|jr|j|d<|j}|jr|j|d<|jr'|j|d<|jr/|j|d<|jr7|j|d<|jr?|j|d<|rTd}| D] \}}|rS||||<qG|S) z7Get the token usage values as OpenTelemetry attributes.zgen_ai.usage.input_tokenszgen_ai.usage.output_tokensrrrrrzgen_ai.usage.details.) rrr"rrrrrritems)r'resultr"prefixkeyvaluer(r(r)opentelemetry_attributesDs.         z"UsageBase.opentelemetry_attributescs2fddtD}jjdd|dS)Nc3s0|]}t|jr|jdVqdS)=N)getattrname).0fr'r3r(r) `s.z%UsageBase.__repr__..(z, ))r __class__ __qualname__join)r'kv_pairsr(r:r)__repr___szUsageBase.__repr__boolcCstt|S)z(Whether any values are set and non-zero.)any dataclassesasdictvaluesr&r(r(r) has_valuescszUsageBase.has_valuesN)r#r)r#r.r#rC)__name__ __module__r?r__annotations__rrrrrrrEfielddictr"propertyr r*r,r-r4rBrHr(r(r(r)rs>            rc@sFeZdZdZeddZdddZdd d Zed d ddddZ d S)rzLLM usage associated with a single request. This is an implementation of `genai_prices.types.AbstractUsage` so it can be used to calculate the price of the request using [genai-prices](https://github.com/pydantic/genai-prices). cCsdS)Nrr(r&r(r(r)requestspszRequestUsage.requests incr_usager#NonecCs t||SzhIncrement the usage in place. Args: incr_usage: The usage to increment by. )_incr_usage_tokensr'rQr(r(r)incrts zRequestUsage.incrothercCt|}|||S)zAdd two RequestUsages together. This is provided so it's trivial to sum usage information from multiple parts of a response. **WARNING:** this CANNOT be used to sum multiple requests without breaking some pricing calculations. rrVr'rW new_usager(r(r)__add__|s zRequestUsage.__add__defaultN) api_flavorr"datarproviderstr provider_urlprovider_fallbackr^r"dict[str, Any] | Nonec Cs|pi}d|f|df|dffD]4\}}z'td||} | j||d\} } |didd| jDd|iWStyCYqw||dS)aExtract usage information from the response data using genai-prices. Args: data: The response data from the model API. provider: The actual provider ID provider_url: The provider base_url provider_fallback: The fallback provider ID to use if the actual provider is not found in genai-prices. For example, an OpenAI model should set this to "openai" in case it has an obscure provider ID. api_flavor: The API flavor to use when extracting usage information, e.g. 'chat' or 'responses' for OpenAI. details: Becomes the `details` field on the returned `RequestUsage` for convenience. N)r^cSsi|] \}}|dur||qSr%r()r8kvr(r(r) sz(RequestUsage.extract..r")r"r()r find_provider extract_usage__dict__r/ Exception) clsr_r`rbrcr^r" provider_idprovider_api_url provider_obj _model_refextracted_usager(r(r)extracts,  zRequestUsage.extract)rQrr#rR)rWrr#r)r_rr`rarbrarcrar^rar"rdr#r) rJrKr?__doc__rOrPrVr\ classmethodrrr(r(r(r)rhs    rc@seZdZUdZdZded< dZded< dZded< dZded< dZ ded< dZ ded < dZ ded < dZ ded < e jed Zd ed< dddZdddZdS)rzLLM usage associated with an agent run. Responsibility for calculating request usage is on the model; Pydantic AI simply sums the usage information across requests. rrrP tool_callsrrrrrrr r.r"rQRunUsage | RequestUsager#rRcCs4t|tr|j|j7_|j|j7_t||SrS) isinstancerrPrurTrUr(r(r)rVs  z RunUsage.incrrWcCrX)z{Add two RunUsages together. This is provided so it's trivial to sum usage information from multiple runs. rYrZr(r(r)r\s zRunUsage.__add__N)rQrvr#rR)rWrvr#r)rJrKr?rsrPrLrurrrrrrrErMrNr"rVr\r(r(r(r)rs,           rslfrvrQr#rRcCs|j|j7_|j|j7_|j|j7_|j|j7_|j|j7_|j|j7_|jD]\}}|j|d||j|<q5dS)zIncrement the usage in place. Args: slf: The usage to increment. incr_usage: The usage to increment by. rN) rrrrrrr"r/get)rxrQr2r3r(r(r)rTsrTz-`Usage` is deprecated, use `RunUsage` insteadc@seZdZdZdS)rz Deprecated alias for `RunUsage`.N)rJrKr?rsr(r(r(r)rsrc @s"eZdZUdZdZded< dZded< dZded< dZded< dZ ded < d Z d ed < e e d d*ddZ e e dd*ddZedddddd dd+ddZee ddddddd dd,ddZdddddd dddd-ddZd.dd Zd/d#d$Zd/d%d&Zd0d(d)ZejZdS)1raELimits on model usage. The request count is tracked by pydantic_ai, and the request limit is checked before each request to the model. Token counts are provided in responses from the model, and the token limits are checked after each response. Each of the limits can be set to `None` to disable that limit. 2 int | None request_limitNtool_calls_limitinput_tokens_limitoutput_tokens_limittotal_tokens_limitFrCcount_tokens_before_requestzF`request_tokens_limit` is deprecated, use `input_tokens_limit` insteadr#cCr$r%)r~r&r(r(r)request_tokens_limitr+z UsageLimits.request_tokens_limitzH`response_tokens_limit` is deprecated, use `output_tokens_limit` insteadcCr$r%)rr&r(r(r)response_tokens_limitr+z!UsageLimits.response_tokens_limitr|r}r~rrrrRcC(||_||_||_||_||_||_dSr%r)r'r|r}r~rrrr(r(r)__init__s   zUsageLimits.__init__zmUse `input_tokens_limit` instead of `request_tokens_limit` and `output_tokens_limit` and `total_tokens_limit`)r|r}rrrrrrcCrr%r)r'r|r}rrrrr(r(r)r-s  )r|r}r~rrrrrc Cs0||_||_|p ||_|p||_||_||_dSr%r) r'r|r}r~rrrrrr(r(r)rBs     cCstdd|j|j|jfDS)axReturns `True` if this instance places any limits on token counts. If this returns `False`, the `check_tokens` method will never raise an error. This is useful because if we have token limits, we need to check them after receiving each streamed message. If there are no limits, we can skip that processing in the streaming response iterator. css|]}|duVqdSr%r()r8limitr(r(r)r;^s z/UsageLimits.has_token_limits..)rDr~rrr&r(r(r)has_token_limitsVszUsageLimits.has_token_limitsusagercCs|j}|dur|j|krtd||j}|jdur,||jkr,td|jd|d|j}|jdurE||jkrGtd|jd|ddSdS)z[Raises a `UsageLimitExceeded` exception if the next request would exceed any of the limits.Nz3The next request would exceed the request_limit of z8The next request would exceed the input_tokens_limit of  (input_tokens=r=z8The next request would exceed the total_tokens_limit of  (total_tokens=)r|rPrrr~r-r)r'rr|rr-r(r(r)check_before_requestbsz UsageLimits.check_before_requestcCs|j}|jdur||jkrtd|jd|d|j}|jdur2||jkr2td|jd|d|j}|jdurK||jkrMtd|jd|ddSdS) zURaises a `UsageLimitExceeded` exception if the usage exceeds any of the token limits.Nz#Exceeded the input_tokens_limit of rr=z$Exceeded the output_tokens_limit of z (output_tokens=z#Exceeded the total_tokens_limit of r)rr~rrrr-r)r'rrrr-r(r(r) check_tokenstszUsageLimits.check_tokensprojected_usagecCs:|j}|j}|dur||krtd|d|ddSdS)zbRaises a `UsageLimitExceeded` exception if the next tool call(s) would exceed the tool call limit.Nz;The next tool call(s) would exceed the tool_calls_limit of z (tool_calls=z).)r}rur)r'rr}rur(r(r)check_before_tool_callsz"UsageLimits.check_before_tool_call)r#r{)r|r{r}r{r~r{rr{rr{rrCr#rR)r|r{r}r{rr{rr{rr{rrCr#rR)r|r{r}r{r~r{rr{rr{rrCrr{rr{rI)rrr#rR)rrr#rR)rJrKr?rsr|rLr}r~rrrrOr rrr rrrrrrdataclasses_no_defaults_reprrBr(r(r(r)rsj           r)rxrvrQrvr#rR) __future__r _annotationsrErrrtypingrrgenai_prices.data_snapshotrpydanticr r r typing_extensionsr r r exceptionsr__all__rrrrTrrr(r(r(r)s.       U @ 6