U ={f @sUdZddlmZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl m Z mZddlmZmZddlmZddlmZddlmZmZmZdd lmZdd lmZdd lmZmZmZdd 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,m-Z-dd l m.Z.ddl/m0Z0m1Z1m2Z2m3Z3ddl4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;ddlm?Z?m@Z@ddlAmBZBmCZCmDZDddlEmFZFmGZGmHZHddlImJZJddlKmLZLddl mMZMddlNmOZOmPZPmQZQmRZRmSZSddlTmUZUmVZVddlWmXZXmYZYddlOmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`maZambZbddlPmcZcmdZdmeZemfZfmgZgmhZhmiZimjZjmkZkmlZlmmZmmnZnddlompZpddlqmrZrmsZsdd ltmuZudd!lvmwZwmxZxmyZymzZzdd"l{m|Z|dd#lSm}Z}m~Z~dd$lmZe r dd%lmZmZdd&lmZdd'lmZdd(lmZdd)lmZdd*l{mZe jd+kZee5ed,fZe+ejefeefZe*d-ed.Ze+ecejecefeceefZe?Ze"e!ege2j0fZee jgZd/ed0<ee jejjgZd/ed1<ee jejjgZd/ed2<ee jejjgZd/ed3<ee j#ejjejj(gZd/ed4<d5d6d7d8d9d:Zd;dd?d@ZdAd6dBdCdDdEZdFdGdHdFdIdJdKZdLdMdNdOdPdQdRZe#e)e!eDfZdSdNdTdTdUdVdWZe+e#ee!fdfZGdXdYdYZdNdNdNdZd[d\ZGd]d^d^Zd_d`dad`dbd`dcd`ddd`ded`dfd`dgd`dhZdiedj<dFdkdHdFdldmdnZdod7dpdqdrZdFdsdtdFdudvdwZdxdFdFdydzd{ZdNdTd|d}d~dZdOdddddZdOddddZGddde8ZdddddddFddHdddNddddZGdddZdTdddddZGdddZGdddZdS)z-Convert python types to pydantic-core schema.) annotationsN) ExitStackcontextmanager)copydeepcopy)Enum)partial) Parameter_ParameterKind signature)chain) attrgetter) FunctionType LambdaType MethodType) TYPE_CHECKINGAnyCallableDictFinal ForwardRefIterableIteratorMappingTypeTypeVarUnioncastoverload)warn) CoreSchemaPydanticUndefined core_schemato_jsonable_python) AnnotatedLiteral TypeAliasType TypedDictget_args get_origin is_typeddict)AliasGenerator)GetCoreSchemaHandlerGetJsonSchemaHandler) ConfigDictJsonDict JsonEncoder)PydanticSchemaGenerationErrorPydanticUndefinedAnnotationPydanticUserError)JsonSchemaValue) version_short)PydanticDeprecatedSince20) _core_utils _decorators_discriminated_union_known_annotated_metadata _typing_extra) ConfigWrapperConfigWrapperStack)CoreMetadataHandlerbuild_metadata_dict) CoreSchemaOrFieldcollect_invalid_schemasdefine_expected_missing_refsget_ref get_type_refis_function_with_inner_schema%is_list_like_schema_with_items_schemasimplify_schema_referencesvalidate_core_schema) DecoratorDecoratorInfosFieldSerializerDecoratorInfoFieldValidatorDecoratorInfoModelSerializerDecoratorInfoModelValidatorDecoratorInfoRootValidatorDecoratorInfoValidatorDecoratorInfoget_attribute_from_basesinspect_field_serializerinspect_model_serializerinspect_validator)extract_docstrings_from_cls)collect_dataclass_fieldsget_type_hints_infer_globalns)PydanticRecursiveRef)get_standard_typevars_maphas_instance_in_typerecursively_defined_type_refs replace_types)CallbackGetCoreSchemaHandler) is_finalvar is_self_type)lenient_issubclass)ComputedFieldInfo FieldInfo BaseModel) Discriminator)FieldValidatorModes)StandardDataclass)GetJsonSchemaFunction) {FieldDecoratorInfoType)boundz list[type] TUPLE_TYPES LIST_TYPES SET_TYPESFROZEN_SET_TYPES DICT_TYPESFieldDecoratorInfostrbool)infofieldreturncCs,d|jkrdS|jD]}||krdSqdS)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)fields)rxryZ v_field_namer}b/var/www/html/Darija-Ai-API/env/lib/python3.8/site-packages/pydantic/_internal/_generate_schema.py)check_validator_fields_against_field_nameqs  rzIterable[AnyFieldDecorator]z Iterable[str]None) decoratorsr|rzcCsft|}|D]T}d|jjkrq |jjdkr,q |jjD]*}||kr4td|jd|jdddq4q dS) avCheck 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)zdecorator-missing-fieldcodeN)setrxr|Z check_fieldsr4Zcls_ref cls_var_name)rr|decryr}r}r~check_decorator_fields_exists    rz+Iterable[Decorator[FieldDecoratorInfoType]]z'list[Decorator[FieldDecoratorInfoType]])validator_functionsryrzcsfdd|DS)Ncsg|]}t|jr|qSr})rrx).0rryr}r~ s z8filter_field_decorator_info_by_field..r})rryr}rr~$filter_field_decorator_info_by_fieldsrcore_schema.CoreSchemaz'list[Decorator[ValidatorDecoratorInfo]] str | None)schemaeach_item_validators field_namerzcCs|ddkr$t|d|||d<|S|ddkr`|d}dk rt|d||||d|<nt|r|dd}|dkrt}t||||d<nP|ddkr|dd}|dkrt}t||||d<n|rtd |d|S) Ntypenullablertuplevariadic_item_indexZ items_schemadictZ values_schemazO`@validator(..., each_item=True)` cannot be applied to fields with a schema of )apply_each_item_validatorsgetapply_validatorsrHr" any_schema TypeError)rrrr inner_schemar}r}r~rs2       rrBr.rr5)schema_or_fieldhandlerclsrzc Csddlm}ddlm}||}||}d|krP|d}|d|ig|d<d|krb|j|d<||krndn|j}|rd|krt ||d<n&t ||r|j d j r|j d j |d<|S) a0Add 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. r+re) RootModelz$refZallOftitleN descriptionroot) mainrf root_modelrZresolve_ref_schemaclear__name____doc__inspectcleandoc issubclass model_fieldsr) rrrrfr json_schemaoriginal_schemarefZ docstringr}r}r~modify_model_json_schemas     rzJsonEncoders | Noner ) json_encoderstprrzcCs~|s|Sd|kr|S|ft|d|jjddD]F}||}|dkrJq2tdtdttj |dd|d<|S|S) aIterate 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/zZdddd@dAdBdCZdDd@dEdFdGZddd6dHdIZdddJdKdLdMZddd-dNdOZeddPdQdRdSdTZ eddUd-dVdTZ ddddUdRdXdTZ ddd-dYdZZ!dd[d-d\d]Z"dd@d-d^d_Z#dd@d-d`daZ$ddddbdcddZ%d?dedfdgdhddidjdkdlZ&dfdgdhdmdndodpZ'dfdgdhdqdndrdsZ(e)dtdgdfddudvdwZ*e)dtdxdfdydzd{Z+dfdgdhd|dnd}d~Z,dd@dddZ-ddd-ddZ.dddddZ/ddd@dddZ0ddd@dddZ1e2j3dfdfdddddddZ4dd@dddZ5d@dddZ6dd@dddZ7dd@dddZ8dd@dddZ9dddddZ:dd@dddZ;d@dddZdd@dddZ?ddddddZ@dd@dddZAddQddddZBddÄfdddddƜddȄZCd@dd@dɜdd˄ZDd@dd@dɜdd̈́ZEdddddќddӄZFdd@ddd@d՜ddׄZGd@dd@dٜddۄZHdS)GenerateSchemaz\Generate core schema for a Pydantic model, dataclass and types like `str`, `datetime`, ... .)_config_wrapper_stackr _typevars_mapfield_name_stackmodel_type_stackdefsNr>zdict[str, Any] | Nonezdict[Any, Any] | Noner)config_wrapperr typevars_maprzcCs6t||_t||_||_t|_t|_t |_ dSr) r?rrrr_FieldNameStackr_ModelTypeStackr _Definitionsr)rrrrr}r}r~r?s   zGenerateSchema.__init__r?rrr)config_wrapper_stacktypes_namespace_stackrrrrzcCs4||}||_||_||_||_t|_||_|Sr)__new__rrrrrrr)rrrrrrobjr}r}r~Z __from_parentMs zGenerateSchema.__from_parentrcCs|jjSr)rrrr}r}r~_config_wrapper_szGenerateSchema._config_wrappercCs|jjSr)rrrr}r}r~_types_namespacecszGenerateSchema._types_namespacecCs(|jjp t}||j|j|j|j|jSr) rZschema_generatorr_GenerateSchema__from_parentrrrrr)rrr}r}r~_current_generate_schemags z'GenerateSchema._current_generate_schemarwcCs|jjSr)rZarbitrary_types_allowedrr}r}r~_arbitrary_typesrszGenerateSchema._arbitrary_typesr cCstS)zGenerate a CoreSchema for `str`)r" str_schemarr}r}r~rvszGenerateSchema.str_schemar)r items_typerzcCst||Sr)r" list_schemagenerate_schemarrrr}r}r~ _list_schema|szGenerateSchema._list_schema)r keys_type values_typerzcCst||||Sr)r"Z dict_schemar)rrrrr}r}r~ _dict_schemaszGenerateSchema._dict_schemacCst||Sr)r"Z set_schemarrr}r}r~ _set_schemaszGenerateSchema._set_schemacCst||Sr)r"Zfrozenset_schemarrr}r}r~_frozenset_schemasz GenerateSchema._frozenset_schemarrzcCs,t|ts"t|dttSt|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`.) isinstancerr UserWarningr"ris_instance_schema)rrr}r}r~_arbitrary_type_schemas z%GenerateSchema._arbitrary_type_schemarrzcCstd|ddS)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() within `__get_pydantic_core_schema__` then you likely need to call `handler.generate_schema()` since we do not call `__get_pydantic_core_schema__` on `` otherwise to avoid infinite recursion.)r2rrr}r}r~_unknown_type_schemas z#GenerateSchema._unknown_type_schemazstr | Discriminator | None)r discriminatorrzcCsF|dkr |Szt||WStjk r@t|||YSXdSr)r;Zapply_discriminatorZMissingDefinitionForUnionRefZset_discriminator_in_metadata)rrrr}r}r~_apply_discriminator_to_unionsz,GenerateSchema._apply_discriminator_to_unionc@s eZdZdS)zGenerateSchema.CollectedInvalidN)rrrr}r}r}r~CollectedInvalidsrrrzcCs8||}t|}t|r"|t|}t|}|Sr)collect_definitionsrIrCrr;Zapply_discriminatorsrJrrr}r}r~ clean_schemas  zGenerateSchema.clean_schemacCsPtd|dd}|r"||jj|<d|kr8t|d}t|t|jjS)Nrr) rrr definitionsr"definition_reference_schemaZdefinitions_schemalistvalues)rrrr}r}r~rs z"GenerateSchema.collect_definitionszCallable[..., Any])metadata_schema js_functionrzcCs,t|j}|dg}||kr(||dS)Npydantic_js_functions)r@metadata setdefaultr)rr r r r r}r}r~_add_js_functions  zGenerateSchema._add_js_functionTr)rfrom_dunder_get_core_schemarzcCsvd}|r |||}|dk r |}|dkr2||}t||}|dk rbt||jj}|rb|||t|jj ||}|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 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_property_generate_schema_inner!_extract_get_pydantic_json_schemaresolve_original_schemarrrrrr)rrrr from_propertymetadata_js_functionr r}r}r~rs    zGenerateSchema.generate_schemaztype[BaseModel])rrzc sj|\}}|dk r,|W5QRS|j}|jj}ttjj j | | t |j dd}||}ttt|dgd}j} d} |ddkrz|jd|kst|jd tkst|jdd D]} t| d id d} | dk rt| tr0ttj| dd d j} t| } | tt fkrNt!dj"| d dd}|t#k r$|} qzqj%&|rj'&|Xj(|j)r*d|d}|d}t+|| d}t,j-||t|ddd t|dd|||d}nt,j.fdd|/Dfdd|D| |j0d}t1|j2d}t3|t4}|dk rb|}t+|| d}t,j-||t|dddt|dd|||d}5|j6}t+|| d}|jj7|<t,8|W5QRW5QRW5QRSQRXW5QRXW5QRXdS)z%Generate schema for a Pydantic model.NF)checkr js_functionsZextra_fields_behaviorallowrr__annotations__Z__pydantic_extra__T) is_argumentZis_classzEThe type annotation for `__pydantic_extra__` must be `Dict[str, ...]`requiredr8rrinnerZ__pydantic_custom_init__Z__pydantic_post_init__)Z custom_initr post_initconfigrr cs i|]\}}|||qSr})_generate_md_field_schemarkvrrr}r~ Dsz0GenerateSchema._model_schema..csg|]}|jqSr}_computed_field_schemafield_serializersrdr'r}r~rEsz0GenerateSchema._model_schema..)computed_fields extras_schemaZ model_nameouter)9rget_schema_or_refr__pydantic_decorators__r.rr field_validatorsr r+ validatorskeysr>Z model_config core_configrArrmodel_validatorsrrAssertionErrorobjectrrrvr=eval_type_backportZ_make_forward_refrr)rrr2 _get_args_resolving_forward_refsrrrrrrZ__pydantic_root_model___common_field_schemaapply_model_validatorsr" model_schemaZmodel_fields_schemaitemsrrroot_validatorsrDr]_apply_model_serializersmodel_serializersrr)rrZ model_ref maybe_schemar|r.rr6r r7r/Z candidate_clsZextras_annotationrZextra_items_typeZ root_fieldrr>Z fields_schemaZnew_inner_schemarr}r'r~ _model_schemas                   zGenerateSchema._model_schemacsHddddd|ddkrD|jjfdd |dD|d }|S) zuUnpack all 'definitions' schemas into `GenerateSchema.defs.definitions` and return the inner schema. r rv)srzcSs|dS)Nrr})rEr}r}r~rEgsz1GenerateSchema._unpack_refs_defs..get_refrrcsi|]}||qSr}r})rrErEr}r~r(ksz4GenerateSchema._unpack_refs_defs..r)rrupdaterr}rFr~_unpack_refs_defsbs   z GenerateSchema._unpack_refs_defszcore_schema.CoreSchema | None)rsourcerzc Csdt|r|j}|j|"\}}|dk r<|W5QRSW5QRX||krTd}nd}t|dd}dk rtt|j dkr||}n||t |j ||d}nft|dd}dk r|dd|kr|}n.rr)rarrrr1rlenrr parametersr_rrr7r" chain_schemarHrGrrErr) rrrI_rCrLZ get_schemarZexisting_schemar4rr}r}r~rosN       z-GenerateSchema._generate_schema_from_propertyc Csvztj||jd}Wn.tk rB}zt||W5d}~XYnXt|tr`t|jd||j rrt ||j }|S)N)globalnsz%Unable to evaluate forward reference ) r=r:r NameErrorr3from_name_errorrr__forward_arg__rr^)rrer}r}r~_resolve_forward_refs  z#GenerateSchema._resolve_forward_refz Literal[True]ztuple[Any, ...])rrrzcCsdSrr})rrrr}r}r~r;sz/GenerateSchema._get_args_resolving_forward_refsztuple[Any, ...] | NonecCsdSrr}rr}r}r~r;sFcs<t|}|r$tfdd|D}n|r8td|d|S)Ncs$g|]}t|tr|n|qSr})rrrX)rrrr}r~rszCGenerateSchema._get_args_resolving_forward_refs..z Expected z+ to have generic parameters but it had none)r(rr)rrrargsr}rr~r;s cCs||}|stS|dS)Nr)r;r)rrrYr}r}r~_get_first_arg_or_anys z$GenerateSchema._get_first_arg_or_anyztuple[Any, Any]cCsJ||}|sttfSt|dkr:t|}td|d|d|dfS)Nr+z Expected two type arguments for z, got 1rr8)r;rrOr)r)rrrYoriginr}r}r~_get_first_two_args_or_anys  z)GenerateSchema._get_first_two_args_or_anyc Cst|tr||St|tr"|St|tr4t|}t|trN|||Sddlm }t ||r|j || |W5QRSQRXt|trtj|jdS||S)Nr+re) schema_ref)r_AnnotatedType_annotated_schemarrvrrrXrrfrbrrrDrZr"rZtype_ref match_type)rrrfr}r}r~rs        z%GenerateSchema._generate_schema_innercCs|tkr|S|tkr tS|tkr0tS|tkr@tS|t krPt S|t ks`|t krht S|dksz|tjkrtS|tkr||S|tkr||||S|tkr||||S|tkr||||S|tkr|j|f||St|tr||S|t kr,|!St"|r@t#St$|rV|%|St&|rl|'|dSt(|r|)|dSt*|r|+|j,S|t-j.kr|/|S|t0j1j2ks|t3j2kr|4St|t3j5r|6|St7|r|t8krt S|+||St|t9t:t;t?|rht@|tArhddlBmC}|||jDjEStF|r|G|dS|H|d}|dk r|\}}|I||StJ|}|dk r|K||S|jLr|M|S|N|S)aMain 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. Nr8)get_enum_core_schemar})Orvrbytesr"Z bytes_schemaintZ int_schemafloatZ float_schemarwZ bool_schemarr9rr=NoneTypeZ none_schemarp _tuple_schemarqrrZrrrrsrrtrr\rr&_type_alias_type_schemar _type_schemaZis_callable_typeZcallable_schemaZis_literal_type_literal_schemar*_typed_dict_schema is_namedtuple_namedtuple_schemaZ is_new_typer __supertype__rePattern_pattern_schema collectionsabcHashabletyping_hashable_schemar_unsubstituted_typevar_schemar`rrrrr_callable_schemarisclassrr_std_types_schemarar config_dict is_dataclass_dataclass_schema0_get_prepare_pydantic_annotations_for_known_type_apply_annotationsr)_match_generic_typerrr)rrrares source_typerr[r}r}r~r`s                               zGenerateSchema.match_type)rr[rzcCst|tr||St|r*|||St|r@|||S|||}|dk rX|St |rl| |S|t kr~| |S|t kr||||S|tkr||||S|tkr||||S|tkr|j|f||St|r|||S|tjtfkr||S|tjtjjhkr8| |S|tj!tjj!tj"tjj"hkr`|#|S|t$j%tj%fkr||&|S|j'r|(|S|)|Sr)*rr&rgr=r{r|rkrlrorigin_is_union _union_schemarprfrqrrZrrrrsrrtrr\r*rjrtrr_subclass_schemaSequencerqrr_sequence_schemar Generator_iterable_schemarnrorprrr)rrr[rr}r}r~rNsD                 z"GenerateSchema._match_generic_typerrvrdrLzcore_schema.TypedDictField)name field_inforrrzcCsD||||}tj|d|s$dn||d|d|d|ddS)zAPrepare a TypedDictField to represent a model or typeddict field.rFserialization_excludevalidation_aliasserialization_aliasr )rrrrr )r<r"Ztyped_dict_field is_required)rrrrr common_fieldr}r}r~_generate_td_field_schemazs z(GenerateSchema._generate_td_field_schemazcore_schema.ModelField)rrrrzcCs<||||}tj|d|d|d|d|d|ddS)z0Prepare a ModelField to represent a model field.rrrrfrozenr rrrrr )r<r"Z model_fieldrrrrrr}r}r~r#sz(GenerateSchema._generate_md_field_schemazcore_schema.DataclassFieldc CsV||||}tj||d|j|jp&d|jr0dnd|d|d|d|d|dd S) zJPrepare a DataclassField to represent the parameter/field, of a dataclass.rNFrrrrr )initZ init_onlykw_onlyrrrrr )r<r"Zdataclass_fieldrZinit_varrrr}r}r~_generate_dc_field_schemas z(GenerateSchema._generate_dc_field_schemaz%Callable[[str], str] | AliasGenerator)alias_generatorrrrzcCs|jdks4|jdks4|jdks4|jdks4|jdkr d\}}}t|trZ||\}}}n2t|tr||}t|tst d|d|j |jdks|jdkrd|_|jdkrt |||_t |||_||_|jdkr||_|jdkrt |||_|jdkr t |||_dS)aApply 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. Nr8NNNalias_generator  must return str, not ) alias_priorityaliasrrrr,generate_aliasesrrvrrr)rrrrrrr}r}r~$_apply_alias_generator_to_field_infos:           z3GenerateSchema._apply_alias_generator_to_field_inforcrcomputed_field_infocomputed_field_namecCs|jdks|jdks|jdkrd\}}}t|trD||\}}}n2t|trv||}t|tsvtd|d|j|jdks|jdkrd|_|jdkrt |||_dS)aApply 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. Nr8rrr) rrrr,rrrvrrr)rrrrrrr}r}r~-_apply_alias_generator_to_computed_field_infos"     zi }| ddj Dtj|}|jk rt|ts||} | j_| j D](\} } | jkr| jkrt| | q| jj_jj} } dddfdd }j|0jdk r$j| | |d }n | | }W5QRXt|j|}t|rZd _d d |Dfdd |D}t||}t |t|||}t |t|j!||}"st#|}$|t|j%|}j&j't(j)pj)dkpdt*j+d}dd| D}j,}t-t.||gd}j/j0}|dk rV1||t2j3||frtj34}nj3}t5|j6rd nd|j7j8|dS)Nr+) AliasChoices AliasPathrdcSsi|]\}}|j|qSr})rr$r}r}r~r(sz7GenerateSchema._common_field_schema..r rcs|j}|Sr)rrr)rrr}r~set_discriminator1sz>GenerateSchema._common_field_schema..set_discriminator)transform_inner_schemaTcSsg|]}|jjdkr|qS)T)rxZ each_itemrNr}r}r~rEs z7GenerateSchema._common_field_schema..csg|]}|kr|qSr}r}rN)rr}r~rFs)rr deprecatedexamplescSsi|]\}}|dk r||qSrr}r$r}r}r~r(]sZjs_annotation_functionsr)9rrrr|rdr\ annotationrrvrrrrGr?r=eval_type_lenientrZfrom_annotationZ_attributes_setZmetadata_lookupsetattrr rrrr~rr4r $_validators_require_validate_defaultvalidate_defaultrrr3r wrap_default_apply_field_serializersr+rrrwrr#rjson_schema_extrarAget_json_schema_update_funcrrrrrZconvert_to_aliases _common_fieldexcluderr)rrrrrrrdrZ evaluatedZnew_field_infor%r&rrrrZthis_field_validatorsZjson_schema_updatesrr rrr})rrrr~r<s            z#GenerateSchema._common_field_schema) union_typerzc Cs|j|dd}g}d}|D],}|dks0|tjkr6d}q|||qt|dkr^|d}nNg}|D]:}|ditj} | dk r||| fqf||qft |}|rt |}|S)zGenerate schema for a Union.TrFNr8rr ) r;r=rerrrOrr9ZTAGGED_UNION_TAG_KEYr" union_schemaZnullable_schema) rrrYchoicesrargrEZchoices_with_tagschoicetagr}r}r~rws&     zGenerateSchema._union_schemac Cs|j|\}}|dk r*|W5QRSt|p4|}|j}t|}|j|@t||j }t ||}| |}|ddkst ||d<W5QRX||jj |<t|W5QRSQRXdS)Nrrr)rr1r)Z __value__r[rrr=rrr^rr8rr"r)rrrrCr[rrrr}r}r~rgs    z&GenerateSchema._type_alias_type_schema) literal_typerzcCs&t|}|std|t|S)zGenerate schema for a Literal.z(literal "expected" cannot be empty, obj=)r=Zall_literal_valuesr8r"Zliteral_schema)rrexpectedr}r}r~ris zGenerateSchema._literal_schema)typed_dict_clsr[rzc sddlm}j|j|n\}}|dk rT|W5QRW5QRSt|}|dk rh|}tst|j dkrt dddzt |d}Wnt k rd}YnXj |j|j|}j|j} i} t|jjr t|d d } nd} t|jd d D]\} } t| |} | | k}t| tjkrfd }j| d d d } n&t| tjkrd}j| d d d } | | }| dk r|j!dkr| | kr| | |_!j"| ||d | | <q$t#t$t%|dg|d}t&j'| fddj()D|||d}*|j+)}t,|j-)d}|jj.|<t&/|W5QRW5QRW5QRW5QRSQRXW5QRXW5QRXW5QRXdS)aGenerate 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+rNrtzXPlease use `typing_extensions.TypedDict` instead of `typing.TypedDict` on Python < 3.12.ztyped-dict-versionr__pydantic_config__T)Z use_inspect)localnsinclude_extrasrrFr)rrcsg|]}|jqSr}r)r,r'r}r~r sz5GenerateSchema._typed_dict_schema..)r.rr r"all)0r|rdrrrr1r[_SUPPORTS_TYPEDDICTrrr4rSAttributeErrorrrrr6rZ__required_keys__rLbuildZuse_attribute_docstringsrWrYrr?r^r)r=ZRequiredr;Z NotRequiredrrrrArrr"Ztyped_dict_schemar.r rArBr=r7rr)rrr[rdZtyped_dict_refrCrr"r6Z required_keysr|Zfield_docstringsrrrrr Z td_schemarr}r'r~rjs              z!GenerateSchema._typed_dict_schema)namedtuple_clsr[rzc sjj\}}|dk rD|W5QRW5QRSt|dk rX|tdjd}|s|ddjD}rfdd|D}t j fdd|Dt dd d }t j ||d W5QRW5QRSQRXW5QRXdS) z!Generate schema for a NamedTuple.NT)rrcSsi|] }|tqSr})r)rr%r}r}r~r()sz5GenerateSchema._namedtuple_schema..csi|]\}}|t|qSr}r^rrrrr}r~r(,sc s,g|]$\}}j||j|tjdqS))default)_generate_parameter_schema_field_defaultsrr emptyr)rrr}r~r2s z5GenerateSchema._namedtuple_schema..)Zjs_prefer_positional_arguments)r )r) rrrr1r[rYr_fieldsr?r"arguments_schemarA call_schema)rrr[Znamedtuple_refrCrrr})rrrr~rls4   z!GenerateSchema._namedtuple_schemarzLLiteral[('positional_only', 'positional_or_keyword', 'keyword_only')] | Nonezcore_schema.ArgumentsParameter)rrrmoderzc Csddlm}|tjkr"||}n |||}|jdk s@td|j|j}}|j || ||} W5QRX| st || } t|| } |dk r|| d<|jdk r|j| d<nB|jj} t| tr| jdk r| || d<nt| tr| || d<| S)zXPrepare a ArgumentsParameter to represent a field in a namedtuple or function signature.r+rNzfsz/GenerateSchema._tuple_schema..r)rrr+z&Variable tuples can only have one typer8r}csg|]}|qSr})rrrr}r~r{sz0GenerateSchema._tuple_schema..N) r[r;rrpr"Z tuple_schemarEllipsisrOr ValueError)rrparamsr})rrr~rf_s      zGenerateSchema._tuple_schemacCstjttdddS)NZis_typezInput should be a typeZcustom_error_typeZcustom_error_message)r"custom_error_schemarrrr}r}r~rh}s zGenerateSchema._type_schemacs&j|dd}tfdd|DS)z*Generate schema for `Type[Union[X, ...]]`.Trcsg|]}tj|qSr}rrtr)rrYrr}r~rsz.)r;r"r)rrrYr}rr~_union_is_subclass_schemasz(GenerateSchema._union_is_subclass_schema)type_rzcs|}|tkrSt|tjr~|jrTtt |jrH |jSt |jS|j rtt fdd|j DSSn"tt |r |St |SdS)z-Generate schema for a Type, e.g. `Type[int]`.csg|]}tj|qSr}r)rcrr}r~rsz3GenerateSchema._subclass_schema..N)rZrrhrrtr __bound__r=rr)rr"Zis_subclass_schema__constraints__r)rrZ type_paramr}rr~rs       zGenerateSchema._subclass_schema) sequence_typerzc Csddlm}||}||}t|}tjtjdd}|t krdddl m }t |t ||g}tj||dd}tj|||dS) z5Generate schema for a Sequence, e.g. `Sequence[int]`.r8)serialize_sequence_via_listr)Zcls_repr)sequence_validatorT)rinfo_arg)r python_schemar)ryrrZrr"rrrtrr _validatorsrrQno_info_wrap_validator_function#wrap_serializer_function_ser_schemaZjson_or_python_schema) rrr item_typeZitem_type_schemarrrrr}r}r~rs(     zGenerateSchema._sequence_schemazcore_schema.GeneratorSchemacCs||}t||S)z$Generate a schema for an `Iterable`.)rZr"Zgenerator_schemar)rrrr}r}r~rs zGenerateSchema._iterable_schema) pattern_typerzcCsddlm}tddgd}tjtddtd}|tjksH|t jkrZtj |j ||d S|j |d d d }|t krtj |j||d S|tkrtj |j||d Std |ddS)Nr8)rcSs dddS)Nstringregex)rformatr})_1_2r}r}r~z0GenerateSchema._pattern_schema..rpatternr)r return_schema)rr Trrrr)rrrAr"rr rrtrorn no_info_plain_validator_functionZpattern_either_validatorr;rvZpattern_str_validatorrbZpattern_bytes_validatorr2)rrrr Zserrr}r}r~rps@ zGenerateSchema._pattern_schemacCstjttjjdddS)NZ is_hashablezInput should be hashabler)r"rrrqrrrsrr}r}r~rus  zGenerateSchema._hashable_schemaztype[StandardDataclass]ztype[StandardDataclass] | None) dataclassr[rzc sj|j|\}}|dk rH|W5QRW5QRSt|}|dk r\|}t0}|jD] }t|rl| j |qlt |jD],}t|rt |dd}| j |qj|} jddlm} | |rt|j} |r.| D]} | |jqnt|j|d} j jjdkrr| D]*\} } | jdkrFtd| d d d qF|jd pt |t!fd d| Dddd}t"|d}t"|d}t#j$|j%|fddj&D|d}t'|j(d}j)}t*||d}t#j+||||ddt,|D|| d}-|j.}t*||d}|jj/|<t#0|W5QRW5QRW5QRSQRXdst1dW5QRXW5QRXdS)z Generate schema for a dataclass.Nrr+)is_pydantic_dataclassrrFzField zd has `init=False` and dataclass has config setting `extra="allow"`. This combination is not allowed.z dataclass-init-false-extra-allowrr2c3s |]\}}||VqdSr)rr$r'r}r~rsz3GenerateSchema._dataclass_schema..cSs|ddk S)NrFr)rr}r}r~rrz2GenerateSchema._dataclass_schema..)key __post_init__ __slots__csg|]}|jqSr}r)r,r'r}r~r#sz4GenerateSchema._dataclass_schema..)r.Zcollect_init_onlyr cSsg|] }|jqSr})r)rryr}r}r~r4s)r!rr|slotsr"r0Z Unreachable)2rrrr1r[rr dataclassesr{ enter_contextrreversedrrrr6rrrZ__pydantic_fields__r Zapply_typevars_maprrXrextrar?rr4__dict__rrLrsortedhasattrr"Zdataclass_args_schemarr.rr@r7r=Zdataclass_schemar|rArBrrr8)rrr[Z dataclass_refrCrZdataclass_bases_stackZdataclass_baser"r6rr|ryrrY has_post_initZ has_slotsZ args_schemarr7Z dc_schemarr}r'r~r|s                       4z GenerateSchema._dataclass_schemazcore_schema.CallSchema)functionrzcCst|}t|}tjdtjdtjdi}g}d}d}|jD]\}} | j |j krXt } n||} | | j } | dk r||| | j| } || q>| j tjkr|| }q>| j tjkst| j || }q>d} |j}|jr| d}|dk r||} tjtj||||jd|| dS)zsGenerate schema for a Callable. TODO support functional validators once we support them in Config Zpositional_onlyZpositional_or_keyword keyword_onlyNrz)var_args_schemavar_kwargs_schemapopulate_by_name)r)r r=Zget_function_type_hintsr POSITIONAL_ONLYPOSITIONAL_OR_KEYWORD KEYWORD_ONLYrPr?rrrrkindrrrVAR_POSITIONALr VAR_KEYWORDr8rZvalidate_returnr"rrr )rrsigZ type_hintsZ mode_lookupZarguments_listr r rprZparameter_modeZ arg_schemarrZ return_hintr}r}r~rwAsP         zGenerateSchema._callable_schemaztyping.TypeVar)typevarrzcCst|tjst|j}|j}z |}Wn$tk rLt|dddk }YnX|dk t |dk|dkrrt d|r| |j S|r| tj|S|r| |}tjddtd|d<|StSdS) N __default__rr8zZPydantic does not support mixing more than one of TypeVar bounds, constraints and defaultscSs||Srr})xhr}r}r~rrz>GenerateSchema._unsubstituted_typevar_schema..rr)rrtrr8rrZ has_defaultrrrONotImplementedErrorrrrrr"rr)rrro constraintsZtypevar_has_defaultrr}r}r~rvvs.    z,GenerateSchema._unsubstituted_typevar_schemazDecorator[ComputedFieldInfo]z2dict[str, Decorator[FieldSerializerDecoratorInfo]]zcore_schema.ComputedField)r-r+rzc sztjjj|j}Wn.tk rH}zt||W5d}~XYnX|t kr^t dddt ||j }t jj|d_||}|j|t|jdd}|jj}|dk r|j|jjddd d d fd d }t|gd}tjj|jj|dS)NzComputed field is missing return type annotation or specifying `return_type` to the `@computed_field` decorator (e.g. `@computed_field(return_type=int|str)`)zmodel-field-missing-annotationr) return_typeTcomputed_fieldrrBr.r5)rrrzcs||}d|d<jj}|dk r(||d<jj}|dk r@||d<jjsTjjdkr\d|d<jj}|dk rxt||d<jj}|dk rt|||S)NTZreadOnlyrrrrr)rxrrrrr#radd_json_schema_extra)rrrrrrrr-r}r~set_computed_field_metadatas"  zJGenerateSchema._computed_field_schema..set_computed_field_metadatar)rrr )r:get_function_return_typefuncrxrrrTr3rUr!r4r^rrreplacerrrr rrrrrAr"rr) rr-r+rrWZreturn_type_schemarr r r}rr~r*s@   z%GenerateSchema._computed_field_schema)annotated_typerzcCsLddlm}|j|dd^}}|||}|D]}t||r.t||}q.|S)zdGenerate schema for an Annotated type, e.g. `Annotated[int, Field(...)]` or `Annotated[int, Gt(0)]`.r+rTr)r|rdr;r~rr)rr$rdrrrrr}r}r~r_s     z GenerateSchema._annotated_schemaztuple[Any, list[Any]] | None)rrrzcCs^ddlm}z t|Wntk r.YdSX|D]$}||||jj}|dk r4|Sq4dS)Nr8)PREPARE_METHODS)ryr%hashrrrz)rrrr%genrr}r}r~r}s   z?GenerateSchema._get_prepare_pydantic_annotations_for_known_typecCs|Srr})rr}r}r~rrzGenerateSchema.z list[Any]z"Callable[[CoreSchema], CoreSchema])rrrrzc stt|}|t|}|dk r.|\}}g}dddfdd }t|}|D]}|dkrdqV|||}qV||} |rt| j} | dg |t j j || S)aApply 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). Nrr rcs`||}|dkr |}n|}t||}|dk rXt|jj}|dk rX|||Sr)rrrrrrr)rrrrr rrr}r~ inner_handler s    z8GenerateSchema._apply_annotations..inner_handler pydantic_js_annotation_functions)rr<Zexpand_grouped_metadatar}rr__get_wrapped_inner_schemar@r rextendrrr) rrrrrr*r)get_inner_schemarrr r}r(r~r~s(   z!GenerateSchema._apply_annotations)rr rzc Cs`ddlm}t||rJ|jD]}|||}q|jdk rF|||j}|S|ddkr|dt }|||}|r~||d<|S|}|dd}|dk r| }|dt |}||j j kr|j j |S||d<nh|ddkr>|d }||j j kr>|j j | }|dt |}||j j kr6|j j |S||d<t|| } | dk r\| S|S) Nr+rrrrrrRdefinition-refr])r|rdrr _apply_single_annotationrrrr"rrreprrrr<Zapply_known_metadata) rrr rdfield_metadatar rrZnew_refZmaybe_updated_schemar}r}r~r/'sB            z'GenerateSchema._apply_single_annotationcCsddlm}t||r|jD]}|||}qi}|jrB|j|d<|jrR|j|d<|jrft|j|d<|j }|st|rt |j dg t |||S)Nr+rrrrr*)r|rdrr $_apply_single_annotation_json_schemarrrr#rr@rrr)rrr rdr1json_schema_updaterr}r}r~r2Qs"     z3GenerateSchema._apply_single_annotation_json_schemar-zlist[GetJsonSchemaFunction]r_)r-rr*rzcs:tddpdddddfdd }t|S) NrKcSs||Srr})rIrr}r}r~rorz:GenerateSchema._get_wrapped_inner_schema..rr)rIrzcsB|}|}|}t|}|dk r>||Sr)r/r2rr)rIrrrr-Zmetadata_get_schemar*rr}r~ new_handlerrs     z=GenerateSchema._get_wrapped_inner_schema..new_handler)rr_)rr-rr*r5r}r4r~r+hs   z(GenerateSchema._get_wrapped_inner_schemaz-list[Decorator[FieldSerializerDecoratorInfo]])r serializersrrzc Cs@|rr8rErA)rr4rrrLrr}r}r~r=s,   r=rd)rrrzcCs@|jrtj||j|jdS|jtk r8tj||j|jdS|SdS)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)rrN)rNr"Zwith_default_schemarrr!)rrr}r}r~rMs  rzGetJsonSchemaFunction | None)rrrzcCst|dd}t|drvddlm}|dk o@|jj|t|ddfk}|svt|dd}td|rfd |d nd d d dt|drt|tt t dfst |j |S|dkrdS|S)z`Extract `__get_pydantic_json_schema__` from a type, handling the deprecated `__modify_schema__`.__get_pydantic_json_schema__NZ__modify_schema__rre__func__rzjThe `__modify_schema__` method is not supported in Pydantic v2. Use `__get_pydantic_json_schema__` insteadz in class ``rrzcustom-json-schemar __origin__ placeholder) rrZpydanticrfrOrPr4rrr$rcrrR)rrZjs_modify_functionrfZhas_custom_v2_modify_js_funccls_namer}r}r~rcs&      rz3JsonDict | typing.Callable[[JsonDict], None] | Nonerj)r3rrzcsddddfdd }|S)NrBr.r5)core_schema_or_fieldrrzcs||}t||Sr)r)rUrrrr3r}r~json_schema_update_funcs  z.json_schema_update_funcr})r3rrWr}rVr~rsrrrcCs.t|tr|t|nt|r*||dSr)rrrGr#callablerXr}r}r~rs rc@s>eZdZUded<ded<ded<ded<ded <d ed <d S) rrr4str | list[str | int] | list[list[str | int]] | Nonerrr bool | Nonerrzdict[str, Any]r N)rrrrr}r}r}r~rs r)rrrrr rZr[)rrrrrr rzcCs||||||dS)Nrrrrrr r}r\r}r}r~rs rc@s2eZdZdZddddZedddd d Zd S) rz*Keeps track of references and definitions.rrcCst|_i|_dSr)rseenrrr}r}r~rsz_Definitions.__init__rz3Iterator[tuple[str, None] | tuple[str, CoreSchema]]rc cs\t|}||jks||jkr.|t|fVn*|j|z|dfVW5|j|XdS)aoGet 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)rFr]rr"radddiscard)rrrr}r}r~r1s z_Definitions.get_schema_or_refN)rrrrrrr1r}r}r}r~rsrzdict[str, CoreSchema]zCoreSchema | None)rrrzcCs8|ddkr||ddS|ddkr0|dS|SdS)Nrr.r]rrr)rrr}r}r~rs   rc@s@eZdZdZddddZedddd d Zd dd d ZdS)r_stackrrcCs g|_dSrr`rr}r}r~rsz_FieldNameStack.__init__rvIterator[None])rrzccs |j|dV|jdSrrarr)rrr}r}r~rs z_FieldNameStack.pushrcCs|jr|jdSdSdSrr`rr}r}r~rs z_FieldNameStack.getNrrrrrrrrr}r}r}r~rs rc@s@eZdZdZddddZedddd d Zd dd d ZdS)rr`rrcCs g|_dSrr`rr}r}r~rsz_ModelTypeStack.__init__rrb)type_objrzccs |j|dV|jdSrrc)rrer}r}r~rs z_ModelTypeStack.pushz type | NonecCs|jr|jdSdSdSrr`rr}r}r~r s z_ModelTypeStack.getNrdr}r}r}r~rs r)r __future__rZ _annotationscollections.abcrqrrrnsysrtr contextlibrrrrenumr functoolsrr r r itertoolsr operatorr typesrrrrrrrrrrrrrrrrrrZ pydantic_corer r!r"r#Ztyping_extensionsr$r%r&r'r(r)r*aliasesr,Zannotated_handlersr-r.r"r/r0r1errorsr2r3r4rr5versionr6r7rr9r:r;r<r=_configr>r?Z_core_metadatar@rArBrCrDrErFrGrHrIrJrKrLrMrNrOrPrQrRrSrTrUrVZ_docs_extractionrWrrXrYZ _forward_refrZZ _genericsr[r\r]r^Z_schema_generation_sharedr_r`ra_utilsrbr|rcrdrrfrgr4rhZ _dataclassesrirj version_inforrrcr^rurnZAnyFieldDecoratorZModifyCoreSchemaWrapHandlerZGetCoreSchemaFunctionrTuplerprrListrrMutableSequencerqrSet MutableSetrr frozenset FrozenSetrsrMutableMappingrtrrrrrZ JsonEncodersrrvrrrrrKrrr=rrrrrrrrrrr}r}r}r~s     @ $    , 8           %"" < /   '