}tj(e~UddlZddlZddlZddlmZddlmZmZmZm Z m Z ddl m Z m Z ddlmZmZmZmZmZmZmZmZmZmZ ddlmZmZn:#e$r2 ddlmZmZn%#e$reddiZed diZYnwxYwYnwxYwd d lmZm Z m!Z!eegdfZ"ed Z#ed e$e%efZ&e'Z(edee#dee#fdZ)eddde*deee#gee#ffdZ)d>dddee#dzde*dee#eee#gee#fzfdZ)dee&de$ddfdZ+e dee&defdZ,dee&de$e%effdZ-eedddddfde.e"e"zdeded e*d!e*d"e*dzd#e*d$e$dzd%edefd&Z/de"fd'Z0d(e%d)ed*eddfd+Z1d(e%d)eddfd,Z2d(e%d)ed-e3ed.fddfd/Z4d(e%d)ed-e3ed.fddfd0Z5d(e%d)ed-e3ed.fddfd1Z6d(e%d)ed-e3ed.fddfd2Z7d(e%d)ed-e3ed.fddfd3Z8d(e%d)ed-e3ed.fddfd4Z9d(e%d)ed-e3ed.fddfd5Z:d(e%d)ed*eddfd6Z;d7ede"fd8Zee4ee5e.e6e$e7e3e8e?e9ej@jAe:iZBe$eee%ee3ed.fgdffeCd<<e4eBejD<gd=ZEdS)?N)Callable)MISSINGFieldfieldfieldsmake_dataclass) lru_cachewraps) AnnotatedAny ForwardRefLiteralTypeTypeVarUnionget_args get_originoverload) NotRequiredRequiredrr)#StrictDataclassClassValidationErrorStrictDataclassDefinitionError#StrictDataclassFieldValidationErrorT TypedDictType)boundclsreturncdSNr)rs Y/var/www/html/CA-Chatbot/venv/lib/python3.11/site-packages/huggingface_hub/dataclasses.pystrictr$0s%(SF accept_kwargsr'cdSr"rr&s r#r$r$4sLOCr%cvdttdttffd }| ||n|S)a Decorator to add strict validation to a dataclass. This decorator must be used on top of `@dataclass` to ensure IDEs and static typing tools recognize the class as a dataclass. Can be used with or without arguments: - `@strict` - `@strict(accept_kwargs=True)` Args: cls: The class to convert to a strict dataclass. accept_kwargs (`bool`, *optional*): If True, allows arbitrary keyword arguments in `__init__`. Defaults to False. Returns: The enhanced dataclass with strict validation on field assignment. Example: ```py >>> from dataclasses import dataclass >>> from huggingface_hub.dataclasses import as_validated_field, strict, validated_field >>> @as_validated_field >>> def positive_int(value: int): ... if not value >= 0: ... raise ValueError(f"Value must be positive, got {value}") >>> @strict(accept_kwargs=True) ... @dataclass ... class User: ... name: str ... age: int = positive_int(default=10) # Initialize >>> User(name="John") User(name='John', age=10) # Extra kwargs are accepted >>> User(name="John", age=30, lastname="Doe") User(name='John', age=30, *lastname='Doe') # Invalid type => raises >>> User(name="John", age="30") huggingface_hub.errors.StrictDataclassFieldValidationError: Validation error for field 'age': TypeError: Field 'age' expected int, got str (value: '30') # Invalid value => raises >>> User(name="John", age=-1) huggingface_hub.errors.StrictDataclassFieldValidationError: Validation error for field 'age': ValueError: Value must be positive, got -1 ``` rr c tdstdjdi}tD]}g}|t ||jd}|\t|ts|g}|D],}t|std|j d|d-| ||||j <|_ jdtd t d td dffd }|_rj}t%|d td dffd }|_tdsd td dfd} | _jt%d t ffd } jjdur| _g} t/D]} | dst3| } t5| s8t7t9j| jdkrtdjd| d| | | _dt@d dffd }d|_!tdr.t3j"ddstdjd|_"jt%dfd }tGd|S)N__dataclass_fields__zClass 'z.' must be a dataclass before applying @strict. validatorzInvalid validator for field '': z.. Must be a callable taking a single argument.selfnamevaluer c|j|gD]9} ||#ttf$r}t |||d}~wwxYw|||dS)z1Custom __setattr__ method for strict dataclasses.)rcauseN)__validators__get ValueError TypeErrorr)r.r/r0r,eoriginal_setattrs r#__strict_setattr__z0strict..wrap..__strict_setattr__s"044T2>> Z Z ZIe$$$$"I.ZZZ=DPQRRRXYYZ  T4 / / / / /s ,AAAkwargscdt Dfd|D}t|dkr(td jdt|dt D]}|j|vr"t ||j||j-|jturt ||j|jW|j tur)t ||j| td|jdi}|D]\}}|vr|||<|j d i|dS) Nch|] }|j Sr)r/).0fs r# z9strict..wrap..__init__..s#@#@#@qAF#@#@#@r%c$i|] \}}|v || Srr)r=kvdataclass_fieldss r# z:strict..wrap..__init__..s*"\"\"\DAqaK[F[F[1aF[F[F[r%rzWhen `accept_kwargs=True`, z, accepts only keyword arguments, but found `z` positional args.zMissing required field - ''r) ritemslenr5__name__r/setattrdefaultrdefault_factoryr6 __post_init__) r.argsr:standard_kwargsr>additional_kwargsr/r0rCrs @r#__init__z&strict..wrap..__init__s$A#@F3KK#@#@#@ "\"\"\"\FLLNN"\"\"\ t99q==$DclDD&)$iiDDD  PPAv00afoaf.EFFFF'11afai8888*'99afa.?.?.A.ABBBB'(NQV(N(N(NOOO%'!#)<<>>88KD%#33327)$/""77%677777r%rLc\|D]\}}t|||dS)z2Default __post_init__ to accept additional kwargs.N)rFrI)r.r:r/r0s r#rLz+strict..wrap..__post_init__s<'-||~~33 edE222233r%c|}fd|jD}d|}|r|ddd|dn|S)Nc8g|]\}}|jvd|d|S)*=)r+)r=rArBrs r# z:strict..wrap..__repr__..sC%%%1 888"MMAMM888r%z, ))__dict__rFjoin)r. standard_reprrOadditional_reprr original_reprs r#__repr__z&strict..wrap..__repr__s!. d 3 3 %%%%!% 3 3 5 5%%%! #')),=">">GXj-,BBBBBB]jjr%T validate_rz' has a class validator 'z' that takes more than one argument. Class validators must take only 'self' as an argument. Methods starting with 'validate_' are considered to be class validators.cjD]>} ||#ttf$r}t|j||d}~wwxYwdS)z%Run class validators on the instance.)r,r2N)__class_validators__r5r6rrH)r.r,r7rs r#validatez&strict..wrap..validatesz 5 l l lIdOOOO"I.lll= HZbcdddjkkl l ls AAArb"__is_defined_by_strict_decorator__Fz' already implements a method called 'validate'. This method name is reserved when using the @strict decorator on a dataclass. If you want to keep your own method, please rename it.cJ|g|Ri||dS)z*Run class validators after initialization.N)rb)r.rMr:r initial_inits r#init_with_validatez0strict..wrap..init_with_validates= L / / / / / / / LL     r%rP)r N)$hasattrrrHrappend_create_type_validatormetadatar4 isinstancelist _is_validatorr/extendr3 __setattr__r strrPr rLr^__dataclass_params__reprdir startswithgetattrcallablerGinspect signature parametersrarrcrbrI)rfield_validatorsr> validatorscustom_validatorr,r9 original_initrPrLr^class_validatorsr/methodrbrfrer]r8r's` @@@r#wrapzstrict..wrappsSs233 0V#,VVV  :< 2 2AJ   4Q77 8 8 8 z~~k:: +!"2D99:(8'9$!1I(33<AAFAAyAAA!!"2333'1 QV $ $-? 0S 0 0C 0D 0 0 0 0 0 0- H (LM = ! ! 8 8 8 8 8 8 8" ! 8D$CL300 23#3$3333 %2! LM = ! ! k# k k k k k k" ! k ',44' HH , ,D??;// S$''FF## 7$V,,788A==4>cl>>T>>>  # #F + + + +#3  l1 l l l l l l l7;3 3 # # 3<)MuUU 4NclNNN   | |            Z!3444 r%)rr)rr'rs ` r#r$r$8sYph$q'hd1ghhhhhhV44999T1r%schemadatac4t|}|di|dS)a Validate that a dictionary conforms to the types defined in a TypedDict class. Under the hood, the typed dict is converted to a strict dataclass and validated using the `@strict` decorator. Args: schema (`type[TypedDictType]`): The TypedDict class defining the expected structure and types. data (`dict`): The dictionary to validate. Raises: `StrictDataclassFieldValidationError`: If any field in the dictionary does not conform to the expected type. Example: ```py >>> from typing import Annotated, TypedDict >>> from huggingface_hub.dataclasses import validate_typed_dict >>> def positive_int(value: int): ... if not value >= 0: ... raise ValueError(f"Value must be positive, got {value}") >>> class User(TypedDict): ... name: str ... age: Annotated[int, positive_int] >>> # Valid data >>> validate_typed_dict(User, {"name": "John", "age": 30}) >>> # Invalid type for age >>> validate_typed_dict(User, {"name": "John", "age": "30"}) huggingface_hub.errors.StrictDataclassFieldValidationError: Validation error for field 'age': TypeError: Field 'age' expected int, got str (value: '30') >>> # Invalid value for age >>> validate_typed_dict(User, {"name": "John", "age": -1}) huggingface_hub.errors.StrictDataclassFieldValidationError: Validation error for field 'age': ValueError: Value must be positive, got -1 ``` Nr)!_build_strict_cls_from_typed_dict)rr strict_clss r#validate_typed_dictrs0X36::JJr%c t|}t|dds|D]\}}t|}|tur\t |^}}t |s t|}tt|gt|z||<yt |st|||<g}|D]\}}t|turAt |^}}|j ||ttd|dif\|j ||ttftt|j|S)N __total__Tr,r)rJrj)rJ)_get_typed_dict_annotationsrurFrr r_is_required_or_notrequiredrtuplerlrhr_TYPED_DICT_DEFAULT_VALUEr$rrH)r type_hintskeyr0originbasemetars r#rrPs-V44J 6; - - 5$**,, 5 5JC&&F""&uoo t2488-&t,D"+E4&4::2E,F,F"G 3077 5"-e"4 3F &&((RR U e   ) )"5//KD4 FM3e4MYdfjklfmXn&o&o&op q q q q FM3u5N'O'O'OP Q Q Q Q .&99 : ::r%c ddl}||S#t$r:d|jdiDcYSwxYw)z0Extract type annotations from a TypedDict class.rNc<i|]\}}|||ntdSr")type)r=r/r0s r#rDz/_get_typed_dict_annotations..ws?   e 5,%%$t**   r%__annotations__) annotationlibget_annotations ImportErrorrYr4rF)rrs r#rros  ,,V444       &223DbIIOOQQ        sAAATr,rJrKinitrrhashcomparerjr:c lt|ts|g}|i}||d<td|||||||d|S)a< Create a dataclass field with a custom validator. Useful to apply several checks to a field. If only applying one rule, check out the [`as_validated_field`] decorator. Args: validator (`Callable` or `list[Callable]`): A method that takes a value as input and raises ValueError/TypeError if the value is invalid. Can be a list of validators to apply multiple checks. **kwargs: Additional arguments to pass to `dataclasses.field()`. Returns: A field with the validator attached in metadata Nr,rJrKrrrrrrjr)rkrlr) r,rJrKrrrrrrjr:s r#validated_fieldrsm4 i & & K %H[  '         r%cttdddddfdtdtdtdtdtdzdtd tdzd tffd }|S) a Decorates a validator function as a [`validated_field`] (i.e. a dataclass field with a custom validator). Args: validator (`Callable`): A method that takes a value as input and raises ValueError/TypeError if the value is invalid. TNrJrKrrrrrrjr:c .tf|||||||d|S)Nr)r) rJrKrrrrrrjr:r,s r#_innerz"as_validated_field.._innersC   +      r%)rr booldict)r,rs` r#as_validated_fieldrs&  $       Tk    +       , Mr%r/r0 expected_typeczt|}t|}|turdS|t||dSt|x}r||||dSt |trt|||dSt |tst |trdS|tur5|turtd|dt|||ddS|tur$|turdSt|||ddStd|d|)z.Validate that 'value' matches 'expected_type'.NField 'z' is required but missing.rzUnsupported type for field 'r-)rrr _validate_none_BASIC_TYPE_VALIDATORSr4rkr_validate_simple_typer rprrr6type_validatorr)r/r0rrrMr,s r#rrsw  & &F M " "D  tU#####,0088 8Q $t$$$$$ M4 ( ( QdE=99999 M: . . Q*]C2P2P Q 8   - - -FdFFFGG GtUDG,,,,, ;   - - - FtUDG,,,,,OtOO OOPPPr%cX|'td|dt|jdS)zValidate None type. 'None' is not a type, it's a special value. Type should be `NoneType` instead. But in type annotations 'None' is accepted so we must support it. Nrz' expected None, got )r6rrH)r/r0s r#rrs:  S$SST%[[=QSSTTTr%rM.c  g}|D]O} t|||dS#t$r,}|t|Yd}~Hd}~wwxYwtd|dt |d|dd|)z8Validate that value matches one of the types in a Union.Nrz ' with value z doesn't match any type in z . Errors: z; )rr6rhrprrrZ)r/r0rMerrorstr7s r#_validate_unionrs F "" " 4 * * * FF " " " MM#a&& ! ! ! ! ! ! ! ! " p$ppT%[[ppTpp]a]f]fgm]n]npp  s A"A  Ac2t|tr(|d|Dvrtd|d|d|dSt|tr(|d|Dvrtd|d|d|dS||vrtd|d|d|dS)zValidate Literal type.c<g|]}t|t|Sr)rkrr=args r#rVz%_validate_literal..s'FFF 30E0EFFFFr%rz' expected one of , got cfg|].}t|tt|t,|/Sr)rkintrrs r#rVz%_validate_literal..s8ccc 30D0DcZX[]aMbMbccccr%N)rkrr6r)r/r0rMs r#_validate_literalrs%O FFFFF F FQdQQdQQ%QQRR R G F E3  O ccccc c cQdQQdQQ%QQRR R d c d  M$MM$MMeMMNNN  r%c :t|ts'td|dt|j|d}t |D]F\}} t |d|d||#t$r}td|d|d|d }~wwxYwd S) zValidate list[T] type.rz' expected a list, got r[]Invalid item at index z in list 'rEN)rkrlr6rrH enumeraterr/r0rM item_typeiitemr7s r#_validate_listr s eT " "WU$UUtE{{?SUUVVVQIU##RR4 R d>>Q>>>4 ; ; ; ; R R RIQII$IIIJJPQ Q RRRsA22 B<BBc`t|ts'td|dt|j|\}}|D]W\}} t |d||t |d|d||2#t$r}td|d|d}~wwxYwdS) zValidate dict[K, V] type.rz' expected a dict, got z.keyrrzInvalid key or value in dict 'rEN)rkrr6rrHrFr)r/r0rMkey_type value_typerArBr7s r#_validate_dictrs eT " "WU$UUtE{{?SUUVVV Hj MM1 M d===!X 6 6 6 d++Q+++Q ; ; ; ; M M MDTDDDEE1 L M MMs+B B+B&&B+c t|ts'td|dt|jt |dkrm|dt ur^t|D]L\}} t|d|d||d$#t$r}td|d |d |d }~wwxYwd St |t |kr2td|d t |d t |tt||D]I\}\}} t|d|d||!#t$r}td|d |d |d }~wwxYwd S)zValidate Tuple type.rz' expected a tuple, got rrrrrz in tuple 'rENz' expected a tuple of length r) rkrr6rrHrGEllipsisrrzip)r/r0rMrrr7expecteds r#_validate_tupler)s eU # #XV$VVU @TVVWWW 4yyA~~$q'X-- '' W WGAt W$~~~~~tT!W==== W W W N N Nt N N NOOUVV W W W Tc%jj b$bbSYYbbVYZ_V`V`bbccc#,S-=-=#>#> W W Ah W$~~~~~tX>>>> W W W N N Nt N N NOOUVV W W Ws04B B8B33B85E  E3E..E3c.t|ts'td|dt|j|d}t |D]@\}} t |d||#t$r}td|d|d}~wwxYwdS)zValidate set[T] type.rz' expected a set, got rz itemzInvalid item in set 'rEN)rksetr6rrHrrrs r# _validate_setr@s eS ! !VT$TTd5kk>RTTUUUQIU##DD4 D d>>>4 ; ; ; ; D D D;D;;;<>Q>>>4 ; ; ; ; V V VMQMMdMMMNNTU U VVVs(B B& B!!B&c b|turUt|tr@td|d|jdt |jdt |d t||s@td|d|jdt |jdt |d dS)z&Validate simple type (int, str, etc.).rz ' expected rz (value: rXN)rrkrr6rHrrr)r/r0rs r#rr`s 5$ 7 7 rd r r}'= r rT%[[EY r rdhindodo r r r    e] + +  rd r r}'= r rT%[[EY r rdhindodo r r r     r%rc&dtddffd }|S)z-Create a type validator function for a field.r0r Nc>tj|jdSr")rr/r)r0rs r#r,z)_create_type_validator..validatorpsuz5%*55555r%)r )rr,s` r#ririls766666666 r%ct|sdStj|}t|j}t |dkrdS|djtjj tjj tjj fvrdS|ddD]}|j tjj krdS dS)zCheck if a function is a validator. A validator is a Callable that can be called with a single positional argument. The validator can have more arguments with default values. Basically, returns True if `validator(value)` is possible. FrrNT)rvrwrxrlryvaluesrGkind ParameterPOSITIONAL_OR_KEYWORDPOSITIONAL_ONLYVAR_POSITIONALrJempty)r,rxry parameters r#rmrmvs I  u!),,Ii*113344J :!u!}/)(" u^   1 7 7 755 8 4r% type_hintc\|ttfvpt|ttfvS)z2Helper to check if a type is Required/NotRequired.)rrr)rs r#rrs* ;/ / eJy4I4IhXcMd4der%r)r$rr Validator_Trrrr")Fcollections.abcrrwtypesr dataclassesrrrrr functoolsr r typingr r r rrrrrrrrrrtyping_extensionsrrrrrrrrrprobjectrr$rrrrrlrrrrrrrrrrrrrrirmrrrrrr UnionType__all__rr%r#rs $$$$$$EEEEEEEEEEEEEE&&&&&&&&                         2,,,,,,,,,2222;;;;;;;;; 2224 B++d="b11 2 2ud{#  GCLLtCH~>>> "FHH (Q(DG((( ( $)OOOTOhQy$q'7I.JOOO Oc2c2c2c2Q$c2c2$q'T\^bcd^e]fhlmnho]oTpJpc2c2c2c2L/] 3/4/D////d ;d=.A;d;;; ;<  ](;  S#X     $" ((K ;.( ((  (  ( + ((Tk(( ((((V+DQQSQQQQQQ6UUSUTUUUU # c sCx T     OC O O5c? Ot O O O O R RS Rc3h RD R R R R M MS Mc3h MD M M M MW#WcWsCxWTWWWW. D DC DuS#X D4 D D D DVSVVE#s(OVVVVV$    C         %KST6f3f4ffff  ? .. ?O0RS(CeCHo+F+L"MMN+:u'   s6A BABA=:B<A==BB