
    h-iy             	         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mZ ddlmZ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 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$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+ ddlm,Z, ddl-m.Z.m/Z/m0Z0m1Z1 ddl2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z: ddl;m<Z<m=Z= ddl>m?Z?m@Z@mAZA ddlBmCZCmDZDmEZE ddlFmGZG ddlHmIZI ddlmJZJ ddlKmLZLmMZMmNZNmOZOmPZP ddlQmRZRmSZS ddlTmUZUmVZV ddlLmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_ ddlMm`Z`maZambZbmcZcmdZdmeZemfZfmgZgmhZhmiZimjZjmkZk ddllmmZmmnZn ddlompZp ddlqmrZrmsZsmtZtmuZu dd lvmwZw dd!lPmxZx dd"lymzZzm{Z{ er&dd#l|m}Z}m~Z~ dd$lmZ dd%lmZ dd&lmZ dd'lmZ dd(lvmZ e	j                  d)k\  Z ee3ed*f         Ze)egecebf   Z e(d+e,      Ze)e`eg   e`ec   e`eb   f   Ze<Ze!e ege0j\                  f   Zee
j$                  gZd-ed.<   ee
j,                  ej.                  j0                  gZd-ed/<   ee
j6                  ej.                  j8                  gZd-ed0<   ee
j>                  ej.                  j6                  gZd-ed1<   ee
jD                  ej.                  jD                  ej.                  jL                  gZd-ed2<   	 	 	 	 	 	 dXd3ZdYd4Z	 	 	 	 	 	 dZd5Z	 	 	 	 	 	 	 	 d[d6Z	 	 	 	 	 	 	 	 d\d7Ze"e'e    eAf   Z	 	 	 	 	 	 	 	 d]d8Z G d9 d:      Zd; d< d= d> d? d@ dA dB dCZdDedE<   	 	 	 	 	 	 	 	 d^dFZd_dGZ	 	 	 	 	 	 	 	 d`dHZdadIZdbdJZ	 	 	 	 	 	 dcdKZ	 	 	 	 dddLZ G dM dNe7      ZddddddO	 	 	 	 	 	 	 	 	 	 	 	 	 dedPZ G dQ dR      ZdfdSZ G dT dU      ZdV f	 	 	 	 	 	 	 	 	 dgdWZy)hz-Convert python types to pydantic-core schema.    )annotationsN)contextmanager)copydeepcopy)Enum)partial)	Parameter_ParameterKind	signature)chain)
attrgetter)FunctionType
LambdaType
MethodType)TYPE_CHECKINGAnyCallableDict
ForwardRefIterableIteratorMappingTypeTypeVarUnioncastoverload)warn)
CoreSchemaPydanticUndefinedcore_schemato_jsonable_python)	AnnotatedFinalLiteralTypeAliasType	TypedDictget_args
get_originis_typeddict   )GetCoreSchemaHandlerGetJsonSchemaHandler)
ConfigDictJsonDictJsonEncoder)PydanticSchemaGenerationErrorPydanticUndefinedAnnotationPydanticUserError)JsonSchemaValue)version_short)PydanticDeprecatedSince20   )_core_utils_decorators_discriminated_union_known_annotated_metadata_typing_extra)ConfigWrapperConfigWrapperStack)CoreMetadataHandlerbuild_metadata_dict)	,NEEDS_APPLY_DISCRIMINATED_UNION_METADATA_KEYCoreSchemaOrFieldcollect_invalid_schemasdefine_expected_missing_refsget_refget_type_ref%is_list_like_schema_with_items_schemasimplify_schema_referencesvalidate_core_schema)	DecoratorDecoratorInfosFieldSerializerDecoratorInfoFieldValidatorDecoratorInfoModelSerializerDecoratorInfoModelValidatorDecoratorInfoRootValidatorDecoratorInfoValidatorDecoratorInfoget_attribute_from_basesinspect_field_serializerinspect_model_serializerinspect_validator)collect_dataclass_fieldsget_type_hints_infer_globalns)PydanticRecursiveRef)get_standard_typevars_maphas_instance_in_typerecursively_defined_type_refsreplace_types)CallbackGetCoreSchemaHandler)is_finalvar)is_valid_identifierlenient_issubclass)ComputedFieldInfo	FieldInfo	BaseModel)Discriminator)FieldValidatorModes)StandardDataclass)GetJsonSchemaFunction)      {   FieldDecoratorInfoType)boundz
list[type]TUPLE_TYPES
LIST_TYPES	SET_TYPESFROZEN_SET_TYPES
DICT_TYPESc                ~    t        | t        t        f      rd| j                  v ry| j                  D ]	  }||k(  s	 y y)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.
    *TF)
isinstancerQ   rM   fields)infofieldv_field_names      bD:\DhanshreeandTeamAI\Github\ai_code\venv\Lib\site-packages\pydantic/_internal/_generate_schema.py)check_validator_fields_against_field_namer{   p   sB     $/1LMN$++5  $     c           	     Z   t        |      }| D ]  }t        |j                  t        t        f      rd|j                  j
                  v r<|j                  j                  du rU|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.
    rt   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)
setru   rw   rQ   rM   rv   check_fieldsr3   cls_refcls_var_name)
decoratorsrv   decrx   s       rz   check_decorator_fields_existr      s     [Fchh!79T UV[^bebjbjbqbq[q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{   rw   )validator_functionsrx   r   s      rz   $filter_field_decorator_info_by_fieldr      s0     /m.C2[\_\d\dfk2lC.mmms   ((c                t   | d   dk(  rt        | d   ||      | d<   | S t        |       r:| j                  dd       }|t        j                         }t        |||      | d<   | S | d   dk(  r:| j                  dd       }|t        j                         }t        |||      | d<   | S |rt        d| d          | S )Ntypenullableschemaitems_schemadictvalues_schemazO`@validator(..., each_item=True)` cannot be applied to fields with a schema of )apply_each_item_validatorsrG   getr!   
any_schemaapply_validators	TypeError)r   each_item_validators
field_nameinner_schemas       rz   r   r      s     f~#5fX6FH\^hix	.v	6zz.$7&113L!1,@TV`!a~ M 
6	! zz/48&113L"2<AUWa"b
 M	 
]^dek^l]mn
 	
 Mr|   c                    ||       }|j                  |      }d|v r|d   }|j                          d|ig|d<   d|vr|j                  |d<   |j                  }|rd|vrt	        j
                  |      |d<   |S )a0  Add title and description for model-like classes' JSON schema.

    Args:
        schema_or_field: The schema data to generate a JSON schema from.
        handler: The `GetCoreSchemaHandler` instance.
        cls: The model-like class.

    Returns:
        JsonSchemaValue: The updated JSON schema.
    z$refallOftitledescription)resolve_ref_schemaclear__name____doc__inspectcleandoc)schema_or_fieldhandlerclsjson_schemaoriginal_schemaref	docstrings          rz   modify_model_json_schemar      s     /*K00=O f%%+SM? o%#&<< I]/9)0)9)9))D&r|   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   warningsr   r5   r6   r!   $plain_serializer_function_ser_schema)json_encoderstpr   baseencoders        rz   ,_add_custom_serialization_from_json_encodersr      s     &  Hgb)R\\-A-AB3BGH##D)?KMOK\  ]Y  Z%	
 #."R"RSZfl"m I Mr|   c                     e Zd ZdZdZ	 dH	 	 	 	 	 	 	 dIdZe	 	 	 	 	 	 	 	 	 	 dJd       ZedKd       Z	edLd       Z
edMd       ZdNd	ZdOd
ZdPdZdOdZdOdZdOdZdQdZdRdZdSdZ	 	 	 	 	 	 dTdZ G d de      ZdUdZdUdZdVdZ	 dW	 	 	 	 	 dXdZdYdZdUdZdZdZd[dZe d\d       Z!e d]d       Z!d^d_d Z!d[d!Z"d`d"Z#dad#Z$dbd$Z%dbd%Z&dbd&Z'dcd'Z(dd(	 	 	 	 	 	 	 	 	 ddd)Z)	 	 	 	 	 	 	 	 ded*Z*	 	 	 	 	 	 	 	 dfd+Z+	 	 	 	 	 	 	 	 dgd,Z,dhd-Z-	 	 	 	 dSd.Z.did/Z/djd0Z0dkd1Z1e2jf                  df	 	 	 	 	 	 	 	 	 dld2Z4dmd3Z5dnd4Z6dhd5Z7dod6Z8dpd7Z9dqd8Z:drd9Z;dnd:Z<	 	 	 	 	 	 dsd;Z=dtd<Z>dud=Z?	 	 	 	 	 	 dvd>Z@dwd?ZA	 	 	 	 	 	 dxd@ZBdA f	 	 	 	 	 	 	 dydBZCdzdCZD	 	 	 	 	 	 dzdDZE	 	 	 	 	 	 	 	 d{dEZF	 d^	 	 	 	 	 	 	 d|dFZG	 	 	 	 	 	 d}dGZHy)~GenerateSchemaz\Generate core schema for a Pydantic model, dataclass and types like `str`, `datetime`, ... .)_config_wrapper_stack_types_namespace_typevars_map _needs_apply_discriminated_union_has_invalid_schemafield_name_stackdefsNc                    t        |      | _        || _        || _        d| _        d| _        t               | _        t               | _	        y NF)
r>   r   r   r   r   r   _FieldNameStackr   _Definitionsr   )selfconfig_wrappertypes_namespacetypevars_maps       rz   __init__zGenerateSchema.__init__  sE     &8%G" /)05-#(  / 1 N	r|   c                    | j                  |       }||_        ||_        ||_        d|_        d|_        t               |_        ||_        |S r   )	__new__r   r   r   r   r   r   r   r   )r   config_wrapper_stackr   r   r   objs         rz   __from_parentzGenerateSchema.__from_parent$  sQ     kk#$8!.(/4,"'.0
r|   c                .    | j                   j                  S r   )r   tailr   s    rz   _config_wrapperzGenerateSchema._config_wrapper6  s    ))...r|   c                    | j                   j                  xs t        }|j                  | j                  | j
                  | j                  | j                        S r   )r   schema_generatorr   _GenerateSchema__from_parentr   r   r   r   )r   r   s     rz   _current_generate_schemaz'GenerateSchema._current_generate_schema:  sM    ""33E~  &&!!II	
 	
r|   c                .    | j                   j                  S r   )r   arbitrary_types_allowedr   s    rz   _arbitrary_typeszGenerateSchema._arbitrary_typesD  s    ##;;;r|   c                *    t        j                         S )zGenerate a CoreSchema for `str`)r!   
str_schemar   s    rz   r   zGenerateSchema.str_schemaH  s    %%''r|   c                J    t        j                  | j                  |            S r   )r!   list_schemagenerate_schemar   r   
items_types      rz   _list_schemazGenerateSchema._list_schemaN  s    &&t';';J'GHHr|   c                j    t        j                  | j                  |      | j                  |            S r   )r!   dict_schemar   )r   r   	keys_typevalues_types       rz   _dict_schemazGenerateSchema._dict_schemaQ  s,    &&t';';I'FH\H\]hHijjr|   c                J    t        j                  | j                  |            S r   )r!   
set_schemar   r   s      rz   _set_schemazGenerateSchema._set_schemaT  s    %%d&:&::&FGGr|   c                J    t        j                  | j                  |            S r   )r!   frozenset_schemar   r   s      rz   _frozenset_schemaz GenerateSchema._frozenset_schemaW  s    ++D,@,@,LMMr|   c                J    t        j                  | j                  |            S r   )r!   tuple_variable_schemar   r   s      rz   _tuple_variable_schemaz%GenerateSchema._tuple_variable_schemaZ  s    001E1Ej1QRRr|   c                r    |D cg c]  }| j                  |       }}t        j                  |      S c c}w r   )r   r!   tuple_positional_schema)r   r   items_typesr   items_schemass        rz   _tuple_positional_schemaz'GenerateSchema._tuple_positional_schema]  s8    LWXKj--j9KX22=AA Ys   4c                    t        |t              s't        |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`.)ru   r   r   UserWarningr!   r   is_instance_schema)r   r   s     rz   _arbitrary_type_schemaz%GenerateSchema._arbitrary_type_schemaa  sL    "d#& 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.)r1   r   r   s     rz   _unknown_type_schemaz#GenerateSchema._unknown_type_schemam  s#    +:3' Bf f
 	
r|   c                    ||S 	 t        j                  ||      S # t         j                  $ r> t        j                  ||       d|v rd|d   t        <   nt        di|d<   d| _        |cY S w xY w)NmetadataT)r:   apply_discriminatorMissingDefinitionForUnionRefset_discriminatorrA   r   )r   r   discriminators      rz   _apply_discriminator_to_unionz,GenerateSchema._apply_discriminator_to_unionx  s      M	';;  $@@ 	 22 V#SWz"#OP&RTX%Yz"48D1M	s    AA-,A-c                      e Zd Zy)GenerateSchema.CollectedInvalidN)r   
__module____qualname__ r|   rz   CollectedInvalidr	    s    r|   r  c                    | j                  |      }t        |      }t        j                  |      }t	        |      r| j                         t        |      }|S r   )collect_definitionsrH   r:   apply_discriminatorsrC   r  rI   )r   r   s     rz   clean_schemazGenerateSchema.clean_schema  sR    ))&1+F3%::6B"6*''))%f-r|   c                *   t        d|j                  dd             }|r|| j                  j                  |<   d|v rt	        j
                  |d         }t	        j                  |t        | j                  j                  j                                     S )N
str | Noner   )	r   r   r   definitionsr!   definition_reference_schemadefinitions_schemalistvalues)r   r   r   s      rz   r  z"GenerateSchema.collect_definitions  s|    <E4!89)/DII!!#&F? <<VE]KF--&&--/0
 	
r|   c                ~    t        |      j                  }|j                  dg       }||vr|j                  |       y y )Npydantic_js_functions)r?   r  
setdefaultappend)r   metadata_schemajs_functionr  r  s        rz   _add_js_functionzGenerateSchema._add_js_function  sD    &7@@ ( 3 34KR P 33!((5 4r|   Tc                H   d}|r| j                  ||      }||}|| j                  |      }t        ||      }|4t        || j                  j
                        }|r| j                  ||       t        | j                  j                  ||      }| j                  |      }|S )a  Generate core schema.

        Args:
            obj: The object to generate core schema for.
            from_dunder_get_core_schema: Whether to generate schema from either the
                `__get_pydantic_core_schema__` function or `__pydantic_core_schema__` property.

        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 non-string value.
                - 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_property_generate_schema!_extract_get_pydantic_json_schemaresolve_original_schemar   r  r  r   r   r   _post_process_generated_schema)r   r   from_dunder_get_core_schemar   from_propertymetadata_js_functionr  s          rz   r   zGenerateSchema.generate_schema  s    6 %)& ??SIM(&>**3/F@fM+5fdii>S>STO%%o7KL=d>R>R>`>`begmn44V<r|   c                N   | j                   j                  |      5 \  }}||cddd       S |j                  }|j                  }|j                  }t        t        |j                  j                         |j                  j                         |j                  j                               h |j                         |j                                t        |j                  d      }|j                  |      }t        t!        t"        |      g      }	|j$                  j                         }
d}|j'                  d      dk(  r|g|j(                  D ]  }|j*                  j'                  dd      }|"t-        |      }|t.        t0        fvrt3        d	      | j5                  |j*                  d   d
      d   }|t6        usr| j9                  |      } n | j:                  j=                  |      5  | j>                  } |j@                  r]| jC                  d|d   |      }|d   }tE        ||
d      }tG        jH                  ||tK        |dd      d
tK        |dd      |||	      }n	tG        jL                  |jO                         D ci c]  \  }}|| jQ                  |||       c}}|j                         D cg c]  }| jS                  ||j                          c}||jT                        }tW        ||jX                  j                         d      }t[        |t]                     }||}tE        ||
d      }tG        jH                  ||tK        |dd      dtK        |dd      |||	      }| j_                  ||j`                  j                               }tE        ||
d      }| jc                  |      | j                   jd                  |<   tG        jf                  |      cddd       cddd       S 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 Pydantic model.NF)checkr   js_functionsextra_fields_behaviorallow__pydantic_extra__zEThe type annotation for `__pydantic_extra__` must be `Dict[str, ...]`Trequiredr7   rootr   inner__pydantic_custom_init____pydantic_post_init__)custom_init
root_model	post_initconfigr   r  )computed_fieldsextras_schema
model_nameouter)4r   get_schema_or_refmodel_fields__pydantic_decorators__r;  r   r   field_validatorsr  field_serializers
validatorskeysr=   model_configcore_configr@   r   r   model_validatorsr   r   __annotations__r)   r   r   r1    _get_args_resolving_forward_refsr   r   r   pushr   __pydantic_root_model___common_field_schemaapply_model_validatorsr!   model_schemar   model_fields_schemaitems_generate_md_field_schema_computed_field_schemar   r   root_validatorsrD   r[   _apply_model_serializersmodel_serializersr%  r  r  )r   r   	model_refmaybe_schemarv   r   r;  r   rG  r  rH  r<  r   extras_annotationextra_items_type
root_fieldr   rO  kvdfields_schemanew_inner_schemar   s                           rz   _model_schemazGenerateSchema._model_schema  s   YY((-1J)\'# .- %%F44J(88O(//66800779))002
 :&++-9/"6"6"89 +3+;+;5IN(44S9K*AY_b9c8deH)::AAC M677B--B(+(;(;(?(?@TVZ([%(4'(9:dD\1"? g#  ,0+P+P//0DE%) ,Q , ,( ,36,0,@,@AQ,RM! .  ++00@44..!%!:!:66&>S]!^J#-h#7L#9,HXZa#bL#.#;#;$$+C1KT$R#'")#/G"N*%!)	$L =H<[<[Y_YeYeYghYgQUQRTUD::1aLLYgh &5%;%;%=)%= !77:;W;WX%=) '4#&<<=M $4M:C]C]CdCdCfhl#mL'CLRoRq'r$'3'7#9,HXZa#bL#.#;#;$$+C1KT$R#(")#/G"N*%!)	$L 66|ZEaEaEhEhEjk/8H'R373V3VW]3^		%%i0">>yI] A@O .-r i)' A@@O .--sV   PEP6AP/P5BPO:+P #P #DP'	P:PP	
PP$c                    dd}|d   dk(  rB| j                   j                  j                  |d   D ci c]  } ||      | c}       |d   }|S c c}w )zuUnpack all 'definitions' schemas into `GenerateSchema.defs.definitions`
        and return the inner schema.
        c                    | d   S )Nr   r  )ss    rz   rE   z1GenerateSchema._unpack_refs_defs.<locals>.get_ref@  s    U8Or|   r   r  r   )rd  r   returnstr)r   r  update)r   r   rE   rd  s       rz   _unpack_refs_defsz GenerateSchema._unpack_refs_defs;  s`    
	 &>]*II!!((AV)WAVA'!*a-AV)WXH%F *Xs   Ac                   | j                   j                  |      5 \  }}||cddd       S 	 ddd       ||u rd}nd}t        |dd      }|\t        |dd      }|yt        dt               t        j                   |       D cg c]  }t        j                  |       c}      }	nSt        t        j                  |      j                        dk(  r	 ||      }	n ||t        | j                  | |            }	| j                  |	      }	t        |	      }
|
r=| j!                  |	      | j                   j"                  |
<   t        j$                  |
      S | j!                  |	      }	|	S # 1 sw Y   ?xY wc c}w )	a0  Try to generate schema from either the `__get_pydantic_core_schema__` function or
        `__pydantic_core_schema__` property.

        Note: `__get_pydantic_core_schema__` takes priority so it can
        decide whether to use a `__pydantic_core_schema__` attribute, or generate a fresh schema.
        Nunpackzto-def__get_pydantic_core_schema____get_validators__zc`__get_validators__` is deprecated and will be removed, use `__get_pydantic_core_schema__` instead.r7   )ref_mode)r   r?  r   r   r6   r!   chain_schema"with_info_plain_validator_functionlenr   r   
parametersr]   r"  rh  rE   r%  r  r  )r   r   source_rX  rm  
get_schemarD  r]  r   r   s              rz   r!  z-GenerateSchema._generate_schema_from_propertyH  su    YY((-1B!\'# .-' . &=HH S"@$G
 &:DAJ!u) !--jtjv.wjvef{/]/]^_/`jv.wxF7$$Z0;;<A#F+#89N9NPT_gh ''/fo)-)L)LV)TDII!!#&::3??44V<K .-$ /xs   E+E8+E5c                .   	 t        j                  || j                        }t        |t              rt	        |j                  d|       | j                  rt        || j                        }|S # t        $ r}t	        j
                  |      |d }~ww xY w)N)globalnsz%Unable to evaluate forward reference )r<   evaluate_fwd_refr   	NameErrorr2   from_name_errorru   r   __forward_arg__r   r\   )r   r   es      rz   _resolve_forward_refz#GenerateSchema._resolve_forward_refw  s    	H00t?T?TUC
 c:&-c.A.AEjknjoCpqqT%7%78C
  	H-==a@aG	Hs   !A0 0	B9BBc                     y r   r  )r   r   r2  s      rz   rJ  z/GenerateSchema._get_args_resolving_forward_refs      r|   c                     y r   r  r   s     rz   rJ  z/GenerateSchema._get_args_resolving_forward_refs  r~  r|   c           	         t        |      }|r<t        |D cg c]%  }t        |t              r| j	                  |      n|' c}      }|S |rt        d| d      |S c c}w )Nz	Expected z+ to have generic parameters but it had none)r(   tupleru   r   r|  r   )r   r   r2  argsas        rz   rJ  z/GenerateSchema._get_args_resolving_forward_refs  sq    }dhidh_`*Q
:S$33A6YZZdhijD  iu,WXYY js   *Ac                >    | j                  |      }|st        S |d   S )Nr   )rJ  r   )r   r   r  s      rz   _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   r7   )rJ  r   rp  r)   r   )r   r   r  origins       rz   _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                l    d|v r|d   }| j                   |t        <   |S t        | j                   i|d<   |S )Nr  )r   rA   )r   r   r  s      rz   r%  z-GenerateSchema._post_process_generated_schema  sL    j)HEIEjEjHAB
  =d>c>c"F: r|   c                    | j                   }d| _         | j                  }d| _        | j                  | j                  |            }| j                   xs || _         | j                  xs || _        |S )zJRecursively generate a pydantic-core schema for any supported python type.F)r   r   r%  _generate_schema_inner)r   r   has_invalid_schemaneeds_apply_discriminated_unionr   s        rz   r"  zGenerateSchema._generate_schema  ss    !55#( *.*O*O'05-44T5P5PQT5UV#'#;#;#Q?Q 040U0U0xYx-r|   c                   t        |t              r| j                  |      S t        |t              r|S t        |t              rt        |      }t        |t
              r | j                  | j                  |            S ddlm	} t        ||      r| j                  |      S t        |t              r t        j                  |j                        S | j!                  |      S )Nr+   rc   )
schema_ref)ru   _AnnotatedType_annotated_schemar   rf  r   r   r|  mainrd   r`   ra  rX   r!   r  type_ref
match_type)r   r   rd   s      rz   r  z%GenerateSchema._generate_schema_inner  s    c>*))#..c4 Jc3S/Cc:&''(A(A#(FGG$c9-%%c**c/0::cllSSs##r|   c                   |t         u r| 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 s|t        u rt        j                         S ||t        j                  u rt        j                          S |t"        v r| j%                  |      S |t&        v r!| j)                  || j+                  |            S |t,        v r!| j/                  || j+                  |            S |t0        v r!| j3                  || j+                  |            S |t4        v r" | j6                  |g| j9                  |       S t;        |t<              r| j?                  |      S |t@        k(  r| jC                         S t        jD                  |      rt        jF                         S t        jH                  |      r| jK                  |      S tM        |      r| jO                  |d      S t        jP                  |      r| jS                  |d      S t        jT                  |      r| jW                  |jX                        S |tZ        j\                  k(  r| j_                  |      S |t`        jb                  jd                  u s|tf        jd                  u r| ji                         S t;        |tf        jj                        r| jm                  |      S to        |      r<|tp        u rt        j                         S | jW                  | j+                  |            S t;        |tr        tt        tv        tx        f      r| j{                  |      S t}        j~                  |      r3t        |t              r#ddlBmC}  ||| j                  j                        S t        j                  |      r| j                  |d      S | j                  |d      }||\  }}| j                  ||      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.
        Nr7   )get_enum_core_schemar  )Orf  r   bytesr!   bytes_schemaint
int_schemafloatfloat_schemaboolbool_schemar   objectr   r<   NoneTypenone_schemarn   _tuple_schemaro   r   r  rp   r   rq   r   rr   r   r  ru   r&   _type_alias_type_schemar   _type_schemais_callable_typecallable_schemais_literal_type_literal_schemar*   _typed_dict_schemais_namedtuple_namedtuple_schemais_new_typer   __supertype__rePattern_pattern_schemacollectionsabcHashabletyping_hashable_schemar   _unsubstituted_typevar_schemar^   r$   r   r   r   r   _callable_schemar   isclass
issubclassr   _std_types_schemar  r   config_dictis_dataclass_dataclass_schema0_get_prepare_pydantic_annotations_for_known_type_apply_annotationsr)   _match_generic_typer   r   r   )r   r   r  ressource_typer   r  s          rz   r  zGenerateSchema.match_type  s    #:??$$E\++--CZ))++E\++--D[**,,CZ3&=))++[C=#9#99**,,K%%c**J$$S$*D*DS*IJJI##C)C)CC)HII$$))#t/I/I#/NOOJ$4$$SP4+J+J3+OPP]+//44D[$$&&++C0..00**3/'',,#**355((-**355&&s+''(9(9::BJJ'',,KOO,,,v0F((**V^^,55c::e|"--//''**3/  lJ
GLM((--__S!jd&;?'T-A-A-M-MNN%%c*))#t44CCCL?'*$K**;DDC++C88  ..s33((--r|   c                f   t        |t              r| j                  |      S t        j                  |      r| j                  ||      S t        j                  |      r| j                  ||      S | j                  ||      }||S t        j                  |      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*                  |g| j-                  |       S t/        |      r| j1                  ||      S |t2        j4                  t6        fv r| j9                  |      S |t2        j:                  t<        j>                  j:                  hv r| jA                  |      S |t2        jB                  t<        j>                  jB                  t2        jD                  t<        j>                  jD                  hv r| jG                  |      S |tH        jJ                  t2        jJ                  fv r| jM                  |      S | jN                  r| jQ                  |      S | jS                  |      S r   )*ru   r&   r  r<   r  r  r  r  r!  origin_is_union_union_schemarn   r  ro   r   r  rp   r   rq   r   rr   r   r  r*   r  r  r   r   _subclass_schemaSequencer  r  _sequence_schemar   	Generator_iterable_schemar  r  r  r   r   r   )r   r   r  r'  s       rz   r  z"GenerateSchema._match_generic_type0  sR   fm,//44 %%f-))#v66&&v.**377;;FCH$  ((0%%c**{"%%c**z!$$S$*D*DS*IJJy ##C)C)CC)HII''))#t/I/I#/NOOz!$4$$SP4+J+J3+OPP&!**377T**((--)A)ABB((--)A)A6CSCSU`UdUdUnUnoo((--

FNN33'',,  ..v66((--r|   r1  c          	         | j                  |||      }t        j                  |d   |j                         sdn||d   |d   |d   |d         S )zAPrepare a TypedDictField to represent a model or typeddict field.r   Fserialization_excludevalidation_aliasserialization_aliasr  )r2  r  r  r  r  )rM  r!   typed_dict_fieldis_required)r   name
field_infor   r2  common_fields         rz   _generate_td_field_schemaz(GenerateSchema._generate_td_field_schema\  sf     00z:N++"","8"8":U"./F"G)*<= ,-B C!*-
 	
r|   c           	         | j                  |||      }t        j                  |d   |d   |d   |d   |d   |d         S )z0Prepare a ModelField to represent a model field.r   r  r  r  frozenr  r  r  r  r  r  )rM  r!   model_fieldr   r  r  r   r  s        rz   rR  z(GenerateSchema._generate_md_field_schemao  s^     00z:N&&""./F"G)*<= ,-B C)!*-
 	
r|   c                    | j                  |||      }t        j                  ||d   |j                  xs d|j                  rdnd|d   |d   |d   |d   |d   		      S )
zJPrepare a DataclassField to represent the parameter/field, of a dataclass.r   NFr  r  r  r  r  )	init_onlykw_onlyr  r  r  r  r  )rM  r!   dataclass_fieldinit_varr  r  s        rz   _generate_dc_field_schemaz(GenerateSchema._generate_dc_field_schema  s|     00z:N**" ))1T&..DE"./F"G)*<= ,-B C)!*-

 
	
r|   c                	    ddl m}m}m} t	        j
                  t        t        f      r	 j                  } j                  r[|xs i j                         }|j                   j                  j                         D 	ci c]  \  }}	|j                  |	 c}	}       t        j                  j
                  |d       }
|
j
                  urgt	        |
t               sW|
_         |j"                  |
      }|j$                  j                         D ]!  \  }}	|j$                  vst'        ||	       # j
                  j(                  }}d fd} j*                  j-                  |      5  j.                   j1                  |||      }n j1                  ||      }d d d        t3        |j4                  j7                         |      }t9        |      rd_        |D 	cg c]  }	|	j<                  j>                  du s|	 }}	|D 	cg c]	  }	|	|vs|	 }}	tA        ||      }tC        |t3        ||      |      }tC        |t3        |jD                  j7                         |      |      }jG                         stI        |      } jK                  |t3        |jL                  j7                         |            }jN                  jP                  tS        jT                        d}|j                         D 	ci c]  \  }}	|		||	 }}}	jV                  }tY        t[        ||      g      } j\                  j^                  }|rj`                  j`                  dk  sjb                   ||      }te        |t              stg        d	| d
|jh                         jb                  'jj                  |_5        jl                  |_6        n|_5        |_6        d_0        |_1        te        jl                  ||f      rjl                  jo                         }njl                  }tq        |jr                  rdnd |jj                  jt                  |      S c c}	}w # 1 sw Y   xY wc c}	w c c}	w c c}	}w )Nr+   )AliasChoices	AliasPathrb   c                @    j                  | j                        } | S r   )r  r  )r   r  r   s    rz   r  z>GenerateSchema._common_field_schema.<locals>.set_discriminator  s     77
@X@XYFMr|   )transform_inner_schemaT)r   r   examplesjs_annotation_functionsr7   alias_generator  must return str, not r  r   r   re  r   );rv   r  r  rb   rZ   
annotationr   rf  r   r   r   rg  rQ  r   r<   eval_type_lenientrX   from_annotation_attributes_setsetattrr  r   rK  r  r  r   rD  r  $_validators_require_validate_defaultvalidate_defaultrw   	each_itemr   r   rB  r  wrap_default_apply_field_serializersrC  r   r   r"   r  json_schema_extrar@   get_json_schema_update_funcr   alias_generatoralias_priorityaliasru   r   r   r  r  convert_to_aliases_common_fieldexcluder  )r   r  r  r   r  r  rb   r   r\  r]  	evaluatednew_field_infor  r   r  r   this_field_validatorsr   json_schema_updatesr  r  r  r  r  s   ` `                     rz   rM  z#GenerateSchema._common_field_schema  s]    	@?
 5 5
C7HI"33O!!#2#8b">">"@&&$BTBTBZBZB\']B\$!Q

AB\']^%77
8M8M`deI
 5 55>RS\^r>s(1
% ";!:!:9!E*::@@BDAq 
 : ::
Aq1	 C $.#8#8*:M:M[	 ""''-''300kbs0t00	 . !EZEZEZEaEaEcei j/0EF*.J'+@]+@aAFFDTDTX\D\+@],A c,AqQNbEb,A c+F4H$O!&*NOdfj*kmqr!89T9T9[9[9]_cdfj
 %%'!*f5F..89U9U9\9\9^`de
  %%%11*:+>+>?

 1D0I0I0K]0K1q}q!t0K]&88&%@ATVg%h$i

 ..>>%%-1J1Ja1OS]ScScSk#D)EeS)"2?2CCYZ_ZiZiYj kll'1195:J2..627J/16
..3
+,-
)$Jj11L)3LM)::MMO)::*4*<*<$$- * > >$$
 	
w (^( .-   ^ c, ^s6   Q+
14Q1'Q>Q>	RR
RR1Q;c                   | j                  |d      }g }d}|D ]9  }||t        j                  u rd}|j                  | j	                  |             ; t        |      dk(  r|d   }ng }|D ]j  }|j                  d      }	t        |	t              s%|	j                  t        j                        }
|
|j                  ||
f       Z|j                  |       l t        j                  |      }|rt        j                  |      }|S )zGenerate schema for a Union.Tr1  Fr7   r   r  )rJ  r<   r  r  r   rp  r   ru   r   r8   TAGGED_UNION_TAG_KEYr!   union_schemanullable_schema)r   
union_typer  choicesr   argrd  choices_with_tagschoicer  tags              rz   r  zGenerateSchema._union_schema  s    44Z$4O$&C{c]%;%;;t33C89	  w<1
AKM!!::j1h-",,{'G'GHC)00&#?)008 " (():;A++A.Ar|   c                X   | j                   j                  |      5 \  }}||cd d d        S t        |      xs |}| j                  xs i j	                         }i t        j                  |      |}|j                  }|| _        t        |      }t        j                  || j                  d       }t        ||      }| j                  |      }	|	d   dk7  sJ ||	d<   |xs d | _        |	| j                   j                  |<   t        j                  |      cd d d        S # 1 sw Y   y xY w)Nr   r  r   )r   r?  r)   r   r   r<   get_cls_types_namespace	__value__rY   r  r\   r   r  r!   r  )
r   r   r   rX  r  	namespacenew_namespacer  r   r   s
             rz   r  z&GenerateSchema._type_alias_type_schema   s    YY((-1D#|'# .-  _+F..4"::<IZ}DDVLZPYZM))J$1D!4S9L&88TEZEZ\`aJ&z<@J))*5F&>]222F5M$-$5D!)/DII!!#&::3?) .--s   D C)D  D)c                n    t        j                  |      }|s
J d|        t        j                  |      S )zGenerate schema for a Literal.z(literal "expected" cannot be empty, obj=)r<   all_literal_valuesr!   literal_schema)r   literal_typeexpecteds      rz   r  zGenerateSchema._literal_schema:  s8     33LARCL>RRx))(33r|   c                   ddl m} | j                  j                  |      5 \  }}||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$                  |      }t'        || j(                  d	
      j+                         D ]  \  }}t-        ||      }||	v }t/        |      t0        j2                  k(  rd	}| j5                  |d	      d   }n4t/        |      t0        j6                  k(  rd}| j5                  |d	      d   } |j8                  |      }| j;                  ||||      |
|<    t=        t?        t@        |      g|      }tC        jD                  |
|jF                  jI                         D cg c]  }| jK                  ||jL                          c}|||      }| jO                  ||jP                  jI                               }tS        ||jT                  jI                         d      }| jW                  |      | j                  jX                  |<   tC        jZ                  |      cddd       cddd       S # t        $ r d}Y Zw xY wc c}w # 1 sw Y   nxY w	 ddd       y# 1 sw Y   yxY w)a  Generate schema for a TypedDict.

        It is not possible to track required/optional keys in TypedDict without __required_keys__
        since TypedDict.__new__ erases the base classes (it replaces them with just `dict`)
        and thus we can track usage of total=True/False
        __required_keys__ was added in Python 3.9
        (https://github.com/miss-islington/cpython/blob/1e9939657dd1f8eb9f596f77c1084d2d351172fc/Doc/library/typing.rst?plain=1#L1546-L1548)
        however it is buggy
        (https://github.com/python/typing_extensions/blob/ac52ac5f2cb0e00e7988bae1e2a1b8257ac88d6d/src/typing_extensions.py#L657-L666).

        On 3.11 but < 3.12 TypedDict does not preserve inheritance information.

        Hence to avoid creating validators that do not do what users expect we only
        support typing.TypedDict on Python >= 3.12 or typing_extension.TypedDict on all versions
        r+   rb   Nr  zXPlease use `typing_extensions.TypedDict` instead of `typing.TypedDict` on Python < 3.12.ztyped-dict-versionr   __pydantic_config__T)localnsinclude_extrasr1  r   Fr+  )r-  typed_dict_cls)r;  r   r  r:  all).rv   rb   r   r?  rY   _SUPPORTS_TYPEDDICTr   r
  r3   rR   AttributeErrorr   rK  r   rG  r   __required_keys__rK   buildrW   r   rQ  r\   r)   r<   RequiredrJ  NotRequiredr  r  r@   r   r   r!   typed_dict_schemar;  r  rS  rC  rU  rV  rN  rH  r%  r  r  )r   r  r  rb   typed_dict_refrX  r   r:  rG  required_keysrv   r   r   r  r2  r  r  r^  	td_schemar   s                       rz   r  z!GenerateSchema._typed_dict_schema@  s     	'YY((8<Z^\'# 98 5^DL!!'&4+?+J+Jh+V'n- 
,D^Uj,k ++008"22>>~N440>0P0P@B+11.A
.K"D,A,ARV/%'/*J
 "/z<!HJ)]:H!*-1G1GG#'%)%J%J&%) &K & &
 $J/=3L3LL#(%)%J%J&%) &K & &

 ";!:!::!FJ)-)G)G"J
X *H *F:&)/0 /")*B"W!Xiw (99 ",!;!;!B!B!D%!DA 33Az7S7ST!D% '%&		 66y*B^B^BeBeBgh/
8S8S8Z8Z8\^cd8<8[8[\b8c		%%n5">>~Nk 98' 98  " X%S 988' 988s`   K3:K3.K:K3E%K:#KBK3	K3KK3KK3KK&	"K33K<c                   | j                   j                  |      5 \  }}||cddd       S t        |      }||}t        |d| j                        }|s|j
                  D ci c]	  }|t         }}|r-|j                         D 	ci c]  \  }}	|t        |	|       }}}	t        j                  |j                         D 	cg c]A  \  }}	| j                  ||	|j                  j                  |t        j                              C c}	}t!        d            }
t        j"                  |
||      cddd       S c c}w c c}	}w c c}	}w # 1 sw Y   yxY w)z!Generate schema for a NamedTuple.NT)r  r  )default)js_prefer_positional_arguments)r  )r   )r   r?  rY   rW   r   _fieldsr   rQ  r\   r!   arguments_schema_generate_parameter_schema_field_defaultsr   r	   emptyr@   call_schema)r   namedtuple_clsr  namedtuple_refrX  r   r   r\  r   r  r*  s              rz   r  z!GenerateSchema._namedtuple_schema  su   YY((8<Z^\'# 98 5^DL!!'*GtT=R=R+K /=/E/EF/E!q#v/EF 3>2C2C2E2E.
J j, GG2E  
  +;;
 3>2C2C2E	 3F.
J 33"J8V8V8Z8Z[egpgvgv8w 4  3F	 -DQ  **+;^Q_`; 98 G+ 98s;   E7E$E 2E	E %EAE+E EEc                N   ddl m} |t        j                  u r |j                  |      }n |j
                  ||      }|j                  J d       |j                  |j                  }}| j                  j                  |      5  | j                  ||      }	ddd       |j                         st        |	      }	t        j                  |	      }
|||
d<   |j                  |j                  |
d<   |
S | j                   j"                  }|r ||      |
d<   |
S # 1 sw Y   xY w)zXPrepare a ArgumentsParameter to represent a field in a namedtuple or function signature.r+   r  Nz<field.annotation should not be None when generating a schemamoder  )rv   rb   r	   r-  r  from_annotated_attributer  r  r   rK  r  r  r  r!   arguments_parameterr  r   r  )r   r  r  r'  r2  rb   rx   r  r   r   parameter_schemar  s               rz   r+  z)GenerateSchema._generate_parameter_schema  s#    	'ioo%-I--j9E6I66z7KE+k-kk+#(#3#3U^^[""''-,,[+FF .   "!%0F&::4H'+V$;;"(-W%
   #22BBO,;D,A ) .-s   DD$c                   t        |      | j                  |      }r|rt        fd|D              }|s1|t        v rt	        j
                         S t	        j                  g       S |d   t        u r.t        |      dk(  r| j                  ||d         S t        d      t        |      dk(  r|d   dk(  r| j                  |g       S | j                  |t        |            S )zIGenerate schema for a Tuple, e.g. `tuple[int, str]` or `tuple[int, ...]`.c              3  6   K   | ]  }t        |        y wr   )r\   ).0paramr   s     rz   	<genexpr>z/GenerateSchema._tuple_schema.<locals>.<genexpr>  s     R6%==6s   r   r+   r   z&Variable tuples can only have one typer7   r  )rY   rJ  r  rn   r!   r   r   Ellipsisrp  r   
ValueErrorr   r  )r   
tuple_typeparamsr   s      @rz   r  zGenerateSchema._tuple_schema  s     1<66zBFR6RRF [("88:: #::2>>BZ8#6{a22:vayII !!IJJ[A&)r/ 00R@@00T&\JJr|   c                `    t        j                  t        j                  t              dd      S )Nis_typezInput should be a typecustom_error_typecustom_error_message)r!   custom_error_schemar   r   r   s    rz   r  zGenerateSchema._type_schema  s)    ..**40'!9
 	
r|   c           	         | j                  |d      }t        j                  |D cg c]$  }| j                  t        j
                  |         & c}      S c c}w )z*Generate schema for `Type[Union[X, ...]]`.Tr1  )rJ  r!   r  r   r  r   )r   r  r  s      rz   _union_is_subclass_schemaz(GenerateSchema._union_is_subclass_schema  sR    44Z$4O'']a(b]aUY)=)=fkk$>O)P]a(bcc(bs   )Ac           	        | j                  |      }|t        k(  r| j                         S t        |t        j
                        r|j                  rbt        j                  t        |j                              r| j                  |j                        S t        j                  |j                        S |j                  rMt        j                  |j                  D cg c]$  }| j                  t        j                   |         & c}      S | j                         S t        j                  t        |            r| j                  |      S t        j                  |      S c c}w )z-Generate schema for a Type, e.g. `Type[int]`.)r  r   r  ru   r  r   	__bound__r<   r  r)   rF  r!   is_subclass_schema__constraints__r  r   r   )r   type_
type_paramcs       rz   r  zGenerateSchema._subclass_schema  s   //6
$$&&
FNN3## 00J<P<P1QR99*:N:NOO"55j6J6JKK++"//CMC]C]^C]aT))&++a.9C]^  ((****:j+AB11*==11*== _s   )E c                X   | j                  |      }t        j                  | j                  |            }t        j                  t
        j                  d      }|t        k7  r1ddlm	} t        j                  |t        j                  ||      g      }t        j                  ||      S )z5Generate schema for a Sequence, e.g. `Sequence[int]`.r  )cls_reprr7   )sequence_validator)r   python_schema)r  r!   r   r   r   r  r  r   _validatorsrP  rn  no_info_wrap_validator_functionjson_or_python_schema)r   sequence_type	item_typer   rQ  rP  s         rz   r  zGenerateSchema._sequence_schema  s    ..}=	!--d.B.B9.MN#66vQ[\7'44 K KL^`k lmM 00[Xeffr|   c                l    | j                  |      }t        j                  | j                  |            S )z$Generate a schema for an `Iterable`.)r  r!   generator_schemar   )r   rK  rV  s      rz   r  zGenerateSchema._iterable_schema+  s.    ..u5	++D,@,@,KLLr|   c                   ddl m} t        d g      }t        j                  t        d      dt        j                               }|t        j                  k(  s|t        j                  k(  r"t        j                  |j                  ||      S | j                  |d	
      d   }|t        k(  r"t        j                  |j                  ||      S |t        k(  r"t        j                  |j                   ||      S t#        d|d      )Nr7   )rR  c                    dddS )Nstringregex)r   formatr  )_1_2s     rz   <lambda>z0GenerateSchema._pattern_schema.<locals>.<lambda>4  s
    XahDir|   r,  patternr   )r   return_schema)r   r  Tr1  r   r   r~   ) rR  r@   r!   r   r   r   r  r  r   no_info_plain_validator_functionpattern_either_validatorrJ  rf  pattern_str_validatorr  pattern_bytes_validatorr1   )r   pattern_typerR  r  serr9  s         rz   r  zGenerateSchema._pattern_schema1  s   !&5i4jk>>y!V;CYCYC[
 6>>)\RZZ-G??44CRZ  55 6 
  C<??11x  e^??333QY  02^_k^nno0pqqr|   c                    t        j                  t        j                  t        j                  j
                        dd      S )Nis_hashablezInput should be hashablerA  )r!   rD  r   r  r  r  r   s    rz   r  zGenerateSchema._hashable_schemaM  s3    ..**;??+C+CD+!;
 	
r|   c                *     j                   j                  |      5 \  }}||cddd       S t        |      }||}t        |dd      } j                  j                  |      5   j                  j                  |      } j                   ddl	m
}  ||      rIt        |j                        }	|rJ|	j                         D ]  }
|
j                  | j                           nt!        | j                  |      }	|j"                  j%                  d      xs t'        j(                  |      t+         fd|	j-                         D        d 	      }t/        |d
      }t/        |d      }t1        j2                  |j4                  |j6                  j                         D cg c]  } j9                  |j:                          c}|      }t=        |j>                  j                         d      }j@                  j                         }tC        ||d      }t1        jD                  ||||t        jF                  |      D 
cg c]  }
|
jH                   c}
||      } jK                  |jL                  j                               }tC        ||d      } jO                  |       j                   jP                  |<   t1        jR                  |      cddd       cddd       S 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 dataclass.Nr  r+   )is_pydantic_dataclass)r   rA  c              3  J   K   | ]  \  }}j                  ||        y wr   )r  )r8  r\  r]  r   r   s      rz   r:  z3GenerateSchema._dataclass_schema.<locals>.<genexpr>w  s'     aR`$!QT33Aq*ER`s    #c                (    | j                  d      duS )Nr  Fr   )r  s    rz   r`  z2GenerateSchema._dataclass_schema.<locals>.<lambda>x  s    !%%	"2%"?r|   )key__post_init__	__slots__)r;  collect_init_onlyr4  )r9  r   rv   slotsr:  r>  )*r   r?  rY   r   r   rK  r   rG  r   dataclassesrm  r   __pydantic_fields__r  apply_typevars_mapr   rV   __dict__r   rK   r  sortedrQ  hasattrr!   dataclass_args_schemar   r;  rS  rC  r   rT  rH  rN  dataclass_schemarv   r  rU  rV  r%  r  r  )r   	dataclassr  dataclass_refrX  r   r:  rG  rm  rv   rx   r  has_post_init	has_slotsr^  args_schemar   rH  	dc_schemar   r   s   `                   @rz   r  z GenerateSchema._dataclass_schemaT  s    YY((37T|'# 43 5Y?L!"	Y(=tDF++008"22>>yI44?(3%i&C&CDF#%+]]_E!44\4CXCXY &5 6!--%1F
 '//334MNqR`RfRfgpRq
 aRXR^R^R`a? !(	? C#I{;	)??&& ",!;!;!B!B!D%!DA 33Az7S7ST!D% '4  0Z=W=W=^=^=`bfg#-#>#>#E#E#G 5lDTV]^'88 +%4?4F4Fy4QR4Q5EJJ4QR#&	 66y*B^B^BeBeBgh/8H'R7;7Z7Z[a7b		%%m4">>}Mo 98 43P%" Sa 988 433sI   L	7L	&D>K3$#K)A?K3K.A=K3	L	)
K33K<	8L		Lc                   t        |      }t        j                  |      }t        j                  dt        j
                  dt        j                  di}g }d}d}|j                  j                         D ]  \  }}	|	j                  |j                  u rt        }
n||   }
|j                  |	j                        }|0| j                  ||
|	j                  |      }|j!                  |       w|	j                  t        j"                  k(  r| j%                  |
      }|	j                  t        j&                  k(  sJ |	j                         | j%                  |
      } d}| j(                  }|j*                  r$|j                  d      }|| j%                  |      }t-        j.                  t-        j0                  ||||j2                        ||      S )zsGenerate schema for a Callable.

        TODO support functional validators once we support them in Config
        positional_onlypositional_or_keywordkeyword_onlyNre  )var_args_schemavar_kwargs_schemapopulate_by_name)rb  )r   r<   get_function_type_hintsr	   POSITIONAL_ONLYPOSITIONAL_OR_KEYWORDKEYWORD_ONLYrq  rQ  r  r-  r   r   kindr+  r'  r  VAR_POSITIONALr   VAR_KEYWORDr   validate_returnr!   r.  r*  r  )r   functionsig
type_hintsmode_lookuparguments_listr  r  r  pr  parameter_mode
arg_schemarb  r   return_hints                   rz   r  zGenerateSchema._callable_schema  s   
 !"::8D
 %%'8++-D""Nr
 @B9=;?~~++-GD!||syy( 
'-
(__QVV4N)!<<T:qyyZhi
%%j19333"&"6"6z"Bvv!6!66>>6$($8$8$D! .  8<--))$..2K& $ 4 4[ A&&(( /"3!/!@!@	 '	
 		
r|   c                   t        |t        j                        sJ |j                  }|j                  }t        |dd       }|d ut        |      dk7  z   |d uz   dkD  rt        d      || j                  |      S |r"| j                  t        j                  |         S |r@| j                  |      }t        j                  d t        j                               |d<   |S t        j                         S )N__default__r   r7   zZPydantic does not support mixing more than one of TypeVar bounds, constraints and defaultsc                     ||       S r   r  )xhs     rz   r`  z>GenerateSchema._unsubstituted_typevar_schema.<locals>.<lambda>  s    QqTr|   )r   r   )ru   r  r   rH  rJ  r   rp  NotImplementedErrorr   r  r   r!   #wrap_serializer_function_ser_schemar   )r   typevarrm   constraintsr'  r   s         rz   r  z,GenerateSchema._unsubstituted_typevar_schema  s    '6>>222!!--'=$7#k"2a"78G4<OPSTT%l  ''00%%fll;&?@@))%0F&1&U&U!+*@*@*B'F?# M))++r|   c                   	 t        j                  j                  j                  j                  | j
                        }|t        u rt        dd      t        || j                        }t        j                  j                  |      _        | j                  |      }| j!                  |t#        |j%                         j&                        d      }| j(                  j*                  }|rj                  j,                  j                  j,                  dk  r_ |j&                        }t/        |t0              st3        d| d	|j4                         |j                  _        dj                  _        dfd
}t9        |g      }	t;        j<                  j&                  |j                  j6                  |	      S # t        $ r}t        j                  |      |d }~ww xY w)NzComputed 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_typeTcomputed_fieldr7   r  r  c                *    ||       }d|d<   j                   j                  }|||d<   j                   j                  }|||d<   j                   j                  }|t	        |      |d<   j                   j
                  }|t        ||       |S )NTreadOnlyr   r   r  )rw   r   r   r  r"   r  add_json_schema_extra)r   r   r   r   r   r  r  r^  s          rz   set_computed_field_metadatazJGenerateSchema._computed_field_schema.<locals>.set_computed_field_metadata  s    !&/K&*K
#FFLLE ',G$&&,,K&-8M*vvH#*<X*FJ' ! 8 8 ,%k3DEr|   r  )rb  r  r  )r   rB   r   r-   re  r4   )r9   get_function_return_typefuncrw   r  r   rx  r2   ry  r    r3   r\   r   rv  replacer   r  r   r  r   r   r  r  ru   rf  r   r   r  r@   r!   r  )
r   r^  rC  r  r{  return_type_schemar  r  r  r  s
    `        rz   rS  z%GenerateSchema._computed_field_schema  s   
	H%>>qvvqvvGYGY[_[p[pqK ++#d5  $K1C1CD $$QVVE!11+>!::01B1I1I1KQ^^\ ; 
 ..>> 5 5 =AVAVZ[A[#ANN3EeS)"2?2CCYZ_ZiZiYj kll AFFL$%AFF!	. '@[?\]))NN*<AFFLL[c
 	
o  	H-==a@aG	Hs   ?G
 
	G.G))G.c                    ddl m} | j                  |d      ^}}| j                  ||      }|D ]  }t	        ||      st        ||      } |S )zdGenerate schema for an Annotated type, e.g. `Annotated[int, Field(...)]` or `Annotated[int, Gt(0)]`.r+   r  Tr1  )rv   rb   rJ  r  ru   r  )r   annotated_typerb   r  r   r   r  s          rz   r  z GenerateSchema._annotated_schema*  sc    &$($I$I %J %
!k ((kB &J*i0%j&9 & r|   c                    ddl m} 	 t        |       |D ]&  } |||| j                  j
                        }|$|c S  y # t        $ r Y y w xY w)Nr7   )PREPARE_METHODS)r  r  hashr   r   r  )r   r   r   r  genr  s         rz   r  z?GenerateSchema._get_prepare_pydantic_annotations_for_known_type:  s\     	7	I
 #Cc;(<(<(H(HIC
 #
   		s   ? 	A
Ac                    | S r   r  r  s    rz   r`  zGenerateSchema.<lambda>Q  s    qr|   c                    t        t        j                  |            } j                  |t	        |            }||\  }}g }d fd}t        |       }|D ]  }| j                  |||      }  ||      }	|r6t        |	      j                  }
|
j                  dg       j                  |       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                  |       }n|}t        | |      }|4t        |j                  j
                        }|j                  ||        |      S r   )r!  r"  r#  r$  r   r  r  )r   r'  r   r(  r  r   r  s        rz   inner_handlerz8GenerateSchema._apply_annotations.<locals>.inner_handler`  s{     ??SIM$..s3&#DS&#Q #/"9&$))BWBW"X".))/;OP)&11r|    pydantic_js_annotation_functionsr   r   re  r   )r  r;   expand_grouped_metadatar  r  r]   _get_wrapped_inner_schemar?   r  r  extendr   r   r   )r   r  r   r  r  r  r  get_inner_schemar  r   r  s   `  `       rz   r  z!GenerateSchema._apply_annotationsM  s     4LL[YZCCKQVWbQcd?'*$KHJ(	2 8tL%J!#== *.N  & "+.+*62;;H BBGNNOop;D<P<P<^<^`kmsttr|   c                   ddl m} t        ||      rM|j                  D ]  }| j	                  ||      } |j
                  | j                  ||j
                        }|S |d   dk(  r?|j                  dt        j                               }| j	                  ||      }|r||d<   |S |}|j                  dd       }|X|j                         }|dt        |       z   }|| j                  j                  v r| j                  j                  |   S ||d<   n|d   dk(  r|d	   }|| j                  j                  v rn| j                  j                  |   j                         }|dt        |       z   }|| j                  j                  v r| j                  j                  |   S ||d<   t        j                  ||j                               }	|	|	S |S )
Nr+   r  r   r   r   r   rs  definition-refr  )rv   rb   ru   r  _apply_single_annotationr  r  r   r!   r   r   reprr   r  r;   apply_known_metadata)
r   r   r  rb   field_metadatar4  r   r   new_refmaybe_updated_schemas
             rz   r  z'GenerateSchema._apply_single_annotation|  s   &h	*"*"3"366v~N #4 %%1;;FHDZDZ[M&>Z'JJx)?)?)ABE11%BE#(x M jj%?[[]FaX/00G$))///yy,,W55#F5MF^//&Cdii+++..s388:!DN#3 44dii333990099 'u8MMhX^XcXcXef+''r|   c                   ddl m} t        ||      r|j                  D ]  }| j	                  ||      } i }|j
                  r|j
                  |d<   |j                  r|j                  |d<   |j                  rt        |j                        |d<   |j                  }|s|r>t        |      j                  j                  dg       j                  t        ||             |S )Nr+   r  r   r   r  r  )rv   rb   ru   r  $_apply_single_annotation_json_schemar   r   r  r"   r  r?   r  r  r  )r   r   r  rb   r  json_schema_updater  s          rz   r  z3GenerateSchema._apply_single_annotation_json_schema  s     	'h	*"*"3"3BB6>Z #424~~.6nn"7+##4<4H4H"=1  1CHDUDU1V":. ( : :!%6#F+44??@bdfgnn/0BDUV r|   c                \     t        dd       xs d d fd}t        |       S )Nrk  c                     ||       S r   r  )rr  r   s     rz   r`  z:GenerateSchema._get_wrapped_inner_schema.<locals>.<lambda>  s    GFOr|   c                     |       }j                  |      }j                  |      }t        |      }|j                  |       |S r   )r  r  r#  r  )rr  r   r(  r  r  metadata_get_schemar  r   s      rz   new_handlerz=GenerateSchema._get_wrapped_inner_schema.<locals>.new_handler  s\    (1ABF226:FF>>vzRF#DZQW#X #/0778LMMr|   )rr  r   re  core_schema.CoreSchema)r   r]   )r   r  r  r  r  r  s   ```` @rz   r  z(GenerateSchema._get_wrapped_inner_schema  s9     6=ZIgim5n 6
3 		 	 ,K>>r|   c                   |rt        |      }|d   dk(  r|d   }| j                  ||      |d<   |S t        j                  d|j	                  dd            }|t        j                  |      }|d   }t        |j                  |j                  j                  |      \  }}	 t        j                  |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   zstr|Noner   Nr   r  wrap)is_field_serializerinfo_argrb  r   r   plain)r   r  r  r   r   r!   r  rS   r  rw   r2  r9   r  r  r   rx  r2   ry  r    r   r  r   r   )r   r   serializersr  r   r   
serializerr  r  r  r{  rb  s               rz   r  z'GenerateSchema._apply_field_serializers  s    &\Ff~.%h/#'#@#@{#[x kk*fjj.EF?(DDSIF %RJ,D!5!5n-)L)BBOOZ__%@%@$BWBW // $ $ 4 4[ A##v-*5*Y*YOO(;%"/(oo77+'   "++w666*5*Z*ZOO(;%"/(oo77+' 3  L1AA!D!KLs   %?F. .	G7GGc                   |j                  dd      }|r!t        |      d   }t        |j                  |j                  j
                        }	 t        j                  |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  rb  r   r   )popr  rT   r  rw   r2  r9   r  r  r   rx  r2   ry  r    r   r!   r  r   r   )
r   r   r  r   r  r  r  r{  rb  
ser_schemas
             rz   rU  z'GenerateSchema._apply_model_serializers
  s=    !**UD1k*2.J/
AUAUVHL)BBOOZ__%@%@$BWBW
 // $ $ 4 4[ A##v-4?4c4cOO%"/(oo77	5
 )MMOO%"/(oo77	
 '1F?#F5M3  L1AA!D!KLs   ?E   	E$	EE$r   )r   r=   r   dict[str, Any] | Noner   dict[Any, Any] | Nonere  None)
r   r>   r   r  r   r  r   r   re  r   )re  r=   )re  r   )re  r  )re  r   )r   r   r   r   re  r   )r   r   r   r   r   r   re  r   )r   r   r   	list[Any]re  r   )r   r   re  r   r  )r   r   r  zstr | Discriminator | Nonere  r   r  )r  r   r  Callable[..., Any]re  r  )T)r   r   r&  r  re  r  )r   ztype[BaseModel]re  r  )r   r   rr  r   re  zcore_schema.CoreSchema | None)r   r   re  r   )r   r   r2  zLiteral[True]re  tuple[Any, ...])r   r   re  tuple[Any, ...] | None)F)r   r   r2  r  re  r  )r   r   re  ztuple[Any, Any])r   r  re  r  )r   r   re  r  )r   r   r  r   re  r   )
r  rf  r  rb   r   rK   r2  r  re  zcore_schema.TypedDictField)r  rf  r  rb   r   rK   re  zcore_schema.ModelField)r  rf  r  rb   r   rK   re  zcore_schema.DataclassField)r  rf  r  rb   r   rK   re  _CommonField)r  r   re  r  )r  r   re  r   )r  r   r  r   re  r  )r/  r   r  r   re  r  )
r  rf  r  z	type[Any]r'  r   r2  zJLiteral['positional_only', 'positional_or_keyword', 'keyword_only'] | Nonere  zcore_schema.ArgumentsParameter)r=  r   re  r  )re  r  )rK  r   re  r  )rU  r   re  r  )rK  r   re  zcore_schema.GeneratorSchema)rh  r   re  r  )r~  ztype[StandardDataclass]r  ztype[StandardDataclass] | Nonere  r  )r  r  re  zcore_schema.CallSchema)r  ztyping.TypeVarre  r  )r^  zDecorator[ComputedFieldInfo]rC  z2dict[str, Decorator[FieldSerializerDecoratorInfo]]re  zcore_schema.ComputedField)r  r   re  r  )r   r   r   r  re  ztuple[Any, list[Any]] | None)r  r   r   r  r  z"Callable[[CoreSchema], CoreSchema]re  r   )r   r  r  r   re  r  )r  r,   r  r   r  zlist[GetJsonSchemaFunction]re  r]   )r   r  r  z-list[Decorator[FieldSerializerDecoratorInfo]]r  r  re  r  )r   r  r  z1Iterable[Decorator[ModelSerializerDecoratorInfo]]re  r  )Ir   r
  r  r   rs  r   classmethodr   propertyr   r   r   r   r   r   r   r   r   r   r   r   r  	Exceptionr  r  r  r  r   ra  rh  r!  r|  r   rJ  r  r  r%  r"  r  r  r  r  rR  r  rM  r  r  r  r  r  r	   r-  r+  r  r  rF  r  r  r  r  r  r  r  r  rS  r  r  r  r  r  r  r  rU  r  r|   rz   r   r     sh   fI /3	#%# /# ,	#
 
# 0 / ,	
  
 " / / 
 
 < <(IkHNSB
2	
 1K	.9 	
	6 -1// &*/ 
 	/bWJr-^,     	$0U.n*.d 

 
 #	
 
 
$
&

 
 #	

 
 
"

 
 #	

 
$
(m
m
%.m
<Jm
	m
^:@@ 
@44ZOxaJ ![_     	 
 Y  
( BK<
d
>*gMr8
DN0DN:XDN	DNL3
j,2@
'@
 N@
 
#	@
D %4	%. FQ	-u-u -u !C	-u
 
-u^(T,8;	.?.? ? +F	?
 
&?4  %	5&5 C5 	5
 
 5n&,&;l&	&r|   r   c                .    t        j                  | |      S r   )r!   !no_info_before_validator_functionfr   rs  s      rz   r`  r`  7  s    0]0]^_ag0hr|   c                .    t        j                  | |      S r   )r!    no_info_after_validator_functionr  s      rz   r`  r`  8  s    {/[/[\]_e/fr|   c                ,    t        j                  |       S r   )r!   rd  )r  r^  r_  s      rz   r`  r`  9  s    K,X,XYZ,[r|   c                .    t        j                  | |      S r   )r!   rS  r  s      rz   r`  r`  :  s    k.Y.YZ[]c.dr|   c                2    t        j                  | ||      S N)r   )r!   #with_info_before_validator_functionr  r   r   s      rz   r`  r`  ;  s    ;;j;j	6j<r|   c                2    t        j                  | ||      S r  )r!   "with_info_after_validator_functionr  s      rz   r`  r`  >  s    +:h:h	6j;r|   c                0    t        j                  | |      S r  )r!   ro  )r  rs  r   s      rz   r`  r`  A  s    [5c5c	j6r|   c                2    t        j                  | ||      S r  )r!   !with_info_wrap_validator_functionr  s      rz   r`  r`  D  s    9f9f	6j:r|   ))beforeno-info)afterr  )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, str | None], core_schema.CoreSchema]]_VALIDATOR_F_MATCHc                    |D ]b  }t        |j                  |j                  j                        }|rdnd}t	        |j                  j                  |f   |j                  | |      } d | 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  r  )rU   r  rw   r2  r  )r   rD  r   	validatorr  val_types         rz   r   r   J  s`    "  	$Y^^Y^^5H5HI"*;	#Y^^%8%8($CDY^^U[]gh	  
 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)rw   always)rD  r  s     rz   r  r  c  s#      	>>     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                        }|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                  |       } lt        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   Nr4  r  r>  r  )r  r   r  )r  rw   r2  rU   r  r!   r  rS  r  r  r  r  )r   rD  r2  r   r  r  s         rz   rN  rN  s  s\   & jj-C	7?y~~22h>7?y~~22h>$Y^^Y^^5H5HI>>&($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+  , uMr|   c                    | j                   r,t        j                  || 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`.
    )default_factoryr  )r'  r  )r  r!   with_default_schemar  r'  r    )r  r   s     rz   r  r    sr     !!..J$>$>Q[QlQl
 	
 
		#4	4..J..A\A\
 	
 r|   c                F   t        | dd      }t        | d      r@ddlm} |duxr% |j                  j
                  |t        |dd      fv}|st        dd	      t        | d
      r8t        | t        t        t        df               st        | j                  |      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   rc   __func__zkThe `__modify_schema__` method is not supported in Pydantic v2. Use `__get_pydantic_json_schema__` instead.zcustom-json-schemar   
__origin__placeholder)r   r{  pydanticrd   r  r
  r3   ru   r   r#   r  r#  r  )r   r   js_modify_functionrd   has_custom_v2_modify_js_funcs        rz   r#  r#    s     %CTJr&'& d* W66??&0BJPT(UVW 	% ,#>)  r< BYsMGY=Z8[)\0GG!r|   c                $     	 	 	 	 	 	 d fd}|S )Nc                8    i  ||       }t        |       |S r   )r  )core_schema_or_fieldr   r   r  r  s      rz   json_schema_update_funcz<get_json_schema_update_func.<locals>.json_schema_update_func  s-     N!56M:LMk+<=r|   )r  rB   r   r-   re  r4   r  )r  r  r  s   `` rz   r  r    s(    /:N	 #"r|   c                    t        |t              r| j                  t        |             y t	        |      r	 ||        y y r   )ru   r   rg  r"   callable)r   r  s     rz   r  r    s:     #T*-.?@A	#	$+& 
%r|   c                  J    e Zd ZU ded<   ded<   ded<   ded<   ded	<   d
ed<   y)r  r  r   4str | list[str | int] | list[list[str | int]] | Noner  r  r  bool | Noner  r  zdict[str, Any]r  N)r   r
  r  rI  r  r|   rz   r  r    s&    ""JJ##&&r|   r  )r  r  r  r  r  c                   | |||||dS )Nr   r  r  r  r  r  r  r  s         rz   r  r    s      ,2!6 r|   c                  *    e Zd ZdZddZedd       Zy)r   z*Keeps track of references and definitions.c                0    t               | _        i | _        y r   )r   seenr  r   s    rz   r   z_Definitions.__init__  s    !e	>@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)ao  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:

        - BaseModel
        - Dataclasses
        - TypedDict
        - TypeAliasType
        N)rF   r  r  r!   r  adddiscard)r   r   r   s      rz   r?  z_Definitions.get_schema_or_ref  s     ( 2$))sd&6&66??DEEIIMM#'Dk!		!!#&		!!#&s   AB" B &B"BB"Nre  r  )r   r   re  z3Iterator[tuple[str, None] | tuple[str, CoreSchema]])r   r
  r  r   r   r   r?  r  r|   rz   r   r     s    4A ' 'r|   r   c                Z    | d   dk(  r|j                  | d   d       S | d   dk(  r| d   S | S )Nr   r  r  r  r   rp  )r   r  s     rz   r$  r$  /  sA    f~))vl3T::	=	(h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    rz   r   z_FieldNameStack.__init__;  s	    !#r|   c              #  ~   K   | j                   j                  |       d  | j                   j                          y wr   )r%  r  r  )r   r   s     rz   rK  z_FieldNameStack.push>  s)     :&s   ;=c                :    | j                   r| j                   d   S y )Nr   r$  r   s    rz   r   z_FieldNameStack.getD  s    ;;;;r?"r|   Nr!  )r   rf  re  zIterator[None])re  r  )r   r
  r  rs  r   r   rK  r   r  r|   rz   r   r   8  s%    I$  
r|   r   c                    | S r   r  r  s    rz   r`  r`  O  s    r|   c           	     b   ddl m} t        |       j                  j	                         }i }d}d} ||dd      D ]W  }	|	j
                  dk(  r|	j                  t              }	|	j                  |	j                  u r|	}C ||	      ||	j                  <   Y |r|j                  }
|j                         D ]  \  }}t        |j                  t              r|j                  }n|}||v s||v r8t!        |      s|
rt!        |      r|}nd}V|j#                         ri nd	|j%                  d
      i} |t'        |t&        j(                  fd|j+                         i|      ||<    |j,                  dk(  rd}|r|rdt&        j.                  fdt&        j                  fg}|D cg c]  }|j                  |j                  f c}|k(  rd}n|j                  }||v r
|dz  }||v r
 ||j                  |            ||<   t1        j2                  t5        |j	                               d      S c c}w )a  Generate signature for a pydantic class generated by inheriting from BaseModel or
       using the dataclass annotation

    Args:
        init: The class init.
        fields: The model fields.
        config_wrapper: The config wrapper instance.
        post_process_parameter: Optional additional processing for parameter

    Returns:
        The dataclass/BaseModel subclass signature.
    r   )isliceNFr7   r   )r  Tr'  )call_default_factoryr  r/  __pydantic_self__data
extra_datars  )r  )rq  return_annotation)	itertoolsr+  r   rq  r  r  r  r   r  r  r  r  rQ  ru   r  rf  r_   r  get_defaultr	   r  rebuild_annotationextrar  r   	Signaturer  )initrv   r   post_process_parameterr+  present_paramsmerged_paramsvar_kw
use_var_kwr9  allow_namesr   rx   
param_namekwargsdefault_model_signaturer  var_kw_names                     rz   generate_pydantic_signaturerA  K  s1   $ !t_//668N*,MFJ40 u$MMSM1E::***F$:5$Aejj! 1 $55!'J%++s+"[[
'
]*jM.I&z2#6z#B!+J!%J ,,.RY@Q@Qgl@Q@m4nF(>*i&<&<nIaIaIcngmn)M*%% "0, w&
* !)"A"ABY**+#
 '55nQVVQVVn59PP&K !++K V#3K V#%;FNNP[N<\%]k"]-A-A-C(DX\]] 6s   !H,)rw   FieldDecoratorInforx   rf  re  r  )r   zIterable[AnyFieldDecorator]rv   zIterable[str]re  r  )r   z+Iterable[Decorator[FieldDecoratorInfoType]]rx   rf  re  z'list[Decorator[FieldDecoratorInfoType]])r   r  r   z'list[Decorator[ValidatorDecoratorInfo]]r   r  re  r  )r   rB   r   r-   r   r   re  r4   )r   zJsonEncoders | Noner   r   r   r   re  r   )r   r  rD  zIterable[Decorator[RootValidatorDecoratorInfo]] | Iterable[Decorator[ValidatorDecoratorInfo]] | Iterable[Decorator[FieldValidatorDecoratorInfo]]r   r  re  r  )rD  z+Iterable[Decorator[ValidatorDecoratorInfo]]re  r  )r   r  rD  z0Iterable[Decorator[ModelValidatorDecoratorInfo]]r2  z Literal['inner', 'outer', 'all']re  r  )r  rb   r   r  re  r  )r   r   r   r   re  zGetJsonSchemaFunction | None)r  r4   r  3JsonDict | typing.Callable[[JsonDict], None] | Nonere  rh   )r   r4   r  rC  )r   r  r  r  r  r  r  r  r  r  r  r   re  r  )r   r   r  zdict[str, CoreSchema]re  zCoreSchema | None)
r6  zCallable[..., None]rv   zdict[str, FieldInfo]r   r=   r7  z Callable[[Parameter], Parameter]re  zinspect.Signature)r   
__future__r   _annotationscollections.abcr  rv  r   r  sysr  r   
contextlibr   r   r   enumr   	functoolsr   r	   r
   r   r1  r   operatorr   typesr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   pydantic_corer   r    r!   r"   typing_extensionsr#   r$   r%   r&   r'   r(   r)   r*   annotated_handlersr,   r-   r:  r.   r/   r0   errorsr1   r2   r3   r   r4   versionr5   r6   rc  r8   r9   r:   r;   r<   _configr=   r>   _core_metadatar?   r@   rA   rB   rC   rD   rE   rF   rG   rH   rI   rJ   rK   rL   rM   rN   rO   rP   rQ   rR   rS   rT   rU   r)  rV   rW   _forward_refrX   	_genericsrY   rZ   r[   r\   _schema_generation_sharedr]   r^   _utilsr_   r`   rv   ra   rb   r  rd   re   rD  rf   _dataclassesrg   rh   version_infor  r   r  r  rB  rl   AnyFieldDecoratorModifyCoreSchemaWrapHandlerGetCoreSchemaFunctionr  Tuplern   rI  r  Listr  MutableSequencero   r   Set
MutableSetrp   	frozenset	FrozenSetrq   r   MutableMappingrr   r{   r   r   r   r   JsonEncodersr   r   r  r   r  rN  r  r#  r  r  r  r  r   r$  r   rA  r  r|   rz   <module>rf     s   3 2    	 
   %    8 8   6 6     X X u u u K 6 6 b b ) # 0 f f 6 D
 
 
    M . t t ' ;5 %0/@&&'1 iS)*13NPllm  !9AST $%)**+-  3  #'B!C[E[E[![\  !&,,/Z /[__-L-LM
J Mfjj+//*D*DE	: E )6+;+;[__=P=PQ * Q[__-K-K[__MdMde
J e
 
,6nDnMPn,n"A  	@&1EOR8 DI{*+&,/9CDh h^1 if[d   ."7
  2 ,",@, +, 	,^,<
#'
#<o
#
#' '5h'9  NR&*)-" K $	
 '   &$' $'N . @K	Q^
Q^ Q^ "Q^ =	Q^
 Q^r|   