g1"0UddlmZddlZddlZddlmZmZmZddl m Z m Z ddl m Z mZddlmZmZddlmZddlmZdd lmZmZmZmZmZmZmZmZdd lmZdd l m!Z!dd l"m#Z#m$Z$m%Z%m&Z&erd dl'm(Z(m)Z)m*Z*d dl+m,Z,e#dZ-edZ.d&dZ/d'dZ0d(dZ1edZ2e Gddee2Z3ee3e2dfZ4de5d< GddZ6e6Z7d)dZ8edZ9edZ:Gdd ee9e:fZ;e d*d!Zd-d$Z?d.d%Z@y)/) annotationsN) AsyncIterable AsyncIteratorIterator)asynccontextmanagersuppress) dataclass is_dataclass)datetimetimezone)partial) GenericAlias) TYPE_CHECKINGAnyCallableGenericTypeVarUnioncastoverload) BaseModel)JsonSchemaValue) ParamSpec TypeAlias TypeGuard is_typeddict)RetryPromptPart ToolCallPartToolReturnPart)ObjectJsonSchema_P_RcK|r9tjjdt|g|i|d{Stjjd|g|d{S727wN)asyncioget_running_looprun_in_executorr )funcargskwargss G/var/www/openai/venv/lib/python3.12/site-packages/pydantic_ai/_utils.pyr(r(si --/??gdFdUYFd]cFdeee?W--/??dRTRRRfRs!7A0A,-A0'A.(A0.A0ct|txr=t|t xr*t|txst |xs t |S)zCheck if something is a pydantic model, dataclass or typedict. These should all generate a JSON Schema with `{"type": "object"}` and therefore be usable directly as function parameters. ) isinstancetyper issubclassrr r)type_s r, is_model_liker2!sK 5$ Y5,/ / Y y ) W\%-@ WLQVDWcJddlm}|jddk(r|S|d)Nr) UserErrorr/objectzSchema must be an object) exceptionsr5get)schemar5s r,check_object_json_schemar:.s'% zz&X% 233r3TceZdZUdZded<y)Somez(Analogous to Rust's `Option::Some` type.r;valueN)__name__ __module__ __qualname____doc____annotations__r3r,r=r=:s 2 Hr3r=rOptionceZdZdZy)Unsetz(A singleton to represent an unset value.N)r?r@rArBrDr3r,rGrGEs2r3rGc|tuSr%)UNSET) t_or_unsets r,is_setrKNs U ""r3LeftRightceZdZdZdZed dZed dZeefddZeddZ eddZ ddZ dd Z d Z y )EitherzTwo member Union that records which member was set, this is analogous to Rust enums with two variants. Usage: ```python if left_thing := either.left: use_left(left_thing.value) else: use_right(either.right) ``` )_left_rightcyr%rDselflefts r,__init__zEither.__init__es/2r3cyr%rD)rTrights r,rVzEither.__init__hs14r3c|tur.|tusJdttt||_y|tusJdd|_tt ||_y)Nz>`Either` must receive exactly one argument - `left` or `right`)rIr=rrLrPrMrQ)rTrUrXs r,rVzEither.__init__ksX u E> c#c c>'+Dt,<'=DJ% g'g g%DJue,DKr3c|jSr%rPrTs r,rUz Either.leftts zzr3c|jSr%)rQr\s r,rXz Either.rightxs {{r3c|jduSr%r[r\s r,is_leftzEither.is_left|szz%%r3c^|j|jjS|jSr%rPr>rXr\s r, whicheverzEither.whichevers$#'::#9tzzItzzIr3c^|jx}rd|jdSd|jdS)Nz Either(left=)z Either(right=rarSs r,__repr__zEither.__repr__s7:: 4 !$**q1 1"4::.2 2r3N)rUrLreturnNone)rXrMrfrg)rUz Left | UnsetrXz Right | Unsetrfrg)rfz Option[Left])rfrM)rfbool)rfz Left | Right)r?r@rArB __slots__rrVrIpropertyrUrXr_rbrerDr3r,rOrOVsl "I 22 44,1%-&J3r3rOcKdfd }|yddfd } |r>jdttj5d{dddyy7#1swYyxYw#rKjdttj5d{7dddw#1swYwxYwwxYww)aGroup items from an async iterable into lists based on time interval between them. Effectively debouncing the iterator. This returns a context manager usable as an iterator so any pending tasks can be cancelled if an error occurs during iteration. Usage: ```python async with group_by_temporal(yield_groups(), 0.1) as groups_iter: async for groups in groups_iter: print(groups) ``` Args: aiter: The async iterable to group. soft_max_interval: Maximum interval over which to group items, this should avoid a trickle of items causing a group to never be yielded. It's a soft max in the sense that once we're over this time, we yield items as soon as `aiter.__anext__()` returns. If `None`, no grouping/debouncing is performed Returns: A context manager usable as an iterator async iterable of lists of items from the input async iterable. Nc8K23d{}|g7 6ywr%rD)itemaiters r,async_iter_groups_noopz1group_by_temporal..async_iter_groups_noops # df  escKdk\sJdg}tj} |}ntj|z z }#tjj tj f|d{\}}|rI |j j}|j|d| tj}n |r |g}d}7^#t$r |r|dYywxYww)Nrz+soft_max_interval must be a positive number)timeout) time monotonicr& create_task __anext__waitpopresultappendStopAsyncIteration) buffergroup_start_time wait_timedone_rmrnsoft_max_intervaltasks r,async_iter_groupsz,group_by_temporal..async_iter_groupss!,1Ba1GvIvvG>>+'- .1ADT1TU |**5??+<=$LL$)DDGD!<88:,,.DMM$'D'/+/>>+;( #' OE *$ D s6BDC' DC)17D)C>;D=C>>Dz#Cancelling due to error in iterator)rfzAsyncIterator[list[T]])cancelrr&CancelledError)rnrrorrs`` @r,group_by_temporalrs8  %&&$(D.(`!!  KK= >'001 21 21  KK= >'001 211 siC A=,CA1 A/!A1% C/A11A:6C=-C *B?0B3 1B?6 C ?C C  Cc||S||S||zS)zAdd two optional strings.rD)abs r, add_optionalrsy 1u r3cR t|S#t$r}t|d}~wwxYw)zGet the next item from a sync iterator, raising `StopAsyncIteration` if it's exhausted. Useful when iterating over a sync iterator in an async context. N)next StopIterationrz)iteratores r, sync_anextrs, *H~ * ")*s & !&cJtjtjS)N)tz)r nowr utcrDr3r,now_utcrs <<8<< ((r3cJ|j J|d||jS)zWType guard that checks a `tool_call_id` is not None both for static typing and runtime.z$ requires `tool_call_id` to be set: ) tool_call_id)t model_sources r,guard_tool_call_idrs/ >> %_,7[\][^'__ % >>r3)r)zCallable[_P, _R]r*z_P.argsr+z _P.kwargsrfr#)r1rrfrh)r9rrfr!)rJz T | Unsetrfz TypeGuard[T])rnzAsyncIterator[T]rz float | Nonerfz%AsyncIterator[AsyncIterable[list[T]]])r str | Nonerrrfr)rz Iterator[T]rfr;)rfr )rz/ToolCallPart | ToolReturnPart | RetryPromptPartrstrrfr)A __future__r _annotationsr&rrcollections.abcrrr contextlibrr dataclassesr r r r functoolsr typesrtypingrrrrrrrrpydanticrpydantic.json_schemartyping_extensionsrrrrmessagesrrr toolsr!r"r#r(r2r:r;r=rErCrGrIrKrLrMrOrrrrrrDr3r,rs52 BB4/'XXX0KKGG't_ T]S 4 CL  71:   $q'4-( (f  #v03WT5[ !03f^ ^0<^*^^B*)r3