o 0je@sNUddlZddlZddlZddlmZddlmZmZmZm Z m Z m Z ddl m Z mZddlmZmZmZmZmZmZmZmZmZmZz ddlmZmZWn)eyvz ddlmZmZWneyseddiZed diZYnwYnwd d lm Z m!Z!m"Z"eegdfZ#ed Z$ed e%e&efdZ'e(Z)edee$dee$fddZ*eddde+deee$gee$ffddZ*dQdddee$dBde+dee$eee$gee$fBfddZ*dee'de%ddfddZ,e dee'defddZ-dee'de%e&effddZ.eed d dd dfd!e/e#e#Bd"eeBd#egefeBd$e+d%e+d&e+dBd'e+d(e%dBd)edefd*d+Z0d!e#fd,d-Z1d.e&d/ed0eddfd1d2Z2d.e&d/eddfd3d4Z3d.e&d/ed5e4ed6fddfd7d8Z5d.e&d/ed5e4ed6fddfd9d:Z6d.e&d/ed5e4ed6fddfd;d<Z7d.e&d/ed5e4ed6fddfd=d>Z8d.e&d/ed5e4ed6fddfd?d@Z9d.e&d/ed5e4ed6fddfdAdBZ:d.e&d/ed5e4ed6fddfdCdDZ;d.e&d/ed0eddfdEdFZdLede+fdMdNZ?ee5ee6e/e7e%e8e4e9e@e:ejAjBe;iZCe%eee&ee4ed6fgdffeDdO<e5eCejE<gdPZFdS)RN)Callable) _MISSING_TYPEMISSINGFieldfieldfieldsmake_dataclass) lru_cachewraps) AnnotatedAny ForwardRefLiteralTypeTypeVarUnionget_args get_originoverload) NotRequiredRequiredrr)#StrictDataclassClassValidationErrorStrictDataclassDefinitionError#StrictDataclassFieldValidationErrorT TypedDictType)boundclsreturncCdSNrrrr\/var/www/html/Deteccion_Ine/venv/lib/python3.10/site-packages/huggingface_hub/dataclasses.pystrict0r%F accept_kwargsr(cCr!r"rr'rrr$r%4r&cs2dttdttffdd }|dur||S|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 csBtdstdjdi}tD]<}g}|t||jd}|durKt|t s1|g}|D]}t |sEtd|j d|dq3| ||||j <q|_ jdtd td td dffd d }|_rj}t|dtd dffdd }|_tdsdtd dfdd} | _jtd tffdd } jjdur| _g} tD]-} | dsqt| } t| sqtt| jdkrtdjd| d| | q| _dt d dffdd }d|_!tdrtj"ddstdjd |_"jtd$fd!d" }t#d#|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 sZ|j|gD]}z||Wqttfy$}zt||d|d}~ww|||dS)z1Custom __setattr__ method for strict dataclasses.)rcauseN)__validators__get ValueError TypeErrorr)r,r-r.r*e)original_setattrrr$__strict_setattr__s z0strict..wrap..__strict_setattr__kwargscsddtDfdd|D}t|dkr(tdjdt|dtD]7}|j|vr>t||j||jq,|jturLt||j|jq,|j tur[t||j| q,t d |jd i}|D] \}}|vrv|||<qj|j d i|dS) NcSsh|]}|jqSr)r-).0frrr$ sz9strict..wrap..__init__..csi|] \}}|vr||qSrrr8kvZdataclass_fieldsrr$ sz:strict..wrap..__init__..rzWhen `accept_kwargs=True`, z, accepts only keyword arguments, but found `z` positional args.zMissing required field - ''r) ritemslenr2__name__r-setattrdefaultrdefault_factoryr3 __post_init__)r,argsr7Zstandard_kwargsr9additional_kwargsr-r.r#r>r$__init__s,      z&strict..wrap..__init__rGc[s"|D] \}}t|||qdS)z2Default __post_init__ to accept additional kwargs.N)rArD)r,r7r-r.rrr$rGsz+strict..wrap..__post_init__csJ|}fdd|jD}d|}|r#|ddd|dS|S)Ncs*g|]\}}|jvrd|d|qS)*=)r)r;r#rr$ s  z:strict..wrap..__repr__..z, ))__dict__rAjoin)r,Z standard_reprrIZadditional_repr)r original_reprrr$__repr__s    z&strict..wrap..__repr__TZ 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.c sHjD]}z||Wqttfy!}zt|j|d|d}~wwdS)z%Run class validators on the instance.)r*r/N)__class_validators__r2r3rrC)r,r*r4r#rr$validates  z&strict..wrap..validaterU"__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.cs$|g|Ri||dS)z*Run class validators after initialization.N)rU)r,rHr7)r initial_initrr$init_with_validatesz0strict..wrap..init_with_validaterJ)r N)$hasattrrrCrappend_create_type_validatormetadatar1 isinstancelist _is_validatorr-extendr0 __setattr__r strrJr rGrS__dataclass_params__reprdir startswithgetattrcallablerBinspect signature parametersrTrrVrUrD)rZfield_validatorsr9Z validatorsZcustom_validatorr*r6Z original_initrJrGrSZclass_validatorsr-methodrUrXr')rrWrRr5r$wrapps~        "         zstrict..wrapN)rr)rr(rmrr'r$r%8s8,schemadatacCst|}|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)rnroZ strict_clsrrr$validate_typed_dicts,rqc Cst|}t|ddsA|D]2\}}t|}|tur6t|^}}t|s(t|}tt|gt |||<qt|s@t|||<qg}|D],\}}t|turht|^}}| ||t t d|didfqG| ||t t dfqGt t|j|S)N __total__Tr*r)rEr\)rE)_get_typed_dict_annotationsrgrArr r_is_required_or_notrequiredrtupler^rZr_TYPED_DICT_DEFAULT_VALUEr%rrC)rnZ type_hintskeyr.originbasemetarrrr$rpPs&     "rpcCsDz ddl}||WSty!dd|jdiDYSw)z0Extract type annotations from a TypedDict class.rNcSs&i|]\}}||dur |ntdqSr")type)r8r-r.rrr$r?wsz/_get_typed_dict_annotations..__annotations__) annotationlibget_annotations ImportErrorrPr1rA)rnr}rrr$rsos   rsTr*rErFinitrdhashcomparer\r7c KsBt|ts|g}|duri}||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*rErFrrdrrr\r)r]r^r) r*rErFrrdrrr\r7rrr$validated_fields rcsZttdddddfdttBdtgtftBdtdtdtdBdtd tdBd tffd d }|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. TNrErFrrdrrr\r7c s tf|||||||d|S)Nr)r)rErFrrdrrr\r7r*rr$_inners  z"as_validated_field.._inner)rr rrbooldict)r*rrrr$as_validated_fields2 rr-r. expected_typecCst|}t|}|turdS|durt||dSt|}r(||||dSt|tr5t|||dSt|t s?t|t rAdS|t ur[|t urQt d|dt|||ddS|turo|t uredSt|||ddSt d|d|)z.Validate that 'value' matches 'expected_type'.NField 'z' is required but missing.rzUnsupported type for field 'r+)rrr _validate_none_BASIC_TYPE_VALIDATORSr1r]r{_validate_simple_typer rbrrvr3type_validatorr)r-r.rrxrHr*rrr$rs* rcCs&|durtd|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 )r3r{rC)r-r.rrr$rsrrH.c Cs~g}|D]%}z t|||WdSty)}z |t|WYd}~qd}~wwtd|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; )rr3rZrbrdrQ)r-r.rHerrorstr4rrr$_validate_unions $rcCst|tr|dd|Dvrtd|d|d|dSt|tr:|dd|Dvr8td|d|d|dS||vrKtd|d|d|dS)zValidate Literal type.cSsg|] }t|tr|qSr)r]rr8argrrr$rMsz%_validate_literal..rz' expected one of , got cSs$g|]}t|trt|ts|qSr)r]intrrrrr$rMs$N)r]rr3r)r-r.rHrrr$_validate_literals  rc Cst|tstd|dt|j|d}t|D]*\}}zt|d|d||WqtyD}z td|d|d|d }~wwd S) zValidate list[T] type.rz' expected a list, got r[]Invalid item at index z in list 'r@N)r]r^r3r{rC enumeraterr-r.rHZ item_typeiitemr4rrr$_validate_list s rc Cst|tstd|dt|j|\}}|D]0\}}zt|d||t|d|d||WqtyJ}z td|d|d}~wwdS) zValidate dict[K, V] type.rz' expected a dict, got z.keyrrzInvalid key or value in dict 'r@N)r]rr3r{rCrAr)r-r.rHZkey_typeZ value_typer<r=r4rrr$_validate_dicts rc Cs@t|tstd|dt|jt|dkrQ|dturQt|D],\}}zt|d|d||dWq"tyN}z td|d |d |d }~wwd St|t|krjtd|d t|d t|tt ||D],\}\}}zt|d|d||Wqqty}z td|d |d |d }~wwd S)zValidate Tuple type.rz' expected a tuple, got rrrrrz in tuple 'r@Nz' expected a tuple of length r) r]rur3r{rCrBEllipsisrrzip)r-r.rHrrr4expectedrrr$_validate_tuple)s*  "rc Cst|tstd|dt|j|d}t|D]$\}}z t|d||Wqty>}z td|d|d}~wwdS)zValidate set[T] type.rz' expected a set, got rz itemzInvalid item in set 'r@N)r]setr3r{rCrrrrrr$ _validate_set@s rc Cst|tjjstd|dt|j|sdS|d}t|D]*\}}zt|d|d||Wq tyJ}z td|d|d |d}~wwdS) z&Validate Sequence or Sequence[T] type.rz' expected a Sequence, got Nrrrrz in sequence 'r@) r] collectionsabcSequencer3r{rCrrrrrr$_validate_sequenceNsrc Cs||tur t|tr td|d|jdt|jdt|d t||s.validator)r )rr*rrr$r[lsr[cCst|sdSt|}t|j}t|dkrdS|djtjj tjj tjj fvr,dS|ddD] }|j tjj kr>dSq2dS)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)rhrirjr^rkvaluesrBkind ParameterPOSITIONAL_OR_KEYWORDPOSITIONAL_ONLYVAR_POSITIONALrEempty)r*rjrkZ parameterrrr$r_vs"  r_ type_hintcCs|ttfvp t|ttfvS)z2Helper to check if a type is Required/NotRequired.)rrr)rrrr$rtsrtr)r%rqr Validator_Trrrr")Gcollections.abcrritypesr dataclassesrrrrrr functoolsr r typingr r r rrrrrrrrrrZtyping_extensionsr{rrrrrrrrbrobjectrvr%rrqrprsr^rrrrrurrrrrrrrr[r_rtrrrrr| UnionType__all__rrrr$s   0    ,@g2   +"" "" """"  *