o 0iUb@sZUddlZddlZddlZddlZddlmZmZmZm Z m Z m Z ddl m Z mZddlmZmZmZmZmZmZmZmZmZmZmZmZz ddlmZmZWn)eyxz ddlmZmZWneyue ddiZe ddiZYnwYnwd d l!m"Z"m#Z#m$Z$eegdfZ%ed Z&ed e'e(efd Z)e*Z+edee&dee&fddZ,eddde-deee&gee&ffddZ, dOdddeee&de-deee&eee&gee&fffddZ,de e)de'ddfddZ.e de e)defddZ/de e)de'e(effddZ0eedddddfd ee1e%e%fd!eeefd"eegefefd#e-d$e-d%ee-d&e-d'ee'd(edefd)d*Z2d e%fd+d,Z3d-e(d.ed/eddfd0d1Z4d-e(d.ed2e5ed3fddfd4d5Z6d-e(d.ed2e5ed3fddfd6d7Z7d-e(d.ed2e5ed3fddfd8d9Z8d-e(d.ed2e5ed3fddfd:d;Z9d-e(d.ed2e5ed3fddfdd?Z;d-e(d.ed2e5ed3fddfd@dAZd ede-fdGdHZ?dIede-fdJdKZ@ee6ee7e1e8e'e9e5e:eAe;ejBjCe>> 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!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||qSrrr9kvZdataclass_fieldsrr% sz:strict..wrap..__init__..rzWhen `accept_kwargs=True`, z, accepts only keyword arguments, but found `z` positional args.zMissing required field - ''r) ritemslenr3__name__r.setattrdefaultrdefault_factoryr4 __post_init__)r-argsr8Zstandard_kwargsr:additional_kwargsr.r/r$r?r%__init__s,      z&strict..wrap..__init__rHc[s"|D] \}}t|||qdS)z2Default __post_init__ to accept additional kwargs.N)rBrE)r-r8r.r/rrr%rHsz+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__rBjoin)r-Z standard_reprrJZadditional_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+r0N)__class_validators__r3r4rrD)r-r+r5r$rr%validates  z&strict..wrap..validaterV"__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)rV)r-rIr8)r initial_initrr%init_with_validatesz0strict..wrap..init_with_validaterK)r!N)$hasattrrrDrappend_create_type_validatormetadatar2 isinstancelist _is_validatorr.extendr1 __setattr__r strrKr rHrT__dataclass_params__reprdir startswithgetattrcallablerCinspect signature parametersrUrrWrVrE)r Zfield_validatorsr: validatorsZcustom_validatorr+r7Z original_initrKrHrTZclass_validatorsr.methodrVrYr()r rXrSr6r%wrapts~        "         zstrict..wrapN)rr)r r)rorr(r%r&:s:,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)rprqZ strict_clsrrr%validate_typed_dict"s,rsc 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)rFr])rF)_get_typed_dict_annotationsrhrBrr r_is_required_or_notrequiredrtupler_r[r_TYPED_DICT_DEFAULT_VALUEr&rrD)rpZ type_hintskeyr/originbasemetarrrr%rrTs&     "rrcCsDz ddl}||WSty!dd|jdiDYSw)z0Extract type annotations from a TypedDict class.rNcSs&i|]\}}||dur |ntdqSr#)type)r9r.r/rrr%r@{sz/_get_typed_dict_annotations..__annotations__) annotationlibget_annotations ImportErrorrQr2rB)rprrrr%russ   ruTr+rFrGinitrehashcomparer]r8c 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+rFrGrrerrr]r)r^r_r) r+rFrGrrerrr]r8rrr%validated_fields rcsbttdddddfdtttfdttgtftfdtdtdttdtd ttd 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. TNrFrGrrerrr]r8c s tf|||||||d|S)Nr)r)rFrGrrerrr]r8r+rr%_inners  z"as_validated_field.._inner)rrr rr boolrdict)r+rrrr%as_validated_fields2  rr.r/ expected_typecCst|}t|}|turdSt|}r||||dSt|tr*t|||dSt|ts4t|t r6dS|t urP|t urFt d|dt |||ddS|turd|t urZdSt |||ddSt d|d|)z.Validate that 'value' matches 'expected_type'.NField 'z' is required but missing.rzUnsupported type for field 'r,)rrr _BASIC_TYPE_VALIDATORSr2r^r}_validate_simple_typer rcrrxr4type_validatorr)r.r/rrzrIr+rrr%rs& rrI.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; )rr4r[rcrerR)r.r/rIerrorstr5rrr%_validate_unions $rcCs&||vrtd|d|d|dS)zValidate Literal type.rz' expected one of , got N)r4)r.r/rIrrr%_validate_literalsrc 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 'rAN)r^r_r4r}rD enumeraterr.r/rIZ item_typeiitemr5rrr%_validate_lists 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 'rAN)r^rr4r}rDrBr)r.r/rIZkey_type value_typer=r>r5rrr%_validate_dict s 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 'rANz' expected a tuple of length r) r^rwr4r}rDrCEllipsisrrzip)r.r/rIrrr5expectedrrr%_validate_tuples*  "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 'rAN)r^setr4r}rDrrrrrr% _validate_set2s 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 'rA) r^ collectionsabcSequencer4r}rDrrrrrr%_validate_sequence@src Cs<t||std|d|jdt|jdt|d dS)z&Validate simple type (int, str, etc.).rz ' expected rz (value: rPN)r^r4rDr}re)r.r/rrrr%rRs (rrcsdtddffdd }|S)z-Create a type validator function for a field.r/r!Ncstj|jdSr#)rr.r})r/rrr%r+^sz)_create_type_validator..validator)r )rr+rrr%r\Zsr\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)rirjrkr_rlvaluesrCkind ParameterPOSITIONAL_OR_KEYWORDPOSITIONAL_ONLYVAR_POSITIONALrFempty)r+rkrlZ parameterrrr%r`ds"  r` type_hintcCs|ttfvp t|ttfvS)z2Helper to check if a type is Required/NotRequired.)rrr)rrrr%rvsrvr) )r&rsr Validator_Trrrr#)Icollections.abcrrjsystypes dataclassesrrrrrr functoolsrr typingr r r r rrrrrrrrrrrZtyping_extensionsr}rrrrrrrrcrobjectrxr&rrsrrrur_rrrrwrrrrrrrrr\r`rvrrrrr~ version_info UnionType__all__rrrr%s  8    ,   i2   +"""""""" *