
    Ki                   N   U d Z ddlmZ ddlZddlZddlZddlZddl	Z	ddl
Z
ddlZddlZddlZddlZddlmZmZmZmZ ddlmZ ddlmZ ddlmZ ddlmZ dd	lmZ dd
lmZ ddlmZmZ ddl m!Z!m"Z"m#Z#m$Z$m%Z%m&Z& ddl'm(Z( ddl)m*Z* ddl+m,Z,m-Z-m.Z.m/Z/ ddlm0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9 ddl:m;Z; ddl<m=Z= ddl>Z>ddl?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZH ddl>mIZImJZJmKZKmLZLmMZM ddlNmOZO ddlPmQZQmRZRmSZS ddlTmUZUmVZV ddlWmXZXmYZY ddlZm[Z[m\Z\m]Z]m^Z^ ddl_m`Z`maZambZbmcZcmdZd ddlemfZfmgZgmhZhmiZimjZj ddlkmlZl ddlmmnZn ddlmoZompZpmqZqmrZr d d!lsmtZtmuZumvZvmwZwmxZx d d"lymzZzm{Z{ d d#l|m}Z}m~Z~ d d$lmZmZmZ d d%ltmZmZmZmZmZmZmZmZmZmZmZmZ d d&lmZ d d'lmZmZmZmZmZ d d(lmZ d d)lmZmZ d d*lmZmZ d d+lmZ d d,lmZmZ d d-lmZmZ d d.lmZ d d/lmZmZ e0r dd0lmZmZ dd1lmZ dd2l+mZ d d3lmZ d d4lmZ ejj                  d5k\  Ze7eeef   Z e6d6e7      Ze7ee   ee   ee   f   ZeXZd8ed9<   e2e1egeGj                  f   Zd8ed:<   d;Zd8ed<<   ej|                  egZd=ed><   ej                  eej                  j                  gZd=ed?<   ej                  eej                  j                  gZd=ed@<   ej                  eej                  j                  gZd=edA<   ej                  egZd=edB<   e!e"e#e$e%e&gZd=edC<   ej                  ej                  j                  gZd=edD<   ej                   ej                  j                   ej                  ej                  j                  gZd=edE<   ej                  egZd=edF<   ej                  ej                  gZd=edG<   e	j                  e
j                  e
j                  e
j                  e
j                  e
j                  gZd=edH<   ej$                  ej                  ej                  j$                  ej                  j                  ej                  e>j                  ej                  ej                  gZej                  ej                  gZej                  ej                  gZd=edI<   e7e.e,e/ef   Z eKe      ZdJdKdLdMeEfdNdOdPdQdRdSdTdUdVgZdWedX<   	 egefeiejdYZdZed[<   	 	 	 	 	 	 dd\Zdd]Z	 	 	 	 	 	 dd^Z	 	 	 	 	 	 dd_Z	 	 	 	 dd`Zeee1   e]f   Z	 	 	 	 	 	 	 	 ddaZe`eaebecfZ	  G db dce      Z G dd de      Zdf dg dh di dj dk dl dm dnZdoedp<   	 	 	 	 	 	 ddqZddrZ	 	 	 	 ddsZ	 	 	 	 	 	 	 	 ddtZdduZddvZddxZ 	 	 	 	 ddyZ G dz dw      Z G d{ d|      Z G d} d~      Zy)z-Convert python types to pydantic-core schema.    )annotationsN)	GeneratorIterableIteratorMapping)contextmanager)copy)Decimal)Enum)Fraction)partial)	Parameter_ParameterKind)IPv4AddressIPv4InterfaceIPv4NetworkIPv6AddressIPv6InterfaceIPv6Network)chain)
attrgetter)FunctionTypeGenericAlias
LambdaType
MethodType)
TYPE_CHECKINGAnyCallableFinal
ForwardRefLiteralTypeVarUnioncastoverload)UUID)ZoneInfo)	MISSING
CoreSchemaMultiHostUrlPydanticCustomError$PydanticSerializationUnexpectedValuePydanticUndefinedUrlcore_schemato_jsonable_python)	TypeAliasTypeAliasTypeget_args
get_originis_typeddict)typing_objects)AnnotationSourceget_literal_valuesis_union_origin   )AliasChoices	AliasPath)GetCoreSchemaHandlerGetJsonSchemaHandler)
ConfigDictJsonDictJsonEncoderJsonSchemaExtraCallable)PydanticForbiddenQualifierPydanticInvalidForJsonSchemaPydanticSchemaGenerationErrorPydanticUndefinedAnnotationPydanticUserError)AfterValidatorBeforeValidatorFieldValidatorModesPlainValidatorWrapValidator)JsonSchemaValue)version_short)ArbitraryTypeWarningPydanticDeprecatedSince20TypedDictExtraConfigWarning UnsupportedFieldAttributeWarning   )_decorators_discriminated_union_known_annotated_metadata_repr_typing_extra)ConfigWrapperConfigWrapperStack)CoreMetadataupdate_core_metadata)get_refget_type_ref%is_list_like_schema_with_items_schema)	DecoratorDecoratorInfosFieldSerializerDecoratorInfoFieldValidatorDecoratorInfoModelSerializerDecoratorInfoModelValidatorDecoratorInfoRootValidatorDecoratorInfoValidatorDecoratorInfoget_attribute_from_basesinspect_field_serializerinspect_model_serializerinspect_validator)extract_docstrings_from_cls)collect_dataclass_fieldsrebuild_dataclass_fieldsrebuild_model_fieldstakes_validated_data_argumentupdate_field_from_config)PydanticRecursiveRef)get_standard_typevars_mapreplace_types)import_cached_base_modelimport_cached_field_info)MockCoreSchema)NamespacesTuple
NsResolver)MissingDefinitionErrorgather_schemas_for_cleaning)CallbackGetCoreSchemaHandler)lenient_issubclasssmart_deepcopy)ComputedFieldInfo	FieldInfo	BaseModel)Discriminator)StandardDataclass)GetJsonSchemaFunction)      FieldDecoratorInfoType)boundr1   ModifyCoreSchemaWrapHandlerGetCoreSchemaFunctionz1Callable[[int, str, Any], Literal['skip'] | None]ParametersCallbackz
list[type]TUPLE_TYPES
LIST_TYPES	SET_TYPESFROZEN_SET_TYPES
DICT_TYPESIP_TYPESSEQUENCE_TYPESITERABLE_TYPES
TYPE_TYPESPATTERN_TYPES
PATH_TYPESDEQUE_TYPES)aliasN)validation_aliasN)serialization_aliasNdefault)default_factoryN)excludeN)
deprecatedN)reprT)validate_defaultN)frozenN)initN)init_varN)kw_onlyNlist[tuple[str, Any]]+UNSUPPORTED_STANDALONE_FIELDINFO_ATTRIBUTES)beforeafterplainwrapzbdict[FieldValidatorModes, type[BeforeValidator | AfterValidator | PlainValidator | WrapValidator]]_mode_to_validatorc                .    | j                   }d|v xs ||v S )zCheck if field name is in validator fields.

    Args:
        info: The field info.
        field: The field name to check.

    Returns:
        `True` if field name is in validator fields, `False` otherwise.
    *)fields)infofieldr   s      o/home/jay/workspace/scripts/.codegraph-venv/lib/python3.12/site-packages/pydantic/_internal/_generate_schema.py)check_validator_fields_against_field_namer      s      [[F&=+EVO+    c           	        t        |      }| D ]{  }d|j                  j                  v r|j                  j                  du r5|j                  j                  D ].  }||vst	        d|j
                   d|j                   dd       } y)	av  Check if the defined fields in decorators exist in `fields` param.

    It ignores the check for a decorator if the decorator has `*` as field or `check_fields=False`.

    Args:
        decorators: An iterable of decorators.
        fields: An iterable of fields name.

    Raises:
        PydanticUserError: If one of the field names does not exist in `fields` param.
    r   Fz*Decorators defined with incorrect fields: .zO (use check_fields=False if you're inheriting from the model and intended this)zdecorator-missing-fieldcodeN)setr   r   check_fieldsrG   cls_refcls_var_name)
decoratorsr   decr   s       r   check_decorator_fields_existr      s     [F #((//!88  E)XX__ 	EF"'@QsO_O_N`ef2 	r   c                Z    | D cg c]  }t        |j                  |      s| c}S c c}w N)r   r   )validator_functionsr   r   s      r   $filter_field_decorator_info_by_fieldr      s*     /mC2[\_\d\dfk2lCmmms   ((c                   |s| S | d   dk(  rt        | d   |      | d<   | S | d   dk(  r-| j                  d      x}t        | d   |   |      | d   |<   | S t        |       r5| j                  dt	        j
                               }t        ||      | d<   | S | d   dk(  r5| j                  dt	        j
                               }t        ||      | d<   | S t        d	| d          )
Ntypenullableschematuplevariadic_item_indexitems_schemadictvalues_schemazO`@validator(..., each_item=True)` cannot be applied to fields with a schema of )apply_each_item_validatorsgetapply_validatorsr_   r/   
any_schema	TypeError)r   each_item_validatorsr   inner_schemas       r   r   r      s"     
 f~#5fX6FH\]x	7	"#)::.C#DDQ:J~&':;$;F>"#67 M 
/v	6zz.+2H2H2JK!1,@T!U~ M 
6	!zz/;3I3I3KL"2<AU"V
 M ]^dek^l]mn
 	
r   c                *   | j                   | j                  t        | j                        xs | j                  dk(  xs d t	        | j
                        d}|j                         D ci c]  \  }}|	|| }}}|xs d | j                  fS c c}}w )N )titledescriptionr   examples)r   r   boolr   r0   r   itemsjson_schema_extra)r   json_schema_updateskvs       r   )_extract_json_schema_info_from_field_infor     s     ''4??+Lt"/DL&t}}5	 -@,E,E,GYDAq1=1a4YY'4)?)?@@ Zs   *
B5Bc                "   | s|S d|v r|S |gt        |d|j                  j                        dd D ]Y  }| j                  |      }|t	        j
                  dt                dt               t        j                  |d      |d<   |c S  |S )	a  Iterate over the json_encoders and add the first matching encoder to the schema.

    Args:
        json_encoders: A dictionary of types and their encoder functions.
        tp: The type to check for a matching encoder.
        schema: The schema to add the encoder to.
    serialization__mro__Nz=`json_encoders` is deprecated. See https://docs.pydantic.dev/z</concepts/serialization/#custom-serializers for alternativesjson	when_used)
getattr	__class__r   r   warningswarnrN   rP   r/   $plain_serializer_function_ser_schema)json_encoderstpr   baseencoders        r   ,_add_custom_serialization_from_json_encodersr   /  s     &  Hgb)R\\-A-AB3BGH ##D)?KMOK\  ]Y  Z%	
 #."R"RSZfl"m Mr   c                      e Zd ZdZy)InvalidSchemaErrorzThe core schema is invalid.N)__name__
__module____qualname____doc__ r   r   r   r   Z  s    %r   r   c                      e Zd ZdZdZ	 	 dJ	 	 	 	 	 	 	 dKdZdL fdZedMd       ZedNd       Z	edOd       Z
dPd	ZdQd
ZdPdZdPdZdRdZdSdZdTdZdPdZdUdZdVdZdSdZdWdZ	 	 	 	 	 	 dXdZdYdZdZdZ	 	 	 	 d[dZd\dZd]dZd^dZd]dZed_d       Z ed`d       Z dadbdZ d]d Z!dcd!Z"d[d"Z#d[d#Z$ddd$Z%d%d&	 	 	 	 	 	 	 	 	 ded'Z&	 	 	 	 	 	 	 	 dfd(Z'	 	 	 	 	 	 	 	 dgd)Z(	 	 	 	 	 	 	 	 dhd*Z)did+Z*djd,Z+dkd-Z,dld.Z-dmd/Z.e/j`                  df	 	 	 	 	 	 	 	 	 	 	 dnd0Z1e/j`                  f	 	 	 	 	 	 	 	 	 	 	 dod1Z2dpd2Z3dqd3Z4dqd4Z5did5Z6drd6Z7dsd7Z8dtd8Z9dud9Z:dqd:Z;	 	 	 	 	 	 dvd;Z<dwd<Z=	 dx	 	 	 	 	 dyd=Z>	 dx	 	 	 	 	 dzd>Z?d{d?Z@	 	 	 	 	 	 d|d@ZAd}dAZBdB d%f	 	 	 	 	 	 	 	 	 d~dCZC	 d	 	 	 	 	 	 	 ddDZD	 	 	 	 	 	 ddEZEddFZF	 da	 	 	 	 	 	 	 	 	 ddGZG	 	 	 	 	 	 ddHZH	 	 	 	 	 	 ddIZI xZJS )GenerateSchemaz\Generate core schema for a Pydantic model, dataclass and types like `str`, `datetime`, ... .)_config_wrapper_stack_ns_resolver_typevars_mapfield_name_stackmodel_type_stackdefsNc                    t        |      | _        |xs
 t               | _        || _        t               | _        t               | _        t               | _
        y r   )rZ   r   ry   r   r   _FieldNameStackr   _ModelTypeStackr   _Definitionsr   )selfconfig_wrapperns_resolvertypevars_maps       r   __init__zGenerateSchema.__init__j  sG     &8%G"'7:<) / 1 / 1 N	r   c                Z    t         |           t        j                  dt        d       y )NzeSubclassing `GenerateSchema` is not supported. The API is highly subject to change in minor versions.r:   )
stacklevel)super__init_subclass__r   r   UserWarning)clsr   s    r   r  z GenerateSchema.__init_subclass__x  s#    !#s	
r   c                .    | j                   j                  S r   )r   tailr  s    r   _config_wrapperzGenerateSchema._config_wrapper  s    ))...r   c                .    | j                   j                  S r   )r   types_namespacer  s    r   _types_namespacezGenerateSchema._types_namespace  s      000r   c                .    | j                   j                  S r   )r  arbitrary_types_allowedr  s    r   _arbitrary_typeszGenerateSchema._arbitrary_types  s    ##;;;r   c                J    t        j                  | j                  |            S r   )r/   list_schemagenerate_schemar  
items_types     r   _list_schemazGenerateSchema._list_schema  s    &&t';';J'GHHr   c                j    t        j                  | j                  |      | j                  |            S r   )r/   dict_schemar  )r  	keys_typevalues_types      r   _dict_schemazGenerateSchema._dict_schema  s,    &&t';';I'FH\H\]hHijjr   c                J    t        j                  | j                  |            S r   )r/   
set_schemar  r  s     r   _set_schemazGenerateSchema._set_schema  s    %%d&:&::&FGGr   c                J    t        j                  | j                  |            S r   )r/   frozenset_schemar  r  s     r   _frozenset_schemaz GenerateSchema._frozenset_schema  s    ++D,@,@,LMMr   c           	       
 t        j                  j                               
t              j                  sd nt        j                  j                        }|dk(  rd }j                  |dj                         D ci c]  \  }}|	|| c}}d t        t              rdt        j                  d      }nft        t              rdt        j                  d      }n>t        t              rdt        j                  d      }nt        j                  d       }
rdfd}t!        j"                  dd       t$        j"                  j&                  u }t        j(                  
|rd nj"                  d	|gi
      }| j*                  j,                  r!t        j.                  t1        d      ||      }|S d
fd}	t        j2                  d	|	gi      S c c}}w )NzAn enumeration.)r   r   intstrfloatc                    | S r   r   xs    r   <lambda>z-GenerateSchema._enum_schema.<locals>.<lambda>  s    XY r   c                \     ||       }|j                  |      }|j                         |S r   )resolve_ref_schemaupdate)r   handlerjson_schemaoriginal_schema
js_updatess       r   get_json_schemaz4GenerateSchema._enum_schema.<locals>.get_json_schema  s0    %fo")"<"<["I&&z2""r   __func__pydantic_js_functions)sub_typemissingrefmetadatavalue)r   c                     |t        j                              }|j                  |      }|j                         |S )N)r<  r>  )r/   enum_schemar3  r4  )	_r5  r6  r7  casesenum_ref	enum_typer8  r<  s	       r   get_json_schema_no_casesz=GenerateSchema._enum_schema.<locals>.get_json_schema_no_cases  sD    %k&=&=iYago&pq")"<"<["I&&z2""r   r?  )r   r)   r5  r>   returnrM   )r5  r>   rI  rM   )list__members__valuesr^   r   inspectcleandocr   r   
issubclassr+  r/   simple_ser_schemar,  r-  r   r   	_missing_r   r:  rB  r  use_enum_values no_info_after_validator_functionr   is_instance_schema)r  rF  r   r   r   value_ser_typer9  default_missingrB  rG  rD  rE  r8  r<  s    `        @@@@r   _enum_schemazGenerateSchema._enum_schema  s   	 5 5 < < >?	*"+"3"3d9I9I)J[J[9\,,K(11+N
'1'7'7'9Ktq!Q]adK
:>i%H4?4Q4QRW4XN	3'H(::5AN	5)H(::7CN )MMkZN# &i&9&9:tLPTP^P^PgPggO%11! /Y5H5H1O3DEK ##33)JJw'N # # 1114L3MN s Ls   

G0G0c                   ddl m}m} t        dt        dt
        dt        dt        dt        didfd	}t        j                  t        j                  |         t        j                  t        j                  t        j                               t        j                        
      t        j                   |dd      dfdgi      S )NrS   )IP_VALIDATOR_LOOKUPIpTypeipv4ipv4networkipv4interfaceipv6ipv6networkipv6interfacec           	         t        | t        f      st        d dt        |        d|  d      |j                  dk(  r| S t        |       S Nz
Expected `z` but got `z` with value `'z-'` - serialized value may not be as expected.python
isinstancer,  r,   r   mode)ipr   r   s     r   ser_ipz)GenerateSchema._ip_schema.<locals>.ser_ip  sW    b2s),: KRzLyz  yyH$	r7Nr   r6  python_schemaTalwaysinfo_argr   r;  c                    d   dS )Nstringr   formatr   )_1_2ip_type_json_schema_formatr   s     r   r1  z+GenerateSchema._ip_schema.<locals>.<lambda>  s    (VpqsVt9u r   
lax_schemastrict_schemar   r?  )rg  r   r   core_schema.SerializationInforI  zstr | IpType)_validatorsrY  rZ  r   r   r   r   r   r   r/   lax_or_strict_schema no_info_plain_validator_functionjson_or_python_schemarS  
str_schemarT  r   )r  r   rY  rZ  rh  rt  s    `   @r   
_ip_schemazGenerateSchema._ip_schema  s    < ???
"	 //"CCDWXZD[\%;;'HH[McMcMef)<<R@ &JJ6\`ltu'*u)v

 
	
r   c           	       	 t         j                  u r0t        t        hvr"t	        j
                        st        dd      t         j                  u rt        j                  n	t        u rt        j                  d      nt        j                  d      }t        u rt        j                         nt        j                         }d	fd}dfd}t        j                  t        j                  ||      t        j                              }t        j                  t        j                   |t        j                  ||      gd	d
       |t        j"                  |dd      dd gi      }|S )Nz;`os.PathLike` can only be used with `str`, `bytes` or `Any`zschema-for-unknown-typer   Tstrictc                2   	 t         u r.t        | t               r	 | j                         } n(t	        dd      t        | t
              st	        dd       |       S # t        $ r}t	        dd      |d }~ww xY w# t        $ r}t	        dd      |d }~ww xY w)N
bytes_typezInput must be valid byteszInput must be bytes	path_typezInput is not a valid path)bytesre  decodeUnicodeDecodeErrorr+   r,  r   )input_valueepath_constructorr  s     r   path_validatorz3GenerateSchema._path_schema.<locals>.path_validator  s    [%!+u5h*5*<*<*>K 2,@UVV#K5-k;VWW'44  2 h"5lD_"`fggh  [)+7RSYZZ[s9   A; A 0A; 	A8&A33A88A; ;	BBBc           	         t        | t        f      st        d dt        |        d|  d      |j                  dk(  r| S t        |       S rb  rd  )pathr   r   s     r   ser_pathz-GenerateSchema._path_schema.<locals>.ser_path   sX    dRI.: KT
|?4&P}~  yyH$t9r   ri  r  zInput is not a valid path for custom_error_typecustom_error_messagerk  rl  r;  c                    i  ||       ddiS )Nrq  r  r   )sourcer5  s     r   r1  z-GenerateSchema._path_schema.<locals>.<lambda>9  s    Hm7SY?Hm\dflHm r   ru  )r  zstr | bytesrI  zos.PathLike[Any])r  r   r   rx  rI  zstr | os.PathLike[Any])osPathLiker,  r  r6   is_anyrG   pathlibPurePathr/   bytes_schemar}  r|  rS  rT  rz  union_schemar   )
r  r   r  strict_inner_schemalax_inner_schemar  r  instance_schemar   r  s
    ``      @r   _path_schemazGenerateSchema._path_schema  sS   )C<"?H]H]^gHh#MTm  02R[[/@7++b6?56HK$$D1{OeOemqOr 	 ;Du:L;335S^SiSiSk	["	 &;;#DD^Uef%88<

 11"//#@@Qde #.'EbT%J *%JJ8^bnvw-0m/no
 r   c           	        ddl m} ddlm} | j	                  |      }t        j                  |d      }t        j                  |t        j                  t        j                  d            }t        j                  ||      }t        j                  |t        j                  ||g      t        j                  ||d	
            S )NrS   serialize_sequence_via_list)deque_validatorFr  Dequecls_reprri  Tr   rm  rv  rw  r   )_serializersr  ry  r  r  r/   r  r|  rT  collectionsdequeno_info_wrap_validator_functionrz  chain_schema#wrap_serializer_function_ser_schema)r  r  r  r  item_type_schemar  check_instancerv  s           r   _deque_schemazGenerateSchema._deque_schema=  s    =0//
; "--.>uM$::#%889J9JU\]

 !@@R]^
//!%22NJ3OP%II+4Dt
 	
r   c           	        ddl m}m}m} ||   }| j	                  |      }t        j                         5  t        j                  dt               | j	                  |      }	d d d        t        j                  |	d      }
|t        u r|
}|S t        j                  |
t        j                  |            }|t        j                  u r. ||      }t!        t        j"                  t!        ||            }nt!        t        j$                  |      } ||
      }t        j&                  ||g      }t        j(                  ||t        j*                  d	 |
d
            }|S # 1 sw Y   xY w)NrS   )MAPPING_ORIGIN_MAPdefaultdict_validator'get_defaultdict_default_default_factoryignorecategoryFr  ri  )default_default_factoryc                     ||       S r   r   )r   hs     r   r1  z0GenerateSchema._mapping_schema.<locals>.<lambda>~  s
    1 r   r  r  )ry  r  r  r  r  r   catch_warningssimplefilterrR   r/   r   r   r|  rT  r  defaultdictr   r  rS  r  rz  r  )r  r   r!  r"  r  r  r  mapped_originkeys_schemar   r   r   r  r  coerce_instance_wraprv  rw  s                    r   _mapping_schemazGenerateSchema._mapping_schemaV  sX   ss*2.**95$$& 	> !!(5UV 00=M	> "--k=QVWD  F6 3 )>>')<<]KN
 [,,,*QR]*^''.??1Kbc($
 (/{/[/[]j'k$-k:J'44nj5QRM 55%+)MM%kEF O	> 	>s   -E""E,c           	        ddl m} t        j                  t        j                  |      t        j
                  t        j                  |      t        j                  t                    t        j                  d      dd gi      S )	z7Support for [`fractions.Fraction`][fractions.Fraction].rS   )fraction_validatorri  rk  r   r;  c                    dddS )Nro  fractionrp  r   rr  rs  s     r   r1  z1GenerateSchema._fraction_schema.<locals>.<lambda>  s    \f?g r   ru  )	ry  r  r/   rz  r{  r|  rT  r   to_string_ser_schema)r  r  s     r   _fraction_schemazGenerateSchema._fraction_schema  sp    3 //"CCDVW%;;'HHI[\)<<XF
 &::XN-0g/hi	
 		
r   c                    t        |t              s1t        j                  |dt               t        j                         S t        j                  |      S )Na   is not a Python type (it may be an instance of an object), Pydantic will allow any object with no validation since we cannot even enforce that the input is an instance of the given type. To get rid of this error wrap the type with `pydantic.SkipValidation`.)re  r   r   r   rO   r/   r   rT  )r  r   s     r   _arbitrary_type_schemaz%GenerateSchema._arbitrary_type_schema  sP    "d#MM& Z Z % ))++--b11r   c                     t        d|d      )N,Unable to generate pydantic-core schema for a  . Set `arbitrary_types_allowed=True` in the model_config to ignore this error or implement `__get_pydantic_core_schema__` on your type to fully support it.

If you got this error by calling handler(<some type>) within `__get_pydantic_core_schema__` then you likely need to call `handler.generate_schema(<some type>)` since we do not call `__get_pydantic_core_schema__` on `<some type>` otherwise to avoid infinite recursion.)rE   r  objs     r   _unknown_type_schemaz#GenerateSchema._unknown_type_schema  s#    +:3' Bf f
 	
r   c                    ||S 	 t        j                  ||| j                  j                        S # t         j                  $ r t        j
                  ||       |cY S w xY wr   )rU   apply_discriminatorr   _definitionsMissingDefinitionForUnionRefset_discriminator_in_metadata)r  r   discriminators      r   _apply_discriminator_to_unionz,GenerateSchema._apply_discriminator_to_union  sl      M	';;		&& 
 $@@ 	 >> M	s   *1 +AAc                8    | j                   j                  |      S r   )r   finalize_schema)r  r   s     r   clean_schemazGenerateSchema.clean_schema  s    yy((00r   c                    |j                  di       }|j                  dg       }||vr|j                  |       ||d<   y )Nr?  r;  )r   
setdefaultappend)r  metadata_schemajs_functionr?  r;  s        r   _add_js_functionzGenerateSchema._add_js_function  sK    "&&z26 ( 3 34KR P
 33!((5&.
#r   c                    | j                  ||      }|| j                  |      }t        |      }|*t        || j                        }|r| j                  ||       t        | j                  j                  ||      }|S )aX  Generate core schema.

        Args:
            obj: The object to generate core schema for.

        Returns:
            The generated core schema.

        Raises:
            PydanticUndefinedAnnotation:
                If it is not possible to evaluate forward reference.
            PydanticSchemaGenerationError:
                If it is not possible to generate pydantic-core schema.
            TypeError:
                - If `alias_generator` returns a disallowed type (must be str, AliasPath or AliasChoices).
                - If V1 style validator with `each_item=True` applied on a wrong field.
            PydanticUserError:
                - If `typing.TypedDict` is used instead of `typing_extensions.TypedDict` on Python < 3.12.
                - If `__modify_schema__` method is used instead of `__get_pydantic_json_schema__`.
        )	'_generate_schema_from_get_schema_method_generate_schema_inner!_extract_get_pydantic_json_schemaresolve_original_schemar   r  r   r  r   )r  r  r   metadata_js_functionr  s        r   r  zGenerateSchema.generate_schema  s    0 ==c3G>005F@E+5fdiiHO%%o7KL=d>R>R>`>`begmnr   c                
   t               }| j                  j                  |      5 \  }}||cddd       S |j                  j	                  d      }|ot        |t              s_|d   dk(  r| j                  j                  |      }t        |      }|r$| j                  j                  |      cddd       S |cddd       S t        |j                  d      }| j                  j                  |      5  | j                  j                  |      5  | j                  j!                  |j"                        }|j$                  s||u rt'        |di       }	t'        |d	d      }
nhd|j                  vr%t)        |j"                  d
|j"                  d      	 t+        || j                  | j                  | j,                  xs i       \  }	}
|j2                  }|j4                  }t7        t9        |j:                  j=                         |j>                  j=                         |j@                  j=                               h |	jC                         |jC                                |jD                  j=                         }d}d}|j	                  d      dk(  r|
tG        |
jH                        }|tJ        vrtM        d      | jO                  |
jH                  d      \  }}|tP        ur| jS                  |      }tU        jV                  |      s| jS                  |      }t'        |di       j	                  d      }|jX                  rZ| j[                  d|	d   |      \  }}t]        ||d      }t_        j`                  |||t'        |dd      dt'        |dd      ||      }nt_        jb                  |	je                         D ci c]  \  }}|| jg                  |||       c}}|j=                         D cg c]  }| ji                  ||j>                          c}|||j"                        }tk        ||jl                  j=                               }t]        ||d      }t_        j`                  |||t'        |dd      dt'        |dd      ||      }| jo                  ||jp                  j=                               }t]        ||d      }| j                  j                  |      cddd       cddd       cddd       S # t.        $ r}t)        j0                  |      |d}~ww xY wc c}}w c c}w # 1 sw Y   nxY wddd       n# 1 sw Y   nxY wddd       y# 1 sw Y   yxY w)z%Generate schema for a Pydantic model.N__pydantic_core_schema__r   definitionsF)checkr   __pydantic_fields____pydantic_extra_info__zClass z is not defined)namemessager  r  r  extra_fields_behaviorallowzEThe type annotation for `__pydantic_extra__` must be `dict[str, ...]`Trequired__pydantic_generic_metadata__originrootinner__pydantic_custom_init____pydantic_post_init__)generic_origincustom_init
root_model	post_initconfigr>  )computed_fieldsextras_schemaextras_keys_schema
model_nameouter)9ru   r   get_schema_or_ref__dict__r   re  rw   unpack_definitionsr]   "create_definition_reference_schemarY   model_configr   pushr   r  core_configr   __pydantic_fields_complete__r   rF   ro   r   	NameErrorfrom_name_error__pydantic_decorators__r  r   r   field_validatorsrL  field_serializers
validatorskeysmodel_validatorsr4   
annotationr   rE    _get_args_resolving_forward_refsr,  r  r6   r  __pydantic_root_model___common_field_schemaapply_model_validatorsr/   model_schemamodel_fields_schemar   _generate_md_field_schema_computed_field_schemar   root_validators_apply_model_serializersmodel_serializers)r  r  
BaseModel_	model_refmaybe_schemar   r>  r  r
  r   
extra_infor  r   r  r  r   r  r   extra_keys_typeextra_items_typer  r   rC  r  r   r   dfields_schemas                               r   _model_schemazGenerateSchema._model_schema  s_   -/
YY((- {	L1J)\'#{	L {	L \\%%&@AF!*V^*L&>]2!YY99&AFfo99GGO{	L {	L "{	L {	L +3+;+;5IN++00@ kL$BSBSBXBXY\B] kL"22>>S\\>R33sj7H$S*?DF!(.G!NJ,CLL@ :!$&,S\\,<O$L T-A+/+?+?(,(9(9)-););)Ar	.*
 !88
","<"<,"33::<"44;;="--446
 >fkkm=o&:&:&<= $.#>#>#E#E#G  $%)"??#:;wF:Ka#J$9$9:B+;c 
 9=8]8]"--!% 9^ 95O%5 'c1-1-A-A/-R*)001AB(,(<(<=M(N9@Fegi9j9n9now9x..&*&?&?vXb&cOL!#9,HXZa#bL#.#;#;$'5$+C1KT$R#'")#/G"N*%	$L =H<[<[Y_YeYeYghQUQRTUD::1aLLh &5%;%;%=) ! !77:;W;WX) '4+=#&<<	=M $4M:C]C]CdCdCf#gL#9,HXZa#bL#.#;#;$'5$+C1KT$R#(")#/G"N*%	$L 66|ZEaEaEhEhEjk/8H'RyyCCFKWkL kL kL!{	L {	LZ % T9II!LRSSTj i)gkL kL kL kL kL!{	L {	L {	Ls   UA7U8U2U5UBT/4S=G6T/T$T/4#T*C
T/!	U*	U=	T!	T	T!	!T//T84U;	UU		UU"c                X    | j                   j                         }|t        dd      |S )Nz(`typing.Self` is invalid in this contextzinvalid-self-typer   )r   r   rG   r  s     r   _resolve_self_typez!GenerateSchema._resolve_self_typeu  s/    ##'');#$NUhii
r   c                <   t               }t        |dd       }t        |dd       |j                  j                  u }||s| j                  j                  |      5 \  }}||cd d d        S 	 d d d        ||u rd}nd} ||t        | j                  | |            }	|	d   dk(  r| j                  j                  |	      }	t        |	      }
|
r| j                  j                  |	      S |	S |t        |dd       x}d	d
lm} t        ||      r)t        j                  d|j                    dt"               nt        j                  dt$               t'        j(                   |       D cg c]  }t'        j*                  |       c}      S y y # 1 sw Y   "xY wc c}w )N__get_pydantic_core_schema__r:  unpackzto-def)ref_moder   r  __get_validators__r   r   zeMixing V1 models and V2 models (or constructs, like `TypeAdapter`) is not supported. Please upgrade `z` to V2.zc`__get_validators__` is deprecated and will be removed, use `__get_pydantic_core_schema__` instead.)ru   r   r,  r:  r   r  r|   r  r  r]   r  pydantic.v1r   rO  r   r   r   r  rP   r/   r  "with_info_plain_validator_function)r  r  r  r   
get_schemais_base_model_get_schemarC  r"  r.  r   r>  r  BaseModelV1r   s                 r   r  z6GenerateSchema._generate_schema_from_get_schema_method{  s   -/
S"@$G
J
D1Z5\5\5e5ee 	!
 " - ,,S1 (5Fa+'( (+( f}##4T5P5PRVaijF f~.55f=&/CyyCCFKK M>RTX1Y#Y:"f<#{+{|  }I  }I  |J  JR  S
 y- ++hrht,ucd[-[-[\]-^,uvv #g-( (F -vs   F'FFc                ,   	 t        j                  |g| j                   }t        |t              rt	        |j                  d|       | j                  rt        || j                        }|S # t        $ r}t	        j
                  |      |d }~ww xY w)Nz%Unable to evaluate forward reference )rX   eval_type_backportr  r  rF   r  re  r    __forward_arg__r   rt   )r  r  r  s      r   _resolve_forward_refz#GenerateSchema._resolve_forward_ref  s    	H223O9N9NOC
 c:&-c.A.AEjknjoCpqqT%7%78C
  	H-==a@aG	Hs    A/ /	B8BBc                     y r   r   )r  r  r  s      r   r  z/GenerateSchema._get_args_resolving_forward_refs  s    fir   c                     y r   r   r  s     r   r  z/GenerateSchema._get_args_resolving_forward_refs  s    TWr   c                     t        |      }|r/t        |t              r	d |D        }t         fd|D              }|S |rt	        d| d      |S )Nc              3  j   K   | ]+  }t        |t              rt        j                  |      n| - y wr   )re  r,  rX   _make_forward_ref).0as     r   	<genexpr>zBGenerateSchema._get_args_resolving_forward_refs.<locals>.<genexpr>  s+     f\]jC>P77:VWWfs   13c              3  d   K   | ]'  }t        |t              rj                  |      n| ) y wr   )re  r    r8  )r>  r?  r  s     r   r@  zBGenerateSchema._get_args_resolving_forward_refs.<locals>.<genexpr>  s,     h^_Az9R2215XYYhs   -0z	Expected z+ to have generic parameters but it had none)r3   re  r   r   r   )r  r  r  argss   `   r   r  z/GenerateSchema._get_args_resolving_forward_refs  s^    }#|,
 gaefhcghhD  iu,WXYYr   c                >    | j                  |      }|st        S |d   S )Nr   )r  r   )r  r  rB  s      r   _get_first_arg_or_anyz$GenerateSchema._get_first_arg_or_any  s#    44S9JAwr   c                    | j                  |      }|st        t        fS t        |      dk  rt        |      }t	        d| d      |d   |d   fS )Nr:   z Expected two type arguments for z, got 1r   rS   )r  r   lenr4   r   )r  r  rB  r  s       r   _get_first_two_args_or_anyz)GenerateSchema._get_first_two_args_or_any  s[    44S9:t9q=_F>vhgNOOAwQr   c                   t        j                  |      r| j                  |      }t        j                  t	        |            r| j                  |      S t        |t              r|S t        |t              rt        |      }t        |t              r | j                  | j                  |            S t               }t        ||      r6| j                  j                  |      5  | j!                  |      cd d d        S t        |t"              r t%        j&                  |j(                        S | j+                  |      S # 1 sw Y   JxY w)N)
schema_ref)r6   is_selfr*  is_annotatedr4   _annotated_schemare  r   r,  r    r  r8  ru   r}   r   r	  r(  rr   r/   definition_reference_schematype_ref
match_type)r  r  r   s      r   r  z%GenerateSchema._generate_schema_inner  s
   !!#&))#.C&&z#7))#..c4 Jc3S/Cc:&''(A(A#(FGG,.	c9-&&++C0 /))#./ / c/0::cllSSs##/ /s   $E  E	c                   |t         u rt        j                         S |t        u rt        j                         S |t
        u rt        j                         S |t        u rt        j                         S |t        u rt        j                         S |t        u rt        j                         S t        j                  |      s|t        u rt        j                          S |t"        j$                  u rt        j&                         S |t"        j"                  u rt        j(                         S |t"        j*                  u rt        j,                         S |t"        j.                  u rt        j0                         S |t2        u rt        j4                         S |t6        u rt        j8                         S |t:        u rt        j<                         S |t>        u r| jA                         S |tB        u rt        jD                         S ||tF        jH                  u rt        jJ                         S |tL        u rt        jN                         S |tP        v r| jS                  |      S |tT        v r| jW                  |      S |tX        v r| j[                  t\              S |t^        v r| ja                  t\              S |tb        v r| je                  t\              S |tf        v r| ji                  t\              S |tj        v r| jm                  |      S |tn        v r| jq                  t\        t\              S |tr        v r| ju                  |t\              S |tv        v r| jy                  t\              S |tz        v r| j}                  |t\        t\              S |t~        v r| j}                  |t\        t
              S t        j                  |      r| j                  |      S |t        u r| j                         S tG        j                  |      rt        j                         S t        j                  t        |            r| j                  |      S t        |      r| j                  |d      S t        j                  |      r!t        |t              r| j                  |      S tG        j                  |      r| j                  |d      S t        j                  |      r| j                  |j                        S |t        v r| j                  |      S tG        j                  |      r| j                         S t        |t        j                        r| j                  |      S tG        j                  |      r<|t        u rt        j                          S | j                  | j                  |            S t        |t              r| j                  |      S |t        u r| j                         S t        j                  |      r| j                  |d      S t        |      }|| j                  ||      S | j                  r| j                  |      S | j                  |      S )a  Main mapping of types to schemas.

        The general structure is a series of if statements starting with the simple cases
        (non-generic primitive types) and then handling generics and other more complex cases.

        Each case either generates a schema directly, calls into a public user-overridable method
        (like `GenerateSchema.tuple_variable_schema`) or calls into a private method that handles some
        boilerplate before calling into the user-facing method (e.g. `GenerateSchema._tuple_schema`).

        The idea is that we'll evolve this into adding more and more user facing methods over time
        as they get requested and we figure out what the right API for them is.
        N)kr,  r/   r}  r  r  r+  
int_schemar-  float_schemar   bool_schemacomplexcomplex_schemar6   r  objectr   datetimedatedate_schemadatetime_schematimetime_schema	timedeltatimedelta_schemar
   decimal_schemar&   uuid_schemar.   
url_schemar   r  r*   multi_host_url_schemarX   NoneTypenone_schemar(   missing_sentinel_schemar   r~  r   _tuple_schemar   r  r   r   r&  r   r)  r   _sequence_schemar   _iterable_schemar   r#  r   r  r   r  MAPPING_TYPESr  COUNTER_TYPESis_typealiastype_type_alias_type_schemar   _type_schemais_callablecallable_schema
is_literalr4   _literal_schemar5   _typed_dict_schemarM  isclassrO  r   rW  is_namedtuple_namedtuple_schema
is_newtyper  __supertype__r   _pattern_schemais_hashable_hashable_schemare  typingr"   _unsubstituted_typevar_schemais_finalvarr   rD  VALIDATE_CALL_SUPPORTED_TYPES_call_schemar'   _zoneinfo_schemadataclassesis_dataclass_dataclass_schema_match_generic_typer  r  r  )r  r  r  s      r   rO  zGenerateSchema.match_type  s3    #:))++E\++--CZ))++E\++--D[**,,G^--//""3'3&=))++HMM!**,,H%%%..00HMM!**,,H&&&//11G^--//D[**,,CZ))++H_((**L 4466[C=#9#99**,,'>6688H_??3''K%%c**J$$S))I##C(($$))#..N"((--N"((--J$$S#..J$$S#..K%%c**M!''S#66M!''S#66,,S1//44D[$$&&&&s+..00&&z#7'',,#**355__S!jd&; $$S))((-**355&&s+''(9(9::M!'',,&&s+((**V^^,55c::&&s+e|"--//''**3/  :;$$S))H_((** ##C())#t44C++C88  ..s33((--r   c                   t        j                  |      r| j                  ||      S t        j                  |      r| j                  ||      S | j                  ||      }||S t        j                  |      r| j                  |      S t        |      r| j                  |      S |t        v r| j                  |      S |t        v r | j                  | j!                  |            S |t"        v r | j%                  | j!                  |            S |t&        v r | j)                  | j!                  |            S |t*        v r | j,                  | j/                  |       S |t0        v r!| j3                  || j!                  |            S |t4        v r | j7                  | j!                  |            S |t8        v r" | j:                  |g| j/                  |       S |t<        v r&| j;                  || j!                  |      t>              S tA        |      r| jC                  ||      S |tD        v r| jG                  |      S |tH        v r | jK                  | j!                  |            S |tL        v r| jO                  |      S |tP        v r| jS                  |      S | jT                  r| jW                  |      S | jY                  |      S r   )-r  r  r  rX   rt  ru  r  r6   rk  rl  r9   _union_schemar   rf  r   r  rD  r   r&  r   r)  r   r#  rG  r   r  r   r  ri  r  rj  r+  r5   rr  r   _subclass_schemar   rg  r   rh  r   rx  r  r  r  )r  r  r  r   s       r   r  z"GenerateSchema._match_generic_type  s   
 ##F+))#v66&&v.**377==fcJM**62//44V$%%c**{"%%c**z!$$T%?%?%DEEy ##D$>$>s$CDD''))$*D*DS*IJJz!$4$$d&E&Ec&JKKz!$$VT-G-G-LMM{"%%d&@&@&EFF}$'4''V1P1PQT1UVV}$''0J0J30OQTUU&!**377z!((--~%(()C)CC)HII~%((--}$'',,  ..v66((--r   Tr  c          	         | j                  |||      \  }}t        j                  ||j                         sdn||j                  t        |j                        |j                  |j                  |      S )zAPrepare a TypedDictField to represent a model or typeddict field.F)r  serialization_excluder   r   serialization_exclude_ifr?  )	r  r/   typed_dict_fieldis_requiredr   _convert_to_aliasesr   r   
exclude_if)r  r  
field_infor   r  r   r?  s          r   _generate_td_field_schemaz(GenerateSchema._generate_td_field_schema  so      44T:zR++","8"8":U","4"401L1LM * > >%/%:%:
 	
r   c           	         | j                  |||      \  }}t        j                  ||j                  t	        |j
                        |j                  |j                  |j                  |      S )z0Prepare a ModelField to represent a model field.)r  r   r   r  r   r?  )	r  r/   model_fieldr   r  r   r   r  r   r  r  r  r   r   r?  s         r   r  z(GenerateSchema._generate_md_field_schema  sh      44T:zR&&","4"401L1LM * > >%/%:%:$$
 	
r   c                0   | j                  |||      \  }}t        j                  |||j                  |j                  xs d|j
                  rdnd|j                  t        |j                        |j                  |j                  |j                  |      S )zJPrepare a DataclassField to represent the parameter/field, of a dataclass.NF)	r   	init_onlyr   r  r   r   r  r   r?  )r  r/   dataclass_fieldr   r   r   r   r  r   r   r  r   r  s         r   _generate_dc_field_schemaz(GenerateSchema._generate_dc_field_schema  s      44T:zR** ))1T&..DE","4"401L1LM * > >%/%:%:$$
 	
r   c                    j                   j                  }}d fd}t        |j                  j	                         |      D cg c].  }t
        |j                  j                     j                  |      0 }} j                  j                  |      5  j                   j                  |||z   |      }	n j                  |||z         }	d d d        t        |j                  j	                         |      }
t        |
      rd_        |
D cg c]  }|j                  j                   du s| }}|
D cg c]	  }||vs| }
}t#        	|      }	t%        |	|
      }	j'                         st)        |	      }	 j+                  |	t        |j,                  j	                         |            }	t/              \  }}i }t1        |||       |	|fS c c}w # 1 sw Y   xY wc c}w c c}w )Nc                @    j                  | j                        } | S r   )r  r  )r   r  r  s    r   set_discriminatorz>GenerateSchema._common_field_schema.<locals>.set_discriminator  s     77
@X@XYFMr   )transform_inner_schemaTpydantic_js_updatespydantic_js_extrar   r)   rI  r)   )r  r?  r   r  rL  r   r   rf  _from_decoratorr   r	  r  _apply_annotationsr  $_validators_require_validate_defaultr   	each_itemr   r   r  wrap_default_apply_field_serializersr  r   r\   )r  r  r  r   source_typer   r  	decoratorvalidators_from_decoratorsr   this_field_validatorsr   r   r  r  core_metadatas   ` `             r   r  z#GenerateSchema._common_field_schema  s    $.#8#8*:M:M[	 B*B]B]BdBdBfhlm&
 y~~223CCIN&
" &

 ""''- 		''300/I!Ibs 1  00"<<		 !EZEZEZEaEaEcei j/0EF*.J'+@]aAFFDTDTX\D\]],A cqQNbEb c c+F4HI!&*?@
 %%'!*f5F..89U9U9\9\9^`de
 2[[e1f..(*/BVg	
 }$$[&

		 		$  ^ cs*   3G:GG(2G(<	G-G-G%c                   | j                  |d      }g }d}|D ]9  }||t        j                  u rd}|j                  | j	                  |             ; t        |      dk(  r|d   }ntg }|D ]X  }t        t        |j                  di             j                  d      }	|	|j                  ||	f       H|j                  |       Z t        j                  |      }|rt        j                  |      }|S )zGenerate schema for a Union.Tr  FrS   r   r?  pydantic_internal_union_tag_key)r  rX   rc  r  r  rF  r$   r[   r   r/   r  nullable_schema)
r  
union_typerB  choicesr   argschoices_with_tagschoicetags
             r   r  zGenerateSchema._union_schema-  s    44Z$4O$& 	:C{c]%;%;;t33C89		: w<1
AKM! 5<J)CDHHIjk?%,,fc];%,,V45 (():;A++A.Ar   c                J   | j                   j                  |      5 \  }}||cd d d        S t        |      xs |}t        |      }| j                  j                  |      5  	 t        j                  |j                  g| j                   }t        ||      }| j                  |      }|d   dk7  sJ ||d<   d d d        | j                   j                        cd d d        S # t        $ r}t        j                  |      |d }~ww xY w# 1 sw Y   TxY w# 1 sw Y   y xY w)Nr   r  r>  )r   r  r4   rs   r   r	  rX   	eval_type	__value__r  r  rF   r  rt   r  r  )	r  r  r>  r"  r  r  r  r  r   s	            r   rl  z&GenerateSchema._type_alias_type_schemaH  s-   YY((- 	H1D#|'#	H 	H %/sO$:sF4S9L""''/ $P!.!8!89I9I!bDLaLa!bJ +:|D
--j9f~666 #u$ 99??G!	H 	H ! P5EEaHaOP$ $	H 	HsL   D5D"D$*C&,D:"D&	D
/DD

DD	DD"c                    t        t        |dd            }|s
J d|        t        j                  |      }| j                  j
                  r)t        d |D              rt        j                  d |      }|S )zGenerate schema for a Literal.Feager)
type_checkunpack_type_aliasesz(literal "expected" cannot be empty, obj=c              3  <   K   | ]  }t        |t                y wr   )re  r   )r>  r   s     r   r@  z1GenerateSchema._literal_schema.<locals>.<genexpr>a  s     7^PQ
1d8K7^s   c                >    t        | t              r| j                  S | S r   )re  r   r@  )r   s    r   r1  z0GenerateSchema._literal_schema.<locals>.<lambda>c  s    Z4%8!'' a r   )rJ  r8   r/   literal_schemar  rR  anyrS  )r  literal_typeexpectedr   s       r   rq  zGenerateSchema._literal_schema[  su    *<E_fghRCL>RRx++H5//C7^U]7^4^ AA?F r   c                
   t               }| j                  j                  |      5  | j                  j	                  |      5 \  }}||cddd       cddd       S t        |      }||}t        s%t        |      j                  dk(  rt        dd      	 t        |d      }| j                  j                  |      5  | j                  j                  |j                        }|j                   }	i }
t#        j$                  |d	      }|j'                  | j                         | j                  j(                  rt+        |d
      }nd}	 t-        j.                  || j0                        }g }|j9                         D ]  \  }} |j:                  |t<        j>                        }tA        |jB                  |      |_!        ||	v xs d|jD                  v xr d|jD                  v}d|jD                  v r|jG                  |       ||jH                  ||v r
||   |_$        tK        | j                  ||       | jM                  ||||      |
|<    |r_djO                  d |D              }tQ        |      dk\  }tS        jT                  d|rdnd d| d|j                  d|rdnd d	tV               d}d}tY        t[        |dd            }t[        |dt\        j^                        }|rd }d}n2ta        jb                  |      sd!}| je                  tA        ||            }| j                  jf                  x}d"v rw|r/|d!k(  r*tS        jT                  d#|jh                  d$tj        %       nFta        jb                  |      s/|d k(  r*tS        jT                  d#|jh                  d&tj        %       n|}tm        jn                  |
||jp                  js                         D cg c]  }| ju                  ||jv                          c}||||'      }| jy                  ||jz                  js                               }t}        ||j~                  js                         d(      }| j                  j                  |      cddd       cddd       cddd       S # t        $ r d}Y w xY w# t2        $ r}t5        j6                  |      |d}~ww xY wc c}w # 1 sw Y   nxY w	 ddd       n# 1 sw Y   nxY wddd       y# 1 sw Y   yxY w))a,  Generate a core schema for a `TypedDict` class.

        To be able to build a `DecoratorInfos` instance for the `TypedDict` class (which will include
        validators, serializers, etc.), we need to have access to the original bases of the class
        (see https://docs.python.org/3/library/types.html#types.get_original_bases).
        However, the `__orig_bases__` attribute was only added in 3.12 (https://github.com/python/cpython/pull/103698).

        For this reason, we require Python 3.12 (or using the `typing_extensions` backport).
        Nr{  zXPlease use `typing_extensions.TypedDict` instead of `typing.TypedDict` on Python < 3.12.ztyped-dict-versionr   __pydantic_config__r  Freplace_wrapped_methodsT)use_inspectr  _sourcer  not_required	read_onlyr  , c              3  2   K   | ]  }t        |        y wr   r   )r>  fs     r   r@  z4GenerateSchema._typed_dict_schema.<locals>.<genexpr>  s     +MDG+M   r:   Itemr  r    z on TypedDict class areiszk using the `ReadOnly` qualifier. Pydantic will not protect items from any mutation on dictionary instances.r  
__closed____extra_items__forbidr  )r  r  zTypedDict class zk is closed, but 'extra' configuration is set to `'allow'`. The 'extra' configuration value will be ignored.r  zu allows extra items, but 'extra' configuration is set to `'forbid'`. The 'extra' configuration value will be ignored.)r  r  extra_behaviorr   r>  r  all)Arv   r   r	  r   r  rs   _SUPPORTS_TYPEDDICTr   r   rG   rh   AttributeErrorr   r  r
  r   __required_keys__ra   buildupdate_from_configuse_attribute_docstringsrl   rX   get_cls_type_hintsr   r  rF   r  r   from_annotationr7   
TYPED_DICTrt   r  _qualifiersr  r   rq   r  joinrF  r   r   r  r   r   typing_extensionsNoExtraItemsr6   is_noextraitemsr  extrar   rQ   r/   typed_dict_schemar  rL  r  r  r  r  r  r  r  )r  typed_dict_clsr  r   typed_dict_refr"  r  r  r
  required_keysr   r   field_docstringsr   r  readonly_fields
field_namer  r  r  fields_reprpluralr  r   	is_closedextra_itemsconfig_extrar&  	td_schemar   s                                 r   rr  z!GenerateSchema._typed_dict_schemah  sO    -.	 !!&&~6}	LII''7}	L< '#}	L }	L }	L 5^DL!!'&4+?+J+Jh+V'n- 
 -E^Uj,k ++008 bL"22>>^E\E\>]0>0P0P@B+11.Z_`
--d.B.BC''@@'B>_c'd$'+$P"/"B"B>_c_p_p"qK .0.9.?.?.A *J
!:!:!::O_OjOj!kJ,9*:O:OQ],^J) #m3[zZE[E[7[ G(
0F0FF  #j&<&<<'..z: )4&22:&*::1A*1M
.,T-A-A:zZ)-)G)G"J
X *H *F:&%, #"&))+M_+M"MK 1Q6FMMfs"5Q{mCWXfXoXoWrrs$*55 6EE $	 =E37 !u!MN	%n6GIZIgIgh%-N$(M'77D%,N$($8$8{T`9a$bM$($8$8$>$>>LCVV \W%< .~/J/J.M Nd d%@
 ,;;KH\]eMe .~/J/J.M Ne e%@ *6'99& ",!;!;!B!B!D% 33Az7S7ST% $2"/&&	 66y*B^B^BeBeBgh/
8S8S8Z8Z8\^cdyyCCFKEbL bL7}	L }	L }	L0 " ( ! P5EEaHaOPJ%mbL bL bL7}	L }	L }	L }	L }	L }	Ls   S<S'		S<:S'R#S'>BS!R%-I2S#SA5S7	S' 	S<R"S'!R""S'%	S		.S	S			SSS'	S<'S0	,S<<Tc                   | j                   j                  |      5  | j                  j                  |      5 \  }}||cddd       cddd       S t	        |      }||}	 t        j                  || j                        }|j                  D ci c]  }||j                  |t               }}|r-|j                         D 	ci c]  \  }}	|t        |	|       }}}	t!        j"                  |j                         D 	cg c]P  \  }}	| j%                  ||	t&        j(                  |j*                  j                  |t,        j.                              R c}	}ddi      }
t!        j0                  |
||      }| j                  j3                  |      cddd       cddd       S # t        $ r}t        j                  |      |d}~ww xY wc c}w c c}	}w c c}	}w # 1 sw Y   nxY wddd       y# 1 sw Y   yxY w)z!Generate schema for a NamedTuple.Nr  )r  r   'pydantic_js_prefer_positional_argumentsTrH  )r>  )r   r	  r   r  rs   rX   r  r   r  rF   r  _fieldsr   r   r   rt   r/   arguments_schema_generate_parameter_schemar7   NAMED_TUPLE_field_defaultsr   emptycall_schemar  )r  namedtuple_clsr  namedtuple_refr"  r  r   r  r  r  r  r   s               r   ru  z!GenerateSchema._namedtuple_schema  s    !!&&~6*	HII''7*	H< '#*	H *	H *	H 5^DL!!'L+>>~[_[l[lm [iZpZpqJ:{z3'GGqKq 3>2C2C2E.
J j, GG 
  +;; 3>2C2C2E /
J 33""/;; . > > B B:y _	 4  DTJ  !,,-=~SabF99??GU*	H *	H *	H  L1AA!D!KL r=*	H *	H *	H *	H *	Hsv   G5G 	G5G "!F(G G/G G
%G AG>G 	G5(	G1GGG  G)	%G55G>c                   t               }|t        j                  u r |j                  ||      }n |j                  |||      }|j
                  J d       t        | j                  ||       | j                  j                  |      5  | j                  |j
                  |gd      }ddd       |j                         st        |      }t        j                  ||t        |j                               }	|	S # 1 sw Y   SxY w)zGenerate the definition of a field in a namedtuple or a parameter in a function signature.

        This definition is meant to be used for the `'arguments'` core schema, which will be replaced
        in V3 by the `'arguments-v3`'.
        r  Nz<field.annotation should not be None when generating a schemaF'check_unsupported_field_info_attributes)rf  r   )rv   r   r  r  from_annotated_attributer  rq   r  r   r	  r  r  r  r/   arguments_parameterr  r   )
r  r  r  r  r   rf  r   r   r   parameter_schemas
             r   r  z)GenerateSchema._generate_parameter_schema!  s    -.	ioo%-I--j&IE6I66z7TZ[E+k-kk+ !5!5tUC""''- 	,,   9> - F	   "!%0F&::%e&<&<=	
  )	 	s    C>>Dc                   t               }|t        j                  u r |j                  ||      }n |j                  |||      }t        | j                  ||       | j                  j                  |      5  | j                  |j                  |gd      }ddd       |j                         st        |      }t        j                  ||t        |j                               }	|	S # 1 sw Y   SxY w)zGenerate the definition of a parameter in a function signature.

        This definition is meant to be used for the `'arguments-v3'` core schema, which will replace
        the `'arguments`' schema in V3.
        r  Fr  N)r  r   rf  r   )rv   r   r  r  r  rq   r  r   r	  r  r  r  r  r/   arguments_v3_parameterr  r   )
r  r  r  r  rf  r   r   r   r   r  s
             r   _generate_parameter_v3_schemaz,GenerateSchema._generate_parameter_v3_schemaN  s    ( -.	ioo%-I--j&IE6I66z7TZ[E !5!5tUC""''- 	,,   9> - F	   "!%0F&==%e&<&<=	
  )	 	s   9 C++C4c                ^   t        |      | j                  |      }r|rt        fd|D              }|sG|t        v r*t	        j
                  t	        j                         gd      S t	        j
                  g       S |d   t        u rCt        |      dk(  r*t	        j
                  | j                  |d         gd      S t        d      t        |      dk(  r|d   dk(  rt	        j
                  g       S t	        j
                  |D cg c]  }| j                  |       c}      S c c}w )	zIGenerate schema for a Tuple, e.g. `tuple[int, str]` or `tuple[int, ...]`.c              3  6   K   | ]  }t        |        y wr   )rt   )r>  paramr  s     r   r@  z/GenerateSchema._tuple_schema.<locals>.<genexpr>  s     R%==Rs   r   )r   r   r:   z&Variable tuples can only have one typerS   r   )rs   r  r   r   r/   tuple_schemar   EllipsisrF  r  
ValueError)r  
tuple_typeparamsr  r  s       @r   rf  zGenerateSchema._tuple_schema  s    1<66zBFR6RRF [("//1G1G1I0J`abb #//33BZ8#6{a"//1E1EfQi1P0Qghii !!IJJ[A&)r/ ++B//++V\,]UT-A-A%-H,]^^,]s   D*c                `    t        j                  t        j                  t              dd      S )Nis_typezInput should be a typer  )r/   custom_error_schemarT  r   r  s    r   rm  zGenerateSchema._type_schema  s)    ..**40'!9
 	
r   c                n    ddl m} dd gi}t        j                  |t        j                         |      S )z/Generate schema for a zone_info.ZoneInfo objectrS   )validate_str_is_valid_iana_tzr;  c                    dddS )Nro  zoneinforp  r   r  s     r   r1  z1GenerateSchema._zoneinfo_schema.<locals>.<lambda>  s    hZd=e r   r   r?  )ry  r  r/   r{  r  )r  r  r?  s      r   r  zGenerateSchema._zoneinfo_schema  s8    >+.e-fg;;)%::<
 	
r   c           	         | j                  |d      }t        j                  |D cg c]  }| j                  t        |          c}      S c c}w )z*Generate schema for `type[Union[X, ...]]`.Tr  )r  r/   r  r  r   )r  r  rB  s      r   _union_is_subclass_schemaz(GenerateSchema._union_is_subclass_schema  sF    44Z$4O''VZ([d)=)=d4j)I([\\([s   Ac           
        | j                  |      }t        j                  |      xs |}t        j                  |      r| j                         S t        j                  |      r"| j                  t        |j                           S t        j                  |      r|j                  rXt        t        |j                              r| j                  |j                        S t        j                   |j                        S |j"                  rCt        j$                  |j"                  D cg c]  }| j                  t        |          c}      S | j                         S t        t        |            r| j                  |      S t        j&                  |      r| j)                  |      }t        j*                  |      r0t-        d|dt/        j0                  t        |             dd      t3        j4                  |      s3|#t        j                   t        j6                        S t9        d|      t        j                   |      S c c}w )z-Generate schema for a type, e.g. `type[int]`.z`Subscripting `type[]` with an already parametrized type is not supported. Instead of using type[z], use type[z].Nr   zExpected a class, got )rD  rX   annotated_typer6   r  rm  rk  r  r   r  
is_typevar	__bound__r9   r4   r  r/   is_subclass_schema__constraints__r  rJ  r*  is_generic_aliasrG   rW   display_as_typerM  rs  rc  r   )r  type_
type_paramcs       r   r  zGenerateSchema._subclass_schema  s   //6
 #11*=K
  ,$$&&,,Z8''Z-A-A(BCC&&z2##":j.B.B#CD99*:N:NOO"55j6J6JKK++"//XbXrXr0sST1E1Ed1g1N0stt((**Z
3411*==%%j1!44Z@
--j9'--7N,uG\G\]ghr]sGtFuuwy 
 ??:. %&99-:P:PQQ"8 GHH11*==) 1ts   )Ic                   ddl m} | j                  |      }t        j                  |      }t        |      }t        j                  t        j                  d      }t        j                  |      s1ddlm} t        j                  |t        j                  ||      g      }t        j                  ||d      }t        j                   |||      S )	z5Generate schema for a Sequence, e.g. `Sequence[int]`.rS   r  Sequencer  )sequence_validatorTr  )r6  rj  r   )r  r  r  r/   r  r~   rT  r{  r(  r6   r  ry  r)  r  r  r  r|  )	r  r  r  r  r  r6  rj  r)  r   s	            r   rg  zGenerateSchema._sequence_schema  s    =//
;!--.>?$[1#66vQ[\$$Z07'44 K KL^`k lmM $GG'0@4
 00#=P]
 	
r   c                l    | j                  |      }t        j                  | j                  |            S )z$Generate a schema for an `Iterable`.)rD  r/   generator_schemar  )r  r$  	item_types      r   rh  zGenerateSchema._iterable_schema  s.    ..u5	++D,@,@,KLLr   c                   ddl m} dd gi}t        j                  t	        d      dt        j
                               }|t        j                  u s|t        j                  u r"t        j                  |j                  ||      S | j                  |d	
      d   }|t        u r"t        j                  |j                  ||      S |t        u r"t        j                  |j                  ||      S t!        d|d      )NrS   )ry  r;  c                    dddS )Nro  regexrp  r   r  s     r   r1  z0GenerateSchema._pattern_schema.<locals>.<lambda>  s    hZa=b r   patternr   )r   return_schemar  Tr  r   r  r   )r   ry  r/   r   r   r}  r{  Patternrer{  pattern_either_validatorr  r,  pattern_str_validatorr  pattern_bytes_validatorrE   )r  pattern_typery  r?  serr  s         r   rx  zGenerateSchema._pattern_schema  s   !+.b-cd>>y!V;CYCYC[
 6>>)\RZZ-G??44CRZ  55 6 
  C<??11x  e^??333QY  02^_k^nno0pqqr   c           
     V   t        j                  t        j                  t        j                  t        j                         t        j
                  t        j                  j                        g      t        j
                  t        j                  j                              dd      S )Nri  ry  zInput should be hashable)r   r  r  )	r/   r  r|  r  r   rT  r  abcHashabler  s    r   rz  zGenerateSchema._hashable_schema  sy    ..44'44 ++-{/M/MkooNfNf/gh *<<[__=U=UV	 ,!;	
 		
r   c                @
     j                   j                  |      5   j                  j                  |      5 \  }}||cddd       cddd       S |j                  j                  d      }|t        |t              sq|d   dk(  r j                  j                  |      }t        |      }|r- j                  j                  |      cddd       cddd       S |cddd       cddd       S t        |      }||}t        |dd      }ddlm}	  j                  j                  |      5   j                   j                  |      5   |	|      r|j#                         rk|j$                  j'                         D 
ci c]  \  }
}|
t)        |       }}
}|rt|j+                         D ]  } |j,                  |g j.                    ! nA	 t1        | j2                   j                  |xs i       }nt;        || j2                  	      } j2                  j<                  d
k(  r7|j'                         D ]$  \  }}|j>                  du stA        d| dd       |j                  j                  d      2tC        jD                  |d      jG                   j2                         tI         fd|j'                         D        d       }tK        |d      }tK        |d      }tM        jN                  |jP                  |jR                  j+                         D cg c]  } jU                  |jV                          c}|      }tY        |jZ                  j+                               }j\                  j+                         }t_        ||d      } j2                  ja                  |jP                        }tM        jb                  |||||t        jd                  |      D cg c]  }|jf                   c}|| j                   jh                  jj                  	      } jm                  |jn                  j+                               }t_        ||d      } j                  j                  |      cddd       cddd       cddd       cddd       S c c}}
w # t4        $ r}t7        j8                  |      |d}~ww xY wc c}w c c}w # 1 sw Y   nxY wddd       n# 1 sw Y   nxY wddd       n# 1 sw Y   nxY wddd       y# 1 sw Y   yxY w)z Generate schema for a dataclass.Nr  r   r  r  r:   )is_pydantic_dataclassr  )r  r  r  FzField zd has `init=False` and dataclass has config setting `extra="allow"`. This combination is not allowed.z dataclass-init-false-extra-allowr   r  r  c              3  J   K   | ]  \  }}j                  ||        y wr   )r  )r>  r   r   r   r  s      r   r@  z3GenerateSchema._dataclass_schema.<locals>.<genexpr>s  s$     a$!QT33Aq*Eas    #c                (    | j                  d      duS )Nr   F)r   )r?  s    r   r1  z2GenerateSchema._dataclass_schema.<locals>.<lambda>t  s    !%%	"2%"? r   )key__post_init__	__slots__)r  collect_init_onlyr  r  )r  r  r>  r   slotsr  r   r  )8r   r	  r   r  r  r   re  rw   r  r]   r  rs   r   r  r=  r   r   r  r  r   r	   rL  apply_typevars_mapr  rn   r  r  rF   r  rm   r  r   rG   ra   r  r  sortedhasattrr/   dataclass_args_schemar   r  r  r  r   r  r  r  r
  dataclass_schemar   r  r  r   r  r  )r  	dataclassr  dataclass_refr"  r   r>  r  r  r=  f_namer  r   r   r  r  rB  has_post_init	has_slotsr&  args_schemar   r  r
  	dc_schemar   s   `                        @r   r  z GenerateSchema._dataclass_schema!  s   
 !!&&y1t	LII''	2t	L7 '#t	L t	L t	L ''++,FGF!*V^*L&>]2!YY99&AFfo99GGO!t	L t	L t	L$ "%t	L t	L t	L( 5Y?L!"	
 Y(=tDF;""''	2 ULD4N4N4S4STZ4[ UL(3 ==? PYOlOlOrOrOt"9KFD$44" " ()/ _ 8 8 8 ^H]H] ^_X%= )/3/C/C,0,=,=-9-?R	&F 6!%1'+';';F ''--8-3\\^ )
E ::."3"( 5C !D%G#  '//334MN
%!/!5!5iY^!_J11$2F2FG aRXR^R^R`a? !(	? C#I{;	)??&& ",!;!;!B!B!D% 33Az7S7ST% '4  0Z=W=W=^=^=`a#-#>#>#E#E#G 5lDTV]^"22>>YEWEW>X'88 #)+%4?4F4Fy4QR5EJJR#&  55::AA	 66y*B^B^BeBeBgh/8H'RyyCCFKkUL UL UL?t	L t	L t	LL"  ) X"="M"Ma"PVWWXF%( SYUL UL UL UL UL?t	L t	L t	L t	L t	L t	Ls   TS?	TA7S?	TS?	T2=S?/S*6S	R8S	'R$7AS	CS	$#SB%S	,S?A:S	9	S*	S?	TS	$	S-SSS	SS*!	S?*S3/S?6	T?T	TTc                `   | j                  |      }d}| j                  }|j                  rlt        j                  |      }|j
                  }||j                  ur=| j                  \  }}t        j                  |||dh      }	| j                  |	d         }t        j                  |||      S )zsGenerate schema for a Callable.

        TODO support functional validators once we support them in Config
        NrI  )globalnslocalnsinclude_keys)r1  )_arguments_schemar  validate_returnrX   signature_no_evalreturn_annotationr  r  get_function_type_hintsr  r/   r  )
r  functionr  r1  r  sigreturn_hintrR  rS  
type_hintss
             r   r  zGenerateSchema._call_schema  s    
  11(;7;--))11(;C//K#))+$($9$9!'*BBxPXz
 !% 4 4Z5I J&&'
 	
r   c                   t         j                  dt         j                  dt         j                  di}t	        j
                  |      }| j                  \  }}t	        j                  |||      }g }d}	d}
d}t        |j                  j                               D ]9  \  }\  }}|j                  |j                  u rt        j                  t        t              }n||   }| ||||      }|dk(  rX|j!                  |j"                        }|?| j%                  ||t&        j(                  |j*                  |      }|j-                  |       |j"                  t         j.                  k(  r| j1                  |      }	|j"                  t         j2                  k(  sJ |j"                         t	        j4                  |      }|t7        |      xs |}t9        |      st;        d|d	      |j                  j                         D ch c]%  \  }}|j"                  t         j                  k7  s$|' }}}|j=                  |j>                        }|rOt;        d
|j@                  dtC        |      dk\  rdnd ddjE                  d tG        |      D               d	      d}| jI                  |t7        |            }
'd}| j1                  |      }
< tK        jL                  ||	||
| jN                  jP                        S c c}}w )z Generate schema for a Signature.positional_onlypositional_or_keywordkeyword_onlyrR  rS  Nskip7Expected a `TypedDict` class inside `Unpack[...]`, got unpack-typed-dictr   Typed dictionary  overlaps with parameterr:   r  r   r  r  c              3  2   K   | ]  }t        |        y wr   r  r>  ps     r   r@  z3GenerateSchema._arguments_schema.<locals>.<genexpr>       (UQa(Ur  overlapping-unpack-typed-dictzunpacked-typed-dictuniform)var_args_schemavar_kwargs_modevar_kwargs_schemavalidate_by_name))r   POSITIONAL_ONLYPOSITIONAL_OR_KEYWORDKEYWORD_ONLYrX   rW  r  rY  	enumerate
parametersr   r  r  r{  r$   r   r   kindr  r7   FUNCTIONr   r  VAR_POSITIONALr  VAR_KEYWORDunpack_typer4   r5   rG   intersection__annotations__r   rF  r  rF  rr  r/   r  r  rq  )r  rZ  parameters_callbackmode_lookupr[  rR  rS  r]  arguments_listrn  rp  ro  ir  rj  r  resultparameter_mode
arg_schemar{  r  non_pos_only_param_namesoverlapping_paramss                          r   rU  z GenerateSchema._arguments_schema  s   
 %%'8++-D""Nr
 --h7 11'"::8h`gh
?A9=;?<@%cnn&:&:&<= .	ILAya||syy(#[[c2
'-
".,QjAV#(__QVV4N)!<<*&6&?&?N
 %%j19333"&"6"6z"Bvv!6!66>>6+77
C*'4CF'//UVaUde!4 
 -0NN,@,@,B0!(qaffPYPiPiFi0, 0 *B)N)NvOeOe)f&)///BBZ&)*<&=&BsK1#yy(U&AS:T(UUVX "A	  '<O(,(?(?ZXcMd(e%&/O(,(<(<Z(H%].	I` ++++/!11BB
 	
%0s   	%L/Lc                   t         j                  dt         j                  dt         j                  dt         j                  di}t        j                  |      }| j                  \  }}t        j                  |||      }g }t        |j                  j                               D ]  \  }	\  }
}| ||	|
|j                        }|dk(  r&|j                  t         j                  u rt        j                  t         t               }n||
   }|j#                  |j$                        }|,|j$                  t         j&                  k(  sJ |j$                         t        j(                  |      }|t+        |      xs |}t-        |      st/        d|d	      |j                  j                         D 
ch c]%  \  }
}|j$                  t         j                  k7  s$|
' }}
}|j1                  |j2                        }|rOt/        d
|j4                  dt7        |      dk\  rdnd ddj9                  d t;        |      D               d	      d}|}nd}|j=                  | j?                  
|t@        jB                  |jD                                tG        jH                  || jJ                  jL                        S c c}}
w )Nr_  r`  var_argsra  rb  rc  rd  re  r   rf  rg  r:   r  r   r  r  c              3  2   K   | ]  }t        |        y wr   r  ri  s     r   r@  z6GenerateSchema._arguments_v3_schema.<locals>.<genexpr>0  rk  r  rl  var_kwargs_unpacked_typed_dictvar_kwargs_uniform)r   )rq  )'r   rr  rs  ry  rt  rX   rW  r  rY  ru  rv  r   r  r  r{  r$   r   r   rw  rz  r{  r4   r5   rG   r|  r}  r   rF  r  rF  r  r	  r7   rx  r   r/   arguments_v3_schemar  rq  )r  rZ  r~  r  r[  rR  rS  r]  parameters_listr  r  rj  r  r  r  r{  r  r  r  s                      r   _arguments_v3_schemaz#GenerateSchema._arguments_v3_schema  s    %%'8++-D$$j""N	
 	 --h7 11'"::8h`gh
BD%cnn&:&:&<= +	LAya".,QallCV#||y.#[[c2
'-
(__QVV4N%vv!6!66>>6+77
C*'4CF'//UVaUde!4 
 -0NN,@,@,B0!(qaffPYPiPiFi0, 0 *B)N)NvOeOe)f&)///BBZ&)*<&=&BsK1#yy(U&AS:T(UUVX "A	  &FN!,J%9N""22*&6&?&?YZYbYb 3 O+	Z ..!11BB
 	
-0s   4%J?J?c                v   	 |j                         }|r| j                  |j                        S |j                  x}r"| j                  t        j                  |         S |j                  x}r+| j                  |      }t        j                  d      |d<   |S t        j                         S # t        $ r Y w xY w)Nr  r   )has_defaultr  __default__r  r!  r  r{  r#   r  r/   rP  r   )r  typevarr  constraintsr   r   s         r   r|  z,GenerateSchema._unsubstituted_typevar_schemaC  s    	A!--/K
 ++G,?,?@@!111;1%%fll;&?@@%%%5%))%0F&1&C&CE&JF?#M%%''  		s   B, ,	B87B8c                J   |j                   j                  t        ur|j                   j                  }n6	 t        j                  |j
                  | j                  j                        }|t        u rt        dd      t        || j                        }t        j                  |j                   |      |_         | j!                  |      }| j#                  |t%        |j'                         |j(                              }t+        |j                         \  }}i }t-        |ddi|r|ni |       |j                   j.                  }	t1        j2                  |j(                  ||j                   j4                  |	|	      S # t        $ r}t        j                  |      |d }~ww xY w)
NrS  zComputed field is missing return type annotation or specifying `return_type` to the `@computed_field` decorator (e.g. `@computed_field(return_type=int | str)`)zmodel-field-missing-annotationr   )return_typereadOnlyTr  )r1  r   r  r?  )r   r  r-   rT   get_callable_return_typefuncr  localsr  rF   r  rG   rt   r   r  replacer  r  r   rL  r   r   r\   r  r/   computed_fieldr   )
r  r&  r  r  r  return_type_schemar  r  r  r  s
             r   r  z%GenerateSchema._computed_field_schemaW  s   
 66%66&&,,KL *BB166SWShShSoSop ++#f5  $K1C1CD $$QVVE!11+>!::01B1I1I1KQ^^\

 2[[\[a[a1b..(*!+T jM`6Ifh j/	

 VV&&
))NN,&&,,%/"
 	
;  L1AA!D!KLs   5E> >	F"FF"c                    t               }| j                  |d      ^}}| j                  ||      }|D ]  }t        ||      st	        ||      } |S )zdGenerate schema for an Annotated type, e.g. `Annotated[int, Field(...)]` or `Annotated[int, Gt(0)]`.Tr  )rv   r  r  re  r  )r  r  r   r  r   r   r  s          r   rL  z GenerateSchema._annotated_schema  sm    ,.	$($I$I %J %
!k ((kB & 	:J*i0%j&9	: r   c                    | S r   r   r/  s    r   r1  zGenerateSchema.<lambda>  s    q r   c                B    t        t        j                  |            }g }d fd}t        |       }|D ]  }| j	                  ||||      }  |      }	|r|	j                  di       }
t        |
|       t         j                  j                  |	      S )a  Apply arguments from `Annotated` or from `FieldInfo` to a schema.

        This gets called by `GenerateSchema._annotated_schema` but differs from it in that it does
        not expect `source_type` to be an `Annotated` object, it expects it to be  the first argument of that
        (in other words, `GenerateSchema._annotated_schema` just unpacks `Annotated`, this process it).
        c                    j                  |       }|j                  |       }t        |       }|*t        |j                        }|j                  ||        |      S r   )r  r  r  r  r   r  )r  r   r  r  r  r  r  s       r   inner_handlerz8GenerateSchema._apply_annotations.<locals>.inner_handler  sm    AA#{SF~44S9#DS#I #/"9&$))"L".))/;OP)&11r   r  r?  ) pydantic_js_annotation_functionsr  r   rI  r)   )
rJ  rV   expand_grouped_metadatar|   _get_wrapped_inner_schemar  r\   r   r  r   )r  r  r   r  r  r  r  get_inner_schemar  r   r  s   `` `       r   r  z!GenerateSchema._apply_annotations  s     4LL[YZHJ(	2 8tL% 	J!#== 08_	  >  	 "+.+"--j"=M Qqr;D<P<P<^<^`kmsttr   c           
     $   t               }t        ||      r|rt        |      |u r| j                  |      x}D ]*  \  }}t	        j
                  d|d|d|dt               , |j                  r9| j                  j                         d|vrt	        j
                  dt               |j                  D ]  }| j                  ||      } |j                  | j                  ||j                        }|S |d   d	k(  r?|j                  d
t        j                               }	| j                  |	|      }	|	r|	|d
<   |S |d   dk(  rZt!        d t        j"                  |      D              r4|d   D 
cg c]!  }
t        |
t$              r|
d   n|
d   dk7  r|
# }}
t'        |      dk\  rSt        j(                  |      }| j                  ||      }|j+                         }|t-        d |d   D              g|d<   |S t'        |      dk(  rt        |d   t$              r|d   d   n|d   }	| j                  |	|      }	|j+                         }|d   D 
cg c]@  }
t        |
t$              r|
d   d   dk7  r|	|
d   fnt        |
t$              s
|
d   dk7  r|	n|
B c}
|d<   |S |}|j                  d      }|F|j+                         }|dt/        |       z   }| j0                  j3                  |      x}|S ||d<   no|d   dk(  rg|d   }| j0                  j3                  |      x}E|j+                         }|dt/        |       z   }| j0                  j3                  |      x}|S ||d<   t5        j6                  ||      }||S |S c c}
w c c}
w )NzThe z attribute with value zY was provided to the `Field()` function, which has no effect in the context it was used. a   is field-specific metadata, and can only be attached to a model field using `Annotated` metadata or by assignment. This may have happened because an `Annotated` type alias using the `type` statement was used, or if the `Field()` function was attached to a single member of a union type.r  defaut_factoryzA 'default_factory' taking validated data as an argument was provided to the `Field()` function, but no validated data is available in the context it was used.r   r   r   unionc              3  ,   K   | ]  }|d    dk(    yw)r   missing-sentinelNr   r>  r  s     r   r@  z:GenerateSchema._apply_single_annotation.<locals>.<genexpr>  s      -
5;F6N00-
s   r  r   r  r:   c              3  Z   K   | ]#  }t        |t              r|d    n|d   dk(  r| % yw)r   r   r  N)re  r   r  s     r   r@  z:GenerateSchema._apply_single_annotation.<locals>.<genexpr>	  s6      ")3FE)BF1IPVW[mm s   )+rS   r>  rC  definition-refrI  )rv   re  r   &_get_unsupported_field_info_attributesr   r   rR   $default_factory_takes_validated_datar   r   r?  _apply_single_annotationr  r  r/   r   r  iter_union_choicesr   rF  r  r	   nextr   r   get_schema_from_refrV   apply_known_metadata)r  r   r?  r  r   unsupported_attributesattrr@  field_metadatar  r  filtered_choicesfiltered_union	new_unionr7  r>  new_refexistingreferenced_schemamaybe_updated_schemas                       r   r  z'GenerateSchema._apply_single_annotation  s"    -.	h	*7 Ni/>B>i>ijr>s$s$: KD%MMth&<UI FKKO( Snn
 "B AA--113;(0FFMMY!A #+"3"3 O66v~NO %%1;;FHDZDZ[M&>Z'JJx)?)?)ABE11%BE#(x M&>W$ -
?J?]?]^d?e-
 *
 %Y/ !+FE!:F1IOSee    
 #$) "-!9!9:J!K!%!>!>~x!X"KKM	" &,Y&7 (	)$ ! %&!+ 3==Ma=PRW2X(+A.^nop^q55eXF #KKM	 #)"3( 	 "&%0VAYv5FJ\5\ F1I& &fe4K]9] 	 (	)$ !  jj?[[]FaX/00G II99'BBO#F5MF^//&C%)YY%B%B3%GG!T*//1!DN#3 44 $		 = =g FFHS#O 'u8MMhX^_+''w 8(s   5&NANc                    t               }t        ||      rQ|j                  D ]  }| j                  ||      } t	        |      \  }}|j                  di       }t        |||       |S )Nr?  r  )rv   re  r?  $_apply_single_annotation_json_schemar   r  r\   )r  r   r?  r   r  r  r  r  s           r   r  z3GenerateSchema._apply_single_annotation_json_schema<	  s~     -.	h	*"*"3"3 [BB6>Z[ 6__g5h2!2"--j"=M 3FZk r   c                    g }t         D ][  \  }}t        ||      x}|us|dvs| j                  j                         6|dvsd|j                  vsI|j                  ||f       ] |S )zoGet the list of unsupported `FieldInfo` attributes when not directly used in `Annotated` for field annotations.)r   r   )r   r   r   )r   r   r   r   _attributes_setr  )r  r  unused_metadataunused_metadata_nameunset_valueunused_metadata_values         r   r  z5GenerateSchema._get_unsupported_field_info_attributesL	  s    131\ 	V- +*1*>R*SS&\gg )0NN,,002> )0[[j&@&@@  &&(<>S'TU	V" r   c                V     t        dd       d fd}t        |       S )Nr,  c                    
 |       }n. |       }j                  |      }j                  |      }t              }|j                  |       |S )Nr  )r  r  r  r  )	r  r   r  r  annotation_get_schemar  r  r  r  s	      r   new_handlerz=GenerateSchema._get_wrapped_inner_schema.<locals>.new_handlerk	  sw    $0.v7GH)&166<c 7 
 BB6:V#DZ#P #/0778LMMr   )r  r   rI  core_schema.CoreSchema)r   r|   )r  r  r  r  r  r  r  s   ````` @r   r  z(GenerateSchema._get_wrapped_inner_schemab	  s0     ?FjRprv>w	 	" ,K>>r   c                   |rt        |      }|d   dk(  r|d   }| j                  ||      |d<   |S d|v r| j                  j                  |      }|d   }t	        |j
                  |j                  j                        \  }}|j                  j                  t        ur|j                  j                  }n6	 t        j                  |j
                  | j                  j                        }|t        u rd}	n| j#                  |      }	|j                  j                  dk(  r=t%        j&                  |j
                  |||	|j                  j(                  	      |d
<   |S |j                  j                  dk(  sJ t%        j*                  |j
                  |||	|j                  j(                  	      |d
<   |S # t        $ r}t        j                   |      |d}~ww xY w)z$Apply field serializers to a schema.r   r  r   r>  r   r  Nr   )is_field_serializerrm  r1  r   r   r   )r	   r  r   r  ri   r  r   rf  r  r-   rT   r  r  r  r  rF   r  r  r/   r  r   r   )
r  r   serializersr   
serializerr  rm  r  r  r1  s
             r   r  z'GenerateSchema._apply_field_serializers~	  s    &\Ff~.%h/#'#@#@{#[x &EEfM %RJ,DZ__V`VeVeVjVj,k)**2CC(oo99P #."F"F"1F1F1M1M#K // $ $ 4 4[ A##v-*5*Y*YOO(;%"/(oo77+'   "++w666*5*Z*ZOO(;%"/(oo77+' 3 ! P5EEaHaOPs   85F7 7	G GGc                    |j                  dd      }|rJt        |      d   }t        |j                  |j                  j
                        }|j                  j                  t        ur|j                  j                  }n6	 t        j                  |j                  | j                  j                        }|t        u rd}n| j                  |      }|j                  j
                  dk(  r8t!        j"                  |j                  |||j                  j$                        }	n7t!        j&                  |j                  |||j                  j$                        }	|	|d<   |r||d<   |S # t        $ r}t        j                  |      |d}~ww xY w)z$Apply model serializers to a schema.r>  Nr   r  r   )rm  r1  r   r   )poprJ  rj   r  r   rf  r  r-   rT   r  r  r  r  rF   r  r  r/   r  r   r   )
r  r   r  r>  r  rm  r  r  r1  
ser_schemas
             r   r  z'GenerateSchema._apply_model_serializers	  s[    !**UD1k*2.J/
AUAUVH**2CC(oo99P #."F"F"1F1F1M1M#K // $ $ 4 4[ A##v-4?4c4cOO%"/(oo77	5
 )MMOO%"/(oo77	
 '1F?#F5M5 ! P5EEaHaOPs   5E) )	F2FF)NN)r  rY   r  zNsResolver | Noner  zMapping[TypeVar, Any] | NonerI  NonerI  r  )rI  rY   )rI  rx   )rI  r   )r  r   rI  r)   )r!  r   r"  r   rI  r)   )rF  z
type[Enum]rI  r)   )r   r   rI  r)   )r   r   r  r   rI  r)   )r   r   r!  r   r"  r   rI  r)   )rI  r)   r  )r   r)   r  zstr | Discriminator | NonerI  r)   r  )r  r)   r  zCallable[..., Any]rI  r  )r  r   rI  r  )r  ztype[BaseModel]rI  r  )r  r   rI  r   )r  r   r  r   rI  zcore_schema.CoreSchema | None)r  r   r  zLiteral[True]rI  ztuple[Any, ...])r  r   rI  tuple[Any, ...] | None)F)r  r   r  r   rI  r  )r  r   rI  ztuple[Any, Any])r  r   r  r   rI  r)   )
r  r,  r  r   r   ra   r  r   rI  zcore_schema.TypedDictField)r  r,  r  r   r   ra   rI  zcore_schema.ModelField)r  r,  r  r   r   ra   rI  zcore_schema.DataclassField)r  r,  r  r   r   ra   rI  z!tuple[CoreSchema, dict[str, Any]])r  r   rI  r  )r  r2   rI  r)   )r  r   rI  r)   )r  r   r  r   rI  r  )r  r   r  r   rI  r  )r  r,  r  z	type[Any]r  r7   r   r   rf  zJLiteral['positional_only', 'positional_or_keyword', 'keyword_only'] | NonerI  zcore_schema.ArgumentsParameter)r  r,  r  r   r  r7   rf  zLiteral['positional_only', 'positional_or_keyword', 'keyword_only', 'var_args', 'var_kwargs_uniform', 'var_kwargs_unpacked_typed_dict']r   r   rI  z core_schema.ArgumentsV3Parameter)r  r   rI  r  )rI  r  )r$  r   rI  r  )r  r   rI  r  )r$  r   rI  zcore_schema.GeneratorSchema)r7  r   rI  r  )rJ  ztype[StandardDataclass]r  ztype[StandardDataclass] | NonerI  r  )rZ  ValidateCallSupportedTypesrI  zcore_schema.CallSchemar   )rZ  r  r~  ParametersCallback | NonerI  zcore_schema.ArgumentsSchema)rZ  r  r~  r  rI  zcore_schema.ArgumentsV3Schema)r  ztyping.TypeVarrI  r  )r&  zDecorator[ComputedFieldInfo]r  z2dict[str, Decorator[FieldSerializerDecoratorInfo]]rI  zcore_schema.ComputedField)r  r   rI  r  )
r  r   r   z	list[Any]r  z"Callable[[CoreSchema], CoreSchema]r  r   rI  r)   )T)r   r  r?  r   r  r   rI  r  )r   r  r?  r   rI  r  )r  r   rI  r   )
r  r=   r  r   r  zlist[GetJsonSchemaFunction]r  r   rI  r|   )r   r  r  z-list[Decorator[FieldSerializerDecoratorInfo]]rI  r  )r   r  r  z1Iterable[Decorator[ModelSerializerDecoratorInfo]]rI  r  )Kr   r   r   r   rB  r  r  propertyr  r  r  r  r#  r&  r)  rW  r~  r  r  r  r  r  r  r  r  r  r  r(  r*  r  r8  r%   r  rD  rG  r  rO  r  r  r  r  r  r  rl  rq  rr  ru  r   r  r  r	  rf  rm  r  r  r  rg  rh  rx  rz  r  r  rU  r  r|  r  rL  r  r  r  r  r  r  r  __classcell__)r   s   @r   r   r   ^  s   fI *.59	#%# '# 3	#
 
#
 / / 1 1 < <
IkHNFP
B8t
2,\
"
2	
 1K	&1	/%% 
 %NLB9wv, i iW W $8x.t1.r 

 
 #	
 
 
$
(

 
 #	

 
 
$

 
 #	

 
$
,7%7%%.7%<J7%	*7%r6H&ILV,Hf ![_+ +  +  !	+ 
 +  Y+  
(+ t !0 0  0  !	0 

0  0  
*0 d_<
	
]
%>N
.Mr8

xL0xL:XxL	xLt
4 fjI
2I
IbI
	$I
X fjB
2B
IbB
	&B
H((0
'0
 N0
 
#	0
d& FQ8<.u.u .u !C	.u
 26.u 
.uh 9=	r&r r 26	r
 
 rh,8;	 6 9>?.? ? +F	?
 26? 
&?86&6 C6 
 	6p-,-;l-	-r   r   c                .    t        j                  | |      S r   )r/   !no_info_before_validator_functionr  r   s     r   r1  r1  	      [-Z-Z[\^d-e r   c                .    t        j                  | |      S r   )r/   rS  r  s     r   r1  r1  	  s    K,X,XYZ\b,c r   c                ,    t        j                  |       S r   )r/   r{  r  rC  s     r   r1  r1  	  s    {'S'STU'V r   c                .    t        j                  | |      S r   )r/   r  r  s     r   r1  r1  	  s    ;+V+VWXZ`+a r   c                .    t        j                  | |      S r   )r/   #with_info_before_validator_functionr  s     r   r1  r1  	  s    {/^/^_`bh/i r   c                .    t        j                  | |      S r   )r/   "with_info_after_validator_functionr  s     r   r1  r1  	  s    k.\.\]^`f.g r   c                ,    t        j                  |       S r   )r/   r1  r  s     r   r1  r1  	  s    )W)WXY)Z r   c                .    t        j                  | |      S r   )r/   !with_info_wrap_validator_functionr  s     r   r1  r1  	  r  r   ))r   no-info)r   r  )r   r  )r   r  )r   	with-info)r   r  )r   r  )r   r  zMapping[tuple[FieldValidatorModes, Literal['no-info', 'with-info']], Callable[[Callable[..., Any], core_schema.CoreSchema], core_schema.CoreSchema]]_VALIDATOR_F_MATCHc                    |D ]c  }t        |j                  |j                  j                  d      }|rdnd}t	        |j                  j                  |f   |j                  |       } e | S )a  Apply validators to a schema.

    Args:
        schema: The schema to apply validators on.
        validators: An iterable of validators.
        field_name: The name of the field if validators are being applied to a model field.

    Returns:
        The updated schema.
    r   rf  r   r  r  )rk   r  r   rf  r  )r   r  	validatorrm  val_types        r   r   r   	  si        ]	 %Y^^)..:M:MT[\"*;	#Y^^%8%8($CDY^^U[\] Mr   c                B    | D ]  }|j                   j                  s y y)a?  In v1, if any of the validators for a field had `always=True`, the default value would be validated.

    This serves as an auxiliary function for re-implementing that logic, by looping over a provided
    collection of (v1-style) ValidatorDecoratorInfo's and checking if any of them have `always=True`.

    We should be able to drop this function and the associated logic calling it once we drop support
    for v1-style validator decorators. (Or we can extend it and keep it if we add something equivalent
    to the v1-validator `always` kwarg to `field_validator`.)
    TF)r   rk  )r  r  s     r   r  r  
  s(       	>>   r   c                R    t        | t        t        f      r| j                         S | S r   )re  r;   r<   convert_to_aliases)r   s    r   r  r  !
  s'     %,	23''))r   c                `   | j                  dd      }|D ]  }|dk(  r|j                  j                  dk7  r#|dk(  r|j                  j                  dk(  rBt        |j                  |j                  j                  d      }|j                  j                  dk(  rF|r"t        j                  |j                  | 	      } t        j                  |j                  | 	      } |j                  j                  dk(  rH|r#t        j                  |j                  | 	      } t        j                  |j                  | 	      } .|j                  j                  d
k(  sJ |r#t        j                  |j                  | 	      } nt        j                  |j                  | 	      }  |r|| d<   | S )a  Apply model validators to a schema.

    If mode == 'inner', only "before" validators are applied
    If mode == 'outer', validators other than "before" are applied
    If mode == 'all', all validators are applied

    Args:
        schema: The schema to apply validators on.
        validators: An iterable of validators.
        mode: The validator mode.

    Returns:
        The updated schema.
    r>  Nr  r   r  modelr  r   )rZ  r   r   )r  r   rf  rk   r  r/   r  r  r  r  r  rS  )r   r  rf  r>  r  rm  s         r   r  r  *
  sf   & jj-C n	7?y~~22h>7?y~~22h>$Y^^)..:M:MT[\>>&($FFPYP^P^gmn$DDinnekl^^  H,$HHR[R`R`iop$FFPYP^P^gmn>>&&'111$GGQZQ_Q_hno$EEy~~flm+n, uMr   c                   | j                   r@t        j                  || j                   t        | j                         | j                        S | j
                  t        ur,t        j                  || j
                  | j                        S |S )a  Wrap schema with default schema if default value or `default_factory` are available.

    Args:
        field_info: The field info object.
        schema: The schema to apply default on.

    Returns:
        Updated schema by default value or `default_factory`.
    )r   default_factory_takes_datar   )r   r   )r   r/   with_default_schemarp   r   r   r-   )r  r   s     r   r  r  Y
  s     !!..&66'DZE_E_'`'88	
 	
 
		#4	4..J..A\A\
 	
 r   c                (   t        | dd      }t        | d      r]t               }|duxr% |j                  j                  |t        |dd      fv}|s&t        | dd      }t        d|rd| dnd	 d
d      t        |       x}t        |      S |y|S )z`Extract `__get_pydantic_json_schema__` from a type, handling the deprecated `__modify_schema__`.__get_pydantic_json_schema__N__modify_schema__r:  r   zjThe `__modify_schema__` method is not supported in Pydantic v2. Use `__get_pydantic_json_schema__` insteadz in class ``r   r   zcustom-json-schemar   )r   rG  ru   r  r:  rG   r4   r  )r   js_modify_functionr   has_custom_v2_modify_js_funccls_namer  s         r   r  r  r
  s     %CTJr&',.	 d* W66??&0BJPT(UVW 	% ,r:t4H#=Zb{8*TU=Vhj<kkln)  R. - 188!r   r  c                X    | d   dk(  r|j                  | d         S | d   dk(  r| d   S | S )Nr   r  rI  r  r   )r  r   r  s     r   r  r  
  sA    f~))..vl/CDD	=	(hr   c                \    d| v ry| j                  d      }|syt        |      dk(  rd|v ryy)a  Determine the inlining behavior of the `'definition-ref'` schema.

    - If no `'serialization'` schema and no metadata is attached, the schema can safely be inlined.
    - If it has metadata but only related to the deferred discriminator application, it can be inlined
      provided that such metadata is kept.
    - Otherwise, the schema should not be inlined. Doing so would remove the `'serialization'` schema or metadata.
    r   keepr?  inlinerS   %pydantic_internal_union_discriminatorpreserve_metadata)r   rF  )def_refr?  s     r   _inlining_behaviorr	  
  s=     '!{{:&H
8}EQ"r   c                  l    e Zd ZU dZded<   	 ded<   	 ddZedd       ZddZdd	Z	dd
Z
ddZddZy)r  z*Keeps track of references and definitions.zset[str]_recursively_seenz!dict[str, core_schema.CoreSchema]r  c                0    t               | _        i | _        y r   )r   r  r  r  s    r   r  z_Definitions.__init__
  s    !$r   c             #  H  K   t        |      }|| j                  v s|| j                  v r|t        j                  |      f y| j                  j                  |       	 |df | j                  j                  |       y# | j                  j                  |       w xY ww)a  Get a definition for `tp` if one exists.

        If a definition exists, a tuple of `(ref_string, CoreSchema)` is returned.
        If no definition exists yet, a tuple of `(ref_string, None)` is returned.

        Note that the returned `CoreSchema` will always be a `DefinitionReferenceSchema`,
        not the actual definition itself.

        This should be called for any type that can be identified by reference.
        This includes any recursive types.

        At present the following types can be named/recursive:

        - Pydantic model
        - Pydantic and stdlib dataclasses
        - Typed dictionaries
        - Named tuples
        - `TypeAliasType` instances
        - Enums
        N)r^   r  r  r/   rM  adddiscard)r  r   r>  s      r   r  z_Definitions.get_schema_or_ref
  s     , 2$(((C43D3D,D??DEE""&&s+4Dk!&&..s3&&..s3s   AB" B &B"BB"c                8    | j                   j                  |      S )z,Resolve the schema from the given reference.)r  r   )r  r>  s     r   r  z _Definitions.get_schema_from_ref
  s      $$S))r   c                T    |d   }|| j                   |<   t        j                  |      S )zStore the schema as a definition and return a `'definition-reference'` schema pointing to it.

        The schema must have a reference attached to it.
        r>  )r  r/   rM  )r  r   r>  s      r   r  z/_Definitions.create_definition_reference_schema
  s.    
 Um!'#66s;;r   c                D    |d   D ]  }|| j                   |d   <    |d   S )zZStore the definitions of the `'definitions'` core schema and return the inner core schema.r  r>  r   )r  )r  r   
def_schemas      r   r  z_Definitions.unpack_definitions
  s6     / 	>J3=Dj/0	>hr   c                   | j                   }	 t        ||      }i }|d   j	                         D ]  \  }}|t        |      x}dk7  r|dk(  r2|j                          |j                  | j                  ||             O|dk(  sU|j                  d      }	|j                          |j                  | j                  ||             |	|d<   | j                  ||      ||<    |d   D ]`  }
|
d   j                  d	d      }|t        j                  |
j                         ||      }|
j                          |
j                  |       b |r't        j                  |g |j                         
      }|S # t        $ r}t        |d}~ww xY w)zFinalize the core schema.

        This traverses the core schema and referenced definitions, replaces `'definition-ref'` schemas
        by the referenced definition if possible, and applies deferred discriminators.
        )r  Ncollected_referencesr  r  r  r?  deferred_discriminator_schemasr  r  )r  r{   rz   r   r   r	  clearr4  _resolve_definitionr  rU   r  r	   r/   definitions_schemarL  )r  r   r  gather_resultr  remaining_defsr>  inlinable_def_refinlining_behaviormetacsr  applieds                r   r  z_Definitions.finalize_schema
  s    ''	,7'M 13 '44J&K&Q&Q&S 	Q"C" ,GYZkGl2l2Cqw1w$0
 &++-%,,T-E-Ec;-WX&*== -00<D%++-%,,T-E-Ec;-WX48%j1
 '+&>&>sK&Ps#+	Q.   @A 
	B(*:(:(:;bdh(iM$ *>>rwwy-YghGHHJIIg
	  336OiQ_QfQfQhOijFY & 	,$!+	,s   E7 7	F FFc                    ||   }|d   dk7  r|S t               }|d   dk(  rTt        |      dk(  rF|d   }||v rt        | dd      |j                  |       ||   }|d   dk(  rt        |      dk(  rFi |d|iS )	Nr   r  r  rI  z) contains a circular reference to itself.zcircular-reference-schemar   r>  )r   r	  rG   r  )r  r>  r  
definitionvisitedrI  s         r   r  z _Definitions._resolve_definition6  s     %
f!11  E $449KJ9W[c9c#L1JW$'eDELg  KK
#$Z0J  $449KJ9W[c9c **)eS))r   Nr  )r   r   rI  zCGenerator[tuple[str, core_schema.DefinitionReferenceSchema | None]])r>  r,  rI  CoreSchema | None)r   r)   rI  %core_schema.DefinitionReferenceSchema)r   zcore_schema.DefinitionsSchemarI  r)   r  )r>  r,  r  zdict[str, CoreSchema]rI  r)   )r   r   r   r   r}  r  r   r  r  r  r  r  r  r   r   r   r  r  
  sQ    4 43 4 4@*< 8t*r   c                  2    e Zd ZdZddZedd       ZddZy)	r  _stackc                    g | _         y r   r'  r  s    r   r  z_FieldNameStack.__init__L  s	    !#r   c              #  ~   K   | j                   j                  |       d  | j                   j                          y wr   r(  r  r  )r  r  s     r   r	  z_FieldNameStack.pushO  s)     :&   ;=c                :    | j                   r| j                   d   S y Nr   r'  r  s    r   r   z_FieldNameStack.getU      ;;;;r?"r   Nr  )r  r,  rI  Iterator[None])rI  z
str | Noner   r   r   rB  r  r   r	  r   r   r   r   r  r  I  s%    I$  
r   r  c                  2    e Zd ZdZddZedd       ZddZy)	r  r'  c                    g | _         y r   r'  r  s    r   r  z_ModelTypeStack.__init___  s	    "$r   c              #  ~   K   | j                   j                  |       d  | j                   j                          y wr   r+  )r  type_objs     r   r	  z_ModelTypeStack.pushb  s)     8$r,  c                :    | j                   r| j                   d   S y r.  r'  r  s    r   r   z_ModelTypeStack.geth  r/  r   Nr  )r5  r   rI  r0  )rI  ztype | Noner1  r   r   r   r  r  \  s%    I%  
r   r  )r   FieldDecoratorInfor   r,  rI  r   )r   zIterable[AnyFieldDecorator]r   zIterable[str]rI  r  )r   z+Iterable[Decorator[FieldDecoratorInfoType]]r   r,  rI  z'list[Decorator[FieldDecoratorInfoType]])r   r  r   z'list[Decorator[ValidatorDecoratorInfo]]rI  r  )r   zFieldInfo | ComputedFieldInforI  zAtuple[JsonDict | None, JsonDict | JsonSchemaExtraCallable | None])r   zJsonEncoders | Noner   r   r   r)   rI  r)   )r   r  r  zIterable[Decorator[RootValidatorDecoratorInfo]] | Iterable[Decorator[ValidatorDecoratorInfo]] | Iterable[Decorator[FieldValidatorDecoratorInfo]]rI  r  )r  z+Iterable[Decorator[ValidatorDecoratorInfo]]rI  r   )r   z%str | AliasChoices | AliasPath | NonerI  z4str | list[str | int] | list[list[str | int]] | None)r   r  r  z0Iterable[Decorator[ModelValidatorDecoratorInfo]]rf  z Literal['inner', 'outer', 'all']rI  r  )r  r   r   r  rI  r  )r   r   rI  zGetJsonSchemaFunction | None)r   r)   r  r  rI  r$  )r  r%  rI  z.Literal['inline', 'keep', 'preserve_metadata'](  r   
__future__r   _annotationscollections.abcr  r  rW  rM  r  r  r3  sysr{  r   r   r   r   r   
contextlibr   r	   decimalr
   enumr   	fractionsr   	functoolsr   r   r   	ipaddressr   r   r   r   r   r   	itertoolsr   operatorr   typesr   r   r   r   r   r   r   r   r    r!   r"   r#   r$   r%   uuidr&   r  r'   r  pydantic_corer(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   typing_inspectionr6   typing_inspection.introspectionr7   r8   r9   aliasesr;   r<   annotated_handlersr=   r>   r  r?   r@   rA   rB   errorsrC   rD   rE   rF   rG   functional_validatorsrH   rI   rJ   rK   rL   r6  rM   versionrN   rO   rP   rQ   rR   r   rT   rU   rV   rW   rX   _configrY   rZ   _core_metadatar[   r\   _core_utilsr]   r^   r_   r`   ra   rb   rc   rd   re   rf   rg   rh   ri   rj   rk   _docs_extractionrl   r  rm   rn   ro   rp   rq   _forward_refrr   	_genericsrs   rt   _import_utilsru   rv   _mock_val_serrw   _namespace_utilsrx   ry   _schema_gatherrz   r{   _schema_generation_sharedr|   _utilsr}   r~   r   r   r   mainr   r   _dataclassesr   r   version_infor  r7  r   AnyFieldDecoratorr   r}  r   r   Tupler   r   ListrJ  r:  MutableSequencer   Setr   
MutableSetr   	FrozenSet	frozensetr   Dictr   r   r   r(  r   r   Typer   r   r2  r   r  Pathr  	PosixPathPurePosixPathPureWindowsPathr   MutableMappingOrderedDictDefaultDictr  ri  Counterrj  r  r  r   r  r~  r   r   r   r   r   r   r   JsonEncodersr   GENERATE_SCHEMA_ERRORS	Exceptionr   r   r  r   r  r  r  r  r  r  r	  r  r  r  r   r   r   <module>rr     s   3 2     	  	 
   B B %      - f f   D D     
 
 
 [ Z , a a - K O O  x w ) #  a ` 6 > 
    :  / ? M ) 9 O C 65 %/@&&'1 13NPllm  !9AST $%)**+-  *> Y =#+S2M,NP[PfPf,f#g y g S I S!<</Z / ++t[__-L-LM
J MS+//*D*DE	: E & 0 0)[__=P=PQ * Q ++t,
J ,#]Km]hi* i$oo{/G/GH
 H$oo{/G/GIYIY[f[j[j[t[tu
 u ++t,
J ,#^^RZZ8z 8KKLL
J  NN
OOOO""!!
	 $$fnn5&,,fll;Z ; #  !))C D ! !"F +-B " O .Zgh   i
,
,, 
,"6nDnMPn,n " A   F
A
'
AF
A DI{*+&,/9CF  !	  I& &E" E"XD fcVaigZe	   ""7
 4 09,",@, +, 	,^2@23(W* W*t & r   