o i6WddlZddlmZmZmZmZmZmZddlm Z m Z ddl m Z m Z mZmZmZmZmZmZmZmZmZmZ ddl mZmZn:#e$r2 ddlmZmZn%#e$reddiZeddiZYnwxYwYnwxYwd d lmZmZm Z ee gdfZ!ed Z"ed e#e$e f Z%e&Z'edee"dee"fdZ(eddde)deee"gee"ffdZ( d:dddeee"de)deee"eee"gee"fffdZ(dee%de#ddfdZ*e dee%defdZ+dee%de#e$e ffdZ,eedddddfdee-e!e!fdee efdeege fefde)d e)d!ee)d"e)d#ee#d$e de fd%Z.de!fd&Z/d'e$d(e d)e ddfd*Z0d'e$d(e d+e1e d,fddfd-Z2d'e$d(e d+e1e d,fddfd.Z3d'e$d(e d+e1e d,fddfd/Z4d'e$d(e d+e1e d,fddfd0Z5d'e$d(e d+e1e d,fddfd1Z6d'e$d(e d+e1e d,fddfd2Z7d'e$d(e d)eddfd3Z8d4ede!fd5Z9de de)fd6Z:d7e de)fd8Z;ee2ee3e-e4e#e5e1e6edS);N) _MISSING_TYPEMISSINGFieldfieldfieldsmake_dataclass) lru_cachewraps) AnnotatedAnyCallable ForwardRefLiteralOptionalTypeTypeVarUnionget_args get_originoverload) NotRequiredRequiredrr)#StrictDataclassClassValidationErrorStrictDataclassDefinitionError#StrictDataclassFieldValidationErrorT TypedDictType)boundclsreturncdSNr)r!s [/var/www/html/auto_sub_bot/venv/lib/python3.11/site-packages/huggingface_hub/dataclasses.pystrictr&/s%(SF accept_kwargsr)cdSr$rr(s r%r&r&3sLOCr'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 ``` r!r"c ztdstdjdi}tD]}g}|t ||jd}|\t|ts|g}|D],}t|std|j d|d-| ||||j <|_ jdtd t d td dffd }|_rdjt%d td dffd }|_jt%d t ffd }|_g} t)D]} | dst-| } t/| s8t1t3j| jdkrtdjd| d| | | _dt:d dffd } d| _tdr.t-jddstdjd| _jt%dfd } tAd| 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)r0r1r2r.eoriginal_setattrs r%__strict_setattr__z0strict..wrap..__strict_setattr__s"044T2>> Z Z ZIe$$$$"I.ZZZ=DPQRRRXYYZ  T4 / / / / /s ,AAAkwargscdtDfd|D}|fi||D]\}}|vr||| dS)Nch|] }|j Sr)r1).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')ritems __setattr__)r0r<standard_kwargsr1r2rEr! original_inits @r%__init__z&strict..wrap..__init__s$A#@F3KK#@#@#@ "\"\"\"\FLLNN"\"\"\ d66o666$*<<>>66KD%#333((u55566r'c|}fd|jD}d|}|r|ddd|dn|S)Nc8g|]\}}|jvd|d|S)*=)r-)r?rCrDr!s r% z:strict..wrap..__repr__..sC%%%1 888"MMAMM888r'z, ))__dict__rGjoin)r0 standard_repradditional_kwargsadditional_reprr! original_reprs r%__repr__z&strict..wrap..__repr__s!. d 3 3 %%%%!% 3 3 5 5%%%! #')),=">">GXj-,BBBBBB]jjr' 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.r4N)__class_validators__r7r8r__name__)r0r.r9r!s r%validatez&strict..wrap..validatesz 5 l l lIdOOOO"I.lll= HZbcdddjkkl l ls AAATr^"__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)r^)r0argsr<r! initial_inits r%init_with_validatez0strict..wrap..init_with_validates= L / / / / / / / LL     r'rK)r"N)!hasattrrr]rappend_create_type_validatormetadatar6 isinstancelist _is_validatorr1extendr5rHr strrKr rYdir startswithgetattrcallableleninspect signature parametersr\rr_r^setattr)r!field_validatorsr@ validatorscustom_validatorr.r;rKrYclass_validatorsr1methodr^rcrbrJrXr:r)s` @@@@r%wrapzstrict..wrapqss233 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- ( $LM = ! ! 6 6 6 6 6 6 6 6" ! 6$CL LM = ! ! k# k k k k k k" ! k $CLHH , ,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)r!r)r{s ` r%r&r&7sYtH$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)r|r} 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)defaultrg)r)_get_typed_dict_annotationsrorGrr r_is_required_or_notrequiredrtuplerirer_TYPED_DICT_DEFAULT_VALUEr&rr])r| type_hintskeyr2originbasemetars r%rr1s-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?r1r2s r%rFz/_get_typed_dict_annotations..Xs?   e 5,%%$t**   r'__annotations__) annotationlibget_annotations ImportErrorrSr6rG)r|rs r%rrPs  ,,V444       &223DbIIOOQQ        sAAATr.rdefault_factoryinitreprhashcomparergr<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.rrrrrrrgr)rhrir) r.rrrrrrrgr<s r%validated_fieldr`sm4 i & & K %H[  '         r'c6ttdddddfdtttfdttgtftfdt dt dt t dt d t td 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. TNrrrrrrrgr<c .tf|||||||d|S)Nr)r) rrrrrrrgr<r.s r%_innerz"as_validated_field.._innersC   +      r')rrr rr boolrdict)r.rs` r%as_validated_fieldrs.5CJ##'  sM)* xC0-?@    tn    4.       , Mr'r1r2 expected_typecRt|}t|}|turdSt|x}r||||dSt |t rt|||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 _BASIC_TYPE_VALIDATORSr6rhr_validate_simple_typerrlrrr8type_validatorr)r1r2rrrar.s r%rrs[  & &F M " "D,0088 8Q $t$$$$$ M4 ( ( QdE=99999 M: . . Q*]C2P2P Q 8   - - -FdFFFGG GtUDG,,,,, ;   - - - FtUDG,,,,,OtOO OOPPPr'ra.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; )rr8rerlrrT)r1r2raerrorstr9s r%_validate_unionrs F "" " 4 * * * FF " " " MM#a&& ! ! ! ! ! ! ! ! " p$ppT%[[ppTpp]a]f]fgm]n]npp  s A"A  Ac>||vrtd|d|d|dS)zValidate Literal type.rz' expected one of , got N)r8)r1r2ras r%_validate_literalrs< DM$MM$MMeMMNNNr'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 ''N)rhrir8rr] enumeraterr1r2ra item_typeiitemr9s r%_validate_listrs 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 'rN)rhrr8rr]rGr)r1r2rakey_type value_typerCrDr9s 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 'rNz' expected a tuple of length r) rhrr8rr]rqEllipsisrrzip)r1r2rarrr9expecteds r%_validate_tuplers 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 'rN)rhsetr8rr]rrrs r% _validate_setrs eS ! !VT$TTd5kk>RTTUUUQIU##DD4 D d>>>4 ; ; ; ; D D D;D;;;<tj|jdSr$)rr1r)r2rs r%r.z)_create_type_validator..validator)suz5%*55555r')r )rr.s` r%rfrf%s766666666 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)rprrrsrirtvaluesrqkind ParameterPOSITIONAL_OR_KEYWORDPOSITIONAL_ONLYVAR_POSITIONALrempty)r.rsrt parameters r%rjrj/s 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%rrJs* ;/ / eJy4I4IhXcMd4der')r&rr Validator_Trrrr$)?rr dataclassesrrrrrr functoolsr r typingr r r rrrrrrrrrrrrtyping_extensionsrrrrrrrrrlrobjectrr&rrrrrirrrrrrrrrrrrfrjrrr__all__rr'r%rsTTTTTTTTTTTTTTTT&&&&&&&&                             2,,,,,,,,,2222;;;;;;;;; 2224 B++d="b11 2 2ud{#  GCLLtCH~>>> "FHH (Q(DG((( ( $)OOOTOhQy$q'7I.JOOO O"E2