+ }i_|a0t$Rt^RIHt^RIt^RIt^RIt^RIH t ^RI H t ^RI H t HtHtHtHtHtHtHtHt^RIHtHt^RIHtHt^RIHtHtHt^R I H!t!^R I"H#t#^R I$H%t%^R IH&t&H't']PPRT8d^R IH)t)M^R I H)t)]PTt+]PX!RURR/]PZB!RR44t.]PX!RURR/]PZB!RR44t/]PX!RURR/]PZB!RR44t0]PX!RURR/]PZB!RR44t1] 'd!RR])4t2!RR])4t3!RR])4t4!RR])4t5]]3]Pl]2]Pn3,t8]]5]Pr]4]Pt3,t;]]<]]]3,]=]]3,] ],3,t>R ]?R!&]!R"]]8]>3,R#7t@]!R$]];]>3,R#7tA]RV,tBR ]?R&&]R'R(R)R(/R*R+ll4tC]R'R(R)R(/R,R-ll4tC]R.R(R'R(/R/R0ll4tCR.R%R'RR)]/R1R2lltC]!R34tD]!R4RR57tE!R6R7]P])]E,4tG!R8R9])]D,4tH!R:R;])]D,4tI!R<R=])4tJ!R>R?])4tK!R@RA])4tL!RBRC])4tM]]D.]D3,tN]]D]P],.]D3,tP]]I]D,]H]D,3,tQ]]L]M]J]K3,tR]]P]D,]N]D,3,tS]RDREl4tT]RFRGl4tT]RHRIl4tTRJRKltT]!RL4tU] 'd ]]UR(3,tVM)]PX!RU/]PZB!RMRN44tV] 'd ]]UR(3,tWM)]PX!RU/]PZB!RORP44tW]!RQ4tX!RRRS4tYR#)WzBThis module contains related classes and functions for validation.) annotationsN) partialmethod) FunctionType) TYPE_CHECKING AnnotatedAnyCallableLiteralTypeVarUnioncastoverload)PydanticUndefined core_schema)Self TypeAlias) _decorators _generics_internal_dataclass)GetCoreSchemaHandler)PydanticUserError) version_short)ArbitraryTypeWarningPydanticDeprecatedSince212)ProtocolfrozenTcH]tRt^t$RtR]R&RRlt]RRl4tRt R #) AfterValidatora!!! abstract "Usage Documentation" [field *after* validators](../concepts/validators.md#field-after-validator) A metadata class that indicates that a validation should be applied **after** the inner validation logic. Attributes: func: The validator function. Example: ```python from typing import Annotated from pydantic import AfterValidator, BaseModel, ValidationError MyInt = Annotated[int, AfterValidator(lambda v: v + 1)] class Model(BaseModel): a: MyInt print(Model(a=1).a) #> 2 try: Model(a='a') except ValidationError as e: print(e.json(indent=2)) ''' [ { "type": "int_parsing", "loc": [ "a" ], "msg": "Input should be a valid integer, unable to parse string as an integer", "input": "a", "url": "https://errors.pydantic.dev/2/v/int_parsing" } ] ''' ``` Kcore_schema.NoInfoValidatorFunction | core_schema.WithInfoValidatorFunctionfuncc$V^8dQhRRRRRR/# source_typerhandlerrreturncore_schema.CoreSchema)formats"p/Users/ahmad/.openclaw/workspace/my-crawler/.venv/lib/python3.14/site-packages/pydantic/functional_validators.py __annotate__AfterValidator.__annotate__Ks(UUUFZU_uUc >V!V4p\VPRRR7pV'd<\\PVP4p\P !WSR7#\\P VP4p\P!WSR7#)afterfieldmodetypeschema)_inspect_validatorrr rWithInfoValidatorFunction"with_info_after_validator_functionNoInfoValidatorFunction no_info_after_validator_function)selfr#r$r4info_argrs&&& r)__get_pydantic_core_schema__+AfterValidator.__get_pydantic_core_schema__Kso%%diigGL  ==tyyIDAA$V V ;;TYYGD??T Tr,c V^8dQhRRRR/#r" decoratorz>_decorators.Decorator[_decorators.FieldValidatorDecoratorInfo]r%rr')r(s"r)r*r+Vs(((f(ko(r,c (V!VPR7#)rrBclsr@s&&r)_from_decoratorAfterValidator._from_decoratorUs ''r,r'N) __name__ __module__ __qualname____firstlineno____doc____annotations__r< classmethodrE__static_attributes__r'r,r)rrs+(T VUU((r,rcV]tRt^Zt$RtR]R&]tR]R&RRlt] RR l4t R t R #) BeforeValidatora,!!! abstract "Usage Documentation" [field *before* validators](../concepts/validators.md#field-before-validator) A metadata class that indicates that a validation should be applied **before** the inner validation logic. Attributes: func: The validator function. json_schema_input_type: The input type used to generate the appropriate JSON Schema (in validation mode). The actual input type is `Any`. Example: ```python from typing import Annotated from pydantic import BaseModel, BeforeValidator MyInt = Annotated[int, BeforeValidator(lambda v: v + 1)] class Model(BaseModel): a: MyInt print(Model(a=1).a) #> 2 try: Model(a='a') except TypeError as e: print(e) #> can only concatenate str (not "int") to str ``` rrrjson_schema_input_typec$V^8dQhRRRRRR/#r!r')r(s"r)r*BeforeValidator.__annotate__s#FZ_ur,c V!V4pVP\JdRMVPVP4p\VPRRR7pV'd>\ \ PVP4p\ P!VVVR7#\ \ PVP4p\ P!WcVR7#)Nbeforer/r0r4json_schema_input_schema) rQrgenerate_schemar5rr rr6#with_info_before_validator_functionr8!no_info_before_validator_functionr:r#r$r4 input_schemar;rs&&& r)r<,BeforeValidator.__get_pydantic_core_schema__s%**.?? (()D)DE  &diihWM  ==tyyIDBB)5   ;;TYYGD@@l r,c V^8dQhRRRR/#r?r')r(s"r)r*rS  (f ko r,c RV!VPVPPR7#)rrQrinforQrCs&&r)rEBeforeValidator._from_decorator##,>>#H#H  r,r'N rGrHrIrJrKrLrrQr<rMrErNr'r,r)rPrPZs5@ VU"3C3,  r,rPcV]tRt^t$RtR]R&]tR]R&RRlt] RR l4t R t R #) PlainValidatora!!! abstract "Usage Documentation" [field *plain* validators](../concepts/validators.md#field-plain-validator) A metadata class that indicates that a validation should be applied **instead** of the inner validation logic. !!! note Before v2.9, `PlainValidator` wasn't always compatible with JSON Schema generation for `mode='validation'`. You can now use the `json_schema_input_type` argument to specify the input type of the function to be used in the JSON schema when `mode='validation'` (the default). See the example below for more details. Attributes: func: The validator function. json_schema_input_type: The input type used to generate the appropriate JSON Schema (in validation mode). The actual input type is `Any`. Example: ```python from typing import Annotated, Union from pydantic import BaseModel, PlainValidator def validate(v: object) -> int: if not isinstance(v, (int, str)): raise ValueError(f'Expected int or str, go {type(v)}') return int(v) + 1 MyInt = Annotated[ int, PlainValidator(validate, json_schema_input_type=Union[str, int]), # (1)! ] class Model(BaseModel): a: MyInt print(Model(a='1').a) #> 2 print(Model(a=1).a) #> 2 ``` 1. In this example, we've specified the `json_schema_input_type` as `Union[str, int]` which indicates to the JSON schema generator that in validation mode, the input type for the `a` field can be either a [`str`][] or an [`int`][]. rrrrQc$V^8dQhRRRRRR/#r!r')r(s"r)r*PlainValidator.__annotate__s#'''FZ'_u'r,c  ^RIHpV!V4pVPR\P!RVVP V4R74pVP VP 4p\VPRRR7pV'd>\\PVP4p\P!VVVR 7#\\PVP4p\P!VVVR 7# TdRpLi;i) PydanticSchemaGenerationError serializationcV!V4#Nr'vhs&&r)=PlainValidator.__get_pydantic_core_schema__..!A$r,)functionr4 return_schemaNplainr/r0)rorW)pydanticrngetr#wrap_serializer_function_ser_schemarXrQr5rr r6"with_info_plain_validator_functionr8 no_info_plain_validator_function) r:r#r$rnr4ror\r;rs &&& r)r<+PlainValidator.__get_pydantic_core_schema__s ; ![)F#JJ??.!")"9"9+"FM..t/J/JK %diigGL  ==tyyIDAA+)5   ;;TYYGD??+)5 - ! M !sAC>> D  D c V^8dQhRRRR/#r?r')r(s"r)r*rjr_r,c RV!VPVPPR7#rarbrCs&&r)rEPlainValidator._from_decoratorrer,r'N) rGrHrIrJrKrLrrQr<rMrErNr'r,r)rhrhs6,\ VU"%C%'R  r,rhcV]tRtRt$RtR]R&]tR]R&RRlt] R R l4t R t R #) WrapValidatoriab!!! abstract "Usage Documentation" [field *wrap* validators](../concepts/validators.md#field-wrap-validator) A metadata class that indicates that a validation should be applied **around** the inner validation logic. Attributes: func: The validator function. json_schema_input_type: The input type used to generate the appropriate JSON Schema (in validation mode). The actual input type is `Any`. ```python from datetime import datetime from typing import Annotated from pydantic import BaseModel, ValidationError, WrapValidator def validate_timestamp(v, handler): if v == 'now': # we don't want to bother with further validation, just return the new value return datetime.now() try: return handler(v) except ValidationError: # validation failed, in this case we want to return a default value return datetime(2000, 1, 1) MyTimestamp = Annotated[datetime, WrapValidator(validate_timestamp)] class Model(BaseModel): a: MyTimestamp print(Model(a='now').a) #> 2032-01-02 03:04:05.000006 print(Model(a='invalid').a) #> 2000-01-01 00:00:00 ``` zScore_schema.NoInfoWrapValidatorFunction | core_schema.WithInfoWrapValidatorFunctionrrrQc$V^8dQhRRRRRR/#r!r')r(s"r)r*WrapValidator.__annotate__,s#FZ_ur,c V!V4pVP\JdRMVPVP4p\VPRRR7pV'd>\ \ PVP4p\ P!VVVR7#\ \ PVP4p\ P!VVVR7#)Nwrapr/r0rV) rQrrXr5rr rWithInfoWrapValidatorFunction!with_info_wrap_validator_functionNoInfoWrapValidatorFunctionno_info_wrap_validator_functionr[s&&& r)r<*WrapValidator.__get_pydantic_core_schema__,s%**.?? (()D)DE  &diif7K  AA499MD@@)5   ??KD>>)5 r,c V^8dQhRRRR/#r?r')r(s"r)r*rEr_r,c RV!VPVPPR7#rarbrCs&&r)rEWrapValidator._from_decoratorDrer,r'Nrfr'r,r)rrs5$L ^]"3C30  r,rc"]tRtRtRRltRtR#)_OnlyValueValidatorClsMethodiNc$V^8dQhRRRRRR/#r"rDrvaluer%r')r(s"r)r*)_OnlyValueValidatorClsMethod.__annotate__Os???C?s?r,c R#rqr'r:rDrs"""r)__call__%_OnlyValueValidatorClsMethod.__call__OsCr,r'NrGrHrIrJrrNr'r,r)rrNs??r,rc"]tRtRtRRltRtR#)_V2ValidatorClsMethodiQc(V^8dQhRRRRRRRR/#r"rDrrrccore_schema.ValidationInfo[Any]r%r')r(s"r)r*"_V2ValidatorClsMethod.__annotate__RsfffCf7Vf^afr,c R#rqr'r:rDrrcs""""r)r_V2ValidatorClsMethod.__call__Rscfr,r'Nrr'r,r)rrQsffr,rc"]tRtRtRRltRtR#) _OnlyValueWrapValidatorClsMethodiTc(V^8dQhRRRRRRRR/#)r"rDrrr$(core_schema.ValidatorFunctionWrapHandlerr%r')r(s"r)r*-_OnlyValueWrapValidatorClsMethod.__annotate__UsrrrCr:brjmrr,c R#rqr'r:rDrr$s""""r)r)_OnlyValueWrapValidatorClsMethod.__call__Usorr,r'Nrr'r,r)rrTsrrr,rc"]tRtRtRRltRtR#)_V2WrapValidatorClsMethodiWc ,V^8dQhRRRRRRRRRR/#) r"rDrrr$rrcrr%r')r(s"r)r*&_V2WrapValidatorClsMethod.__annotate__Xs<    >   2   r,c R#rqr'r:rDrr$rcs"""""r)r"_V2WrapValidatorClsMethod.__call__Xsr,r'Nrr'r,r)rrWs   r,rr_PartialClsOrStaticMethod"_V2BeforeAfterOrPlainValidatorType)bound_V2WrapValidatorTyper.FieldValidatorModes check_fields.rQc 0V^8dQhRRRRRRRRRR R R /#) r"r/strfieldsr1Literal['wrap']r bool | NonerQrr%z6Callable[[_V2WrapValidatorType], _V2WrapValidatorType]r')r(s"r)r*r*{sNAA AA  A  A  A<Ar,cR#rqr'r/r1rrQrs"$$$*r)field_validatorrzs>Ar,c 0V^8dQhRRRRRRRRRR R R /#) r"r/rrr1zLiteral['before', 'plain']rrrQrr%RCallable[[_V2BeforeAfterOrPlainValidatorType], _V2BeforeAfterOrPlainValidatorType]r')r(s"r)r*r*sO]] ]] % ]  ]  ]X]r,cR#rqr'rs"$$$*r)rrs Z]r,r1c ,V^8dQhRRRRRRRRRR /#) r"r/rrr1Literal['after']rrr%rr')r(s"r)r*r*sD]] ]]  ]  ] X ]r,cR#rqr')r/r1rrs"$$*r)rrs Z]r,c 0V^8dQhRRRRRRRRRR R R /#) r"r/rrr1rrrrQrr%zCallable[[Any], Any]r')r(s"r)r*r*sNll ll  l  l  llr,cxaaaa\V\4'd\RRR7hSR9dS\Jd\RS: 2RR7hS\JdSR8Xd\oV.SO5o\ ;QJdRS4F 'dK RM R M !RS44'g\R R R7hR VVVV3R llpV#)a!!! abstract "Usage Documentation" [field validators](../concepts/validators.md#field-validators) Decorate methods on the class indicating that they should be used to validate fields. Example usage: ```python from typing import Any from pydantic import ( BaseModel, ValidationError, field_validator, ) class Model(BaseModel): a: str @field_validator('a') @classmethod def ensure_foobar(cls, v: Any): if 'foobar' not in v: raise ValueError('"foobar" not found in a') return v print(repr(Model(a='this is foobar good'))) #> Model(a='this is foobar good') try: Model(a='snap') except ValidationError as exc_info: print(exc_info) ''' 1 validation error for Model a Value error, "foobar" not found in a [type=value_error, input_value='snap', input_type=str] ''' ``` For more in depth examples, see [Field Validators](../concepts/validators.md#field-validators). Args: field: The first field the `field_validator` should be called on; this is separate from `fields` to ensure an error is raised if you don't pass at least one. *fields: Additional field(s) the `field_validator` should be called on. mode: Specifies whether to validate the fields before or after validation. check_fields: Whether to check that the fields actually exist on the model. json_schema_input_type: The input type of the function. This is only used to generate the appropriate JSON Schema (in validation mode) and can only specified when `mode` is either `'before'`, `'plain'` or `'wrap'`. Returns: A decorator that can be used to decorate a function to be used as a field_validator. Raises: PydanticUserError: - If `@field_validator` is used bare (with no fields). - If the args passed to `@field_validator` as fields are not strings. - If `@field_validator` applied to instance methods. z`@field_validator` should be used with fields and keyword arguments, not bare. E.g. usage should be `@validator('', ...)`zvalidator-no-fieldscoderzz;`json_schema_input_type` can't be used when mode is set to zvalidator-input-typec3B"TFp\V\4xK R#5irq) isinstancer).0r/s& r) "field_validator..s:6%z%%%6sFTz`@field_validator` fields should be passed as separate string args. E.g. usage should be `@validator('', '', ...)`zvalidator-invalid-fieldsc V^8dQhRRRR/#)r"fzHCallable[..., Any] | staticmethod[Any, Any] | classmethod[Any, Any, Any]r%(_decorators.PydanticDescriptorProxy[Any]r')r(s"r)r*%field_validator..__annotate__s @@ S@ 1@r,c<\P!V4'd\RRR7h\P!V4p\P!SSSSR7p\P !W4#)z8`@field_validator` cannot be applied to instance methodszvalidator-instance-methodr)rr1rrQ)ris_instance_method_from_sigr%ensure_classmethod_based_on_signatureFieldValidatorDecoratorInfoPydanticDescriptorProxy)rdec_inforrrQr1s& r)decfield_validator..decsh  2 21 5 5#JQl   = =a @:: Self: if self.width != self.height: raise ValueError('width and height do not match') return self s = Square(width=1, height=1) print(repr(s)) #> Square(width=1.0, height=1.0) try: Square(width=1, height=2) except ValidationError as e: print(e) ''' 1 validation error for Square Value error, width and height do not match [type=value_error, input_value={'width': 1, 'height': 2}, input_type=dict] ''' ``` For more in depth examples, see [Model Validators](../concepts/validators.md#model-validators). Args: mode: A required string literal that specifies the validation mode. It can be one of the following: 'wrap', 'before', or 'after'. Returns: A decorator that can be used to decorate a function to be used as a model validator. c V^8dQhRRRR/#)r"rrr%rr')r(s"r)r*%model_validator..__annotate__s@@s@?@r,c<\P!V4pSR8Xd@\V\4'd*\P !\ R\4 R2^R7\P!SR7p\P!W4#)r.zUsing `@model_validator` with mode='after' on a classmethod is deprecated. Instead, use an instance method. See the documentation at https://docs.pydantic.dev/z,/concepts/validators/#model-after-validator.)categorymessage stacklevelr) rrrrMwarningswarnrrModelValidatorDecoratorInfor)rrr1s& r)rmodel_validator..decsx  = =a @ 7?z![99 MM3JJW/IZ[GH  ::E221??r,r')r1rsd r)rrsb@@ Jr,AnyTypec^]tRtRtRt]RRl4t]RRl4t]Pt Rt R#) InstanceOfiuGeneric type for annotating a type that is an instance of a given class. Example: ```python from pydantic import BaseModel, InstanceOf class Foo: ... class Bar(BaseModel): foo: InstanceOf[Foo] Bar(foo=Foo()) try: Bar(foo=42) except ValidationError as e: print(e) """ [ │ { │ │ 'type': 'is_instance_of', │ │ 'loc': ('foo',), │ │ 'msg': 'Input should be an instance of Foo', │ │ 'input': 42, │ │ 'ctx': {'class': 'Foo'}, │ │ 'url': 'https://errors.pydantic.dev/0.38.0/v/is_instance_of' │ } ] """ ``` c V^8dQhRRRR/#)r"itemr(r%r')r(s"r)r*InstanceOf.__annotate__s * * *W *r,c (\W!43,#rq)rrDr,s&&r)__class_getitem__InstanceOf.__class_getitem__sT35[) )r,c$V^8dQhRRRRRR/#r"sourcerr$rr%r&r')r(s"r)r*r-s( x xc xDX x]s xr,c ^RIHp\P!\P !V4;'gT4pV!V4p\P !RVR7VR&\P!WER7# TdTu#i;i)rlrmcV!V4#rqr'rrs&&r)ru9InstanceOf.__get_pydantic_core_schema__..#rwr,rxr4ro) python_schema json_schema)r{rnris_instance_schemar get_originr}json_or_python_schema)rDr4r$rninstance_of_schemaoriginal_schemas&&& r)r<'InstanceOf.__get_pydantic_core_schema__s >"-!?!? @T@TU[@\@f@f`f!g  x")&/ 7B6e6e.7"?3#88GYww1 *)) *sA77 BBr'N) rGrHrIrJrKrMr0r<object__hash__rNr'r,r)r*r*s= @  *  *  x  x&??r,r*cT]tRtRtRtRRlt]RRl4t]Pt Rt R#) SkipValidationi.atIf this is applied as an annotation (e.g., via `x: Annotated[int, SkipValidation]`), validation will be skipped. You can also use `SkipValidation[int]` as a shorthand for `Annotated[int, SkipValidation]`. This can be useful if you want to use a type annotation for documentation/IDE/type-checking purposes, and know that it is safe to skip validation for one or more of the fields. Because this converts the validation schema to `any_schema`, subsequent annotation-applied transformations may not have the expected effects. Therefore, when used, this annotation should generally be the final annotation applied to a type. c V^8dQhRRRR/#)r"r,rr%r')r(s"r)r*SkipValidation.__annotate__;s 5 5 5 5r,c 0\V\43,#rq)rrDr/s&&r)r0 SkipValidation.__class_getitem__;sT>#334 4r,c$V^8dQhRRRRRR/#r3r')r(s"r)r*rF?s#  c DX ]s r,c ,a\P!4;_uu_4\P!R\4V!V4oRRR4RV3Rl./p\P !V\P !RSR7R7# +'giLH;i)ignoreN pydantic_js_annotation_functionsc<V!S4#rqr')_crtr?s&&r)ru=SkipValidation.__get_pydantic_core_schema__..Cs 1_K]r,cV!V4#rqr'rrs&&r)rurOGrwr,r8)metadataro)r$catch_warnings simplefilterrr any_schemar})rDr4r$rQr?s&&& @r)r<+SkipValidation.__get_pydantic_core_schema__>ss((**%%h0DE")&/+;=]<^_H))!)MM.  +*s $B B r'N) rGrHrIrJrKr0rMr<rArBrNr'r,r)rDrD.s+  5    ??r,rD _FromTypeTc2]tRtRtRtRRltRRltRtR#) ValidateAsiQa-A helper class to validate a custom type from a type that is natively supported by Pydantic. Args: from_type: The type natively supported by Pydantic to use to perform validation. instantiation_hook: A callable taking the validated type as an argument, and returning the populated custom type. Example: ```python {lint="skip"} from typing import Annotated from pydantic import BaseModel, TypeAdapter, ValidateAs class MyCls: def __init__(self, a: int) -> None: self.a = a def __repr__(self) -> str: return f"MyCls(a={self.a})" class Model(BaseModel): a: int ta = TypeAdapter( Annotated[MyCls, ValidateAs(Model, lambda v: MyCls(a=v.a))] ) print(ta.validate_python({'a': 1})) #> MyCls(a=1) ``` c$V^8dQhRRRRRR/#)r"instantiation_hookzCallable[[_FromTypeT], Any] from_typeztype[_FromTypeT]r%Noner')r(s"r)r*ValidateAs.__annotate__ts$55Kf5"25ko5r,c WnW nR#rqr[rZ)r:r[rZs""&r)__init__ValidateAs.__init__ts ""4r,c$V^8dQhRRRRRR/#r3r')r(s"r)r*r]xs#  3 AU Zp r,c jV!VP4p\P!VPVR7#)r3)r[rr9rZ)r:r4r$r4s&&& r)r<'ValidateAs.__get_pydantic_core_schema__xs/(;;  # #  r,r_N)rGrHrIrJrKr`r<rNr'r,r)rXrXQsD5  r,rX) r')rUr.rrz)Z__conditional_annotations__rK __future__r _annotations dataclassessysr$ functoolsrtypesrtypingrrrrr r r r r pydantic_corerrtyping_extensionsrr _internalrrrannotated_handlersrerrorsrversionrrr version_inforinspect_validatorr5 dataclass slots_truerrPrhrrrrrr6r8 _V2Validatorrr_V2WrapValidatorrM staticmethodrrLrrrrrrValidatorFunctionWrapHandlerrrrrrrrModelAfterValidatorWithoutInfoValidationInfoModelAfterValidator_AnyModelWrapValidator_AnyModelBeforeValidator_AnyModelAfterValidatorrr(r*rDrVrX)rgs@r)rsH2 #ccc8-BB4%"Fg* 22 EdE&9&D&DE9(9(F9(x EdE&9&D&DE? ? F? D EdE&9&D&DE` ` F` F EdE&9&D&DEG G FG T@x@ggs8sH--$++ -L!11(// 1,1S#s]1K\Z]_bZbMcersvew1w+xyx)0,L";;<*&##9GWYrGrAst!()K!LYL A !$ A #& A A ] !$ ] #& ] ] ]! ] !$ ] ]l!( l !% l #4 l^\ " ~6   H H(S_J`  HZ$8" *-  (  h  x  8 "*:, *B!C K,F,Fs,KLjXYZ1*=?\]g?hhi 24WYxx 3J ?A_`jAk kl      AH ) 7C<(J<0;;<9#9#=9#xw|,N<0;;<##=#>\ " , , r,