ó
    °"³jƒ  ã                  óÀ  • % S r SSKJr  SrSSKrSSKJr  SSKJrJ	r	  SSK
JrJrJrJr  \" S0 S	9rS
\S'   \S   r\ " S S5      5       r\ " S S5      5       r\ " S S5      5       r\ " S S5      5       rSrS\S'    Sr\R3                  SSSS.5      rSFSGS jjr\" SS9 " S  S!5      5       r\" SS9 " S" S#5      5       r\" SS9 " S$ S%5      5       r\" SS9 " S& S'5      5       r\" S(5      r \" S)5      r!SS*S+S,S)S-.r"S.\S/'   0 \"ES0S1S2.Er#S3\S4'   \" S5\$" 5       S	9r%S6\S5'   SHS7 jr&\RN                  " S85      r(SIS9 jr)SJS: jr*SKS; jr+        SLS< jr,          SMS= jr-SNS> jr.            SOS? jr/              SPS@ jr0              SQSA jr1            SRSB jr2              SSSC jr3              SSSD jr4STSE jr5g)Ua  Generate function signatures from functions and JSON schemas.

This module provides utilities to represent tool definitions as human-readable
function signatures, which LLMs can understand more easily than raw
JSON schemas. Used by code mode to present tools as callable functions.
é    )Úannotations)
ÚFunctionSignatureÚFunctionParamÚTypeSignatureÚTypeFieldSignatureÚTypeExprÚSimpleTypeNameÚSimpleTypeExprÚLiteralTypeExprÚGenericTypeExprÚUnionTypeExprN)Ú
ContextVar)Ú	dataclassÚfield)ÚAnyÚLiteralÚ	TypeAliasÚcastÚ_type_name_overrides)ÚdefaultzContextVar[dict[str, str]])ÚstrÚintÚfloatÚboolr   ÚNonec                  ó<   • \ rS rSr% SrS\S'   SrS\S'   SS jrS	rg
)r
   é*   z5A simple named type like `str`, `int`, `Any`, `None`.r	   ÚnameÚsimplezLiteral['simple']Úkindc                ó   • U R                   $ ©N©r   ©Úselfs    Ú[/home/mande/repo/quber/.venv/lib/python3.13/site-packages/pydantic_ai/function_signature.pyÚ__str__ÚSimpleTypeExpr.__str__1   s   € Ø�y‰yÐó    © N©Úreturnr   ©	Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__doc__Ú__annotations__r    r'   Ú__static_attributes__r*   r)   r&   r
   r
   *   s   ‡ á?à
ÓØ&€DÐ
Ó&÷r)   r
   c                  ó<   • \ rS rSr% SrS\S'   SrS\S'   SS jrS	rg
)r   é5   zDA Literal type expression like `Literal['a', 'b']` or `Literal[42]`.z	list[Any]ÚvaluesÚliteralzLiteral['literal']r    c                óN   • SSR                  S U R                   5       5       S3$ )NzLiteral[ú, c              3  ó8   #   • U  H  n[        U5      v •  M     g 7fr"   )Úrepr)Ú.0Úvs     r&   Ú	<genexpr>Ú*LiteralTypeExpr.__str__.<locals>.<genexpr>=   s   é € Ð#A²[°¤D¨§G G²[ùó   ‚Ú])Újoinr7   r$   s    r&   r'   ÚLiteralTypeExpr.__str__<   s%   € Ø˜$Ÿ)™)Ñ#A°T·[²[Ó#AÓAÐBÀ!ÐDÐDr)   r*   Nr+   r-   r*   r)   r&   r   r   5   s   ‡ áNàÓØ(€DÐ
Ó(÷Er)   r   c                  óF   • \ rS rSr% SrS\S'   S\S'   SrS\S	'   SS
 jrSrg)r   é@   zRA generic type expression like `list[User]`, `dict[str, User]`, `tuple[int, str]`.r   Úbaseúlist[TypeExpr]ÚargsÚgenericzLiteral['generic']r    c                óf   • U R                    SSR                  S U R                   5       5       S3$ )NÚ[r:   c              3  ó8   #   • U  H  n[        U5      v •  M     g 7fr"   ©r   )r=   Úas     r&   r?   Ú*GenericTypeExpr.__str__.<locals>.<genexpr>I   s   é € Ð'Bº	°1¬¨A¯¨º	ùrA   rB   )rG   rC   rI   r$   s    r&   r'   ÚGenericTypeExpr.__str__H   s-   € Ø—)‘)�˜A˜dŸi™iÑ'B¸¿	º	Ó'BÓBÐCÀ1ÐEÐEr)   r*   Nr+   r-   r*   r)   r&   r   r   @   s!   ‡ á\à
ƒIØ
ÓØ(€DÐ
Ó(÷Fr)   r   c                  ó<   • \ rS rSr% SrS\S'   SrS\S'   SS jrS	rg
)r   éL   z8A union type expression like `User | None`, `str | int`.rH   ÚmembersÚunionzLiteral['union']r    c                óF   • SR                  S U R                   5       5      $ )Nz | c              3  ó8   #   • U  H  n[        U5      v •  M     g 7fr"   rN   )r=   Úms     r&   r?   Ú(UnionTypeExpr.__str__.<locals>.<genexpr>T   s   é € Ð7ª, Qœ#˜aŸ&˜&ª,ùrA   )rC   rT   r$   s    r&   r'   ÚUnionTypeExpr.__str__S   s   € Ø�z‰zÑ7¨$¯,ª,Ó7Ó7Ð7r)   r*   Nr+   r-   r*   r)   r&   r   r   L   s   ‡ áBàÓØ$€DÐ
Ó$÷8r)   r   zRTypeSignature | SimpleTypeExpr | LiteralTypeExpr | GenericTypeExpr | UnionTypeExprr   r   ú    z\\z\x00z\")Ú\Ú Ú"r   c                ó:  • U R                  5       R                  [        5      n U R                  5       n[	        U5      S:”  aQ  U S3/nU H/  nUR                  UR                  5       (       a  U U 3OS5        M1     UR                  U S35        U$ U SU  S3/$ )z;Render a description as a list of indented docstring lines.é   z"""Ú )ÚstripÚ	translateÚ_DESCRIPTION_ESCAPESÚ
splitlinesÚlenÚappend)ÚtextÚindentÚdescription_linesÚlinesÚlines        r&   Ú_render_descriptionrm   i   sš   € à�:‰:‹<×!Ñ!Ô"6Ó7€DØŸ™Ó)ÐÜ
ÐÓ Ó!Ø�8˜3�Ð ˆÛ%ˆDØ�L‰L¨d¯j©j¯l©l˜F˜8 D 6Ñ*ÀÖCñ &à�‰˜�x˜s�^Ô$ØˆØˆh�c˜$˜˜sÐ#Ð$Ð$r)   T)Úkw_onlyc                  ób   • \ rS rSr% SrS\S'   S\S'   SrS\S	'   S
rS\S'   SrS\S'   SS jr	Sr
g
)r   év   z4A single field in a TypedDict-style type definition.r   r   r   ÚtypeFr   ÚrequiredNú
str | NoneÚdescriptionr   zLiteral['field']r    c                ó
  • [        U R                  5      nU R                  (       d  SU S3nSU R                   SU 3/nU R                  (       a#  UR                  [        U R                  SS95        SR                  U5      $ )z6Render this field as a line in a TypedDict class body.zNotRequired[rB   r[   ú: ©ri   Ú
)r   rq   rr   r   rt   Úextendrm   rC   )r%   Útype_strrk   s      r&   r'   ÚTypeFieldSignature.__str__€   so   € ä�t—y‘y“>ˆØ�}�}Ø% h Z¨qÐ1ˆHØ" 4§9¡9 +¨R°¨zÐ:Ð;ˆØ××Ø�L‰LÔ,¨T×-=Ñ-=ÀfÑMÔNØ�y‰y˜ÓÐr)   r*   r+   )r.   r/   r0   r1   r2   r3   rr   rt   r    r'   r4   r*   r)   r&   r   r   v   s3   ‡ á>à
ƒIØ
ƒNØ€HˆdÓØ"€K�Ó"Ø$€DÐ
Ó$÷ r)   r   c                  óº   • \ rS rSr% SrS\S'   SrS\S'   \" \\	\
4   S9rS	\S
'   SrS\S'   \SS j5       rSS jrS\" 5       S.     SS jjrSS jrSS jrSrg)r   é‹   z5A TypedDict-style class definition with named fields.r   r   Nrs   rt   ©Údefault_factoryzdict[str, TypeFieldSignature]Úfieldsrq   zLiteral['type']r    c                ór   • [         R                  5       R                  U R                  U R                  5      $ )zIThe type name, with tool-name prefix applied if rendering context is set.)r   Úgetr   r$   s    r&   Údisplay_nameÚTypeSignature.display_name–   s(   € ô $×'Ñ'Ó)×-Ñ-¨d¯i©i¸¿¹ÓCÐCr)   c                ó   • U R                   $ )zKReturn the type name (for use in type expressions like `def foo(x: User)`).)rƒ   r$   s    r&   r'   ÚTypeSignature.__str__›   s   € à× Ñ Ð r)   ©Ú
owner_nameÚconflicting_type_namesc               ó   • U(       aY  U(       aR  U Vs0 s H
  o3U SU 3_M     nn[         R                  U5      n U R                  5       [         R                  U5        $ U R                  5       $ s  snf ! [         R                  U5        f = f)ag  Render the full TypedDict class definition.

Args:
    owner_name: The owning tool name, used to build prefixed type names
        for conflicting types (e.g. `get_user_Address`).
    conflicting_type_names: Set of type names that need tool-name prefixes
        (from `get_conflicting_type_names`). Only effective when `owner_name`
        is also provided.
Ú_)r   ÚsetÚ_render_definitionÚreset)r%   rˆ   r‰   ÚnÚ	overridesÚtokens         r&   Úrender_definitionÚTypeSignature.render_definitionŸ   s„   € ö Ö0Ù9OÓPÒ9O°A˜z˜l¨!¨A¨3Ð/Ò/Ñ9OˆIÐPÜ(×,Ñ,¨YÓ7ˆEð2Ø×.Ñ.Ó0ä$×*Ñ*¨5Õ1Ø×&Ñ&Ó(Ð(ùò Qøô
 %×*Ñ*¨5Õ1ús   “A1¼A6 Á6Bc                óŒ  • SU R                    S3/nU R                  (       a#  UR                  [        U R                  SS95        U R                  (       d#  U R                  (       d  UR                  S5        O;U R                  R                  5        H  nUR                  [        U5      5        M     SR                  U5      $ )zQRender the full TypedDict class definition (internal, assumes overrides are set).zclass z(TypedDict):r[   rw   z    passrx   )	rƒ   rt   ry   rm   r€   rg   r7   r   rC   )r%   rk   Úfs      r&   r�   Ú TypeSignature._render_definition´   s�   € à˜$×+Ñ+Ð,¨LÐ9Ð:ˆØ××Ø�L‰LÔ,¨T×-=Ñ-=ÀfÑMÔNØ�{�{Ø×#×#Ø—‘˜ZÔ(øà—[‘[×'Ñ'Ö)�Ø—‘œS ›VÖ$ñ *à�y‰y˜ÓÐr)   c                óŽ  • [        U R                  R                  5       5      [        UR                  R                  5       5      :w  a  gU R                  R                  5        H^  u  p#UR                  U   nUR                  UR                  :w  a    g[        UR                  5      [        UR                  5      :w  d  M^    g   g)z?Compare two TypeSignatures structurally, ignoring descriptions.FT)rŒ   r€   ÚkeysÚitemsrr   r   rq   )r%   Úotherr   r•   Úother_fs        r&   Ústructurally_equalÚ TypeSignature.structurally_equalÁ   sŽ   € äˆt�{‰{×ÑÓ!Ó"¤c¨%¯,©,×*;Ñ*;Ó*=Ó&>Ó>ØØ—{‘{×(Ñ(Ö*‰GˆDØ—l‘l 4Ñ(ˆGØ�z‰z˜W×-Ñ-Ó-ÙÜ�1—6‘6‹{œc '§,¡,Ó/Õ/Ùñ +ð r)   r*   r+   )rˆ   rs   r‰   úfrozenset[str]r,   r   )rš   r   r,   r   )r.   r/   r0   r1   r2   r3   rt   r   Údictr   r   r€   r    Úpropertyrƒ   r'   Ú	frozensetr’   r�   rœ   r4   r*   r)   r&   r   r   ‹   s„   ‡ á?à
ƒIà"€K�Ó"á,1À$ÀsÐL^ÐG^ÑB_Ñ,`€FÐ)Ó`Ø"€Dˆ/Ó"àóDó ðDô!ð
 +/ÑYbÓYdñ)Ø'ð)ØHVð)à	õ)ô* ÷
r)   r   c                  ób   • \ rS rSr% SrS\S'   S\S'   SrS\S	'   SrS\S
'   SrS\S'   SS jr	Sr
g)r   éÎ   z+A single parameter in a function signature.r   r   r   rq   Nrs   r   rt   ÚparamzLiteral['param']r    c                ó¤   • [        U R                  5      nU R                  b  U R                   SU SU R                   3$ U R                   SU 3$ )z5Render this parameter as a function parameter string.rv   z = )r   rq   r   r   )r%   rz   s     r&   r'   ÚFunctionParam.__str__Ø   sM   € ä�t—y‘y“>ˆØ�<‰<Ñ#Ø—i‘i�[  8 *¨C°·±¨~Ð>Ð>Ø—)‘)�˜B˜x˜jÐ)Ð)r)   r*   r+   )r.   r/   r0   r1   r2   r3   r   rt   r    r'   r4   r*   r)   r&   r   r   Î   s3   ‡ á5à
ƒIØ
ƒNØ€GˆZÓØ"€K�Ó"Ø$€DÐ
Ó$÷*r)   r   c                  ól  • \ rS rSr% SrS\S'   SrS\S'   \" \\	\
4   S9rS	\S
'    S\S'    \" \\   S9rS\S'    SrS\S'    SrS\S'   SSS\" 5       S.           SS jjrSSS.         S S jjr\SS.       S!S jj5       r\S"S j5       r\S#S j5       r\      S$S j5       rSrg)%r   éà   a  Function signature shape with referenced type definitions.

This class holds the structural data (params, return type, referenced types)
needed to render a function signature. Name and description can be overridden
at render time (e.g. from a `ToolDefinition`).
r   r   Nrs   rt   r~   údict[str, FunctionParam]Úparamsr   Úreturn_typeúlist[TypeSignature]Úreferenced_typesFr   Úis_asyncÚfunctionzLiteral['function']r    )r   rt   r®   r‰   c               ó0  • U=(       d    U R                   nUb  UOU R                  nU Vs0 s H
  owU SU 3_M     nn[        R                  U5      n	 U R	                  XX4S9[        R                  U	5        $ s  snf ! [        R                  U	5        f = f)aB  Render the signature with a specific body.

Sets `_type_name_overrides` so that dedup-prefixed types resolve
correctly during rendering.

Args:
    body: The function body (e.g. `'...'` or `'return await tool()'`).
    name: The function name (also used for dedup prefix resolution). Falls back to `self.name`.
    description: Optional docstring to include. Falls back to `self.description`.
    is_async: Override async rendering. If `None`, uses `self.is_async`.
    conflicting_type_names: Set of type names that need tool-name prefixes (from `get_conflicting_type_names`).
r‹   )r   rt   r®   )r   rt   r   rŒ   Ú_renderrŽ   )
r%   Úbodyr   rt   r®   r‰   Úrender_namer�   r�   r‘   s
             r&   ÚrenderÚFunctionSignature.renderù   s“   € ð* ×'˜dŸi™iˆØ%0Ñ%<‘kÀ$×BRÑBRˆÙ6LÓMÒ6L°˜;˜- q¨¨Ð,Ò,Ñ6Lˆ	ÐMÜ$×(Ñ(¨Ó3ˆð	.Ø—<‘< ÀK�<Ðcä ×&Ñ& uÕ-ùò Nøô
 !×&Ñ& uÕ-ús   «A9ÁA> Á>B)rt   r®   c               ó^  • Ub  UOU R                   nU(       a  SOSnSR                  S U R                  R                  5        5       5      n[	        U R
                  5      nU(       a  U SU SU SU S3/n	OU SU S	U S3/n	U(       a  U/O/ n
/ nU R                  R                  5        H~  nUR                  =(       d    S
R                  5       R                  5       nU(       d  M=  UtpïUR                  [         UR                   SU 35        UR                  S U 5       5        M€     U(       a#  U
R                  SR                  S/UQ5      5        SR                  U
5      nU(       a  U	R                  [        USS95        U	R                  SU 35        SR                  U	5      $ )Nz	async defÚdefr:   c              3  ó8   #   • U  H  n[        U5      v •  M     g 7fr"   rN   ©r=   Úps     r&   r?   Ú,FunctionSignature._render.<locals>.<genexpr>!  s   é € ÐDÒ/C¨!œs 1Ÿv˜vÒ/CùrA   Ú z(*, z) -> Ú:z() -> ra   rv   c              3  ó<   #   • U  H  n[         S -   U 3v •  M     g7f)é   N)Ú_DOC_INDENT)r=   rl   s     r&   r?   r»   4  s   é € ÐRÂ\¸T¤¨q¡Ð 1°$°Õ8Â\ùs   ‚rx   zArgs:z

r[   rw   )r®   rC   rª   r7   r   r«   rt   rb   re   rg   rÀ   r   ry   rm   )r%   r²   r   rt   r®   Ú
async_flagÚprefixÚ
params_strÚ
return_strÚpartsÚdescription_sectionsÚ
args_linesr¤   rj   Ú
first_lineÚcontinuations                   r&   r±   ÚFunctionSignature._render  s†  € ð "*Ñ!5‘X¸4¿=¹=ˆ
Þ *‘°ˆØ—Y‘YÑD¨t¯{©{×/AÑ/AÔ/CÓDÓDˆ
ä˜×)Ñ)Ó*ˆ
Þà�x˜q   d¨:¨,°e¸J¸<ÀqÐIÐJ‰Eà�x˜q   f¨Z¨L¸Ð:Ð;ˆEæ0; ™}ÀÐà "ˆ
Ø—[‘[×'Ñ'Ö)ˆEØ!&×!2Ñ!2×!8°b× ?Ñ ?Ó A× LÑ LÓ NÐÞ$ÙØ(9Ð%ˆJØ×Ñ¤ ¨e¯j©j¨\¸¸J¸<ÐHÔIà×ÑÑRÁ\ÓRÖRñ *ö Ø ×'Ñ'¨¯	©	°7Ð2H¸ZÐ2HÓ(IÔJØ—k‘kÐ"6Ó7ˆæØ�L‰LÔ,¨[ÀÑHÔIà�‰�t˜D˜6�]Ô#à�y‰y˜ÓÐr)   )Úreturn_schemac               óÂ  • UR                  S0 5      n0 n[        XEU5        [        X$XQ5      n[        n0 nUb)  UR                  S0 5      n	[        X˜U5        [	        X9X�SS9n[        UR                  5       5      n
UR                  5        HJ  nUR                  UR                  5      nUb  UR                  U5      (       a  M9  U
R                  U5        ML     U " UUUU
S9$ )uÞ  Build a FunctionSignature from JSON schemas.

`name` is stored on the resulting signature and also used for generating
fallback type names (e.g. `GetUserAddress`) when the schema has no `title`.

Parameter and return schemas are processed independently â€” each resolves
`$ref`s against its own `$defs`. Name collisions between parameter and return
types (e.g. both define a `User` `$def` with different structures) are handled
by `get_conflicting_type_names` at a later stage.
z$defsÚReturn)Úpath)r   rª   r«   r­   )
r‚   Ú_process_schema_defsÚ_build_params_from_schemaÚ_ANYÚ_schema_to_type_exprÚlistr7   r   rœ   rg   )Úclsr   Úparameters_schemarË   Ú
param_defsÚparam_referencedrª   Úresolved_return_typeÚreturn_referencedÚreturn_defsÚall_referencedÚret_typeÚexistings                r&   Úfrom_schemaÚFunctionSignature.from_schema@  sö   € ð& '×*Ñ*¨7°BÓ7ˆ
Ø57ÐÜ˜Z¸4Ô@Ü*Ð+<ÐJZÓaˆô *.ÐØ68ÐØÑ$Ø'×+Ñ+¨G°RÓ8ˆKÜ  ÀÔFÜ#7ØÐ,=È(ñ$Ð ô Ð.×5Ñ5Ó7Ó8ˆØ)×0Ñ0Ö2ˆHØ'×+Ñ+¨H¯M©MÓ:ˆHØÑ#¨×(CÑ(CÀH×(MÑ(MÙØ×!Ñ! (Ö+ñ	 3ñ ØØØ,Ø+ñ	
ð 	
r)   c                ó‚  • 0 n[        5       nU  H£  n/ nUR                   Hˆ  nUR                  nXa;  a  XQU'   UR                  U5        M+  X   R	                  U5      (       a#  X   n[        X5U5        UR                  U5        Mf  UR                  U5        UR                  U5        MŠ     XCl        M¥     [        U5      $ )a  Identify TypedDict name conflicts across multiple tool signatures.

Each signature keeps all its referenced types (so it remains self-contained),
but identical types (same name and structure) are unified to the same object
instance.

Returns the set of type names that have conflicts (same name, different
structure) and need tool-name prefixes at render time. Pass this set to
`FunctionSignature.render(conflicting_type_names=...)`.

Use `collect_unique_referenced_types()` when rendering to emit each
definition once.
)rŒ   r­   r   rg   rœ   Ú_replace_type_refsÚaddr¡   )Ú
signaturesÚseenÚprefixedÚsigÚdedupedÚtype_sigr   Ú	canonicals           r&   Úget_conflicting_type_namesÚ,FunctionSignature.get_conflicting_type_namesr  s®   € ð *,ˆÜ ›UˆãˆCØ+-ˆGØ×0Ô0�Ø—}‘}�ØÓ#Ø!)˜‘JØ—N‘N 8Ö,Ø‘Z×2Ñ2°8×<Ñ<Ø $¡
�IÜ& s°iÔ@Ø—N‘N 9Ö-à—L‘L Ô&Ø—N‘N 8Ö,ñ 1ð $+Ö ñ ô  ˜Ó"Ð"r)   c                óÎ   • [        5       n/ nU  HR  nUR                   H?  n[        U5      U;  d  M  UR                  [        U5      5        UR	                  U5        MA     MT     U$ )zPCollect unique TypeSignature objects from signatures, deduplicating by identity.)rŒ   r­   Úidrâ   rg   )rã   Úseen_idsÚresultræ   rè   s        r&   Úcollect_unique_referenced_typesÚ1FunctionSignature.collect_unique_referenced_types–  sY   € ô !›UˆØ&(ˆÛˆCØ×0Ô0�Ü�h“< xÕ/Ø—L‘L¤ H£Ô.Ø—M‘M (Ö+ó 1ñ ð
 ˆr)   c                óz  • [         R                  U 5      nU(       d  / $ 0 nU  HQ  nUR                   H>  nUR                  U;   d  M  [	        U5      U;  d  M&  UR                  U[	        U5      '   M@     MS     / nU H;  nUR                  [	        U5      5      nUR                  UR                  XqS95        M=     U$ )aä  Render unique TypedDict definitions for a set of function signatures.

For types whose names conflict across signatures (as identified by
`get_conflicting_type_names`), each definition is rendered with a
tool-name prefix (e.g. `get_user_Address`).

Args:
    signatures: The function signatures (after `get_conflicting_type_names`).
    conflicting_type_names: The set returned by `get_conflicting_type_names`.

Returns:
    A list of rendered TypedDict class definitions as strings.
r‡   )r   rð   r­   r   rí   r‚   rg   r’   )rã   r‰   Úunique_typesÚ	owner_forræ   ÚtsigÚrenderedÚowners           r&   Úrender_type_definitionsÚ)FunctionSignature.render_type_definitions¢  s©   € ô$ )×HÑHÈÓTˆÞØˆIà$&ˆ	ÛˆCØ×,Ô,�Ø—9‘9Ð 6Õ6¼2¸d»8È9Õ;TØ*-¯(©(�Iœb ›hÓ'ó -ñ ð
 !ˆÛ ˆDØ—M‘M¤" T£(Ó+ˆEØ�O‰O˜D×2Ñ2¸eÐ2ÐsÖtñ !ð ˆr)   r*   )r²   r   r   rs   rt   rs   r®   úbool | Noner‰   rž   r,   r   )
r²   r   r   r   rt   rs   r®   rú   r,   r   )r   r   rÕ   údict[str, Any]rË   zdict[str, Any] | Noner,   r   )rã   úlist[FunctionSignature]r,   rž   )rã   rü   r,   r¬   )rã   rü   r‰   rž   r,   ú	list[str])r.   r/   r0   r1   r2   r3   rt   r   rŸ   r   r   rª   rÓ   r   r­   r®   r    r¡   r´   r±   ÚclassmethodrÞ   Ústaticmethodrê   rð   rø   r4   r*   r)   r&   r   r   à   s–  ‡ ñð ƒIØ"€K�Ó"Ù',¸TÀ#À}ÐBTÑ=UÑ'V€FÐ$ÓVØqàÓØ%á,1À$À}ÑBUÑ,VÐÐ)ÓVØ>à€HˆdÓØ3à *€DÐ
Ó*ð  Ø"&Ø $Ù1:³ñ.àð.ð ð	.ð
  ð.ð ð.ð !/ð.ð 
õ.ðF #'Ø $ñ' àð' ð ð	' ð
  ð' ð ð' ð 
õ' ðR ð 04ñ/
ð ð/
ð *ð	/
ð
 -ð/
ð 
ô/
ó ð/
ðb ó!#ó ð!#ðF ó	ó ð	ð ðØ+ðà .ðð 
óó ór)   r   r   r   r   r   r   )ÚstringÚintegerÚnumberÚbooleanÚnullzdict[str, SimpleTypeName]Ú_JSON_SIMPLE_TYPE_TO_PYTHONrÓ   rŸ   )ÚarrayÚobjectzdict[str, str]Ú_JSON_TYPE_TO_PYTHONÚ_resolving_refszContextVar[frozenset[str]]c                ó@   • [        [        R                  U S5      5      $ )z/Convert a JSON type string to a SimpleTypeExpr.r   )r
   r  r‚   )Ú	json_types    r&   Ú_json_type_to_pythonr  å  s   € äÔ5×9Ñ9¸)ÀUÓKÓLÐLr)   z[^a-zA-Z0-9]c                óÌ   • [         R                  SU 5      n U R                  S5      nSR                  S U 5       5      nU(       a  US   R	                  5       (       a  SU-   nU$ )zConvert a string to PascalCase.r‹   ra   c              3  óR   #   • U  H  o(       d  M  UR                  5       v •  M     g 7fr"   )Ú
capitalize)r=   Úparts     r&   r?   Ú"_to_pascal_case.<locals>.<genexpr>ñ  s   é € ÐA²5¨4»DÓ&�T—_‘_×&Ð&²5ùs   ‚
'�'r   )Ú_NON_ALNUM_REÚsubÚsplitrC   Úisdigit)ÚsrÅ   rï   s      r&   Ú_to_pascal_caser  í  sX   € ä×Ñ˜#˜qÓ!€AØ�G‰G�C‹L€EØ�W‰WÑA±5ÓAÓA€FÞ�&˜‘)×#Ñ#×%Ñ%Ø�v‘ˆØ€Mr)   c                ó˜   • U /UR                  S5       Vs/ s H  o"(       d  M  UPM     sn-   nSR                  S U 5       5      $ s  snf )zþConvert a traversal path to a unique TypedDict name.

Examples:
    _path_to_typename('get_user', '') -> 'GetUser'
    _path_to_typename('get_user', 'address') -> 'GetUserAddress'
    _path_to_typename('get_user', 'home.address') -> 'GetUserHomeAddress'
Ú.ra   c              3  ó8   #   • U  H  n[        U5      v •  M     g 7fr"   )r  r¹   s     r&   r?   Ú$_path_to_typename.<locals>.<genexpr>   s   é € Ð5ªu¨!”? 1×%Ð%ªuùrA   )r  rC   )Ú	tool_namerÎ   rº   rÅ   s       r&   Ú_path_to_typenamer  ÷  sC   € ð ˆK d§j¡j°¤oÓ;¢o »Ÿ1¡oÑ;Ñ;€EØ�7‰7Ñ5©uÓ5Ó5Ð5ùò <s
   –
A¤Ac                ó4   • [        U [        5      (       a  0 $ U $ )uÕ  Normalize a JSON Schema node to a dict.

Per the JSON Schema spec, `True` and `False` are valid schemas anywhere a schema may
appear (most commonly as `additionalProperties`, but also as a property value or an
`allOf`/`anyOf`/`oneOf`/`items`/`$defs` member). `True` (equivalent to `{}`) permits any
value; `False` permits none and is *not* equivalent to `{}`. Neither the "anything" nor
the "nothing" case maps to a precise Python type here, so we deliberately collapse both to
an empty schema, which the walker renders as `Any` â€” the practical fallback for the model.
Non-bool nodes are returned unchanged.

Called at every point where a nested node may be a raw schema, so no walker has to
special-case the boolean form.
)Ú
isinstancer   )Únodes    r&   Ú_normalize_schema_noder!    s   € ô ˜D¤$×'Ñ'ˆ2Ð1¨TÐ1r)   c           	     ó²   • U R                  5        HC  u  p4[        U5      nUR                  S5      S:X  d  M'  SU;   d  M/  X1;  d  M6  [        X5XX#5        ME     g)zTProcess $defs from a JSON schema, adding TypeSignatures for object-type definitions.rq   r  Ú
propertiesN)r™   r!  r‚   Ú_build_and_register_type)Údefsr­   r  Údef_nameÚdef_schema_rawÚ
def_schemas         r&   rÏ   rÏ     sL   € ð %)§J¡J¦LÑ ˆÜ+¨NÓ;ˆ
Ø�>‰>˜&Ó! XÕ-°,À*Õ2LØÕ/Ü(¨¸tÐW`Ökò	 %1r)   c                óê  • U R                  S0 5      n[        U R                  S/ 5      5      n0 n0 nUR                  5        H©  u  p‰[        U	5      n
[	        X¡X#U5      nU
R                  SS5      =(       d    SnSU
;   a  [        U
S   5      n[        X‹XÜS9Xx'   MZ  X…;   a  [        X‹SUS9Xh'   Mn  [        U
5      (       a  [        X‹SUS9Xx'   M�  [        U[        /S	9n[        XŽSUS9Xx'   M«     0 UEUE$ )
z9Convert a JSON schema to a dict of FunctionParam objects.r#  rr   rt   ra   Nr   )r   rq   r   rt   r   ©rT   )
r‚   rŒ   r™   r!  rÒ   r<   r   Ú_schema_allows_nullr   Ú_NONE)Úschemar%  r­   r  r#  rr   Úrequired_paramsÚoptional_paramsÚ	prop_nameÚprop_schema_rawÚprop_schemaÚ	type_exprrt   Údefault_strÚnullable_exprs                  r&   rÐ   rÐ   !  s  € ð —‘˜L¨"Ó-€JÜ�6—:‘:˜j¨"Ó-Ó.€Hà02€OØ02€Oà&0×&6Ñ&6Ö&8Ñ"ˆ	Ü,¨_Ó=ˆÜ(¨Ð<LÐYbÓcˆ	Ø!—o‘o m°RÓ8×@¸Dˆà˜Ó#Ü˜{¨9Ñ5Ó6ˆKÜ)6Ø¸ñ*ˆOÓ&ð Ó"Ü)6Ø¸È+ñ*ˆOÓ&ô
 # ;×/Ñ/Ü-:Ø"¸FÐP[ñ.�Ó*ô !.°yÄ%Ð6HÑ I�Ü-:Ø"ÀÐT_ñ.�Ó*ñ- '9ð4 2ˆoÐ1 Ð1Ð1r)   c                óÊ   • U R                  S5      n[        U[        5      (       a  SU;   a  gSU ;   a  [        S U S    5       5      $ SU ;   a  [        S U S    5       5      $ g)	z-Check if a schema already allows null values.rq   r  TÚanyOfc              3  ó\   #   • U  H"  n[        U5      R                  S 5      S:H  v •  M$     g7f©rq   r  N©r!  r‚   ©r=   r  s     r&   r?   Ú&_schema_allows_null.<locals>.<genexpr>Q  ó&   é € Ð\ÊOÀqÔ)¨!Ó,×0Ñ0°Ó8¸FÖBÊOùó   ‚*,ÚoneOfc              3  ó\   #   • U  H"  n[        U5      R                  S 5      S:H  v •  M$     g7fr9  r:  r;  s     r&   r?   r<  S  r=  r>  F)r‚   r  rÓ   Úany)r-  Úschema_types     r&   r+  r+  K  sf   € à—*‘*˜VÓ$€KÜ�+œt×$Ñ$¨°;Ó)>ØØ�&ÓÜÑ\ÈFÐSZÊOÓ\Ó\Ð\Ø�&ÓÜÑ\ÈFÐSZÊOÓ\Ó\Ð\Ør)   c                ó6  • [        U 5      n SU ;   aË  U S   nUR                  S5      S   nXa;   a›  Xb;  a–  [        X   5      nUR                  S5      S:X  a  SU;   a  [        XgXX45        O`SU;  aZ  [        R                  5       nXh;   a  [
        $ [        R                  X†1-  5      n	 [        XqX#U5      [        R                  U	5        $ Xb;   a  X&   $ [        US9$ SU ;   a  [        U S   XX45      $ S	U ;   a  [        U S	   XX45      $ S
U ;   a+  [        U S
   5      S:X  a  [        U S
   S   XX45      $ [
        $ SU ;   a  [        U S   /5      $ SU ;   a  [        U S   5      $ U R                  S5      n
[        X XX45      $ ! [        R                  U	5        f = f)z$Convert a JSON schema to a TypeExpr.z$refÚ/éÿÿÿÿrq   r  r#  r#   r7  r?  ÚallOfr`   r   ÚconstÚenum)r!  r  r‚   r$  r	  rÑ   rŒ   rÒ   rŽ   r   Ú_handle_union_schemarf   r   Ú_type_to_expr)r-  r%  r­   r  rÎ   ÚrefÚref_nameÚ
ref_schemaÚ	resolvingr‘   rB  s              r&   rÒ   rÒ   W  s»  € ô $ FÓ+€Fð �ÓØ�V‰nˆØ—9‘9˜S“> "Ñ%ˆàÓ Ó @Ü/°±Ó?ˆJØ�~‰~˜fÓ%¨Ó1°lÀjÓ6PÜ(¨¸tÐW`ÕgØ˜zÓ)ô
 ,×/Ñ/Ó1�	ØÓ(ô  �KÜ'×+Ñ+¨I¸
Ñ,BÓC�ð1Ü/°
ÐBRÐ_cÓdä#×)Ñ)¨%Õ0àÓ'Ø#Ñ-Ð-Ü (Ñ+Ð+ð �&ÓÜ# F¨7¡O°TÈYÓ]Ð]Ø�&ÓÜ# F¨7¡O°TÈYÓ]Ð]ð �&ÓÜˆv�g‰Ó 1Ó$Ü'¨¨w©¸Ñ(:¸DÐT]ÓdÐdÜˆð �&ÓÜ  w¡Ð0Ó1Ð1ð �ÓÜ˜v f™~Ó.Ð.ð —*‘*˜VÓ$€KÜ˜¨dÀiÓVÐVøô9 $×)Ñ)¨%Õ0ús   Â)F ÆFc                óV  • [        U [        5      (       a  U [        ;   a  [        [        U    5      $ U S:X  aÐ  UR	                  S0 5      nU(       a¨  [        U[
        5      (       a]  [        [
        [        [        [        4      U5      n[        U5       VV	s/ s H  u  p‰[        X’X4U SU 35      PM     n
nn	[        SU
S9$ [        [        [        [        [        4   U5      X#XE S35      n[        SU/S9$ [        S[        /S9$ U S:X  aï  S	U;   aP  UR	                  S
5      nU(       a  UR                  5       (       a  UO
[        XE5      nXÓ;  a  [        XÑX#XE5        X=   $ SU;   az  US   nUSL a  [        S[        S5      [        /S9$ [        U[        5      (       aB  [        [        [        [        4   U5      n[        XòX4U S35      n[        S[        S5      U/S9$ [        S[        S5      [        /S9$ [        U [
        5      (       a  [!        XX#XE5      $ [        $ s  sn	nf )z$Convert a schema type to a TypeExpr.r  r™   r  Útuple)rG   rI   ÚItemrÓ   r  r#  ÚtitleÚadditionalPropertiesTrŸ   r   ÚValue)r  r   r  r
   r‚   rÓ   r   rŸ   r   Ú	enumeraterÒ   r   rÑ   Úisidentifierr  r$  Ú_type_list_to_expr)rB  r-  r%  r­   r  rÎ   r™   Ú
items_listÚiÚitemÚ
item_exprsÚ	item_exprrR  Útd_nameÚ
additionalÚadditional_schemaÚ
value_exprs                    r&   rJ  rJ  —  s+  € ô �+œs×#Ñ#¨Ô7RÓ(RÜÔ9¸+ÑFÓGÐGð �gÓØ—
‘
˜7 BÓ'ˆÞä˜%¤×&Ñ&Ü!¤$¤t¬C´¨H¡~Ñ"6¸Ó>�
ô $-¨ZÔ#8ôâ#8™˜ô )¨Ð5EÐUYÐTZÐZ[Ð\]Ð[^ÐR_Ö`Ù#8ð ñ ô '¨G¸*ÑEÐEÜ,Ü”Tœ#œs˜(‘^ UÓ+¨TÀYÐRXÐX\ÐP]óˆIô #¨°i°[ÑAÐAÜ F´$°Ñ8Ð8ð �hÓØ˜6Ó!ð —J‘J˜wÓ'ˆEÞ$¨×);Ñ);×)=Ñ)=‘eÔCTÐU^ÓCeˆGØÓ.Ü(¨¸$ÐR[ÔbØ#Ñ,Ð,Ø! VÓ+ØÐ 6Ñ7ˆJØ˜TÒ!Ü&¨F¼.ÈÓ:OÔQUÐ9VÑWÐWÜ˜*¤d×+Ñ+Ü$(¬¬c´3¨h©¸Ó$DÐ!Ü1Ð2CÐK[ÐkoÐjpÐpuÐhvÓw�
Ü&¨F¼.ÈÓ:OÐQ[Ð9\Ñ]Ð]Ü F´.ÀÓ2GÌÐ1NÑOÐOô �+œt×$Ñ$Ü! +°tÈyÓ_Ð_ä€KùóGs   ÂH%c                ó  • SU ;   a+  SU;   a%  [        SXX4U5      nSU ;   a  [        U[        /S9$ U$ U  Vs/ s H  n[        U5      PM     nnU Vs/ s H  n[	        U5      (       d  M  UPM     nn[        U5      S:X  aM  [        S U 5       5      (       a6  U Vs/ s H  n[	        U5      S:w  d  M  UPM     snS   n	[        U	[        /S9$ U(       a  [        U5      S	:”  a	  [        US9$ US   $ [        $ s  snf s  snf s  snf )
z*Handle type lists like ['string', 'null'].r  r#  r  r*  r¿   c              3  ó>   #   • U  H  n[        U5      S :H  v •  M     g7f)r   NrN   )r=   Úts     r&   r?   Ú%_type_list_to_expr.<locals>.<genexpr>ã  s   é € Ð#Iºj¸¤C¨£F¨fÖ$4ºjùs   ‚r   r   r`   )rJ  r   r,  r  r   rf   rA  rÑ   )
rB  r-  r%  r­   r  rÎ   Ú	base_exprrc  Ú
type_exprsÚnon_nones
             r&   rW  rW  Ñ  sû   € ð �;Ó <°6Ó#9Ü! (¨FÐ:JÐW[Ó\ˆ	Ø�[Ó Ü ¨)´UÐ);Ñ<Ð<ØÐáCNÓ!OÂ;¸aÔ"6°qÖ"9Á;€JÐ!OÙ'Ó2šZ˜¬3¨q¯6—!™Z€JÐ2Ü
ˆ:ƒ˜!Ó¤Ñ#I¹jÓ#I× IÑ IÙ)Ó>šz˜!¬S°«V°vÑ-=—A™zÑ>¸qÑAˆÜ h´Ð%6Ñ7Ð7ÞÜ47¸
³OÀaÓ4GŒ} ZÑ0ÐZÈZÐXYÉ]ÐZÜ€Kùò "PùÚ2ùâ>s   ¶C7ÁC<Á)C<ÂDÂ2Dc           
     ó   • / nSnU  HC  n[        U5      nUR                  S5      S:X  a  SnM'  UR                  [        X�X#U5      5        ME     [	        5       n	/ n
U H7  n[        U5      nXÉ;  d  M  U	R                  U5        U
R                  U5        M9     U(       a  U
R                  [        5        [        U
5      S:X  a  U
S   $ [        U
S9$ )z1Handle anyOf/oneOf schemas, returning a TypeExpr.Frq   r  Tr`   r   r*  )
r!  r‚   rg   rÒ   rŒ   r   râ   r,  rf   r   )Úschemasr%  r­   r  rÎ   rf  Úhas_nullÚs_rawr  rä   Úunique_exprsÚexprrö   s                r&   rI  rI  ë  sÇ   € ð "$€JØ€HãˆÜ" 5Ó)ˆØ�5‰5�‹=˜FÓ"ØŠHà×ÑÔ2°1Ð<LÐY]Ó^Ö_ñ ô “U€DØ#%€LÛˆÜ�t“9ˆØÕØ�H‰H�XÔØ×Ñ Ö%ñ	 ö Ø×ÑœEÔ"ä
ˆ<Ó˜AÓØ˜A‰ÐÜ Ñ.Ð.r)   c                ó~   • [        U S9nXcU '   [        XX#XE5      nUR                  Ul        UR                  Ul        U$ )a,  Build a TypeSignature, registering a placeholder first to prevent infinite recursion.

Self-referential schemas (e.g. recursive models) would otherwise cause infinite recursion
when `_build_type_signature` processes properties that `$ref` back to the same type.

Returns the completed TypeSignature.
r#   )r   Ú_build_type_signaturer€   rt   )r   r-  r%  r­   r  rÎ   ÚplaceholderÚbuilts           r&   r$  r$    sD   € ô   TÑ*€KØ(�TÑÜ! $°È	ÓX€EØŸ™€KÔØ#×/Ñ/€KÔØÐr)   c                ó†  • UR                  S0 5      n[        UR                  S/ 5      5      n0 nUR                  5        HZ  u  pš[        U
5      nU(       a  U SU	 3OU	n[	        X²X4U5      nX—;   nUR                  SS5      =(       d    Sn[        U	UUUS9X‰'   M\     UR                  S5      =(       d    Sn[        U UUS9$ )	z,Build a TypeSignature from an object schema.r#  rr   r  rt   ra   N)r   rq   rr   rt   )r   rt   r€   )r‚   rŒ   r™   r!  rÒ   r   r   )r   r-  r%  r­   r  rÎ   r#  rr   r€   r0  r1  r2  Ú	prop_pathr3  Úis_requiredÚdescrt   s                    r&   ro  ro  %  sÌ   € ð —‘˜L¨"Ó-€JÜ�6—:‘:˜j¨"Ó-Ó.€Hà,.€Fà&0×&6Ñ&6Ö&8Ñ"ˆ	Ü,¨_Ó=ˆÞ-1�t�f˜A˜i˜[Ñ)°yˆ	Ü(¨Ð<LÐYbÓcˆ	ØÑ+ˆØ�‰˜}¨bÓ1×9°Tˆä.ØØØ Øñ	
ˆÓñ '9ð —*‘*˜]Ó+×3¨t€KÜ˜d°ÀFÑKÐKr)   c                óR  ^^^• SUUU4S jjmU R                   R                  5        H  nT" UR                  5      Ul        M     T" U R                  5      U l        U R                   H;  nUR
                  R                  5        H  nT" UR                  5      Ul        M     M=     g)zQReplace all references to old_ref with canonical in a signature's TypeExpr trees.c                óÊ  >• U TL a  T$ [        U [        5      (       aT  U R                   Vs/ s H  nT" U5      PM     nn[        S [	        X R                  5       5       5      (       a  X l        U $ [        U [
        5      (       aR  U R                   Vs/ s H  nT" U5      PM     nn[        S [	        X@R                  5       5       5      (       a  X@l        U $ s  snf s  snf )Nc              3  ó,   #   • U  H
  u  pXLv •  M     g 7fr"   r*   ©r=   ÚnewÚorigs      r&   r?   Ú?_replace_type_refs.<locals>._replace_in_expr.<locals>.<genexpr>R  s   é € ÐMÒ4L¡y s�3•?Ò4Lùó   ‚c              3  ó,   #   • U  H
  u  pXLv •  M     g 7fr"   r*   ry  s      r&   r?   r|  V  s   é € ÐSÒ4R¡y s�3•?Ò4Rùr}  )r  r   rI   rA  Úzipr   rT   )rm  rO   Únew_argsrX   Únew_membersÚ_replace_in_exprré   Úold_refs        €€€r&   r‚  Ú,_replace_type_refs.<locals>._replace_in_exprM  s¾   ø€ Ø�7Š?ØÐÜ�dœO×,Ñ,Ø59·Y²YÓ?²Y°Ñ(¨Ö+±YˆHÐ?ÜÑM´C¸Ç)Á)Ô4LÓM×MÑMØ$”	ð
 ˆô	 ˜œm×,Ñ,Ø8<¿ºÓEº°1Ñ+¨AÖ.¹ˆKÐEÜÑS´C¸Ç\Á\Ô4RÓS×SÑSØ*”Øˆùò @ùò Fs   ¬CÂC N)rm  r   r,   r   )rª   r7   rq   r«   r­   r€   )ræ   rƒ  ré   r¤   rè   r•   r‚  s    ``   @r&   rá   rá   J  s�   ú€ ÷ñ ð —‘×"Ñ"Ö$ˆÙ% e§j¡jÓ1ˆŽ
ñ %ñ ' s§¡Ó7€C„Oð ×(Ô(ˆØ—‘×'Ñ'Ö)ˆAÙ% a§f¡fÓ-ˆAŽFó *ò )r)   )ra   )rh   r   ri   r   r,   rý   )r  r   r,   r
   )r  r   r,   r   )r  r   rÎ   r   r,   r   )r   údict[str, Any] | boolr,   rû   )r%  údict[str, dict[str, Any]]r­   údict[str, TypeSignature]r  r   r,   r   )
r-  rû   r%  r†  r­   r‡  r  r   r,   r©   )r-  rû   r,   r   )r-  r…  r%  r†  r­   r‡  r  r   rÎ   r   r,   r   )rB  zstr | list[str] | Noner-  rû   r%  r†  r­   r‡  r  r   rÎ   r   r,   r   )rB  rý   r-  rû   r%  r†  r­   r‡  r  r   rÎ   r   r,   r   )ri  zlist[dict[str, Any] | bool]r%  r†  r­   r‡  r  r   rÎ   r   r,   r   )r   r   r-  rû   r%  r†  r­   r‡  r  r   rÎ   r   r,   r   )ræ   r   rƒ  r   ré   r   r,   r   )6r2   Ú
__future__r   Ú__all__ÚreÚcontextvarsr   Údataclassesr   r   Útypingr   r   r   r   r   r3   r	   r
   r   r   r   r   rÀ   r   Ú	maketransrd   rm   r   r   r   r   rÑ   r,  r  r  r¡   r	  r  Úcompiler  r  r  r!  rÏ   rÐ   r+  rÒ   rJ  rW  rI  r$  ro  rá   r*   r)   r&   Ú<module>r�     s  ðòõ #ð€ó 
Ý "ß (ß 0Ó 0ñ
 4>Ð>TÐ^`Ñ3aÐ Ð0Ó að ÐEÑF€ð ÷ð ó ðð ÷Eð Eó ðEð ÷Fð Fó ðFð ÷8ð 8ó ð8ð k€ˆ)Ó jØ :ð €ð
 —}‘}¨F¸'ÈÑ%NÓOÐ ö
%ñ �4Ñ÷ ð  ó ð ñ( �4Ñ÷?ð ?ó ð?ñD �4Ñ÷*ð *ó ð*ñ" �4Ñ÷að aó ðañJ �eÓ€Ù�vÓ€ð ØØØØñ:Ð Ð6ó ð(Ø!ð(àØò(Ð �nó ñ /9Ð9JÑT]ÓT_Ñ.`€Ð+Ó `ôMð
 —
’
˜?Ó+€ôô	6ô2ð"
lØ
#ð
là.ð
lð ð
lð 
ô	
lð'2Øð'2à
#ð'2ð /ð'2ð ð	'2ð
 ô'2ôT	ð=WØ!ð=Wà
#ð=Wð /ð=Wð ð	=Wð
 ð=Wð ô=Wð@7Ø'ð7àð7ð $ð7ð /ð	7ð
 ð7ð ð7ð ô7ðtØðàðð $ðð /ð	ð
 ðð ðð ôð4 /Ø(ð /à
#ð /ð /ð /ð ð	 /ð
 ð /ð ô /ðFØ
ðàðð $ðð /ð	ð
 ðð ðð ôð.LØ
ðLàðLð $ðLð /ð	Lð
 ðLð ðLð ôLõJ.r)   