,h UdZddlmZddlZddlZddlZddlZddlZddl Z ddl m Z m Z ddl mZmZmZddlmZddlmZddlmZdd lmZmZmZmZmZmZmZmZmZm Z ddl!Z!dd l!m"Z"m#Z#m$Z$m%Z%dd l&m'Z'dd l(m)Z)m*Z*m+Z+m,Z,dd l-m.Z.ddl/m0Z0m1Z1ddl2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9ddl:m;Z;ddlZ>ddl?m@Z@mAZAmBZBer ddlCmDZDddlEmFZFmGZGddlHmIZIddlJmKZKddlLmMZMee$je$jfZP eQeRefZS edZT dddZUdeVd<edZW Gdd eXZYeZZ[ d!Z\ ed"eRZ]ed#eRZ^ed$eRZ_e`e]eTfZaed%e&Zbejd?ie7jGd'd(ZeGd)d*Zfd+e\efd,f d@d-Zgd+dde\efd. dAd/ZheeiejeRekde`d0e`e`eRd1fd2ffZld3eVd1<dBd4ZmdCd5Znejd?ie7jGd6d7ZoGd8d9ZpdDd:Zqed;Zrereerd2fZsn)ejd?ie7jGd<d=ZsdEd>Zty)Fa!!! abstract "Usage Documentation" [JSON Schema](../concepts/json_schema.md) The `json_schema` module contains classes and functions to allow the way [JSON Schema](https://json-schema.org/) is generated to be customized. In general you shouldn't need to use this module directly; instead, you can use [`BaseModel.model_json_schema`][pydantic.BaseModel.model_json_schema] and [`TypeAdapter.json_schema`][pydantic.TypeAdapter.json_schema]. ) annotationsN)Counter defaultdict)HashableIterableSequence)deepcopy)Enum)Pattern) TYPE_CHECKING AnnotatedAnyCallableLiteralNewTypeTypeVarUnioncastoverload) CoreSchema PydanticOmit core_schemato_jsonable_python) ComputedField) TypeAlias assert_never deprecatedfinal)get_literal_values)PydanticDeprecatedSince26PydanticDeprecatedSince29)_config_core_metadata _core_utils _decorators_internal_dataclass _mock_val_ser_schema_generation_shared)GetJsonSchemaHandler)JsonDict JsonValue)PydanticInvalidForJsonSchemaPydanticSchemaGenerationErrorPydanticUserError) ConfigDict)CoreSchemaFieldCoreSchemaOrField)PydanticDataclass)GetJsonSchemaFunction BaseModel) validation serializationInputOutputzdict[JsonSchemaMode, str]_MODE_TITLE_MAPPING)skipped-choicenon-serializable-defaultskipped-discriminatorceZdZdZy)PydanticJsonSchemaWarningaThis class is used to emit warnings produced during JSON schema generation. See the [`GenerateJsonSchema.emit_warning`][pydantic.json_schema.GenerateJsonSchema.emit_warning] and [`GenerateJsonSchema.render_warning_message`][pydantic.json_schema.GenerateJsonSchema.render_warning_message] methods for more details; these can be overridden to control warning behavior. N)__name__ __module__ __qualname____doc__V/var/www/html/Resume-Scraper/venv/lib/python3.12/site-packages/pydantic/json_schema.pyr@r@esrFr@z#/$defs/{model}CoreRefDefsRefJsonRefJsonSchemaKeyT)boundc\eZdZUded<ded<e d dZd dZd dZd dZy )_DefinitionsRemappingzdict[DefsRef, DefsRef]defs_remappingzdict[JsonRef, JsonRef]json_remappingct|}d|i}tdD]}tt|D]%}||}|D]}|j ||'D]}t ||<i} i} |D]+} || }t fd|D} | | | <|| | || <-t| | } | jd|i}||k(r| cS|}td)z This function should produce a remapping that replaces complex DefsRef with the simpler ones from the prioritized_choices such that applying the name remapping would result in an equivalent JSON schema. $defsdc3FK|]}t|dk(s|yw)r"N)len).0xschemas_for_alternativess rG zA_DefinitionsRemapping.from_prioritized_choices..s%(jqCH`abHcDdhiDi(js!!z.Failed to simplify the JSON schema definitions) r rangerlistappend_deduplicate_schemasnextrNremap_json_schemar-)prioritized_choices defs_to_json definitionscopied_definitionsdefinitions_schema_iterdefs_ref alternatives alternativerOrPoriginal_defs_refremapped_defs_ref remappingnew_definitions_schemarXs @rGfrom_prioritized_choicesz._DefinitionsRemapping.from_prioritized_choicessN&k2%'9:3Z 8EMXY]M^ $. _28< #/_K,[9@@AST\A]^_ _5 n5IJbckJl5m(2 n68N57N%0 b!23DE $((jL(j$j!4E01BNO`Ba|,=>?  b .nnMI%.%@%@'K]A^%_ "!%;;  !7 7 8:++[\\rFc:|jj||SN)rOgetselfrefs rGremap_defs_refz$_DefinitionsRemapping.remap_defs_ref""&&sC00rFc:|jj||Sro)rPrprqs rGremap_json_refz$_DefinitionsRemapping.remap_json_refrurFc Zt|tr|jt|St|tr|Dcgc]}|j |c}St|t r|jD]\}}|dk(r.t|tr|jt||d<9|dk(rR|djDcic]/\}}|jt||j |1c}}|d<|j |||<|Scc}wcc}}w)zH Recursively update the JSON schema replacing all $refs $refrR) isinstancestrrwrJr[r_dictitemsrtrI)rrschemaitemkeyvalues rGr_z'_DefinitionsRemapping.remap_json_schemas fc "&&wv7 7  %=CDTD**40D D  %$lln @ U&=Zs%;%)%8%8%HF6NG^+1/*?*?*A'&C++GCL94;Q;QRW;XX'F7O #'"8"8"?F3K @ E 's D"4D'N)r`zdict[DefsRef, list[DefsRef]]razdict[DefsRef, JsonRef]rbzdict[DefsRef, JsonSchemaValue]returnrN)rsrIrrI)rsrJrrJ)r~rrr) rArBrC__annotations__ staticmethodrmrtrwr_rErFrGrNrNsZ****,]9,],,]4,]  ,],]\11rFrNceZdZUdZdZdhZded<defdmdZe dndZ e dod Z dpd Z dqd Z drdsd Zdtd ZdudvdZdudwdZdxdZdydZdzdZd{dZd|dZd}dZd~dZddZddZddZddZddZddZddZddZ dd Z!dd!Z"dd"Z#dd#Z$e%d$d%e&dd&Z'e%d'd%e&dd(Z(dd)Z)dd*Z*dd+Z+dd,Z,dd-Z-dd.Z.dd/Z/dd0Z0dd1Z1dd2Z2dd3Z3dd4Z4dd5Z5dd6Z6dd7Z7 dd8Z8dd9Z9dd:Z:dd;Z;dd<Z dd>Z?dd?Z@dd@ZAddAZBddBZCddCZDddDZEddEZFddFZGddGZHddHZI ddIZJddJZKddKZLddLZM ddMZN ddNZOddOZPddPZQddQZRddRZSddSZTddTZUddUZVddVZWddWZXddXZY ddYZZddZZ[dd[Z\dd\Z]dd]Z^dd^Z_dd_Z`dd`ZaddaZbddbZc ddcZdGdddeZeddfZfddgZgddhZhddiZiddjZjddkZkddlZly)GenerateJsonSchemaa]!!! abstract "Usage Documentation" [Customizing the JSON Schema Generation Process](../concepts/json_schema.md#customizing-the-json-schema-generation-process) A class for generating JSON schemas. This class generates JSON schemas based on configured parameters. The default schema dialect is [https://json-schema.org/draft/2020-12/schema](https://json-schema.org/draft/2020-12/schema). The class uses `by_alias` to configure how fields with multiple names are handled and `ref_template` to format reference names. Attributes: schema_dialect: The JSON schema dialect used to generate the schema. See [Declaring a Dialect](https://json-schema.org/understanding-json-schema/reference/schema.html#id4) in the JSON Schema documentation for more information about dialects. ignored_warning_kinds: Warnings to ignore when generating the schema. `self.render_warning_message` will do nothing if its argument `kind` is in `ignored_warning_kinds`; this value can be modified on subclasses to easily control which warnings are emitted. by_alias: Whether to use field aliases when generating the schema. ref_template: The format string used when generating reference names. core_to_json_refs: A mapping of core refs to JSON refs. core_to_defs_refs: A mapping of core refs to definition refs. defs_to_core_refs: A mapping of definition refs to core refs. json_to_defs_refs: A mapping of JSON refs to definition refs. definitions: Definitions in the schema. Args: by_alias: Whether to use field aliases in the generated schemas. ref_template: The format string to use when generating reference names. Raises: JsonSchemaError: If the instance of the class is inadvertently reused after generating a schema. z,https://json-schema.org/draft/2020-12/schemar<zset[JsonSchemaWarningKind]ignored_warning_kindsTcX||_||_i|_i|_i|_i|_i|_tjtji|_ d|_ i|_ tt|_i|_|j#|_i|_d|_y)Nr7F)by_alias ref_templatecore_to_json_refscore_to_defs_refsdefs_to_core_refsjson_to_defs_refsrbr#ConfigWrapperStack ConfigWrapper_config_wrapper_stack_mode_prioritized_defsref_choicesrint_collision_counter_collision_indexbuild_schema_type_to_method_schema_type_to_method"_core_defs_invalid_for_json_schema_used)rrrrs rG__init__zGenerateJsonSchema.__init__s  (=?=?=?9;;=%,%?%?@U@UVX@Y%Z"%1 KM)2=c2B02&*&F&F&H#`b/ rFc.|jjSro)rtailrrs rGr#zGenerateJsonSchema._config$s))...rFcr|jj|jjS|jSro)r#json_schema_mode_overriderrs rGmodezGenerateJsonSchema.mode(s, << 1 1 =<<99 9:: rFc :i}ttt}|D]'}|jddd} t ||||<)|S#t $rH}t jdrYd}~Otd|dt|jd|d |d}~wwxYw) aOBuilds a dictionary mapping fields to methods for generating JSON schemas. Returns: A dictionary containing the mapping of `CoreSchemaOrFieldType` to a handler method. Raises: TypeError: If no method has been defined for generating a JSON schema for a given pydantic core schema type. -__schema-PYDANTIC_PRIVATE_ALLOW_UNHANDLED_SCHEMA_TYPESNz9No method for generating JsonSchema for core_schema.type=z (expected: .)) r[rCoreSchemaOrFieldTypereplacegetattrAttributeErrorosgetenv TypeErrortyperA)rrmappingcore_schema_typesr method_namees rGrz.GenerateJsonSchema.build_schema_type_to_method/s`b9=>PQf>g9h$ C [[c237;K &t[9  " 99LMOPSwW""&t*"5"5!6a }AG sA  BB,)BBc|jr$tdt|jdd|D]\}}}||_|j | |j }i}|D]4\}}}||_|j |}|j||||f<6d|ji}|j|}d|_||j|dfS)aGenerates JSON schema definitions from a list of core schemas, pairing the generated definitions with a mapping that links the input keys to the definition references. Args: inputs: A sequence of tuples, where: - The first element is a JSON schema key type. - The second element is the JSON mode: either 'validation' or 'serialization'. - The third element is a core schema. Returns: A tuple where: - The first element is a dictionary whose keys are tuples of JSON schema key type and JSON mode, and whose values are the JSON schema corresponding to that pair of inputs. (These schemas may have JsonRef references to definitions that are defined in the second returned element.) - The second element is a dictionary whose keys are definition references for the JSON schemas from the first returned element, and whose values are the actual JSON schema definitions. Raises: PydanticUserError: Raised if the JSON schema generator has already been used to generate a JSON schema. nThis JSON schema generator has already been used to generate a JSON schema. You must create a new instance of  to generate a new JSON schema.json-schema-already-usedcoderRT) rr/rrArgenerate_inner_build_definitions_remappingr_rbsort) rrinputsrrr~definitions_remappingjson_schemas_mapr json_schemas rGgenerate_definitionsz'GenerateJsonSchema.generate_definitionsIs2 ::#559$Z5H5H4IIhj/  & (OAtVDJ    ' (!% A A CQS!' a CvDJ--f5K,A,S,ST_,` c4[ ) a  0 01 +==kJ  ;w+?!@@@rFc||_|jr$tdt|jdd|j |}|j |}tt|jd}|j|j|}||dk(rL|Jt|dk(r<|j}||xxdzcc<tt|jd}d}|j|j||j}|jr|j|d<|j!|}d |_|j#|S) aGenerates a JSON schema for a specified schema in a specified mode. Args: schema: A Pydantic model. mode: The mode in which to generate the schema. Defaults to 'validation'. Returns: A JSON schema representing the specified schema. Raises: PydanticUserError: If the JSON schema generator has already been used to generate a JSON schema. rrrrryNr"rRT)rrr/rrArget_json_ref_countsrrJrpget_schema_from_definitionsrUcopy_garbage_collect_definitionsrrbr_r)rrr~rrjson_ref_countsrsref_json_schemars rGgeneratezGenerateJsonSchema.generatezsK ::#559$Z5H5H4IIhj/  (,':':6'B 22;?7KOOF34o">>sCOs#q(_-HSQ\M]abMb-224 $)$7KOOF$;<Co ))+6 $ A A C   #'#3#3K +==kJ  yy%%rFcn d|vrVt|d}|jf}|jvr,j|jvrdj|iSdfd dfd }t j |}ttj|jdi}|jdx r#|f d fd }t j |}|jdx r#|f d fd }t j |}|jd d D](} || f dfd } t j | }*|jd d D]&} || f dd} t j | }(||} tj|r || } | S)aGenerates a JSON schema for a given core schema. Args: schema: The given core schema. Returns: The generated JSON schema. TODO: the nested function definitions here seem like bad practice, I'd like to unpack these in a future PR. It'd be great if we could shorten the call stack a bit for JSON schema generation, and I think there's potential for that here. rsrycd|vrrt|d}j|\}}t|d}|jdd|k7r+|j|<j j |d|}|S)Nrsry)rHget_cache_defs_ref_schemarJrprbrpop)rrcore_refrfrjson_refrrs rG populate_defsz8GenerateJsonSchema.generate_inner..populate_defss #";u#56,0,J,J8,T)/"?6#:;??640H<1.handler_funcs37KyyO+?0R-_= "ooj9  +"{37ZZ'/:="&":":VV+BbBbcrBs/3/J/J?[aKb/c,":?"KK $&EoEV$WXX rFmetadatapydantic_js_updatesc i||}|SrorE)rcurrent_handlerr js_updatess rGjs_updates_handler_funczBGenerateJsonSchema.generate_inner..js_updates_handler_funcs Q!APZP ""rFpydantic_js_extrac||}ttr|jt|St r||Sro)rzr|updatercallable)rrrjs_extras rGjs_extra_handler_funcz@GenerateJsonSchema.generate_inner..js_extra_handler_funcsM.o> h-&&'9('CD#"h'[)""rFpydantic_js_functionsrEc|||}tj|r ||}|j|}|jdd}|r|r|j ||S)Nry)r%rresolve_ref_schemarr)rrjs_modify_functionroriginal_schemarsrs rGnew_handler_funcz;GenerateJsonSchema.generate_inner..new_handler_funcsd 1/R --o>"/"MK"1"D"D["Q!oofd3;#**;7&&rF pydantic_js_annotation_functionsc|||SrorE)rrrs rGrz;GenerateJsonSchema.generate_inner..new_handler_func*s */?KKrF)rrrJsonSchemaValuerr)rr2rr)rr2rr*rr)rr2rr*rr4rr) rHrrrbrr)GenerateJsonSchemaHandlerrr$ CoreMetadatarpr%r)rrr~r core_mode_refrrrrrrrrrrrs` @@@rGrz!GenerateJsonSchema.generate_innersE F?ve}-H%tyy1M 6 664;Q;QR_;`dhdtdt;t 6 6} EFF $ L4MMdT`a33VZZ B5OP"&;< <: <9H #!2 #!5 #! #8QQRVXopO||$78 88 89H #!2 #!5 #! #8QQRVXmnO"*,,/F"K j 9H? 99 $ **]3KD!BD!BD!BD!B%%#00*0**_*E0;0C{I[')ztuRy')ztuRy')ztuRy')ztuRy    KrFcddi}|j|||jjt|j dt r|j dj |d<|S)zGenerates a JSON schema that matches a string value. Args: schema: The core schema. Returns: The generated JSON schema. rstringpattern)rrr*rzrpr r+rrr~rs rGr&zGenerateJsonSchema.str_schemas^x(  $$[&$:Q:Q:X:XY kooi0' :%0__Y%?%G%GK "rFcd|jjdk(rdndd}|j|||jj|S)zGenerates a JSON schema that matches a bytes value. Args: schema: The core schema. Returns: The generated JSON schema. r*base64 base64urlbinaryrformat)r#ser_json_bytesrrbytesr,s rG bytes_schemazGenerateJsonSchema.bytes_schemasG ($,,B]B]aiBi;owx  $$[&$:Q:Q:W:WXrFc dddS)zGenerates a JSON schema that matches a date value. Args: schema: The core schema. Returns: The generated JSON schema. r*dater1rErs rG date_schemazGenerateJsonSchema.date_schema!F33rFc dddS)zGenerates a JSON schema that matches a time value. Args: schema: The core schema. Returns: The generated JSON schema. r*timer1rErs rG time_schemazGenerateJsonSchema.time_schemar9rFc dddS)zGenerates a JSON schema that matches a datetime value. Args: schema: The core schema. Returns: The generated JSON schema. r*z date-timer1rErs rGdatetime_schemaz"GenerateJsonSchema.datetime_schemas!K88rFcF|jjdk(rddiSdddS)zGenerates a JSON schema that matches a timedelta value. Args: schema: The core schema. Returns: The generated JSON schema. r'rrr*durationr1)r#ser_json_timedeltars rGtimedelta_schemaz#GenerateJsonSchema.timedelta_schemas, << * *g 5H% % J77rFc |dDcgc])}tt|tr |jn|+}}i}t |dk(r |d|d<n||d<|Dchc] }t |}}|t hk(rd|d<|S|thk(rd|d<|S|thk(rd |d<|S|thk(rd |d<|S|thk(rd |d<|S|t d hk(rd |d<|Scc}wcc}w)zGenerates a JSON schema that matches a literal value. Args: schema: The core schema. Returns: The generated JSON schema. expectedr"rconstenumr*rrrr arrayNr) rrzr rrUrr{rr'boolr[)rrr~rrDresultrtypess rGliteral_schemaz!GenerateJsonSchema.literal_schemas"X^^hWijRS&*Q2Eqww1Mjj!# x=A &qkF7O%F6N"*+Qa++ SE>%F6N se^&F6N ug %F6N tf_&F6N  tf_$F6N tDzl "#F6N +k,s .CCc|d}|jsdntj|j}|dk(rd}|j|d}|j Dcic] \}}| || }}}|dDcgc]}t |j }}||d<|Dchc] }t|} }t|ts | thk(rd|d<|St|ts | thk(rd |d<|St|ts | thk(rd |d<|S| thk(rd |d<|S| thk(rd |d<|Scc}}wcc}wcc}w) zGenerates a JSON schema that matches an Enum value. Args: schema: The core schema. Returns: The generated JSON schema. clsNzAn enumeration.)title descriptionmembersrFr*rrrr rG)rDinspectcleandocrAr}rrrrzr{rr'rHr[) rrr~ enum_typerOrIrrrDrrJs rG enum_schemazGenerateJsonSchema.enum_schema(s_5M "+"3"3d9I9I)J[J[9\ , ,K+4+=+=k!Z#)<<>C41aQ]!Q$CC9? 9JKA&qww/KK!v"*+Qa++ i %3%%F6N  3 '5SE>&F6N  5 )Uug-=%F6N  tf_&F6N tf_$F6N %DK,s D6'D66D<Ec4|j|d|ddS)aHandles JSON schema generation for a core schema that checks if a value is an instance of a class. Unless overridden in a subclass, this raises an error. Args: schema: The core schema. Returns: The generated JSON schema. zcore_schema.IsInstanceSchema (rMrhandle_invalid_for_json_schemars rGis_instance_schemaz%GenerateJsonSchema.is_instance_schemaLs*226=[\bch\i[jjk;lmmrFciS)aIHandles JSON schema generation for a core schema that checks if a value is a subclass of a class. For backwards compatibility with v1, this does not raise an error, but can be overridden to change this. Args: schema: The core schema. Returns: The generated JSON schema. rErs rGis_subclass_schemaz%GenerateJsonSchema.is_subclass_schemaYs  rFc&|j|dS)zGenerates a JSON schema that matches a callable value. Unless overridden in a subclass, this raises an error. Args: schema: The core schema. Returns: The generated JSON schema. core_schema.CallableSchemarVrs rGcallable_schemaz"GenerateJsonSchema.callable_schemags226;WXXrFcd|vrin|j|d}d|d}|j|||jj|S)zReturns a schema that matches a list schema. Args: schema: The core schema. Returns: The generated JSON schema. items_schemarGrr}rrrrGrrr~r_rs rG list_schemazGenerateJsonSchema.list_schematR,69rt?R?RSYZhSi?j &>  $$[&$:Q:Q:W:WXrFD`tuple_positional_schema` is deprecated. Use `tuple_schema` instead.)categoryc\tjdtd|j|S)Replaced by `tuple_schema`.re stacklevelwarningswarnr tuple_schemars rGtuple_positional_schemaz*GenerateJsonSchema.tuple_positional_schemas,  R %   ((rFB`tuple_variable_schema` is deprecated. Use `tuple_schema` instead.c\tjdtd|j|S)rhrqrirjrlrs rGtuple_variable_schemaz(GenerateJsonSchema.tuple_variable_schemas,  P %   ((rFcddi}d|vrl|d}|dkDr-||d<|dd|Dcgc]}|j|c}|d<|d zt|dk(r|j|d||d <nJd |d <nD|dDcgc]}|j|}}|r||d<t||d<t||d <|j|||jj|Scc}wcc}w) zGenerates a JSON schema that matches a tuple schema e.g. `tuple[int, str, bool]` or `tuple[int, ...]`. Args: schema: The core schema. Returns: The generated JSON schema. rrGvariadic_item_indexrminItemsr_N prefixItemsr"r}TmaxItems)rrUrrrG)rrr~rrurrws rGrozGenerateJsonSchema.tuple_schemas))/'8 F *"()>"? "Q&*= J':@:PQeRe:f.26D''-. M*#Q&#f^.D*EE'+':':6.;QRe;f'g G$ (, G$AGAWX4..t4XKX-8 M*&)+&6K #&)+&6K # $$[&$:Q:Q:W:WX%.Ys C"<C'c$|j|S)zGenerates a JSON schema that matches a set schema. Args: schema: The core schema. Returns: The generated JSON schema. _common_set_schemars rG set_schemazGenerateJsonSchema.set_schema&&v..rFc$|j|S)zGenerates a JSON schema that matches a frozenset schema. Args: schema: The core schema. Returns: The generated JSON schema. rzrs rGfrozenset_schemaz#GenerateJsonSchema.frozenset_schemar}rFcd|vrin|j|d}dd|d}|j|||jj|S)Nr_rGT)r uniqueItemsr}rarbs rGr{z%GenerateJsonSchema._common_set_schemasR+69rt?R?RSYZhSi?j &tlS  $$[&$:Q:Q:W:WXrFcd|vrin|j|d}d|d}|j|||jj|S)zReturns a JSON schema that represents the provided GeneratorSchema. Args: schema: The schema. Returns: The generated JSON schema. r_rGr`rarbs rGgenerator_schemaz#GenerateJsonSchema.generator_schemardrFc"ddi}d|vr"|j|djni}d|vr%|jdd}|jddnd}d|vr"|j|djni}|jdd|s||||d <n ||i|d <nd |d <|jdd k(rt |d kDsd|vr|jdd||d<|j |||j j|S)zGenerates a JSON schema that matches a dict schema. Args: schema: The core schema. Returns: The generated JSON schema. robject keys_schemaryr+NrN values_schemaadditionalPropertiespatternPropertiesTr*r" propertyNames)rrrrprUrrr)rrr~rr keys_patternrs rG dict_schemazGenerateJsonSchema.dict_schemas4)/'9 KX\bKbd))&*?@EEGhj  $&??9d;L OOGT * LO^bhOh++F?,CDIIKnp '4( L4#6C 234@-3P /026K. /__V $ 0S5E5I$ OOFD )+6K ( $$[&$:Q:Q:X:XYrFc|jdk(r$|jdx}r|j|S|j|dS)zGenerates a JSON schema that matches a function-before schema. Args: schema: The core schema. Returns: The generated JSON schema. r7json_schema_input_schemar~rrprrrr~ input_schemas rGfunction_before_schemaz)GenerateJsonSchema.function_before_schemaK 99 $&**E_:`*`,*`&&|4 4""6(#344rFc*|j|dS)zGenerates a JSON schema that matches a function-after schema. Args: schema: The core schema. Returns: The generated JSON schema. r~rrs rGfunction_after_schemaz(GenerateJsonSchema.function_after_schema#""6(#344rFc|jdk(r$|jdx}r|j|S|j|d|ddS)zGenerates a JSON schema that matches a function-plain schema. Args: schema: The core schema. Returns: The generated JSON schema. r7rz*core_schema.PlainValidatorFunctionSchema (functionr)rrprrWrs rGfunction_plain_schemaz(GenerateJsonSchema.function_plain_schema.s^ 99 $&**E_:`*`,*`&&|4 422 @ AS@TTUV  rFc|jdk(r$|jdx}r|j|S|j|dS)zGenerates a JSON schema that matches a function-wrap schema. Args: schema: The core schema. Returns: The generated JSON schema. r7rr~rrs rGfunction_wrap_schemaz'GenerateJsonSchema.function_wrap_schema>rrFc8|j|d}|j|}|tur|S|jdk(rl|dj dx}rV|j dx}rC|j ddk(r/|j ds||j ddvs ||} |j|}||d<|S#t $r|j d d |d |cYSwxYw#tj$r|j d d |d |cYSwxYw)zGenerates a JSON schema that matches a schema with a default value. Args: schema: The core schema. Returns: The generated JSON schema. r~r8rrfunction-plaininfo_argrrr=zUnable to serialize value z> with the plain serializer; excluding default from JSON schemazDefault value z= is not JSON serializable; excluding default from JSON schemar) rget_default_value NoDefaultrrp Exception emit_warningencode_default pydantic_corePydanticSerializationError)rrr~rrrser_funcencoded_defaults rGdefault_schemaz!GenerateJsonSchema.default_schemaLsS))&*:; ((0 i   II (%h/33ODDD'^^J777v&*::NN:._ )DHk)k #"7+ "11':O"1 I1 #!!.0 ;yz#" #77    *  )fg     s$#C,C+!C('C(++DDc.|jdtS)aGet the default value to be used when generating a JSON Schema for a core schema with a default. The default implementation is to use the statically defined default value. This method can be overridden if you want to make use of the default factory. Args: schema: The `'with-default'` core schema. Returns: The default value to use, or [`NoDefault`][pydantic.json_schema.NoDefault] if no default value is available. r)rprrs rGrz$GenerateJsonSchema.get_default_valueszz)Y//rFcfddi}|j|d}||k(r|S|j||gS)zGenerates a JSON schema that matches a schema that allows null values. Args: schema: The core schema. Returns: The generated JSON schema. rrr~)rr)rrr~ null_schemainner_json_schemas rGnullable_schemaz"GenerateJsonSchema.nullable_schemasKv&  //x0@A  + ++-> ,LM MrFcNg}|d}|D]:}t|tr|dn|} |j|j|<t|dk(r|dS|j|S#t$rYlt $r&}|j d|jYd}~d}~wwxYw)zGenerates a JSON schema that matches a schema that allows values matching any of the given schemas. Args: schema: The core schema. Returns: The generated JSON schema. choicesrr<Nr") rztupler\rrr-rmessagerUr)rrr~ generatedrchoice choice_schemaexcs rG union_schemazGenerateJsonSchema.union_schemas,. # AF)3FE)BF1IM A  !4!4]!CD  A y>Q Q< '' 22   / A!!"2CKK@@ As A++ B$6B$>BB$c *i}|djD]M\}}t|tr |j} |j |j |t |<Ot|j}d|i}|j||}|:||jDcic]\}}||jd|c}}d|d<|S#t$rYt$r&}|jd|jYd}~d}~wwxYwcc}}w)acGenerates a JSON schema that matches a schema that allows values matching any of the given schemas, where the schemas are tagged with a discriminator field that indicates which schema should be used to validate the value. Args: schema: The core schema. Returns: The generated JSON schema. rr<NoneOfry) propertyNamer discriminator)r}rzr rrrr{rr-rrr]values_extract_discriminatorrp) rrr~rrrrone_of_choicesropenapi_discriminators rGtagged_union_schemaz&GenerateJsonSchema.tagged_union_schemas13 9%++- ADAq!T"GG A%)$7$7$:$?$?$A #a&! A.i.>.>.@A(/'@ !% ; ;FN S , 5} |j |}|jdi} t| tr|| vsrF) rzr{r[rUrrrrpr|) rrr~rr alias_pathaliasalias_is_present_on_all_choicesrrrs rGrz)GenerateJsonSchema._extract_discriminators\ -1 f_-s 3/* * f_-t 46/*+q0Z@WXY@Z\_5`o.q11 %_5  !*d3.%$-z?a'"1 !%-26/, F$!%!8!8!@"(L"!=J%j$75 ;R:?7 3,1)$$3 2%$($))*A3s8L!# $s%C-- D6DDcV|jdk(rdnd}|j|d|S)aGenerates a JSON schema that matches a core_schema.ChainSchema. When generating a schema for validation, we return the validation JSON schema for the first step in the chain. For serialization, we return the serialization JSON schema for the last step in the chain. Args: schema: The core schema. Returns: The generated JSON schema. r7rsteps)rr)rrr~ step_indexs rG chain_schemazGenerateJsonSchema.chain_schemas0))|3Q ""6'?:#>??rFcz|jdd}|r|j|dS|j|dS)zGenerates a JSON schema that matches a schema that allows values matching either the lax schema or the strict schema. Args: schema: The core schema. Returns: The generated JSON schema. strictF strict_schema lax_schema)rpr)rrr~ use_stricts rGlax_or_strict_schemaz'GenerateJsonSchema.lax_or_strict_schemasEZZ%0  &&vo'>? ?&&vl';< $C$C$E!//D4R4RSX4Y006-2!'* $ 9 9:K L 0Jt &&t, - (zB &5K #   sB11 B=<B=c|ddk(r|jd|}n4|jdk(r|jd|}n|jd|}t|tr|}|St|trPt d|}|D]=}t|tst |dk(s#t|d ts7|d }|S|St||S) Nrcomputed-fieldrr7validation_aliasserialization_aliaszlist[str] | strr"r)rprrzr{r[rrUr)rrrrrpaths rGrz"GenerateJsonSchema._get_alias_names =, ,7D1E YY, &II0$7EII3T:E eS !D t $*E2E dD)c$i1nDQRGUXAY 7D      rFc*|j|dS)zGenerates a JSON schema that matches a schema that defines a typed dict field. Args: schema: The core schema. Returns: The generated JSON schema. r~rrs rGtyped_dict_field_schemaz*GenerateJsonSchema.typed_dict_field_schemarrFc*|j|dS)zGenerates a JSON schema that matches a schema that defines a dataclass field. Args: schema: The core schema. Returns: The generated JSON schema. r~rrs rGdataclass_field_schemaz)GenerateJsonSchema.dataclass_field_schemarrFc*|j|dS)zGenerates a JSON schema that matches a schema that defines a model field. Args: schema: The core schema. Returns: The generated JSON schema. r~rrs rGmodel_field_schemaz%GenerateJsonSchema.model_field_schemarrFc*|j|dS)zGenerates a JSON schema that matches a schema that defines a computed field. Args: schema: The core schema. Returns: The generated JSON schema. return_schemarrs rGcomputed_field_schemaz(GenerateJsonSchema.computed_field_schemas""6/#:;;rFctd|d}|j}|jj|5|j |d}ddd|j |||S#1swYxYw)zGenerates a JSON schema that matches a schema that defines a model. Args: schema: The core schema. Returns: The generated JSON schema. ztype[BaseModel]rMr~N)r model_configrrrr)rrr~rMrrs rG model_schemazGenerateJsonSchema.model_schemas|$fUm4!!  ' ' , ,V 4 @--fX.>?K @ !!+sF;  @ @s A))A2cddlm}ddlm}|j dx}|j d|nX|j dx}rE||}t |tstd|d|j|j d|d|vr|j|d<||ustj|rdn |j} | r&|j d tj| n9t!||r-|j"d j$x} r|j d | |j d } d |vr| d k(rd|d <n | dk(rd|d <|j d} t!||r8|j&r,|j(d j*} | r | r t-d| r| } t | t.t0fr| j3|} t | t4r|j7| nZt9| r>t;tj<| j>dkDr | ||n| |n| t-d| dtA|drd|d<yy)aUpdate json_schema with the following, extracted from `config` and `cls`: * title * description * additional properties * json_schema_extra * deprecated Done in place, hence there's no return value as the original json_schema is mutated. No ref resolving is involved here, as that's not appropriate for simple updates. r"r5) RootModelrNNmodel_title_generatorzmodel_title_generator z must return str, not rOrootrrrTrFjson_schema_extrazz"model_config['json_schema_extra']" and "Field.json_schema_extra" on "RootModel.root" field must not be set simultaneouslyz"model_config['json_schema_extra']=z$ should be a dict, callable, or None__deprecated__r)!mainr6 root_modelrrp setdefaultrzr{r __class__rA dataclasses is_dataclassrDrQrR issubclass__pydantic_fields__rO__pydantic_root_model__ model_fieldsr ValueErrorr classmethod__get__r|rrrU signature parametershasattr)rrrrMrr6r config_titlerrN docstringroot_descriptionrrroot_json_schema_extras rGrz'GenerateJsonSchema._update_class_schemasg $)"JJw/ /L <  " "7L 9&,jj1H&I I " I)#.EeS)"89N8OOefkfufuev wxx  " "7E 2 + %#&<  ' .   0 1 ' (7$$%67BBCaG!+s3!+.  *45F4GGkl  3( )(,K % *rFczd|vr6|d}|jt|}|td||}d|vr6|S)a$Resolve a JsonSchemaValue to the non-ref schema if it is a $ref schema. Args: json_schema: The schema to resolve. Returns: The resolved schema. Raises: RuntimeError: If the schema reference can't be found in definitions. ryz(Cannot update undefined schema for $ref=)rrJr)rrrrsschema_to_updates rGrz%GenerateJsonSchema.resolve_ref_schemas[ #f%C#?? M '"%McU#STT*K  # rFc |djDcgc],\}}|j|r||j|d|f.}}}|jdk(r0|j |j |j dg|j|}|j dd}|%|j|}|j||d<|Scc}}w) zGenerates a JSON schema that matches a schema that defines a model's fields. Args: schema: The core schema. Returns: The generated JSON schema. rTrr8r extras_schemaNr) r}rrrrrrprrr)rrr~rrrrr rs rGmodel_fields_schemaz&GenerateJsonSchema.model_fields_schema1s &h/557J e$$U+4))%t)?DDFK G !!+sF;  $K"%++"5$7;K;KCKK;XK )4K & G Gs #B==Cc^|jdijd}|d}|Dcgc]}|jddk(s|}}|Dcgc]}|jddvs|}}|Dcgc]}|jddk(s|}}|jd}|jd } |r| xr| } | r|j||z|S| xr| } | r|j||z| S|s| xr| } | r|j||z|Std cc}wcc}wcc}w) Generates a JSON schema that matches a schema that defines a function's arguments. Args: schema: The core schema. Returns: The generated JSON schema. r'pydantic_js_prefer_positional_argumentsarguments_schemar keyword_only>Npositional_or_keywordpositional_onlyvar_args_schemavar_kwargs_schemazfUnable to generate JSON schema for arguments validator with positional-only and keyword-only arguments)rpp_arguments_schemakw_arguments_schemar-) rrr~prefer_positional argumentsakw_only_argumentskw_or_p_argumentsp_only_argumentsr4r5positional_possiblekeyword_possibles rGr0z#GenerateJsonSchema.arguments_schemasg#JJz26::;de-. (1U1QUU6]n5TQUU(1f1QUU6]Fe5eQff'0W!AEE&MEV4VAWW **%67"JJ':; &7"7"Q@Q+>?P+Q (+6R 2338K. /rFcfg}d}|D]k}|j|}|j|dj}|j||d<|j ||dddk7sg|dz }mddi}|r||d<|r||d <|r|j|} | r| |d <|St ||d <|S) zGenerates a JSON schema that matches a schema that defines a function's positional arguments. Args: arguments: The core schema. Returns: The generated JSON schema. rr~rNrrr"rGrwrvr}rx)rArrrr\rU) rrr9r4 prefix_items min_itemsrBrrCrr_s rGr6z%GenerateJsonSchema.p_arguments_schemas/1  ! H))(3D"11(82DEJJLO'+'?'?'EOG $    0!&)Y6Q  )/'8 )5K & &/K # ..?L'3 G$'*,&7K #rFct|d}|jr&|jd}t|tr|}|S |S)zRetrieves the name of an argument. Args: argument: The core schema. Returns: The name of the argument. rr)rrprzr{)rrrBrrs rGrAz$GenerateJsonSchema.get_argument_namesC ==LL)E%%  rFc|d}i}g}|D]}|jdd}|j|}|j|dj}|dk(rd|d}n |dk(rd |d }|j d |j ||||<|d k(rd |vs|dvs|dddk7s|j |d |d} |r|| d <| S)r.r0rr2r~var_argsrGr`var_kwargs_uniformr)rrrNvar_kwargs_unpacked_typed_dictr>rJrKrLrrr)rprArrr rr\) rrr~r9rrrBrrrCrs rGarguments_v3_schemaz&GenerateJsonSchema.arguments_v3_schema(s -. 13  ! &H<<(?@D))(3D"11(82DEJJLOz!+2_"M--+3_"]  & &w0H0H0N O.Jt 99jO>[ccX&v.); %) &,19 'S &.K #rFc*|j|dS)zGenerates a JSON schema that matches a schema that defines a function call. Args: schema: The core schema. Returns: The generated JSON schema. r0rrs rG call_schemazGenerateJsonSchema.call_schemaOs""6*<#=>>rFc*|j|dS)zGenerates a JSON schema that matches a schema that defines a custom error. Args: schema: The core schema. Returns: The generated JSON schema. r~rrs rGcustom_error_schemaz&GenerateJsonSchema.custom_error_schemaZrrFc|jdxstj}|j|}|jdk(rdd|dS|S)zGenerates a JSON schema that matches a schema that defines a JSON object. Args: schema: The core schema. Returns: The generated JSON schema. r~r7r*zapplication/json)rcontentMediaType contentSchema)rprrrr)rrr~content_core_schemacontent_json_schemas rGrzGenerateJsonSchema.json_schemaesV%jj2Nk6L6L6N"112EF 99 $$:L_rs s' &rFc`dddd}|j|||jj|S)zGenerates a JSON schema that matches a schema that defines a URL. Args: schema: The core schema. Returns: The generated JSON schema. r*urir"rr2 minLengthrrr*r,s rG url_schemazGenerateJsonSchema.url_schemavs4 (5qI  $$[&$:Q:Q:X:XYrFc`dddd}|j|||jj|S)zGenerates a JSON schema that matches a schema that defines a URL that can be used with multiple hosts. Args: schema: The core schema. Returns: The generated JSON schema. r*zmulti-host-urir"rYr[r,s rGmulti_host_url_schemaz(GenerateJsonSchema.multi_host_url_schemas6 (3CRST  $$[&$:Q:Q:X:XYrFc dddS)zGenerates a JSON schema that matches a UUID. Args: schema: The core schema. Returns: The generated JSON schema. r*uuidr1rErs rG uuid_schemazGenerateJsonSchema.uuid_schemar9rFc|dD]} |j||j|dS#t$rB}t|d}||j|j ||j f<Yd}~qd}~wwxYw)zGenerates a JSON schema that matches a schema that defines a JSON object with definitions. Args: schema: The core schema. Returns: The generated JSON schema. rbrsNr~)rr-rHr get_defs_refr)rrr~ definitionrrs rGrdz%GenerateJsonSchema.definitions_schemas!/ J ##J/ ""6(#344 0 $+Ju,=$>de778I8I8UYU^U^J_8`a s1 A<8A77A<cJt|d}|j|\}}|S)zGenerates a JSON schema that matches a schema that references a definition. Args: schema: The core schema. Returns: The generated JSON schema. schema_ref)rHr)rrr~rrrs rGdefinition_ref_schemaz(GenerateJsonSchema.definition_ref_schemas.6,/0!;;HE?rFc|d}|dk(s|dk(r%|jd}||j|Sy|dk(s|dk(r#|jtjS|ddk(r|j|d Sy) zGenerates a JSON schema that matches a schema that defines a serialized object. Args: schema: The core schema. Returns: The generated JSON schema. rrz function-wraprNr2z to-stringmodelr~)rprr&r)rrr~ schema_typers rGrzGenerateJsonSchema.ser_schemasVn * *k_.L"JJ7M(**=99 H $ {(B??;#9#9#;< < F^w &&&vh'78 8rFc ddiS)aGenerates a JSON schema that matches a complex number. JSON has no standard way to represent complex numbers. Complex number is not a numeric type. Here we represent complex number as strings following the rule defined by Python. For instance, '1+2j' is an accepted complex string. Details can be found in [Python's `complex` documentation][complex]. Args: schema: The core schema. Returns: The generated JSON schema. rr*rErs rGcomplex_schemaz!GenerateJsonSchema.complex_schemas!!rFc^|jjddjS)zRetrieves a title from a name. Args: name: The name to retrieve a title from. Returns: The title. r )rNrstriprrrs rGrz&GenerateJsonSchema.get_title_from_names&zz|##C-3355rFcztj|r$|ddk(r|d}n|d}|j|Stj|r`|j dry|ddvr|j|dStj |r|j|dS|ddk(ryy t d |) aReturns true if a field with the given schema should have a title set based on the field name. Intuitively, we want this to return true for schemas that wouldn't otherwise provide their own title (e.g., int, float, str), and false for those that would (e.g., BaseModel subclasses). Args: schema: The schema to check. Returns: `True` if the field should have a title set, `False` otherwise. rrrr~rsF>rrrbzdefinition-refTr)r%rrrrpis_function_with_inner_schemar-)rrr~ field_schemas rGrz,GenerateJsonSchema.field_title_should_be_sets  + +F 3f~!11%o6 %h/ 11,? ?  ' ' /zz% f~!GG55fX6FGG88@55fX6FGGf~!11/1PQWPX/YZ ZrFcPtjdd|jddS)zNormalizes a name to be used as a key in a dictionary. Args: name: The name to normalize. Returns: The normalized name. z[^a-zA-Z0-9.\-_]rr__)resubrrps rGnormalize_namez!GenerateJsonSchema.normalize_names%vv)35==c4HHrFc<|\}}tjd|}|Dcgc]}|jddd}}dj|}|Dcgc]}tjdd|}}dj|}t |}t |j|} t |j|d|z} t |j|} t | d|} t |j|} |jj| }|5|j| xxdz cc<|j| x}|j| <t | d |}t | d |}| | | | ||g|j|<|Scc}wcc}w) zOverride this method to change the way that definitions keys are generated from a core reference. Args: core_mode_ref: The core reference. Returns: The definitions key. z([\][,]):r"rz(?:[^.[\]]+\.)+((?:[^.[\]]+))z\1rru) rvsplitrsplitjoinrwr;rIrxrrprr)rrrrr componentsrWcore_ref_no_id short_ref mode_titler name_modemodule_qualnamemodule_qualname_modemodule_qualname_idoccurrence_indexmodule_qualname_occurrencemodule_qualname_occurrence_modes rGrczGenerateJsonSchema.get_defs_refs'$XXk84 3=>aahhsA&q)> >,R\]Qbff=uaH] ]GGJ' (. t**956D// :q =MMN !$"5"5n"EF&/):!J<'HI$T%8%8%BC00445GH  #  # #O 4 9 4KOKbKbcrKs s t445GH%,/@CSBT-U%V"*15I4J"M]L^2_*`'    & + N ))*IJ/.C?^s FFcv||jf}|jj|}||j|}|d|ifS|j |}||j|<||j |<t |jj|}||j|<||j|<d|i}||fS)aThis method wraps the get_defs_ref method with some cache-lookup/population logic, and returns both the produced defs_ref and the JSON schema that will refer to the right definition. Args: core_ref: The core reference to get the definitions reference for. Returns: A tuple of the definitions reference and the JSON schema that will refer to it. ryri) rrrprrcrrJrr2r)rrrrmaybe_defs_refrrfrs rGrz,GenerateJsonSchema.get_cache_defs_ref_schemaOs"499- //33MB  %--mGenerateJsonSchema.get_json_ref_counts.._add_json_refss &$'V#&vf~6H%h4&.)&;Oh'1,'&"#'#9#9(#C#t'N'NN"&"I"I("SS&t'7'7'AB #LLN&DAqJ:a+>!"1% & FD)&A"1%&*$"'223JK! L"s AC##DD)r~rrNone)r)rrrrrs` @@rGrz&GenerateJsonSchema.get_json_ref_countss(/  &: {#rFctd|)Nz!Cannot generate a JsonSchema for )r-)rrr~ error_infos rGrWz1GenerateJsonSchema.handle_invalid_for_json_schema s*-Nzl+[\\rFcb|j||}|tj|tyy)zfThis method simply emits PydanticJsonSchemaWarnings based on handling in the `warning_message` method.N)render_warning_messagermrnr@)rrkinddetailrs rGrzGenerateJsonSchema.emit_warning s.--dF;   MM'#< = rFc0||jvry|d|dS)amThis method is responsible for ignoring warnings as desired, and for formatting the warning messages. You can override the value of `ignored_warning_kinds` in a subclass of GenerateJsonSchema to modify what warnings are generated. If you want more control, you can override this method; just return None in situations where you don't want warnings to be emitted. Args: kind: The kind of warning to render. It can be one of the following: - 'skipped-choice': A choice field was skipped because it had no valid choices. - 'non-serializable-default': A default value was skipped because it was not JSON-serializable. detail: A string with additional details about the warning. Returns: The formatted warning message, or `None` if no warning should be emitted. Nz [])r)rrrrs rGrz)GenerateJsonSchema.render_warning_message s(" 4-- -D6##rFci}|jjD]3}|D],}t|jj |}|||<.5t j |j||jS)Nr)rrrJrr2rNrmrb)rrra defs_refsrfrs rGrz/GenerateJsonSchema._build_definitions_remapping+ s/1 ::AAC 2I% 2"4#4#4#;#;(#;#KL)1 X& 2 2 %==  - -|T=M=M  rFct}t|}|r`|j} |j|}||vr'|j ||j t|j ||r`|j jDcic] \}}||vs ||c}}|_y#t$r|jdsYYwxYwcc}}wr) set_get_all_json_refsrraddrrbrrr})rrr~visited_defs_refsunvisited_json_refs next_json_ref next_defs_refrrs rGrz/GenerateJsonSchema._garbage_collect_definitions6 s*-%08!/335M  $ 6 6} E  $55!%%m4#**+=d>N>N}>]+^_".2-=-=-C-C-E`TQN_I_AqD`  $//0GHI as"B18B1 C"C1CC)rrHrr{)rz_config.ConfigWrapper)rJsonSchemaMode)rzKdict[CoreSchemaOrFieldType, Callable[[CoreSchemaOrField], JsonSchemaValue]])rzGSequence[tuple[JsonSchemaKeyT, JsonSchemaMode, core_schema.CoreSchema]]rzctuple[dict[tuple[JsonSchemaKeyT, JsonSchemaMode], JsonSchemaValue], dict[DefsRef, JsonSchemaValue]])r7)r~rrrrr)r~r2rrro)rrr str | Nonerr)rrrrrr)r~zcore_schema.InvalidSchemarr)r~zcore_schema.AnySchemarr)r~zcore_schema.NoneSchemarr)r~zcore_schema.BoolSchemarr)r~zcore_schema.IntSchemarr)r~zcore_schema.FloatSchemarr)r~zcore_schema.DecimalSchemarr)r~zcore_schema.StringSchemarr)r~zcore_schema.BytesSchemarr)r~zcore_schema.DateSchemarr)r~zcore_schema.TimeSchemarr)r~zcore_schema.DatetimeSchemarr)r~zcore_schema.TimedeltaSchemarr)r~zcore_schema.LiteralSchemarr)r~zcore_schema.EnumSchemarr)r~zcore_schema.IsInstanceSchemarr)r~zcore_schema.IsSubclassSchemarr)r~r\rr)r~zcore_schema.ListSchemarr)r~zcore_schema.TupleSchemarr)r~zcore_schema.SetSchemarr)r~zcore_schema.FrozenSetSchemarr)r~z3core_schema.SetSchema | core_schema.FrozenSetSchemarr)r~zcore_schema.GeneratorSchemarr)r~zcore_schema.DictSchemarr)r~z)core_schema.BeforeValidatorFunctionSchemarr)r~z(core_schema.AfterValidatorFunctionSchemarr)r~z(core_schema.PlainValidatorFunctionSchemarr)r~z'core_schema.WrapValidatorFunctionSchemarr)r~core_schema.WithDefaultSchemarr)r~rrr)r~zcore_schema.NullableSchemarr)r~zcore_schema.UnionSchemarr)r~core_schema.TaggedUnionSchemarr)r~rrlist[JsonDict]rr)r~zcore_schema.ChainSchemarr)r~zcore_schema.LaxOrStrictSchemarr)r~zcore_schema.JsonOrPythonSchemarr)r~zcore_schema.TypedDictSchemarr)rzlist[ComputedField]rz1list[tuple[str, bool, core_schema.ComputedField]])rz+Sequence[tuple[str, bool, CoreSchemaField]]rr)rr1rr{rr{)r~zcore_schema.TypedDictFieldrr)r~zcore_schema.DataclassFieldrr)r~zcore_schema.ModelFieldrr)r~zcore_schema.ComputedFieldrr)r~zcore_schema.ModelSchemarr)rrrMz type[Any]rr0rr)rrrr)r~zcore_schema.ModelFieldsSchemarr)rr1rrH)rzPcore_schema.ModelField | core_schema.DataclassField | core_schema.TypedDictFieldrrHrrH)r~zcore_schema.DataclassArgsSchemarr)r~zcore_schema.DataclassSchemarr)r~zcore_schema.ArgumentsSchemarr)r9$list[core_schema.ArgumentsParameter]r5CoreSchema | Nonerr)r9rr4rrr)rBzAcore_schema.ArgumentsParameter | core_schema.ArgumentsV3Parameterrr{)r~zcore_schema.ArgumentsV3Schemarr)r~zcore_schema.CallSchemarr)r~zcore_schema.CustomErrorSchemarr)r~zcore_schema.JsonSchemarr)r~zcore_schema.UrlSchemarr)r~zcore_schema.MultiHostUrlSchemarr)r~zcore_schema.UuidSchemarr)r~zcore_schema.DefinitionsSchemarr)r~z%core_schema.DefinitionReferenceSchemarr)r~zVcore_schema.SerSchema | core_schema.IncExSeqSerSchema | core_schema.IncExDictSerSchemarJsonSchemaValue | None)r~zcore_schema.ComplexSchemarr)rr{rr{)r~r2rrH)r CoreModeRefrrI)rrHrztuple[DefsRef, JsonSchemaValue])rrJrr)rrrr)rrrrrzdict[str, str]rr)rzlist[JsonSchemaValue]rr)rrrzdict[JsonRef, int])r~r2rr{rr)rJsonSchemaWarningKindrr{rr)rrrr{rr)rrN)r~rrr)mrArBrCrDschema_dialectrrDEFAULT_REF_TEMPLATErpropertyr#rrrrrrrrrr r rrr(r&r5r8r<r>rBrKrTrXrZr]rcrrrprsror|rr{rrrrrrrrrrrrrrrrrrrrrrrrrrrr!rrr'r,r0r7r6rArMrOrQrr\r^rardrgrrlrrrxrcrrrrrrrrrWrrrrrErFrGrrs{BDN:J8J5J(,BV"H//  T4/A]/A l/Ab/&bKZ (j    #  B  4 4 9 8@"H n  Y Vaef ) g)T_cd ) e)!F / / .` 5 5 54l 0N&32#J+%3+%ES+% +%Z @=& :BT,T :TT %P 2* 5 5 5 <*E-N(.$$<_<<  <2I$<" H#=#Rc# #J(=(Pa( (T$%N ? 5'"   45$ l 2"$ 6![F I./`)86  : E* E9C EN\ E  E  @ ""H]> $*  arFrTr7cLddlm}|||}t|jtj r|jj ||ur tdt|jtj rJd|j|j|S)aUtility function to generate a JSON Schema for a model. Args: cls: The model class to generate a JSON Schema for. by_alias: If `True` (the default), fields will be serialized according to their alias. If `False`, fields will be serialized according to their attribute name. ref_template: The template to use for generating JSON Schema references. schema_generator: The class to use for generating the JSON Schema. mode: The mode to use for generating the JSON Schema. It can be one of the following: - 'validation': Generate a JSON Schema for validating data. - 'serialization': Generate a JSON Schema for serializing data. Returns: The generated JSON Schema. r"r5rrzTmodel_json_schema() must be called on a subclass of BaseModel, not BaseModel itself.zthis is a bug! please report it)r) rr6rz__pydantic_core_schema__r(MockCoreSchemarebuildrr)rMrrschema_generatorrr6schema_generator_instances rGmodel_json_schemarK s. 0(Q] ^#.. 0L0LM $$,,. istt#66 8T8TUxWxx $ - -c.J.JQU - VVrF)rrNrOrrcT|D]D\}}t|jtjs+|jj F|||}|D cgc]\} } | | | jf} } } |j | \} } i}| r| |d<|r||d<|r||d<| |fScc} } w)a?Utility function to generate a JSON Schema for multiple models. Args: models: A sequence of tuples of the form (model, mode). by_alias: Whether field aliases should be used as keys in the generated JSON Schema. title: The title of the generated JSON Schema. description: The description of the generated JSON Schema. ref_template: The reference template to use for generating JSON Schema references. schema_generator: The schema generator to use for generating the JSON Schema. Returns: A tuple where: - The first element is a dictionary whose keys are tuples of JSON schema key type and JSON mode, and whose values are the JSON schema corresponding to that pair of inputs. (These schemas may have JsonRef references to definitions that are defined in the second returned element.) - The second element is a JSON schema containing all definitions referenced in the first returned element, along with the optional title and description keys. rrRrNrO)rzrr(rrr)modelsrrNrOrrrMrinstancemrrrrbrs rGmodels_json_schemarp s63Q c22M4P4P Q  ( ( 0 0 23  MH=Cb29!TD!,,-bFb%-$A$A&$I!k"$K* G $ G%0 M" [ ((bsB$)_HashableJsonValue.r.rcnt|Dcic]}t||c}jScc}wro)r[_make_json_hashabler)rr~s rGr]r] s/ 7K$V,f4KRRT UUKs2ct|tr)ttd|j DSt|t rtd|DS|S)Nc3<K|]\}}|t|fywror)rVrrs rGrYz&_make_json_hashable.. sRDAqQ 3A 67Rsc32K|]}t|ywror)rVrs rGrYz&_make_json_hashable.. s;(+;s)rzr|rrr}r[)rs rGrr sH%VREKKMRRSS E4 ;U;;; rFcFeZdZUdZded<dZded< d dZd dZy) WithJsonSchemaaQ!!! abstract "Usage Documentation" [`WithJsonSchema` Annotation](../concepts/json_schema.md#withjsonschema-annotation) Add this as an annotation on a field to override the (base) JSON schema that would be generated for that field. This provides a way to set a JSON schema for types that would otherwise raise errors when producing a JSON schema, such as Callable, or types that have an is-instance core schema, without needing to go so far as creating a custom subclass of pydantic.json_schema.GenerateJsonSchema. Note that any _modifications_ to the schema that would normally be made (such as setting the title for model fields) will still be performed. If `mode` is set this will only apply to that schema generation mode, allowing you to set different json schemas for validation and serialization. rrN-Literal['validation', 'serialization'] | Nonerc|jxs |j}||jk7r||S|jt|jjSro)rrrr)rrrhandlerrs rG__get_pydantic_json_schema__z+WithJsonSchema.__get_pydantic_json_schema__ sTyy(GLL 7<< ;' '    # ##((* *rFc>tt|jSrohashrrrs rG__hash__zWithJsonSchema.__hash__ DO$$rFrzcore_schema.CoreSchemarr*rrrr)rArBrCrDrrrrrErFrGrr s< (':>D 7> +1 +Using a dict for `examples` is deprecated, use a list instead.rirj)rzr|rmrnr!rrrs rGrzExamples.__init__ s3 h % MMP)  !  rFc |jxs |j}||}||jk7r|S|jd}|t|j|d<t |t rt |jt r[tjdtt|jDcgc] }|D]}| c}}|jz|d<nti||j|d<t |t rt |jt rt||jz|d<|St |jt rZtjdtt||jjDcgc] }|D]}| c}}z|d<|Scc}}wcc}}w)NrzUpdating existing JSON Schema examples of type dict with examples of type list. Only the existing examples values will be retained. Note that dict support for examples is deprecated and will be removed in v3.0.zUpdating existing JSON Schema examples of type list with examples of type dict. Only the examples values will be retained. Note that dict support for examples is deprecated and will be removed in v3.0.) rrprrrzr|r[rmrn UserWarningr)rrrrrrrrexs rGrz%Examples.__get_pydantic_json_schema__ syy(GLLk* 7<<  ??:.  &8&GK # h %$--. J  +=%-__%6GEG2RGRG$--W+ J'+==Z=ZDMM=Z*[ J' h %$--.*tt|jSrorrs rGrzExamples.__hash__ rrFro)rdict[str, Any]rrrr)rz list[Any]rrrr)rzdict[str, Any] | list[Any]rrrrrr) rArBrCrDrrrrrrErFrGrr swx^b&.[ yttko 2 :g   %1%r"s> 3 ,88   SS3HH>R5'bbI9J : :K<[<[ [\ sCx.67AHZb1c.c ef  H  )A )S ! )S ! )S !G^+, ):8,778MM9M`m!am!ajC,1C' "W 2"W"W"W/ "W  "W  "WP",1C-) V-)-)  -)  -)  -)/-)u-)f!&T4'@!A5sThOhIiknInCoo!I V8,778%%9%DG%G%T8 ) w|,N[<0;;<9$9$=9$xrF