o
    ú©Zh$ ã                	   @  s  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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/m0Z0 ddlm1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z: ddl;m<Z< ddlm=Z= ddl>m?Z? ddl@Z@ddlAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZI ddl@mJZJmKZKmLZLmMZMmNZNmOZO ddlPmQZQ ddlRmSZSmTZTmUZU ddlVmWZWmXZXmYZY ddlZm[Z[m\Z\ ddl]m^Z^m_Z_m`Z`maZa ddlbmcZcmdZdmeZe ddlfmgZgmhZhmiZimjZjmkZk ddllmmZm ddlnmoZo dd lmpZp d!d"lqmrZrmsZsmtZtmuZumvZv d!d#lwmxZxmyZy d!d$lzm{Z{m|Z| d!d%l}m~Z~mZm€Z€mZ d!d&lrm‚Z‚mƒZƒm„Z„m…Z…m†Z†m‡Z‡mˆZˆm‰Z‰mŠZŠm‹Z‹mŒZŒmZ d!d'lŽmZ d!d(lm‘Z‘m’Z’m“Z“ d!d)l”m•Z• d!d*l–m—Z—m˜Z˜ d!d+l™mšZšm›Z› d!d,lœmZ d!d-lžmŸZŸm Z  d!d.l¡m¢Z¢m£Z£ d!d/l¤m¥Z¥ d!d0l¦m§Z§m¨Z¨ e1rðdd1l©mªZªm«Z« dd2l¬m­Z­ dd3l,m®Z® d!d4l¯m°Z° d!d5l¤m±Z± ej²d6kZ³e8e‰e…e„f Z´e7d7e´d8Zµe8e‚e‰ e‚e… e‚e„ f Z¶e[Z·d9e¸d:< e3e2e·geHjBf Z¹d9e¸d;< d<Zºd9e¸d=< ej»e¼gZ½d>e¸d?< ej¾e¿ejÀjÁgZÂd>e¸d@< ejÃeÄejÀjÅgZÆd>e¸dA< ejÇeÈejÀjÃgZÉd>e¸dB< ejÊeËgZÌd>e¸dC< e"e#e$e%e&e'gZÍd>e¸dD< ejÎejÀjÎgZÏd>e¸dE< ejejÀjejejÀjgZÐd>e¸dF< ejÑeÒgZÓd>e¸dG< ejÔejÔgZÕd>e¸dH< e	jÖe
j×e
jØe
jÙe
jÚe
jÛgZÜd>e¸dI< ejejÝejÀjejÀjÝejÞe@jÞejßejàgZáejâejâgZãejäejågZæd>e¸dJ< e8e/e-e0ef ZçeMeçƒZèehegejekdKœZédLe¸dM< d·dTdU„Zêd¸d[d\„Zëd¹d`da„Zìdºdhdi„Zíd»dldm„ZîeËeÒe2 e`f Zïd¼dsdt„Zðd½dwdx„ZñG dydz„ dzeòƒZóG d{d|„ d|ƒZôd}d~„ dd~„ d€d~„ dd~„ d‚d~„ dƒd~„ d„d~„ d…d~„ d†œZõd‡e¸dˆ< d¾d‹dŒ„Zöd¿dŽd„Z÷dÀd“d”„ZødÁd—d˜„ZùdÂdšd›„ZúG dœd„ deLƒZûddddddžœdÃd¦d§„ZüdÄd«d¬„ZýdÅd°d±„ZþG d²d©„ d©ƒZÿG d³d´„ d´ƒZ G dµd¶„ d¶ƒZdS )Æz-Convert python types to pydantic-core schema.é    )ÚannotationsN)Ú	GeneratorÚIterableÚIteratorÚMapping)Úcontextmanager©Úcopy)ÚDecimal)ÚEnum)ÚFraction)Úpartial)Ú	ParameterÚ_ParameterKindÚ	signature)ÚIPv4AddressÚIPv4InterfaceÚIPv4NetworkÚIPv6AddressÚIPv6InterfaceÚIPv6Network)Úchain)Ú
attrgetter)ÚFunctionTypeÚGenericAliasÚ
LambdaTypeÚ
MethodType)
ÚTYPE_CHECKINGÚAnyÚCallableÚFinalÚ
ForwardRefÚLiteralÚTypeVarÚUnionÚcastÚoverload)ÚUUID)Úwarn)ÚZoneInfo)Ú
CoreSchemaÚMultiHostUrlÚPydanticCustomErrorÚ$PydanticSerializationUnexpectedValueÚPydanticUndefinedÚUrlÚcore_schemaÚto_jsonable_python)Ú	TypeAliasÚTypeAliasTypeÚ	TypedDictÚget_argsÚ
get_originÚis_typeddict)Útyping_objects)ÚAnnotationSourceÚget_literal_valuesÚis_union_originé   )ÚAliasChoicesÚAliasGeneratorÚ	AliasPath)ÚGetCoreSchemaHandlerÚGetJsonSchemaHandler)Ú
ConfigDictÚJsonDictÚJsonEncoderÚJsonSchemaExtraCallable)ÚPydanticSchemaGenerationErrorÚPydanticUndefinedAnnotationÚPydanticUserError)ÚAfterValidatorÚBeforeValidatorÚFieldValidatorModesÚPlainValidatorÚWrapValidator)ÚJsonSchemaValue)Úversion_short)ÚPydanticDeprecatedSince20é   )Ú_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Úvalidate_core_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_model_fieldsÚtakes_validated_data_argument)Ú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)Úboundr2   Ú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)ÚbeforeÚafterÚplainÚwrapzbdict[FieldValidatorModes, type[BeforeValidator | AfterValidator | PlainValidator | WrapValidator]]Ú_mode_to_validatorÚinfoÚFieldDecoratorInfoÚfieldÚstrÚreturnÚboolc                 C  s   | j }d|v p
||v S )z×Check 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)r›   r   r¢   © r£   úZ/var/www/html/lang_env/lib/python3.10/site-packages/pydantic/_internal/_generate_schema.pyÚ)check_validator_fields_against_field_name¨   s   r¥   Ú
decoratorsúIterable[AnyFieldDecorator]r¢   úIterable[str]ÚNonec                 C  sf   t |ƒ}| D ]*}d|jjv rq|jjdu rq|jjD ]}||vr/td|j› d|j› ddd‚qqdS )	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¢   Zcheck_fieldsrH   Zcls_refÚcls_var_name)r¦   r¢   Údecr   r£   r£   r¤   Úcheck_decorator_fields_exist¹   s   ýÿÿûr°   Úvalidator_functionsú+Iterable[Decorator[FieldDecoratorInfoType]]ú'list[Decorator[FieldDecoratorInfoType]]c                   s   ‡ fdd„| D ƒS )Nc                   s   g | ]
}t |jˆ ƒr|‘qS r£   )r¥   r›   )Ú.0r¯   ©r   r£   r¤   Ú
<listcomp>×   ó    z8filter_field_decorator_info_by_field.<locals>.<listcomp>r£   )r±   r   r£   rµ   r¤   Ú$filter_field_decorator_info_by_fieldÔ   s   r¸   Úschemaúcore_schema.CoreSchemaÚeach_item_validatorsú'list[Decorator[ValidatorDecoratorInfo]]Ú
field_nameú
str | Nonec                 C  sØ   |s| S | d dkrt | d ||ƒ| d< | S | d dkr5|  d¡ }d ur3t| d | ||ƒ| d |< | S t| ƒrK|  dt ¡ ¡}t|||ƒ| d< | S | d dkrc|  dt ¡ ¡}t|||ƒ| d< | S td	| d › ƒ‚)
NÚtypeÚnullabler¹   ÚtupleÚvariadic_item_indexZ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]   r0   Ú
any_schemaÚ	TypeError)r¹   r»   r½   rÂ   Úinner_schemar£   r£   r¤   rÅ   Ú   s0   
ýöùýÿrÅ   úFieldInfo | ComputedFieldInfoúAtuple[JsonDict | None, JsonDict | JsonSchemaExtraCallable | None]c                 C  sL   | j | jt| jƒp| jdkpd t| jƒdœ}dd„ | ¡ D ƒ}|p"d | jfS )NÚ )ÚtitleÚdescriptionÚ
deprecatedÚexamplesc                 S  ó   i | ]\}}|d ur||“qS ©Nr£   ©r´   ÚkÚvr£   r£   r¤   Ú
<dictcomp>  ó    z=_extract_json_schema_info_from_field_info.<locals>.<dictcomp>)rÎ   rÏ   r    rÐ   r1   rÑ   ÚitemsZjson_schema_extra)r›   Zjson_schema_updatesr£   r£   r¤   Ú)_extract_json_schema_info_from_field_infoÿ   s   ürÚ   Újson_encodersúJsonEncoders | NoneÚtpr   r*   c                 C  s€   | s|S d|v r
|S |gt |d|jjƒdd… ¢R D ]#}|  |¡}|du r&qt dtƒ › dt¡ tj	|dd|d< |  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__Néÿÿÿÿz=`json_encoders` is deprecated. See https://docs.pydantic.dev/z</concepts/serialization/#custom-serializers for alternativesÚjson©Ú	when_used)
ÚgetattrÚ	__class__rß   rÆ   Úwarningsr(   rO   rP   r0   Ú$plain_serializer_function_ser_schema)rÛ   rÝ   r¹   ÚbaseÚencoderr£   r£   r¤   Ú,_add_custom_serialization_from_json_encoders  s   
$
þrê   ÚaÚbc                 C  s   | dur| S |S )aB  Return the first argument if it is not None, otherwise return the second argument.

    Use case: serialization_alias (argument a) and alias (argument b) are both defined, and serialization_alias is ''.
    This function will return serialization_alias, which is the first argument, even though it is an empty string.
    Nr£   )rë   rì   r£   r£   r¤   Ú_get_first_non_null1  s   rí   c                   @  s   e Zd ZdZdS )ÚInvalidSchemaErrorzThe core schema is invalid.N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r£   r£   r£   r¤   rî   :  s    rî   c                      s˜  e Zd ZdZdZ		dùdúdd„Zdû‡ fdd„Zedüdd„ƒZedýdd„ƒZ	edþdd„ƒZ
dÿdd„Zd dd „Zdÿd!d"„Zdÿd#d$„Zdd'd(„Zdd*d+„Zdd-d.„Zdÿd/d0„Zdd1d2„Zdd3d4„Zdd5d6„Zdd8d9„Zdd=d>„Zdd?d@„Zd	dDdE„Zd
dGdH„ZddKdL„ZddMdN„ZddQdR„ZddSdT„ZeddXdY„ƒZ edd[dY„ƒZ ddd]dY„Z dd^d_„Z!ddadb„Z"d
dcdd„Z#d
dedf„Z$ddhdi„Z%djdkœddsdt„Z&ddvdw„Z'ddydz„Z(e)dd~d„ƒZ*e)ddƒd„„ƒZ+e)dd†d‡„ƒZ,dd‰dŠ„Z-ddŒd„Z.ddd„Z/dd’d“„Z0dd•d–„Z1dd˜d™„Z2e3j4dfd d¡d¢„Z5e3j4fd!d¥d¦„Z6d"d¨d©„Z7d#dªd«„Z8d#d¬d­„Z9dd®d¯„Z:d$d±d²„Z;d%d³d´„Z<d&d¶d·„Z=d'd¹dº„Z>d#d»d¼„Z?d(dÀdÁ„Z@d)dÅdÆ„ZA	d*d+dÊdË„ZB	d*d,dÍdÎ„ZCd-dÑdÒ„ZDd.dØdÙ„ZEd/dÛdÜ„ZFdÝdÞ„ fd0dädå„ZGd1dçdè„ZHd1dédê„ZId2dðdñ„ZJd3dôdõ„ZKd4d÷dø„ZL‡  ZMS (5  Ú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ÚdefsNÚconfig_wrapperrW   Úns_resolverúNsResolver | NoneÚtypevars_mapúMapping[TypeVar, Any] | NonerŸ   r©   c                 C  s8   t |ƒ| _|p	tƒ | _|| _tƒ | _tƒ | _t	ƒ | _
d S rÓ   )rX   rô   rv   rõ   rö   Ú_FieldNameStackr÷   Ú_ModelTypeStackrø   Ú_Definitionsrù   )Úselfrú   rû   rý   r£   r£   r¤   Ú__init__J  s   
zGenerateSchema.__init__c                   s   t ƒ  ¡  tjdtdd d S )NzeSubclassing `GenerateSchema` is not supported. The API is highly subject to change in minor versions.r<   )Ú
stacklevel)ÚsuperÚ__init_subclass__ræ   r(   ÚUserWarning)Úcls©rå   r£   r¤   r  X  s   

ýz GenerateSchema.__init_subclass__c                 C  ó   | j jS rÓ   )rô   Útail©r  r£   r£   r¤   Ú_config_wrapper`  ó   zGenerateSchema._config_wrapperru   c                 C  r
  rÓ   )rõ   Ztypes_namespacer  r£   r£   r¤   Ú_types_namespaced  r  zGenerateSchema._types_namespacer    c                 C  r
  rÓ   )r  Zarbitrary_types_allowedr  r£   r£   r¤   Ú_arbitrary_typesh  r  zGenerateSchema._arbitrary_typesÚ
items_typer   r*   c                 C  ó   t  |  |¡¡S rÓ   )r0   Úlist_schemaÚgenerate_schema©r  r  r£   r£   r¤   Ú_list_scheman  ó   zGenerateSchema._list_schemaÚ	keys_typeÚvalues_typec                 C  s   t  |  |¡|  |¡¡S rÓ   )r0   Údict_schemar  )r  r  r  r£   r£   r¤   Ú_dict_schemaq  s   zGenerateSchema._dict_schemac                 C  r  rÓ   )r0   Z
set_schemar  r  r£   r£   r¤   Ú_set_schemat  r  zGenerateSchema._set_schemac                 C  r  rÓ   )r0   Zfrozenset_schemar  r  r£   r£   r¤   Ú_frozenset_schemaw  r  z GenerateSchema._frozenset_schemaÚ	enum_typeú
type[Enum]c                   sN  t ˆj ¡ ƒ‰ tˆƒ‰ˆjsd nt ˆj¡}|dkrd }ˆj|dœ‰dd„ ˆ ¡ D ƒ‰d ‰t	ˆt
ƒr:d‰t d¡}n!t	ˆtƒrGd‰t d¡}nt	ˆtƒrTd‰t d¡}nt dd	„ ¡}ˆ r’d‡fdd„}tˆjdd ƒtjju }tjˆˆ ˆ|rxd nˆjˆd|gid}| jjrtjtdƒ||d}|S d‡ ‡‡‡‡fdd„}tjˆd|gidS )NzAn enumeration.)rÎ   rÏ   c                 S  rÒ   rÓ   r£   rÔ   r£   r£   r¤   r×   „  rØ   z/GenerateSchema._enum_schema.<locals>.<dictcomp>Úintrž   Úfloatc                 S  ó   | S rÓ   r£   ©Úxr£   r£   r¤   Ú<lambda>“  ó    z-GenerateSchema._enum_schema.<locals>.<lambda>r¹   r*   ÚhandlerrA   rŸ   rN   c                   s    || ƒ}|  |¡}| ˆ ¡ |S rÓ   )Úresolve_ref_schemaÚupdate)r¹   r'  Újson_schemaÚoriginal_schema)Ú
js_updatesr£   r¤   Úget_json_schema—  s   

z4GenerateSchema._enum_schema.<locals>.get_json_schemaÚ__func__Úpydantic_js_functions)Úsub_typeÚmissingÚrefÚmetadataÚvalue)rÞ   c                   s.   |t jˆˆ ˆˆdƒ}| |¡}| ˆ¡ |S )N)r0  r2  )r0   Úenum_schemar(  r)  )Ú_r'  r*  r+  ©ÚcasesZenum_refr  r,  r0  r£   r¤   Úget_json_schema_no_cases±  s   

z=GenerateSchema._enum_schema.<locals>.get_json_schema_no_cases©r3  )r¹   r*   r'  rA   rŸ   rN   )r'  rA   rŸ   rN   )ÚlistÚ__members__Úvaluesr\   rò   ÚinspectÚcleandocrï   rÙ   Ú
issubclassr   r0   Zsimple_ser_schemarž   r!  rç   rä   Ú	_missing_r   r.  r5  r  Úuse_enum_valuesÚ no_info_after_validator_functionr   Úis_instance_schema)r  r  rÏ   Zvalue_ser_typer-  Zdefault_missingr5  r9  r£   r7  r¤   Ú_enum_schemaz  sN   


ú	
ÿþzGenerateSchema._enum_schemarÝ   c                   sŽ   ddl m}m} tdtdtdtdtdtdi‰ d‡fdd„}t	j
t	 |ˆ ¡t	jt	 ˆt	 ¡ ¡t	 ˆ¡dt	j|dddd‡ ‡fdd„gidS )NrQ   )ÚIP_VALIDATOR_LOOKUPÚIpTypeZipv4Zipv4networkZipv4interfaceZipv6Zipv6networkZipv6interfaceÚipr   r›   úcore_schema.SerializationInforŸ   ústr | IpTypec                   óD   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)rH  r›   ©rÝ   r£   r¤   Úser_ipÎ  ó   ÿ
z)GenerateSchema._ip_schema.<locals>.ser_ip©r*  Úpython_schemaTÚalways©Úinfo_argrã   r/  c                   s   dˆ ˆ dœS )NÚstring©r¿   Úformatr£   ©Ú_1Ú_2©Zip_type_json_schema_formatrÝ   r£   r¤   r%  ß  ó    z+GenerateSchema._ip_schema.<locals>.<lambda>©Ú
lax_schemaÚstrict_schemarÞ   r3  )rH  r   r›   rI  rŸ   rJ  )Ú_validatorsrF  rG  r   r   r   r   r   r   r0   Úlax_or_strict_schemaÚ no_info_plain_validator_functionÚjson_or_python_schemarC  Ú
str_schemarD  rç   )r  rÝ   rF  rG  rR  r£   r_  r¤   Ú
_ip_schemaÂ  s&   ú		þÿùzGenerateSchema._ip_schemaÚ	path_typec           	        sü   ˆt ju rˆtthvrt ˆ¡stddd‚ˆt ju rtjnˆ‰ ˆtu r*t	j
ddnt	jdd}ˆtu r8t	 
¡ nt	 ¡ }d‡ ‡fd
d„}d‡fdd„}t	jt	 ||¡t	 ˆ¡d}t	jt	j|t	 ||¡gddˆ› d|t	j|dddddd„ gid}|S )Nz;`os.PathLike` can only be used with `str`, `bytes` or `Any`zschema-for-unknown-typer«   T©ÚstrictÚinput_valueústr | bytesrŸ   úos.PathLike[Any]c              
     s’   z6ˆt u r(t| t ƒr#z|  ¡ } W n! ty" } ztddƒ|‚d }~ww tddƒ‚t| tƒs2tddƒ‚ˆ | ƒW S  tyH } ztddƒ|‚d }~ww )NZ
bytes_typezInput must be valid byteszInput must be bytesrj  zInput is not a valid path)ÚbytesrO  ÚdecodeÚUnicodeDecodeErrorr,   rž   rÉ   )rm  Úe)Úpath_constructorrj  r£   r¤   Úpath_validatorï  s"   
€ÿ



€ÿz3GenerateSchema._path_schema.<locals>.path_validatorÚpathr   r›   rI  ústr | os.PathLike[Any]c                   rK  rL  rN  )rv  r›   rQ  r£   r¤   Úser_path   rS  z-GenerateSchema._path_schema.<locals>.ser_pathrT  rj  zInput is not a valid path for ©Úcustom_error_typeÚcustom_error_messagerV  rW  r/  c                 S  s   i || ƒ¥ddi¥S )Nr[  rv  r£   )Úsourcer'  r£   r£   r¤   r%    ó    z-GenerateSchema._path_schema.<locals>.<lambda>ra  )rm  rn  rŸ   ro  )rv  r   r›   rI  rŸ   rw  )ÚosÚPathLikerž   rp  r8   Úis_anyrH   ÚpathlibÚPurePathr0   Úbytes_schemarh  rg  rC  rD  re  Úunion_schemarç   )	r  rÝ   rj  Zstrict_inner_schemaZlax_inner_schemaru  rx  Zinstance_schemar¹   r£   )rt  rj  rÝ   r¤   Ú_path_schemaã  s6    ÿÿ	
þ
þúõzGenerateSchema._path_schemac                 C  s|   ddl m} ddlm} |  |¡}tj|dd}tj|tjt	j
ddd}t ||¡}tj|t ||g¡tj||d	d
dS )NrQ   ©Úserialize_sequence_via_list)Údeque_validatorFrk  ÚDeque©Zcls_reprrT  T©r¹   rX  ©rb  rc  rÞ   )Ú_serializersr‡  rd  rˆ  r  r0   r  rg  rD  ÚcollectionsÚdequeÚno_info_wrap_validator_functionre  Úchain_schemaÚ#wrap_serializer_function_ser_schema)r  r  r‡  rˆ  Úitem_type_schemar  Úcheck_instancerb  r£   r£   r¤   Ú_deque_schema  s    
þÿýzGenerateSchema._deque_schemac                 C  s¶   ddl m}m}m} |  |¡}|  |¡}t ||¡}	tj|	t |¡d}
|t	j
u r8||ƒ}ttjt||dƒ}nttj|| ƒ}||	ƒ}tj|t |
|g¡tjdd„ |	ddd	}|S )
NrQ   )ÚMAPPING_ORIGIN_MAPÚdefaultdict_validatorÚ'get_defaultdict_default_default_factoryrT  )Údefault_default_factoryc                 S  ó   || ƒS rÓ   r£   )rÖ   Úhr£   r£   r¤   r%  P  ó    z0GenerateSchema._mapping_schema.<locals>.<lambda>Fr‹  rŒ  )rd  r–  r—  r˜  r  r0   r  rg  rD  rŽ  Údefaultdictr   r  rC  re  r„  r’  )r  rÝ   r  r  r–  r—  r˜  Zkeys_schemarÄ   r  r”  r™  Zcoerce_instance_wraprb  r¹   r£   r£   r¤   Ú_mapping_schema6  s0   

þ

þ
ÿýzGenerateSchema._mapping_schemac                 C  sL   ddl m} tjt |¡tjt |¡t t¡dtjddddd„ gid	S )
z7Support for [`fractions.Fraction`][fractions.Fraction].rQ   )Úfraction_validatorrT  rV  râ   r/  c                 S  ó
   dddœS )NrY  ZfractionrZ  r£   r\  r£   r£   r¤   r%  d  ó   
 z1GenerateSchema._fraction_schema.<locals>.<lambda>ra  )	rd  rŸ  r0   re  rf  rg  rD  r   Úto_string_ser_schema)r  rŸ  r£   r£   r¤   Ú_fraction_schemaV  s   þ
øzGenerateSchema._fraction_schemac                 C  s,   t |tƒst|›dtƒ t ¡ S t |¡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`.)rO  r¿   r(   r  r0   rÈ   rD  )r  rÝ   r£   r£   r¤   Ú_arbitrary_type_schemag  s   
û
z%GenerateSchema._arbitrary_type_schemaÚobjc                 C  s   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.)rF   ©r  r¥  r£   r£   r¤   Ú_unknown_type_schemas  s   
ÿz#GenerateSchema._unknown_type_schemar¹   Údiscriminatorústr | Discriminator | Nonec                 C  s@   |d u r|S zt  ||¡W S  t jy   t  ||¡ | Y S w rÓ   )rS   Úapply_discriminatorZMissingDefinitionForUnionRefZset_discriminator_in_metadata)r  r¹   r©  r£   r£   r¤   Ú_apply_discriminator_to_union~  s   þþúz,GenerateSchema._apply_discriminator_to_unionc                 C  s   | j  |¡}t|ƒ}|S rÓ   )rù   Úfinalize_schemar^   )r  r¹   r£   r£   r¤   Úclean_schema  s   zGenerateSchema.clean_schemaÚmetadata_schemaÚjs_functionúCallable[..., Any]c                 C  s6   |  di ¡}| dg ¡}||vr| |¡ ||d< d S )Nr3  r/  )rÆ   Ú
setdefaultÚappend)r  r¯  r°  r3  r/  r£   r£   r¤   Ú_add_js_function•  s
   
zGenerateSchema._add_js_functionrº   c                 C  s^   |   ||¡}|du r|  |¡}t|ƒ}|dur%t|| jƒ}|r%|  ||¡ 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__`.
        N)	Ú'_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¯  r£   r£   r¤   r     s   
zGenerateSchema.generate_schemar  útype[BaseModel]c                   s<  t ƒ }ˆj |¡	\}}|dur|W  d  ƒ S |j d¡}|durQt|tƒsQ|d dkr5ˆj |¡}t|ƒ}|rHˆj 	|¡W  d  ƒ S |W  d  ƒ S t
|jdd}ˆj |¡› ˆj |¡ƒ ˆjj|jd}|jsw||u r~t|di ƒ}	n zt|ˆjˆjp‡i d	}	W n ty }
 zt |
¡|
‚d}
~
ww |j‰ ˆ j}ttˆ j ¡ ˆ j ¡ ˆ j  ¡ ƒh |	 !¡ £| !¡ £ƒ ˆ j" ¡ }d}d}| d
¡dkrG|j#d |u sØJ ‚|j#d t$u sáJ ‚|j#dd… D ]^}t|di ƒ dd¡}|durFt|t%ƒrt&j't&j(|dddgˆj)¢R Ž }t*|ƒ}|t+vrt,dƒ‚ˆj-|dd\}}|t%ur/ˆ .|¡}t/ 0|¡s:ˆ .|¡}|dusD|durF nqèt|di ƒ d¡}|j1r}ˆ 2d|	d ˆ ¡}|d }t3||dƒ}t4j5|||t|ddƒdt|ddƒ||d}nCt4j6‡ ‡fdd„|	 7¡ D ƒ‡ ‡fdd„| ¡ D ƒ|||jd }t8|ˆ j9 ¡ dƒ}t3||dƒ}t4j5|||t|ddƒdt|ddƒ||d}ˆ :|ˆ j; ¡ ¡}t3||d!ƒ}ˆj 	|¡W  d  ƒ W  d  ƒ W  d  ƒ S 1 sîw   Y  W d  ƒ n1 sþw   Y  W d  ƒ dS W d  ƒ dS 1 sw   Y  dS )"z%Generate schema for a Pydantic model.NÚ__pydantic_core_schema__r¿   ÚdefinitionsF)Úcheck©rÎ   Ú__pydantic_fields__)rû   rý   Zextra_fields_behaviorÚallowr   rà   Ú__annotations__Z__pydantic_extra__T)Úis_argumentÚis_classzEThe type annotation for `__pydantic_extra__` must be `dict[str, ...]`©ÚrequiredZ__pydantic_generic_metadata__ÚoriginÚrootr¹   ÚinnerZ__pydantic_custom_init__Z__pydantic_post_init__)Úgeneric_originZcustom_initZ
root_modelÚ	post_initÚconfigr2  c                   s    i | ]\}}|ˆ  ||ˆ ¡“qS r£   )Ú_generate_md_field_schemarÔ   ©r¦   r  r£   r¤   r×   *  s     z0GenerateSchema._model_schema.<locals>.<dictcomp>c                   ó   g | ]	}ˆ  |ˆ j¡‘qS r£   ©Ú_computed_field_schemaÚfield_serializers©r´   ÚdrÍ  r£   r¤   r¶   +  ó    ÿÿz0GenerateSchema._model_schema.<locals>.<listcomp>)Úcomputed_fieldsÚextras_schemaÚextras_keys_schemaZ
model_nameÚouter)<rr   rù   Úget_schema_or_refÚ__dict__rÆ   rO  rt   Úunpack_definitionsr[   Ú"create_definition_reference_schemarW   Zmodel_configrô   Úpushrõ   r  Úcore_configrï   Z__pydantic_fields_complete__rä   rm   rö   Ú	NameErrorrG   Úfrom_name_errorÚ__pydantic_decorators__rÕ  r°   r   Úfield_validatorsr=  rÑ  Ú
validatorsÚkeysÚmodel_validatorsrß   Úobjectrž   rV   Úeval_type_backportÚ_make_forward_refr  r6   rŽ   rF   Ú _get_args_resolving_forward_refsr  r8   r€  Z__pydantic_root_model__Ú_common_field_schemaÚapply_model_validatorsr0   Úmodel_schemaZmodel_fields_schemarÙ   rÇ   Úroot_validatorsÚ_apply_model_serializersÚmodel_serializers)r  r  Ú
BaseModel_Z	model_refÚmaybe_schemar¹   r2  rú   rÞ  r¢   rs  rÕ  rå  rÖ  r×  Zcandidate_clsZextras_annotationrÝ   Zextra_keys_typeÚextra_items_typerÉ  Z
root_fieldrÊ   rì  Zfields_schemar£   rÍ  r¤   Ú_model_schemaÇ  sð   þ
öô 
ý€ÿýú
	ÿ
ÿÿü
ÿ
þ


€

øþø


ø
˜ð4ð$ðzGenerateSchema._model_schemac                 C  s"   | j  ¡ }|d u rtddd‚|S )Nz(`typing.Self` is invalid in this contextzinvalid-self-typer«   )rø   rÆ   rH   r§  r£   r£   r¤   Ú_resolve_self_typeE  s   
z!GenerateSchema._resolve_self_typer|  úcore_schema.CoreSchema | Nonec                 C  sH  t ƒ }t|dd ƒ}t|dd ƒ|jju }|d url|sl| j |¡\}}|d ur/|W  d   ƒ S W d   ƒ n1 s9w   Y  ||u rEd}nd}||t| j| |dƒ}	|	d dkr^| j |	¡}	t	|	ƒ}
|
rj| j 
|	¡S |	S |d u r t|dd ƒ }d ur¢d	d
lm} t||ƒrtd|j› dtƒ ntdtƒ t dd„ |ƒ D ƒ¡S d S d S )NÚ__get_pydantic_core_schema__r.  Úunpackzto-def)Úref_moder¿   r¼  Z__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.c                 S  s   g | ]}t  |¡‘qS r£   ©r0   Z"with_info_plain_validator_function©r´   rÖ   r£   r£   r¤   r¶   „  ó    zJGenerateSchema._generate_schema_from_get_schema_method.<locals>.<listcomp>)rr   rä   rö  r.  rù   rÙ  ry   r¶  rÛ  r[   rÜ  Zpydantic.v1r   r@  r(   rï   r  rP   r0   r‘  )r  r¥  r|  rð  Z
get_schemaZis_base_model_get_schemar6  rñ  rø  r¹   r2  rã  ZBaseModelV1r£   r£   r¤   rµ  K  sL   ÿúþÿÿ
þþóz6GenerateSchema._generate_schema_from_get_schema_methodc              
   C  sp   zt j|g| j¢R Ž }W n ty } zt |¡|‚d }~ww t|tƒr-t|jd|› ƒ‚| j	r6t
|| j	ƒ}|S )Nz%Unable to evaluate forward reference )rV   rç  r  rß  rG   rà  rO  r!   Ú__forward_arg__rö   rq   )r  r¥  rs  r£   r£   r¤   Ú_resolve_forward_ref†  s   €ÿ
z#GenerateSchema._resolve_forward_refrÅ  úLiteral[True]útuple[Any, ...]c                 C  ó   d S rÓ   r£   )r  r¥  rÅ  r£   r£   r¤   ré  œ  ó   z/GenerateSchema._get_args_resolving_forward_refsútuple[Any, ...] | Nonec                 C  r   rÓ   r£   r§  r£   r£   r¤   ré  Ÿ  r  Fc                   sV   t |ƒ}|rt|tƒrdd„ |D ƒ}t‡ fdd„|D ƒƒ}|S |r)td|› dƒ‚|S )Nc                 s  s(    | ]}t |tƒrt |¡n|V  qd S rÓ   )rO  rž   rV   rè  ©r´   rë   r£   r£   r¤   Ú	<genexpr>§  ó   €& zBGenerateSchema._get_args_resolving_forward_refs.<locals>.<genexpr>c                 3  s(    | ]}t |tƒrˆ  |¡n|V  qd S rÓ   )rO  r!   rý  r  r  r£   r¤   r  ¨  r  z	Expected z+ to have generic parameters but it had none)r5   rO  r   rÁ   rÉ   )r  r¥  rÅ  Úargsr£   r  r¤   ré  ¢  s   
þc                 C  s   |   |¡}|s	tS |d S )Nr   )ré  r   )r  r¥  r  r£   r£   r¤   Ú_get_first_arg_or_any­  s   
z$GenerateSchema._get_first_arg_or_anyútuple[Any, Any]c                 C  sJ   |   |¡}|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   rQ   )ré  r   Úlenr6   rÉ   )r  r¥  r  rÆ  r£   r£   r¤   Ú_get_first_two_args_or_any³  s   
z)GenerateSchema._get_first_two_args_or_anyc                 C  sÎ   t  |¡r
|  |¡}t  t|ƒ¡r|  |¡S t|tƒr|S t|tƒr&t	|ƒ}t|t	ƒr3|  
|  |¡¡S tƒ }t||ƒrV| j |¡ |  |¡W  d   ƒ S 1 sQw   Y  t|tƒrbtj|jdS |  |¡S )N)Ú
schema_ref)r8   Úis_selfrô  Zis_annotatedr6   Ú_annotated_schemarO  rÃ   rž   r!   r  rý  rr   rz   rø   rÝ  ró  ro   r0   Údefinition_reference_schemaZtype_refÚ
match_type)r  r¥  r   r£   r£   r¤   r¶  ¼  s$   






 ÿ

z%GenerateSchema._generate_schema_innerc                 C  s¸  |t u rt ¡ S |tu rt ¡ S |tu rt ¡ S |tu r t ¡ S |t	u r(t 
¡ S |tu r0t ¡ S t |¡s9|tu r=t ¡ S |tju rFt ¡ S |tju rOt ¡ S |tju rXt ¡ S |tju rat ¡ S |tu rit ¡ S |tu rqt ¡ S |tu ryt ¡ S |tu r|   ¡ S |t!u r‰t "¡ S |du s’|t#j$u r–t %¡ S |t&v rŸ|  '|¡S |t(v r¨|  )|¡S |t*v r±|  +t,¡S |t-v rº|  .t,¡S |t/v rÃ|  0t,¡S |t1v rÌ|  2t,¡S |t3v rÕ|  4|¡S |t5v rß|  6t,t,¡S |t7v ré|  8|t,¡S |t9v rò|  :t,¡S |t;v rý|  <|t,t,¡S |t=v r	|  <|t,t¡S t >|¡r|  ?|¡S |t@u r|  A¡ S t# B|¡r't C¡ S t DtE|ƒ¡r4|  F|¡S tG|ƒr?|  H|d¡S t# I|¡rK|  J|d¡S t K|¡rW|  L|jM¡S |tNv ra|  O|¡S t# P|¡rk|  Q¡ S tR|tSjTƒrw|  U|¡S t# V|¡rŽ|tWu r†t ¡ S |  L|  X|¡¡S tR|tYƒr™|  Z|¡S t[ \|¡rªt]|t^ƒrª|  _|¡S |t`u r³|  a¡ S tb c|¡r¿|  d|d¡S tE|ƒ}|durÎ|  e||¡S | jfr×|  g|¡S |  h|¡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)irž   r0   rh  rp  rƒ  r   Z
int_schemar!  Zfloat_schemar    Zbool_schemaÚcomplexZcomplex_schemar8   r€  ræ  rÈ   ÚdatetimeÚdateZdate_schemaZdatetime_schemaÚtimeZtime_schemaÚ	timedeltaZtimedelta_schemar
   Zdecimal_schemar'   Zuuid_schemar/   Z
url_schemar   r£  r+   Zmulti_host_url_schemarV   ÚNoneTypeZnone_schemar   ri  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_callableZcallable_schemaZ
is_literalr6   Ú_literal_schemar7   Ú_typed_dict_schemaÚis_namedtupleÚ_namedtuple_schemaZ
is_newtyper  Ú__supertype__r“   Ú_pattern_schemaÚis_hashableÚ_hashable_schemarO  Útypingr#   Ú_unsubstituted_typevar_schemaZis_finalvarr    r  ÚVALIDATE_CALL_SUPPORTED_TYPESÚ_call_schemar>  Úisclassr@  r   rE  r)   Ú_zoneinfo_schemaÚdataclassesÚis_dataclassÚ_dataclass_schemaÚ_match_generic_typer  r¤  r¨  )r  r¥  rÆ  r£   r£   r¤   r  Ø  sÄ   




















ÿ





zGenerateSchema.match_typerÆ  c                 C  sÆ  t  |¡r|  ||¡S t |¡r|  ||¡S |  ||¡}|d ur"|S t |¡r,|  	|¡S t
|ƒr5|  |¡S |tv r>|  |¡S |tv rJ|  |  |¡¡S |tv rV|  |  |¡¡S |tv rb|  |  |¡¡S |tv rn| j|  |¡Ž S |tv r{|  ||  |¡¡S |tv r‡|  |  |¡¡S |tv r—| j|g|  |¡¢R Ž S |tv r¥|  ||  |¡t¡S t |ƒr¯|  !||¡S |t"v r¸|  #|¡S |t$v rÄ|  %|  |¡¡S |t&v rÍ|  '|¡S |t(v rÖ|  )|¡S | j*rÞ|  +|¡S |  ,|¡S rÓ   )-r-  r.  r/  rV   r!  r"  rµ  r8   r  r  r;   Ú_union_schemarŠ   r  r‹   r  r  rŒ   r  r   r  rŽ   r  r
  r”   r…  r•   r•  r  rž  r  r   r7   r   r’   Ú_subclass_schemar   r  r‘   r  r“   r$  r  r¤  r¨  )r  r¥  rÆ  r¹   r£   r£   r¤   r0  N  sT   










z"GenerateSchema._match_generic_typeTrÄ  Únamerž   Ú
field_infor}   r¦   r`   úcore_schema.TypedDictFieldc                C  sD   |   |||¡}tj|d | ¡ sdn||d |d |d |d dS )zAPrepare a TypedDictField to represent a model or typeddict field.r¹   FÚserialization_excludeÚvalidation_aliasÚserialization_aliasr3  )rÅ  r6  r7  r8  r3  )rê  r0   Ztyped_dict_fieldÚis_required)r  r3  r4  r¦   rÅ  Úcommon_fieldr£   r£   r¤   Ú_generate_td_field_schema  s   	úz(GenerateSchema._generate_td_field_schemaúcore_schema.ModelFieldc                 C  s<   |   |||¡}tj|d |d |d |d |d |d dS )z0Prepare a ModelField to represent a model field.r¹   r6  r7  r8  Úfrozenr3  ©r6  r7  r8  r=  r3  )rê  r0   Zmodel_field©r  r3  r4  r¦   r:  r£   r£   r¤   rÌ  ”  s   úz(GenerateSchema._generate_md_field_schemaúcore_schema.DataclassFieldc                 C  sV   |   |||¡}tj||d |j|jpd|jrdnd|d |d |d |d |d d	
S )
zJPrepare a DataclassField to represent the parameter/field, of a dataclass.r¹   NFr6  r7  r8  r=  r3  )ÚinitZ	init_onlyÚkw_onlyr6  r7  r8  r=  r3  )rê  r0   Zdataclass_fieldrA  Zinit_varrB  r?  r£   r£   r¤   Ú_generate_dc_field_schema¥  s   öz(GenerateSchema._generate_dc_field_schemaÚalias_generatorú%Callable[[str], str] | AliasGeneratorr½   c                 C  s  |j du s|j dks|jdu s|jdu s|jdu r†d\}}}t| tƒr,|  |¡\}}}nt| tƒrE| |ƒ}t|tƒsEt	d| › d|j
› ƒ‚|j du sO|j dkrRd|_ |j dkrft||ƒ|_t||ƒ|_||_|jdu rn||_|jdu ryt||ƒ|_|jdu rˆt||ƒ|_dS dS dS )a„  Apply an alias_generator to aliases on a FieldInfo instance if appropriate.

        Args:
            alias_generator: A callable that takes a string and returns a string, or an AliasGenerator instance.
            field_info: The FieldInfo instance to which the alias_generator is (maybe) applied.
            field_name: The name of the field from which to generate the alias.
        NrQ   ©NNNúalias_generator ú must return str, not )Úalias_priorityÚaliasr7  r8  rO  r>   Úgenerate_aliasesr   rž   rÉ   rå   rí   )rD  r4  r½   rJ  r7  r8  r£   r£   r¤   Ú$_apply_alias_generator_to_field_infoº  s4   












ãz3GenerateSchema._apply_alias_generator_to_field_infoÚcomputed_field_infor|   Úcomputed_field_namec                 C  s²   |j du s|j dks|jdu rUd\}}}t| tƒr"|  |¡\}}}nt| tƒr;| |ƒ}t|tƒs;td| › d|j› ƒ‚|j du sE|j dkrHd|_ |j dkrWt	||ƒ|_dS dS dS )a­  Apply an alias_generator to alias on a ComputedFieldInfo instance if appropriate.

        Args:
            alias_generator: A callable that takes a string and returns a string, or an AliasGenerator instance.
            computed_field_info: The ComputedFieldInfo instance to which the alias_generator is (maybe) applied.
            computed_field_name: The name of the computed field from which to generate the alias.
        NrQ   rF  rG  rH  )
rI  rJ  rO  r>   rK  r   rž   rÉ   rå   rí   )rD  rM  rN  rJ  r7  r8  r£   r£   r¤   Ú-_apply_alias_generator_to_computed_field_infoì  s    







ëz<GenerateSchema._apply_alias_generator_to_computed_field_inforË   c                 C  sZ   |j p| j }|du rdS |jdu r+|||ƒ}t|tƒs&td|› d|j› ƒ‚||_dS dS )ae  Apply a field_title_generator on a FieldInfo or ComputedFieldInfo instance if appropriate
        Args:
            config_wrapper: The config of the model
            field_info: The FieldInfo or ComputedField instance to which the title_generator is (maybe) applied.
            field_name: The name of the field from which to generate the title.
        Nzfield_title_generator rH  )Úfield_title_generatorrÎ   rO  rž   rÉ   rå   )rú   r4  r½   rP  rÎ   r£   r£   r¤   Ú*_apply_field_title_generator_to_field_info  s   




ûz9GenerateSchema._apply_field_title_generator_to_field_infoÚ_CommonFieldc                   s¼  ˆj ˆj}}d‡‡fdd„}g }t|j ¡ |ƒD ]}| t|jj  	|¡¡ qˆj
 |¡  ˆjd ur?ˆj||| |d}	nˆ ||| ¡}	W d   ƒ n1 sQw   Y  t|j ¡ |ƒ}
t|
ƒredˆ_dd	„ |
D ƒ‰ ‡ fd
d	„|
D ƒ}
t|	ˆ |ƒ}	t|	|
|ƒ}	ˆ ¡ sŠtˆ|	ƒ}	ˆ |	t|j ¡ |ƒ¡}	ˆ ˆjˆ|¡ tˆƒ\}}i }t|||d ˆjj}|d ur¼ˆ |ˆ|¡ tˆjtt fƒrÊˆj !¡ }nˆj}t"|	ˆj#rÔdnd |ˆj$ˆj%|dS )Nr¹   r*   rŸ   c                   s   ˆ  | ˆ j¡} | S rÓ   )r¬  r©  ©r¹   )r4  r  r£   r¤   Úset_discriminator2  s   z>GenerateSchema._common_field_schema.<locals>.set_discriminator)Útransform_inner_schemaTc                 S  s   g | ]
}|j jd u r|‘qS )T)r›   Z	each_itemrú  r£   r£   r¤   r¶   M  r·   z7GenerateSchema._common_field_schema.<locals>.<listcomp>c                   s   g | ]}|ˆ vr|‘qS r£   r£   rú  )r»   r£   r¤   r¶   N  s    ©Úpydantic_js_updatesÚpydantic_js_extrar>  ©r¹   r*   rŸ   r*   )&Ú
annotationr3  r¸   râ  r=  r³  rš   r›   rP  Z_from_decoratorr÷   rÝ  r©  Ú_apply_annotationsrã  Ú$_validators_require_validate_defaultÚvalidate_defaultrÅ   rÇ   r9  Úwrap_defaultÚ_apply_field_serializersrÑ  rQ  r  rÚ   rZ   rD  rL  rO  r7  r=   r?   Zconvert_to_aliasesÚ_common_fieldÚexcluder8  r=  )r  r3  r4  r¦   Úsource_typer   rT  Zvalidators_from_decoratorsÚ	decoratorr¹   Zthis_field_validatorsrW  rX  Úcore_metadatarD  r7  r£   )r»   r4  r  r¤   rê  -  s`   

ÿþ€ú
ÿÿúz#GenerateSchema._common_field_schemaÚ
union_typec           
      C  sÂ   | j |dd}g }d}|D ]}|du s|tju rd}q| |  |¡¡ qt|ƒdkr/|d }n)g }|D ]}tt| di ¡ƒ d¡}	|	durM| ||	f¡ q3| |¡ q3t	 
|¡}|r_t	 |¡}|S )	zGenerate schema for a Union.TrÄ  FNrQ   r   r3  Zpydantic_internal_union_tag_key)ré  rV   r  r³  r  r	  r%   rY   rÆ   r0   r„  Znullable_schema)
r  re  r  ÚchoicesrÀ   ÚargÚsZchoices_with_tagsÚchoiceÚtagr£   r£   r¤   r1  v  s&   


zGenerateSchema._union_schemar3   c           	      C  s  | j  |¡s\}}|d ur|W  d   ƒ S t|ƒp|}t|ƒ}| j |¡> ztj|jg| j	¢R Ž }W n t
yF } zt |¡|‚d }~ww t||ƒ}|  |¡}|d dksYJ ‚||d< W d   ƒ n1 sgw   Y  | j  |¡W  d   ƒ S 1 s|w   Y  d S )Nr¿   r¼  r2  )rù   rÙ  r6   rp   rõ   rÝ  rV   Z	eval_typeÚ	__value__r  rß  rG   rà  rq   r  rÜ  )	r  r¥  r2  rñ  rÆ  rý   rZ  rs  r¹   r£   r£   r¤   r  ‘  s(   þ€ÿ


ø
	$ðz&GenerateSchema._type_alias_type_schemaÚliteral_typec                 C  s\   t t|dddƒ}|sJ d|› ƒ‚t |¡}| jjr,tdd„ |D ƒƒr,t dd„ |¡}|S )	zGenerate schema for a Literal.FÚeager)Z
type_checkZunpack_type_aliasesz(literal "expected" cannot be empty, obj=c                 s  s    | ]}t |tƒV  qd S rÓ   )rO  r   rú  r£   r£   r¤   r  ª  ó   € z1GenerateSchema._literal_schema.<locals>.<genexpr>c                 S  s   t | tƒr| jS | S rÓ   )rO  r   r4  )rÖ   r£   r£   r¤   r%  ¬  r}  z0GenerateSchema._literal_schema.<locals>.<lambda>)r;  r:   r0   Zliteral_schemar  rB  ÚanyrC  )r  rl  Úexpectedr¹   r£   r£   r¤   r  ¤  s   
ÿzGenerateSchema._literal_schemaÚtyped_dict_clsc                   s.  t ƒ }ˆj |¡‚ ˆj |¡a\}}|dur)|W  d  ƒ W  d  ƒ S t|ƒ}|dur3|}tsBt|ƒjdkrBt	ddd‚zt
|dƒ}W n tyT   d}Y nw ˆj |¡ ˆjj|jd}|j}	i }
t |¡‰ ˆjjrzt|dd	}nd}z
tj|ˆjd
}W n ty˜ } zt |¡|‚d}~ww g }| ¡ D ]P\}}|j|tjd}t|j |ƒ|_ ||	v pºd|j!v o¿d|j!v}d|j!v rÊ| "|¡ |durÜ|j#du rÜ||v rÜ|| |_#ˆ $ˆj||¡ ˆj%||ˆ |d|
|< qŸ|r!d &dd„ |D ƒ¡}t'|ƒdk}t( )d|rdnd› d|› d|j›d|rdnd› d	t*¡ t+j,|
|‡ ‡fdd„ˆ j- .¡ D ƒ||d}ˆ /|ˆ j0 .¡ ¡}t1|ˆ j2 .¡ dƒ}ˆj 3|¡W  d  ƒ W  d  ƒ W  d  ƒ S 1 sgw   Y  W d  ƒ n1 sww   Y  W d  ƒ dS W d  ƒ dS 1 sw   Y  dS ) 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¾  T)Zuse_inspect©rû   ©Ú_sourcerÅ  Znot_requiredZ	read_onlyrÄ  ú, c                 s  ó    | ]}t |ƒV  qd S rÓ   ©Úrepr)r´   Úfr£   r£   r¤   r    ó   € z4GenerateSchema._typed_dict_schema.<locals>.<genexpr>r<   ZItemrh  rÍ   ú z on TypedDict class ZareÚiszk using the `ReadOnly` qualifier. Pydantic will not protect items from any mutation on dictionary instances.c                   rÎ  r£   rÏ  rÒ  rÍ  r£   r¤   r¶     rÔ  z5GenerateSchema._typed_dict_schema.<locals>.<listcomp>)r  rÕ  r2  rË  Úall)4rs   rø   rÝ  rù   rÙ  rp   Ú_SUPPORTS_TYPEDDICTr¿   rð   rH   rg   ÚAttributeErrorrô   r  rÞ  rï   Ú__required_keys__r`   ÚbuildZuse_attribute_docstringsrk   rV   Úget_cls_type_hintsrõ   rß  rG   rà  rÙ   Úfrom_annotationr9   Z
TYPED_DICTrq   rZ  Z_qualifiersr³  rÏ   rQ  r;  Újoinr	  ræ   r(   r  r0   Ztyped_dict_schemarÕ  r=  rî  rï  rë  rå  rÜ  )r  rq  rÆ  r}   Ztyped_dict_refrñ  rý   rË  rÞ  Úrequired_keysr¢   Zfield_docstringsr   rs  Zreadonly_fieldsr½   rZ  r4  rÅ  Zfields_reprÚpluralZ	td_schemar¹   r£   rÍ  r¤   r   ±  s¢   

ÿ
þø
þÿ
€ÿÿþ



ÿ ÿüþø
¿åTåz!GenerateSchema._typed_dict_schemaÚnamedtuple_clsc           	        sV  ˆj  ˆ ¡› ˆj ˆ ¡„\}}|dur$|W  d  ƒ W  d  ƒ S tˆ ƒ‰|dur.|‰ z
tjˆ ˆjd}W n tyJ } zt	 
|¡|‚d}~ww |sUdd„ ˆ jD ƒ}ˆrb‡fdd„| ¡ D ƒ}tj‡ ‡fdd„| ¡ D ƒdd	id
}tj|ˆ |d}ˆj |¡W  d  ƒ W  d  ƒ S 1 s”w   Y  W d  ƒ dS 1 s¤w   Y  dS )z!Generate schema for a NamedTuple.Nrs  c                 S  s   i | ]}|t “qS r£   )r   )r´   rÕ   r£   r£   r¤   r×   0  ó    z5GenerateSchema._namedtuple_schema.<locals>.<dictcomp>c                   s   i | ]
\}}|t |ˆ ƒ“qS r£   ©rq   ©r´   r½   rZ  ©rý   r£   r¤   r×   3  s    
ÿÿc              
     s0   g | ]\}}ˆj ||tjˆ j |tj¡d ‘qS ))r|  Údefault)Ú_generate_parameter_schemar9   ZNAMED_TUPLEÚ_field_defaultsrÆ   r   Úemptyr‹  )rˆ  r  r£   r¤   r¶   9  s    úüÿz5GenerateSchema._namedtuple_schema.<locals>.<listcomp>Z'pydantic_js_prefer_positional_argumentsTr:  )r2  )rø   rÝ  rù   rÙ  rp   rV   rƒ  rõ   rß  rG   rà  Ú_fieldsrÙ   r0   Úarguments_schemaÚcall_schemarÜ  )	r  rˆ  rÆ  Znamedtuple_refrñ  r   rs  r’  r¹   r£   )rˆ  r  rý   r¤   r"    sD   
ÿ
þø	€ÿ
þù	ö
RØz!GenerateSchema._namedtuple_schemarZ  ú	type[Any]r9   r  rP  úJLiteral['positional_only', 'positional_or_keyword', 'keyword_only'] | Noneúcore_schema.ArgumentsParameterc                 C  s
  t ƒ }|tju r|j||d}n|j|||d}|jdus!J dƒ‚| j |¡ |  |j|g¡}W d  ƒ n1 s:w   Y  | 	¡ sHt
||ƒ}t ||¡}	|durV||	d< |jdurb|j|	d< |	S | jj}
t|
tƒry|
jdury|
 |¡|	d< |	S t|
ƒrƒ|
|ƒ|	d< |	S )zñGenerate 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`'.
        rt  Nz<field.annotation should not be None when generating a schemarP  rJ  )rs   r   r  r„  Úfrom_annotated_attributerZ  r÷   rÝ  r[  r9  r^  r0   Zarguments_parameterrJ  r  rD  rO  r>   Úcallable)r  r3  rZ  r|  r  rP  r}   r   r¹   Úparameter_schemarD  r£   r£   r¤   rŽ  G  s.   
ÿ


ûþz)GenerateSchema._generate_parameter_schemaú‡Literal['positional_only', 'positional_or_keyword', 'keyword_only', 'var_args', 'var_kwargs_uniform', 'var_kwargs_unpacked_typed_dict']ú core_schema.ArgumentsV3Parameterc                 C  sì   t ƒ }|tju r|j||d}n|j|||d}| j |¡ |  |j|g¡}W d  ƒ n1 s1w   Y  | 	¡ s?t
||ƒ}tj|||d}	|jdurS|j|	d< |	S | jj}
t|
tƒrj|
jdurj|
 |¡|	d< |	S t|
ƒrt|
|ƒ|	d< |	S )zÖGenerate 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.
        rt  N)r3  r¹   rP  rJ  )rs   r   r  r„  r—  r÷   rÝ  r[  rZ  r9  r^  r0   Zarguments_v3_parameterrJ  r  rD  rO  r>   r˜  )r  r3  rZ  r|  rP  r  r}   r   r¹   r™  rD  r£   r£   r¤   Ú_generate_parameter_v3_scheman  s0   
ÿ
ý

úýz,GenerateSchema._generate_parameter_v3_schemaÚ
tuple_typec                   sÎ   t |ƒ‰ˆ  |¡}ˆr|rt‡fdd„|D ƒƒ}|s-|tv r(tjt ¡ gddS t g ¡S |d tu rJt|ƒdkrFtjˆ  	|d ¡gddS t
dƒ‚t|ƒdkr[|d d	kr[t g ¡S t ‡ fd
d„|D ƒ¡S )zIGenerate schema for a Tuple, e.g. `tuple[int, str]` or `tuple[int, ...]`.c                 3  s    | ]}t |ˆ ƒV  qd S rÓ   rŠ  ©r´   ÚparamrŒ  r£   r¤   r  ¦  rn  z/GenerateSchema._tuple_schema.<locals>.<genexpr>r   )rÂ   rà   r<   z&Variable tuples can only have one typerQ   r£   c                   s   g | ]}ˆ   |¡‘qS r£   )r  rž  r  r£   r¤   r¶   »  rû  z0GenerateSchema._tuple_schema.<locals>.<listcomp>)rp   ré  rÁ   rŠ   r0   Ztuple_schemarÈ   ÚEllipsisr	  r  Ú
ValueError)r  r  Úparamsr£   )r  rý   r¤   r  Ÿ  s   


zGenerateSchema._tuple_schemac                 C  s   t jt  t¡dddS )NZis_typezInput should be a typery  )r0   Úcustom_error_schemarD  r¿   r  r£   r£   r¤   r  ½  s
   ýzGenerateSchema._type_schemac                 C  s.   ddl m} ddd„ gi}tj|t ¡ |dS )z/Generate schema for a zone_info.ZoneInfo objectrQ   )Úvalidate_str_is_valid_iana_tzr/  c                 S  r   )NrY  ÚzoneinforZ  r£   r\  r£   r£   r¤   r%  È  r¡  z1GenerateSchema._zoneinfo_schema.<locals>.<lambda>©rÞ   r3  )rd  r¤  r0   rf  r¢  )r  r¤  r3  r£   r£   r¤   r,  Ä  s   ýzGenerateSchema._zoneinfo_schemac                   s&   ˆ j |dd}t ‡ fdd„|D ƒ¡S )z*Generate schema for `type[Union[X, ...]]`.TrÄ  c                   ó   g | ]	}ˆ   t| ¡‘qS r£   ©r  r¿   )r´   r  r  r£   r¤   r¶   Ò  ó    z<GenerateSchema._union_is_subclass_schema.<locals>.<listcomp>)ré  r0   r„  )r  re  r  r£   r  r¤   Ú_union_is_subclass_schemaÏ  s   z(GenerateSchema._union_is_subclass_schemaÚtype_c                   s0  ˆ   |¡}t |¡p|}t |¡rˆ  ¡ S t |¡r"ˆ  t|j	 ¡S t 
|¡rQ|jr=tt|jƒƒr7ˆ  |j¡S t |j¡S |jrMt ‡ fdd„|jD ƒ¡S ˆ  ¡ S tt|ƒƒr\ˆ  |¡S t |¡rfˆ  |¡}t |¡r}td|›dt t|ƒ¡› ddd‚t |¡s“|du rŒt tj¡S td|›ƒ‚t |¡S )	z-Generate schema for a type, e.g. `type[int]`.c                   r§  r£   r¨  )r´   Úcr  r£   r¤   r¶   å  r©  z3GenerateSchema._subclass_schema.<locals>.<listcomp>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 )r  rV   Úannotated_typer8   r€  r  r  r  r¿   rk  Z
is_typevarÚ	__bound__r;   r6   rª  r0   Zis_subclass_schemaÚ__constraints__r„  r  rô  Zis_generic_aliasrH   rU   Zdisplay_as_typer>  r+  r  rÉ   )r  r«  Ú
type_paramr£   r  r¤   r2  Ô  s@   







ÿÿý

zGenerateSchema._subclass_schemac           	      C  s„   ddl m} |  |¡}t |¡}t|ƒ}tjtjdd}t	 
|¡s2ddlm} t |t ||¡g¡}tj||dd}tj|||dS )	z5Generate schema for a Sequence, e.g. `Sequence[int]`.rQ   r†  ÚSequencerŠ  )Úsequence_validatorTr‹  )r*  rU  rÞ   )r  r‡  r  r0   r  r{   rD  r'  r±  r8   r€  rd  r²  r‘  r  r’  rg  )	r  r  r‡  r“  r  r*  rU  r²  rÞ   r£   r£   r¤   r  û  s    


ÿÿÿzGenerateSchema._sequence_schemaúcore_schema.GeneratorSchemac                 C  s   |   |¡}t |  |¡¡S )z$Generate a schema for an `Iterable`.)r  r0   Zgenerator_schemar  )r  r«  Z	item_typer£   r£   r¤   r    s   
zGenerateSchema._iterable_schemaÚpattern_typec                 C  s®   ddl m} ddd„ gi}tjtdƒdt ¡ d}|tju s#|tju r,tj	|j
||d	S | j|d
dd }|tu rBtj	|j||d	S |tu rOtj	|j||d	S td|›dƒ‚)NrQ   )rd  r/  c                 S  r   )NrY  ÚregexrZ  r£   r\  r£   r£   r¤   r%    r¡  z0GenerateSchema._pattern_schema.<locals>.<lambda>Úpatternrá   )rã   Úreturn_schemar¦  TrÄ  r   r¦  rª   )rÍ   rd  r0   rç   r   rh  r'  ÚPatternÚrerf  Zpattern_either_validatorré  rž   Zpattern_str_validatorrp  Zpattern_bytes_validatorrF   )r  r´  rd  r3  ZserrŸ  r£   r£   r¤   r$    s0   ÿÿþýÿÿzGenerateSchema._pattern_schemac                 C  s<   t jt jt  t  ¡ t  tjj¡g¡t  tjj¡ddddS )NrT  r%  zInput should be hashable)r¹   rz  r{  )	r0   r£  rg  r‘  rÈ   rD  rŽ  ÚabcÚHashabler  r£   r£   r¤   r&  4  s   ÿüøzGenerateSchema._hashable_schemaÚ	dataclassútype[StandardDataclass]útype[StandardDataclass] | Nonec                   s|  ˆj  |¡¬ ˆj |¡‹\}}|dur&|W  d  ƒ W  d  ƒ S |j d¡}|durkt|tƒsk|d dkrAˆj |¡}t	|ƒ}|r[ˆj 
|¡W  d  ƒ W  d  ƒ S |W  d  ƒ W  d  ƒ S t|ƒ}|duru|}t|ddƒ}ddlm}	 ˆj |¡ ˆj |¡ë |	|ƒr²dd	„ |j ¡ D ƒ}
|r±|
 ¡ D ]}|j|gˆj¢R Ž  q¤nt||ˆjd
}
ˆjjdkrØ|
 ¡ D ]\}}|jdu r×td|› ddd‚qÄ|j d¡pât |¡‰ t‡ ‡fdd„|
 ¡ D ƒdd„ d}t|dƒ}t|dƒ}tj |j!|‡ ‡fdd„ˆ j" ¡ D ƒ|d}t#|ˆ j$ ¡ dƒ}ˆ j% ¡ }t&||dƒ}ˆjj'|j!d}tj(|||||dd„ t )|¡D ƒ||ˆjj*j+d	}ˆ ,|ˆ j- ¡ ¡}t&||d ƒ}ˆj 
|¡W  d  ƒ W  d  ƒ W  d  ƒ W  d  ƒ S 1 s~w   Y  W d  ƒ n	1 sŽw   Y  W d  ƒ n1 sžw   Y  W d  ƒ dS W d  ƒ dS 1 s·w   Y  dS )!z Generate schema for a dataclass.Nr»  r¿   r¼  rr  r<   )Úis_pydantic_dataclassc                 S  s   i | ]	\}}|t |ƒ“qS r£   r   )r´   Úf_namer4  r£   r£   r¤   r×   i  r©  z4GenerateSchema._dataclass_schema.<locals>.<dictcomp>)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á  c                 3  s"    | ]\}}ˆ  ||ˆ ¡V  qd S rÓ   )rC  rÔ   rÍ  r£   r¤   r  ‚  s   €  z3GenerateSchema._dataclass_schema.<locals>.<genexpr>c                 S  s   |   d¡duS )NrB  F)rÆ   )rë   r£   r£   r¤   r%  ƒ  r`  z2GenerateSchema._dataclass_schema.<locals>.<lambda>)ÚkeyÚ__post_init__Ú	__slots__c                   rÎ  r£   rÏ  rÒ  rÍ  r£   r¤   r¶   ‹  rÔ  z4GenerateSchema._dataclass_schema.<locals>.<listcomp>)rÕ  Zcollect_init_onlyrÈ  r¾  c                 S  s   g | ]}|j ‘qS r£   )r3  )r´   r   r£   r£   r¤   r¶   Ÿ  r‰  )rÉ  rÊ  r2  r¢   ÚslotsrË  r=  rØ  ).rø   rÝ  rù   rÙ  rÚ  rÆ   rO  rt   rÛ  r[   rÜ  rp   rä   r-  r¿  rõ   rô   r¿  rÙ   r=  Zapply_typevars_mapr  rl   r  ÚextrarA  rH   r`   r‚  ÚsortedÚhasattrr0   Zdataclass_args_schemarï   rÕ  rÇ   rí  rå  rë  rÞ  Zdataclass_schemar¢   r  r=  rî  rï  )r  r¼  rÆ  Zdataclass_refrñ  r¹   r2  rý   rË  r¿  r¢   r   r½   r  Úhas_post_initZ	has_slotsZargs_schemarÊ   rå  rÞ  Z	dc_schemar£   rÍ  r¤   r/  @  s¦   
ÿ
þø

ðî€ý

ýÿþ

þù

õ
»á2€Táz GenerateSchema._dataclass_schemaÚfunctionÚValidateCallSupportedTypesúcore_schema.CallSchemac           
      C  sn   |   |¡}d}| j}|jr/t|ƒ}|j}||jur/| j\}}tj|||dhd}	|  	|	d ¡}t
j|||dS )zsGenerate schema for a Callable.

        TODO support functional validators once we support them in Config
        NrŸ   )ÚglobalnsÚlocalnsZinclude_keys)r·  )Ú_arguments_schemar  Zvalidate_returnr   Úreturn_annotationr  r  rV   Úget_function_type_hintsr  r0   r“  )
r  rÉ  r’  r·  rú   ÚsigZreturn_hintrÌ  rÍ  Ú
type_hintsr£   r£   r¤   r*  ª  s"   



ÿýzGenerateSchema._call_schemaÚparameters_callbackúParametersCallback | Noneúcore_schema.ArgumentsSchemac                 C  sä  t jdt jdt jdi}t|ƒ}| j\}}tj|||d}g }d}	d}
d}t|j	 
¡ ƒD ]º\}\}}|j|ju r>t tt¡}n|| }|durQ||||ƒ}|dkrQq+| |j¡}|durl|  ||tj|j|¡}| |¡ q+|jt jkrx|  |¡}	q+|jt jksƒJ |jƒ‚t |¡}|durÞt|ƒp‘|}t|ƒsŸtd|›dd	‚d
d„ |j	 
¡ D ƒ}| |j¡}|rÓtd|j ›dt!|ƒdkr¿dnd› dd "dd„ t#|ƒD ƒ¡› dd	‚d}|  $|t|ƒ¡}
q+d}|  |¡}
q+t%j&||	||
| j'j(dS )z Generate schema for a Signature.Úpositional_onlyÚpositional_or_keywordÚkeyword_only©rÌ  rÍ  NÚskipú7Expected a `TypedDict` class inside `Unpack[...]`, got úunpack-typed-dictr«   c                 S  ó    h | ]\}}|j tjkr|’qS r£   ©Úkindr   ÚPOSITIONAL_ONLY©r´   r3  Úpr£   r£   r¤   Ú	<setcomp>ô  ó    z3GenerateSchema._arguments_schema.<locals>.<setcomp>úTyped dictionary ú overlaps with parameterr<   rh  rÍ   r|  rv  c                 s  rw  rÓ   rx  ©r´   râ  r£   r£   r¤   r  ü  r{  z3GenerateSchema._arguments_schema.<locals>.<genexpr>úoverlapping-unpack-typed-dictzunpacked-typed-dictÚuniform)Úvar_args_schemaÚvar_kwargs_modeÚvar_kwargs_schemaÚvalidate_by_name))r   rà  ÚPOSITIONAL_OR_KEYWORDÚKEYWORD_ONLYr   r  rV   rÐ  Ú	enumerateÚ
parametersrÙ   rZ  r  r'  r%   r   rÆ   rß  rŽ  r9   ÚFUNCTIONr  r³  ÚVAR_POSITIONALr  ÚVAR_KEYWORDÚunpack_typer6   r7   rH   ÚintersectionrÁ  rï   r	  r…  rÆ  r   r0   r’  r  rí  )r  rÉ  rÓ  Úmode_lookuprÑ  rÌ  rÍ  rÒ  Zarguments_listrê  rì  rë  Úir3  râ  rZ  ÚresultÚparameter_modeZ
arg_schemarõ  rÆ  Únon_pos_only_param_namesÚoverlapping_paramsr£   r£   r¤   rÎ  Ã  sx   ý
ÿ
þÿ
ÿþüûz GenerateSchema._arguments_schemaúcore_schema.ArgumentsV3Schemac                 C  s¨  t jdt jdt jdt jdi}t|ƒ}| j\}}tj|||d}g }t	|j
 ¡ ƒD ]¢\}	\}
}|d ur>||	|
|jƒ}|dkr>q(|jt ju rKt tt¡}n||
 }| |j¡}|d u r»|jt jksdJ |jƒ‚t |¡}|d ur¹t|ƒpr|}t|ƒs€td|›dd	‚d
d„ |j
 ¡ D ƒ}| |j¡}|r´td|j›dt|ƒdkr dnd› dd dd„ t|ƒD ƒ¡› dd	‚d}|}nd}| | j|
|t j!||j"d¡ q(t#j$|| j%j&dS )NrÖ  r×  Zvar_argsrØ  rÙ  rÚ  rÛ  rÜ  r«   c                 S  rÝ  r£   rÞ  rá  r£   r£   r¤   rã  7  rä  z6GenerateSchema._arguments_v3_schema.<locals>.<setcomp>rå  ræ  r<   rh  rÍ   r|  rv  c                 s  rw  rÓ   rx  rç  r£   r£   r¤   r  ?  r{  z6GenerateSchema._arguments_v3_schema.<locals>.<genexpr>rè  Zvar_kwargs_unpacked_typed_dictZvar_kwargs_uniform)r  )rí  )'r   rà  rî  ró  rï  r   r  rV   rÐ  rð  rñ  rÙ   rZ  r  r'  r%   r   rÆ   rß  rô  rõ  r6   r7   rH   rö  rÁ  rï   r	  r…  rÆ  r³  rœ  r9   rò  r  r0   Zarguments_v3_schemar  rí  )r  rÉ  rÓ  r÷  rÑ  rÌ  rÍ  rÒ  Zparameters_listrø  r3  râ  rù  rZ  rú  rõ  rÆ  rû  rü  r£   r£   r¤   Ú_arguments_v3_schema  sl   üþ	

þÿ
ÿþüÿÿþz#GenerateSchema._arguments_v3_schemaÚtypevarútyping.TypeVarc                 C  s„   z|  ¡ }W n	 ty   Y n	w |r|  |j¡S |j }r%|  tj| ¡S |j }r>|  |¡}t	j
dd„ t	 ¡ d|d< |S t	 ¡ S )Nc                 S  rš  rÓ   r£   )r$  r›  r£   r£   r¤   r%  b  rœ  z>GenerateSchema._unsubstituted_typevar_schema.<locals>.<lambda>rS  rÞ   )Úhas_defaultr€  r  Ú__default__r¯  r1  r'  r$   r®  r0   r’  rÈ   )r  rÿ  r  Úconstraintsr†   r¹   r£   r£   r¤   r(  R  s"   þ



þz,GenerateSchema._unsubstituted_typevar_schemarÓ  úDecorator[ComputedFieldInfo]rÑ  ú2dict[str, Decorator[FieldSerializerDecoratorInfo]]úcore_schema.ComputedFieldc           
   
   C  s(  |j jtur|j j}nztj|j| jjd}W n ty) } zt	 
|¡|‚d }~ww |tu r4tddd‚t|| jƒ}tj|j |d|_ |  |¡}|  |t| ¡ |jƒ¡}| jj}|d urf| j||j |jd |  | j|j |j¡ t|j ƒ\}}i }	t|	ddi|r‚|ni ¥|d	 tj|j||j j|	d
S )N©rÍ  zŸComputed 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)rD  rM  rN  ZreadOnlyTrV  )r·  rJ  r3  )r›   r  r.   rR   Úget_callable_return_typeÚfuncr  Úlocalsrß  rG   rà  rH   rq   rö   r-  Úreplacer  r_  r¸   r=  r®   r  rD  rO  rQ  rÚ   rZ   r0   Zcomputed_fieldrJ  )
r  rÓ  rÑ  r  rs  Zreturn_type_schemarD  rW  rX  rd  r£   r£   r¤   rÐ  i  sH   
€ÿý
þ
ÿýÿz%GenerateSchema._computed_field_schemar­  c                 C  sF   t ƒ }| j|dd^}}|  ||¡}|D ]}t||ƒr t||ƒ}q|S )zdGenerate schema for an Annotated type, e.g. `Annotated[int, Field(...)]` or `Annotated[int, Gt(0)]`.TrÄ  )rs   ré  r[  rO  r^  )r  r­  r}   rb  r   r¹   rZ  r£   r£   r¤   r  œ  s   
þ

€z GenerateSchema._annotated_schemac                 C  r"  rÓ   r£   r#  r£   r£   r¤   r%  ¯  r&  zGenerateSchema.<lambda>rb  r   ú	list[Any]rU  ú"Callable[[CoreSchema], CoreSchema]c           
        s„   t t |¡ƒ}g }d
‡ ‡‡fdd„}t|ˆ ƒ}|D ]}|du r qˆ  |||¡}q|ˆƒ}|r:| di ¡}	t|	|d	 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).
        r¥  r   rŸ   r*   c                   sV   ˆ   | ˆ¡}|d u rˆ  | ¡}t| ƒ}|d ur't|ˆ jƒ}|d ur'ˆ  ||¡ ˆ|ƒS rÓ   )rµ  r¶  r·  r¸  rù   r´  )r¥  r¹   r¹  r¯  ©r  rb  rU  r£   r¤   Úinner_handler»  s   
z8GenerateSchema._apply_annotations.<locals>.inner_handlerNr3  )Ú pydantic_js_annotation_functions©r¥  r   rŸ   r*   )
r;  rT   Zexpand_grouped_metadatary   Ú_get_wrapped_inner_schemar²  rZ   rê   r  rÛ   )
r  rb  r   rU  r  r  Úget_inner_schemarZ  r¹   rd  r£   r  r¤   r[  «  s   
ÿz!GenerateSchema._apply_annotationsr3  c                 C  sL  t ƒ }t||ƒr"|jD ]}|  ||¡}q|jd ur |  ||j¡}|S |d dkr>| dt ¡ ¡}|  ||¡}|r<||d< |S |}| d¡}|d urg| 	¡ }|dt
|ƒ›  }| j |¡ }	d urb|	S ||d< n1|d dkr˜|d }| j |¡ }
d ur˜|
 	¡ }|dt
|ƒ›  }| j |¡ }	d ur”|	S ||d< t ||¡}|d ur¤|S |S )Nr¿   rÀ   r¹   r2  r6  údefinition-refr  )rs   rO  r3  Ú_apply_single_annotationr©  r¬  rÆ   r0   rÈ   r	   ry  rù   Úget_schema_from_refrT   Zapply_known_metadata)r  r¹   r3  r}   Úfield_metadatarÈ  r+  r2  Znew_refÚexistingZreferenced_schemaZmaybe_updated_schemar£   r£   r¤   r  ×  sB   




z'GenerateSchema._apply_single_annotationc                 C  sR   t ƒ }t||ƒr'|jD ]}|  ||¡}qt|ƒ\}}| di ¡}t|||d |S )Nr3  rV  )rs   rO  r3  Ú$_apply_single_annotation_json_schemarÚ   r²  rZ   )r  r¹   r3  r}   r  rW  rX  rd  r£   r£   r¤   r  	  s   

ÿz3GenerateSchema._apply_single_annotation_json_schemar  r@   r  úlist[GetJsonSchemaFunction]ry   c                   s,   t ˆ dd ƒ‰d‡ ‡‡‡‡fdd„}t|ˆƒS )	Nrö  r|  r   rŸ   rº   c                   sR   ˆd ur
ˆ| ˆƒ}nˆ| ƒ}ˆ  |ˆ ¡}ˆ |ˆ ¡}tˆ ƒ}|d ur'ˆ |¡ |S rÓ   )r  r  r·  r³  )r|  r¹   r¹  ©rZ  Zannotation_get_schemar  r  r  r£   r¤   Únew_handler	  s   
z=GenerateSchema._get_wrapped_inner_schema.<locals>.new_handler)r|  r   rŸ   rº   )rä   ry   )r  r  rZ  r  r  r£   r  r¤   r  	  s   
z(GenerateSchema._get_wrapped_inner_schemaÚserializersú-list[Decorator[FieldSerializerDecoratorInfo]]c           
   
   C  s0  |r–t |ƒ}|d dkr|d }|  ||¡|d< |S d|v r$| j |¡}|d }t|j|jjƒ\}}|jjt	ur=|jj}nzt
j|j| jjd}W n ty[ } zt |¡|‚d}~ww |t	u rcd}	n|  |¡}	|jjdkrtj|j|||	|jjd	|d
< |S |jjdks‡J ‚tj|j|||	|jjd	|d
< |S )z$Apply field serializers to a schema.r¿   r¼  r¹   r2  rà   r  Nr™   )Úis_field_serializerrX  r·  rã   rÞ   r˜   )r	   r_  rù   rÜ  rh   r
  r›   rP  r  r.   rR   r	  r  r  rß  rG   rà  r  r0   r’  rã   rç   )
r  r¹   r  rÊ   Ú
serializerr   rX  r  rs  r·  r£   r£   r¤   r_  (	  sR   


ÿ€ÿ

ûø
ûz'GenerateSchema._apply_field_serializersú1Iterable[Decorator[ModelSerializerDecoratorInfo]]c           
   
   C  sî   |  dd¡}|rot|ƒd }t|j|jjƒ}|jjtur!|jj}nztj	|j| j
jd}W n ty? } zt |¡|‚d}~ww |tu rGd}n|  |¡}|jjdkr_tj|j|||jjd}	ntj|j|||jjd}	|	|d< |ru||d< |S )z$Apply model serializers to a schema.r2  Nrà   r  r™   )rX  r·  rã   rÞ   )Úpopr;  ri   r
  r›   rP  r  r.   rR   r	  r  r  rß  rG   rà  r  r0   r’  rã   rç   )
r  r¹   r  r2  r!  rX  r  rs  r·  Z
ser_schemar£   r£   r¤   rî  `	  sD   


ÿ€ÿ
üüz'GenerateSchema._apply_model_serializers)NN)rú   rW   rû   rü   rý   rþ   rŸ   r©   ©rŸ   r©   )rŸ   rW   )rŸ   ru   )rŸ   r    )r  r   rŸ   r*   )r  r   r  r   rŸ   r*   )r  r  rŸ   r*   )rÝ   r   rŸ   r*   )rÝ   r   rj  r   rŸ   r*   )rÝ   r   r  r   r  r   rŸ   r*   )rŸ   r*   r  )r¹   r*   r©  rª  rŸ   r*   rY  )r¯  r*   r°  r±  rŸ   r©   )r¥  r   rŸ   rº   )r  rº  rŸ   rº   )r¥  r   rŸ   r   )r¥  r   r|  r   rŸ   rõ  )r¥  r   rÅ  rþ  rŸ   rÿ  )r¥  r   rŸ   r  )F)r¥  r   rÅ  r    rŸ   r  )r¥  r   rŸ   r  )r¥  r   rÆ  r   rŸ   r*   )
r3  rž   r4  r}   r¦   r`   rÅ  r    rŸ   r5  )r3  rž   r4  r}   r¦   r`   rŸ   r<  )r3  rž   r4  r}   r¦   r`   rŸ   r@  )rD  rE  r4  r}   r½   rž   rŸ   r©   )rD  rE  rM  r|   rN  rž   )rú   rW   r4  rË   r½   rž   rŸ   r©   )r3  rž   r4  r}   r¦   r`   rŸ   rR  )re  r   rŸ   rº   )r¥  r3   rŸ   r*   )rl  r   rŸ   r*   )rq  r   rÆ  r   rŸ   rº   )rˆ  r   rÆ  r   rŸ   rº   )r3  rž   rZ  r”  r|  r9   r  r   rP  r•  rŸ   r–  )r3  rž   rZ  r   r|  r9   rP  rš  r  r   rŸ   r›  )r  r   rŸ   rº   )rŸ   rº   )r«  r   rŸ   rº   )r  r   rŸ   rº   )r«  r   rŸ   r³  )r´  r   rŸ   rº   )r¼  r½  rÆ  r¾  rŸ   rº   )rÉ  rÊ  rŸ   rË  rÓ   )rÉ  rÊ  rÓ  rÔ  rŸ   rÕ  )rÉ  rÊ  rÓ  rÔ  rŸ   rý  )rÿ  r   rŸ   rº   )rÓ  r  rÑ  r  rŸ   r  )r­  r   rŸ   rº   )rb  r   r   r  rU  r  rŸ   r*   )r¹   rº   r3  r   rŸ   rº   )r  r@   rZ  r   r  r  rŸ   ry   )r¹   rº   r  r  rŸ   rº   )r¹   rº   r  r"  rŸ   rº   )Nrï   rð   rñ   rò   rÃ  r  r  Úpropertyr  r  r  r  r  r  r  rE  ri  r…  r•  rž  r£  r¤  r¨  r¬  r®  r´  r  ró  rô  rµ  rý  r&   ré  r  r
  r¶  r  r0  r;  rÌ  rC  ÚstaticmethodrL  rO  rQ  rê  r1  r  r  r   r"  r   r  rŽ  rœ  r  r  r,  rª  r2  r  r  r$  r&  r/  r*  rÎ  rþ  r(  rÐ  r  r[  r  r  r  r_  rî  Ú__classcell__r£   r£   r	  r¤   ró   >  s²    ü


H!
: '~;	v9ú1*Ij1ú4ó1'jÿLÿD3ü,*8ró   c                 C  ó   t  | |¡S rÓ   )r0   Ú!no_info_before_validator_function©rz  r¹   r6  r£   r£   r¤   r%  ”	  ó    r%  c                 C  r(  rÓ   )r0   rC  r*  r£   r£   r¤   r%  •	  r+  c                 C  s
   t  | ¡S rÓ   )r0   rf  )rz  r]  r^  r£   r£   r¤   r%  –	  r¡  c                 C  r(  rÓ   )r0   r  r*  r£   r£   r¤   r%  —	  r+  c                 C  ó   t j| ||dS ©N)r½   )r0   Ú#with_info_before_validator_function©rz  r¹   r½   r£   r£   r¤   r%  ˜	  ó    ÿc                 C  r,  r-  )r0   Ú"with_info_after_validator_functionr/  r£   r£   r¤   r%  ›	  r0  c                 C  s   t j| |dS r-  rù  )rz  r6  r½   r£   r£   r¤   r%  ž	  s    ÿc                 C  r,  r-  )r0   Ú!with_info_wrap_validator_functionr/  r£   r£   r¤   r%  ¡	  r0  ))r–   úno-info)r—   r3  )r˜   r3  )r™   r3  )r–   ú	with-info)r—   r4  )r˜   r4  )r™   r4  z Mapping[tuple[FieldValidatorModes, Literal['no-info', 'with-info']], Callable[[Callable[..., Any], core_schema.CoreSchema, str | None], core_schema.CoreSchema]]Ú_VALIDATOR_F_MATCHrã  úIterable[Decorator[RootValidatorDecoratorInfo]] | Iterable[Decorator[ValidatorDecoratorInfo]] | Iterable[Decorator[FieldValidatorDecoratorInfo]]c                 C  sD   |D ]}t |j|jjƒ}|rdnd}t|jj|f |j| |ƒ} q| 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.
    r4  r3  )rj   r
  r›   rP  r5  )r¹   rã  r½   Ú	validatorrX  Zval_typer£   r£   r¤   rÇ   ©	  s
   rÇ   ú+Iterable[Decorator[ValidatorDecoratorInfo]]c                 C  s   | D ]	}|j jr dS qdS )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›   rV  )rã  r7  r£   r£   r¤   r\  Â	  s
   
ÿr\  ú0Iterable[Decorator[ModelValidatorDecoratorInfo]]rP  ú Literal['inner', 'outer', 'all']c                 C  s   |   dd¡}|D ]o}|dkr|jjdkrq|dkr |jjdkr qt|j|jjƒ}|jjdkrB|r9tj|j| d} qtj|j| d} q|jjdkr\|rStj|j| d} qtj	|j| d} q|jjdksdJ ‚|rotj
|j| d} qtj|j| d} q|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.
    r2  NrÈ  r–   rØ  r™   )rÉ  r¹   r—   )r#  r›   rP  rj   r
  r0   r2  r  r.  r)  r1  rC  )r¹   rã  rP  r2  r7  rX  r£   r£   r¤   rë  Ò	  s,   rë  r4  r}   c                 C  sD   | j rtj|| j t| j ƒ| jdS | jtur tj|| j| jd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`.
    )Údefault_factoryZdefault_factory_takes_datar]  )r  r]  )r;  r0   Zwith_default_schemarn   r]  r  r.   )r4  r¹   r£   r£   r¤   r^  
  s   
ü

ÿr^  úGetJsonSchemaFunction | Nonec                 C  s˜   t | ddƒ}t| dƒr8tƒ }|duo|jj|t |ddƒfv}|s8t | ddƒ}td|r0d|› dnd	› d
dd‚t| ƒ }durDt|ƒS |du rJdS |S )z`Extract `__get_pydantic_json_schema__` from a type, handling the deprecated `__modify_schema__`.Ú__get_pydantic_json_schema__NZ__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ä   rÇ  rr   r=  r.  rH   r6   r·  )rÝ   Zjs_modify_functionr   Zhas_custom_v2_modify_js_funcÚcls_namerÆ  r£   r£   r¤   r·  
  s*   
ÿþÿýr·  c                   @  s>   e Zd ZU ded< ded< ded< ded< ded	< d
ed< dS )rR  rº   r¹   ú4str | list[str | int] | list[list[str | int]] | Noner7  r¾   r8  úbool | Noner6  r=  zdict[str, Any]r3  N)rï   rð   rñ   rÁ  r£   r£   r£   r¤   rR  :
  s   
 rR  )r7  r8  r6  r=  r3  r7  r@  r8  r6  rA  r=  r3  c                C  s   | |||||dœS )N©r¹   r7  r8  r6  r=  r3  r£   rB  r£   r£   r¤   r`  C
  s   
úr`  r¼  r  úCoreSchema | Nonec                 C  s2   | d dkr|  | d ¡S | d dkr| d S | S )Nr¿   r  r  r¼  r¹   )r  ©r¹   r¼  r£   r£   r¤   r¸  V
  s
   r¸  Údef_refú%core_schema.DefinitionReferenceSchemaú.Literal['inline', 'keep', 'preserve_metadata']c                 C  s:   d| v rdS |   d¡}|sdS t|ƒdkrd|v rdS dS )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Þ   Úkeepr3  ÚinlinerQ   Ú%pydantic_internal_union_discriminatorÚpreserve_metadata)rÆ   r	  )rE  r3  r£   r£   r¤   Ú_inlining_behavior_
  s   

rL  c                   @  sp   e Zd ZU dZded< 	 ded< 	 d#dd	„Zed$dd„ƒZd%dd„Zd&dd„Z	d'dd„Z
d(dd„Zd)d d!„Zd"S )*r  z*Keeps track of references and definitions.zset[str]Ú_recursively_seenz!dict[str, core_schema.CoreSchema]Ú_definitionsrŸ   r©   c                 C  s   t ƒ | _i | _d S rÓ   )r­   rM  rN  r  r£   r£   r¤   r  ˆ
  s   
z_Definitions.__init__rÝ   r   úCGenerator[tuple[str, core_schema.DefinitionReferenceSchema | None]]c             	   c  sj    t |ƒ}|| jv s|| jv r|t |¡fV  dS | j |¡ z|dfV  W | j |¡ dS | j |¡ 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\   rM  rN  r0   r  ÚaddÚdiscard)r  rÝ   r2  r£   r£   r¤   rÙ  Œ
  s   €z_Definitions.get_schema_or_refr2  rž   rC  c                 C  s   | j  |¡S )z,Resolve the schema from the given reference.)rN  rÆ   )r  r2  r£   r£   r¤   r  ­
  s   z _Definitions.get_schema_from_refr¹   r*   rF  c                 C  s   |d }|| j |< t |¡S )z Store the schema as a definition and return a `'definition-reference'` schema pointing to it.

        The schema must have a reference attached to it.
        r2  )rN  r0   r  )r  r¹   r2  r£   r£   r¤   rÜ  ±
  s   

z/_Definitions.create_definition_reference_schemaúcore_schema.DefinitionsSchemac                 C  s$   |d D ]	}|| j |d < q|d S )zZStore the definitions of the `'definitions'` core schema and return the inner core schema.r¼  r2  r¹   )rN  )r  r¹   Z
def_schemar£   r£   r¤   rÛ  º
  s   z_Definitions.unpack_definitionsc              
   C  s<  | j }zt||d}W n ty } zt|‚d}~ww i }|d  ¡ D ]E\}}|dur`t|ƒ }dkr`|dkrE| ¡  | |  ||¡¡ q#|dkr_| 	d¡}	| ¡  | |  ||¡¡ |	|d< q#|  ||¡||< q#|d D ]!}
|
d  	d	d¡}|du r|qmt
 |
 ¡ ||¡}|
 ¡  |
 |¡ qm|rœtj|g | ¡ ¢d
}|S )záFinalize 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¼  NZcollected_referencesrH  rI  rK  r3  Zdeferred_discriminator_schemasrJ  rD  )rN  rx   rw   rî   rÙ   rL  Úclearr)  Ú_resolve_definitionr#  rS   r«  r	   r0   Zdefinitions_schemar=  )r  r¹   r¼  Zgather_resultrs  Zremaining_defsr2  Zinlinable_def_refZinlining_behaviorÚmetaÚcsr©  Zappliedr£   r£   r¤   r­  À
  sB   
þ€ÿ
€z_Definitions.finalize_schemar¼  údict[str, CoreSchema]c                 C  s’   || }|d dkr|S t ƒ }|d dkrAt|ƒdkrA|d }||v r,t|› ddd‚| |¡ || }|d dkrAt|ƒdksi |¥d|i¥S )	Nr¿   r  rI  r  z) contains a circular reference to itself.zcircular-reference-schemar«   r2  )r­   rL  rH   rP  )r  r2  r¼  Z
definitionÚvisitedr  r£   r£   r¤   rT  ø
  s   
ÿ
ùz _Definitions._resolve_definitionNr$  )rÝ   r   rŸ   rO  )r2  rž   rŸ   rC  )r¹   r*   rŸ   rF  )r¹   rR  rŸ   r*   rY  )r2  rž   r¼  rW  rŸ   r*   )rï   rð   rñ   rò   rÁ  r  r   rÙ  r  rÜ  rÛ  r­  rT  r£   r£   r£   r¤   r  s
  s   
 	

 

	
8c                   @  ó2   e Zd ZdZddd„Zedd	d
„ƒZddd„ZdS )rÿ   ©Ú_stackrŸ   r©   c                 C  ó
   g | _ d S rÓ   rZ  r  r£   r£   r¤   r    ó   
z_FieldNameStack.__init__r½   rž   úIterator[None]c                 c  ó"    | j  |¡ d V  | j  ¡  d S rÓ   ©r[  r³  r#  )r  r½   r£   r£   r¤   rÝ    ó   €z_FieldNameStack.pushr¾   c                 C  ó   | j r| j d S d S ©Nrà   rZ  r  r£   r£   r¤   rÆ     ó   
z_FieldNameStack.getNr$  )r½   rž   rŸ   r^  )rŸ   r¾   ©rï   rð   rñ   rÃ  r  r   rÝ  rÆ   r£   r£   r£   r¤   rÿ     ó    
rÿ   c                   @  rY  )r   rZ  rŸ   r©   c                 C  r\  rÓ   rZ  r  r£   r£   r¤   r  !  r]  z_ModelTypeStack.__init__Útype_objr¿   r^  c                 c  r_  rÓ   r`  )r  rg  r£   r£   r¤   rÝ  $  ra  z_ModelTypeStack.pushútype | Nonec                 C  rb  rc  rZ  r  r£   r£   r¤   rÆ   *  rd  z_ModelTypeStack.getNr$  )rg  r¿   rŸ   r^  )rŸ   rh  re  r£   r£   r£   r¤   r     rf  r   )r›   rœ   r   rž   rŸ   r    )r¦   r§   r¢   r¨   rŸ   r©   )r±   r²   r   rž   rŸ   r³   )r¹   rº   r»   r¼   r½   r¾   rŸ   rº   )r›   rË   rŸ   rÌ   )rÛ   rÜ   rÝ   r   r¹   r*   rŸ   r*   )rë   r   rì   r   rŸ   r   )r¹   rº   rã  r6  r½   r¾   rŸ   rº   )rã  r8  rŸ   r    )r¹   rº   rã  r9  rP  r:  rŸ   rº   )r4  r}   r¹   rº   rŸ   rº   )rÝ   r   rŸ   r<  )r¹   rº   r7  r@  r8  r¾   r6  rA  r=  rA  r3  r   rŸ   rR  )r¹   r*   r¼  r  rŸ   rC  )rE  rF  rŸ   rG  (  rò   Ú
__future__r   Z_annotationsÚcollections.abcrŽ  r-  r  r>  r~  r  r¹  Úsysr'  ræ   r   r   r   r   Ú
contextlibr   r	   Údecimalr
   Úenumr   Ú	fractionsr   Ú	functoolsr   r   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)   Útyping_extensionsZpydantic_corer*   r+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   Ztyping_inspectionr8   Ztyping_inspection.introspectionr9   r:   r;   Úaliasesr=   r>   r?   Zannotated_handlersr@   rA   rË  rB   rC   rD   rE   ÚerrorsrF   rG   rH   Zfunctional_validatorsrI   rJ   rK   rL   rM   r*  rN   ÚversionrO   rP   rÍ   rR   rS   rT   rU   rV   Ú_configrW   rX   Z_core_metadatarY   rZ   Z_core_utilsr[   r\   r]   r^   r_   r`   ra   rb   rc   rd   re   rf   rg   rh   ri   rj   Z_docs_extractionrk   r‘  rl   rm   rn   Z_forward_refro   Z	_genericsrp   rq   Z_import_utilsrr   rs   Z_mock_val_serrt   Z_namespace_utilsru   rv   Z_schema_gatherrw   rx   Z_schema_generation_sharedry   Z_utilsrz   r{   r¢   r|   r}   Úmainr   r€   Z_dataclassesr   r‚   Úversion_infor  rœ   r…   ZAnyFieldDecoratorr‡   rÁ  rˆ   r‰   ÚTuplerÁ   rŠ   ÚListr;  rº  ÚMutableSequencer‹   ÚSetr­   Ú
MutableSetrŒ   Ú	FrozenSetÚ	frozensetr   ÚDictrÃ   rŽ   r   r±  r   r‘   ÚTyper¿   r’   r¸  r“   r  ÚPathr‚  Ú	PosixPathÚPurePosixPathÚPureWindowsPathr”   ÚMutableMappingÚOrderedDictÚDefaultDictr  r  ÚCounterr  r  r‰  r•   rÊ  r)  rš   r¥   r°   r¸   rÅ   rÚ   ZJsonEncodersrê   rí   Ú	Exceptionrî   ró   r5  rÇ   r\  rë  r^  r·  rR  r`  r¸  rL  r  rÿ   r   r£   r£   r£   r¤   Ú<module>   sL    0( 
8
þÿ ú	ø
ýÿ
þ




%

"	                fò
ý



/
 ù

	 