o RhHC@sddlZddlmZmZmZmZmZddlmZddl m Z m Z m Z m Z mZmZmZmZmZmZmZmZmZddlmZmZmZe e gdfZedZedeed eefd d Zed d ded e eegeeffdd Z d:d d deeeded eeee eegeefffdd Zeedddddfdee eefdee efdee ge fefdededeededee de d e fddZdefddZ de!d e d!e d dfd"d#Z"de!d e d$ee d%fd dfd&d'Z#de!d e d$ee d%fd dfd(d)Z$de!d e d$ee d%fd dfd*d+Z%de!d e d$ee d%fd dfd,d-Z&de!d e d$ee d%fd dfd.d/Z'de!d e d$ee d%fd dfd0d1Z(de!d e d!e)d dfd2d3Z*d4ed efd5d6Z+de d efd7d8Z,ee#ee$e-e%e.e&e/e'e0e(iZ1gd9Z2dS);N) _MISSING_TYPEMISSINGFieldfieldfields)wraps) AnyCallableDictListLiteralOptionalTupleTypeTypeVarUnionget_args get_originoverload)#StrictDataclassClassValidationErrorStrictDataclassDefinitionError#StrictDataclassFieldValidationErrorTclsreturncCdSNrrr]/home/air/sanwanet/backup_V2/venv/lib/python3.10/site-packages/huggingface_hub/dataclasses.pystrict r!F accept_kwargsr$cCrrrr#rrr r!$r"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 ``` rrcstdstdjdi}tD]<}g}|t||jd}|durKt|t s1|g}|D]}t |sEtd|j d|dq3| ||||j <q|_ jdtd td td dffd d }|_rjtdtd dffdd }|_jtd tffdd }|_g} tD]-} | dsqt| } t| sqtt| jdkrtdjd| d| | q| _dtd dffdd } d| _tdrtjddstdjd| _jtd!fdd } 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.selfnamevaluerc 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__kwargscsbddtDfdd|D}|fi||D]\}}|vr.|||q dS)NcSsh|]}|jqSr)r)).0frrr sz9strict..wrap..__init__..csi|] \}}|vr||qSrrr4kvdataclass_fieldsrr sz:strict..wrap..__init__..)ritems __setattr__)r(r3standard_kwargsr)r*)r original_initr:r __init__s z&strict..wrap..__init__csJ|}fdd|jD}d|}|r#|ddd|dS|S)Ncs*g|]\}}|jvrd|d|qS)*=)r%r7rrr s  z:strict..wrap..__repr__..z, ))__dict__r=join)r( standard_repradditional_kwargsadditional_repr)r original_reprrr __repr__s    z&strict..wrap..__repr__ 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__r.r/r__name__)r(r&r0rrr validates  z&strict..wrap..validateTrQ"__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)rQ)r(argsr3)r initial_initrr init_with_validatesz0strict..wrap..init_with_validaterA)rN)!hasattrrrPrappend_create_type_validatormetadatar- isinstancelist _is_validatorr)extendr,r>rstrrArrMdir startswithgetattrcallableleninspect signature parametersrOrrRrQsetattr)rfield_validatorsr5 validatorscustom_validatorr&r2rArMclass_validatorsr)methodrQrUr#)rrTr@rLr1r wrapbsv                zstrict..wrapN)rr)rr$rmrr#r r!(s: Tr&defaultdefault_factoryinitreprhashcomparerYr3c 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&rnrorprqrrrsrYr)rZr[r) r&rnrorprqrrrsrYr3rrr validated_fields rucsbttdddddfdtttfdttgtftfdtdtdttdtd 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. TNrnrorprqrrrsrYr3c s tf|||||||d|S)Nrt)ru)rnrorprqrrrsrYr3r&rr _inner$s  z"as_validated_field.._inner)rrrrr boolr r )r&rwrrvr as_validated_fields2  ryr)r* expected_typecCsht|}t|}|turdSt|}r||||dSt|tr*t|||dStd|d|)z.Validate that 'value' matches 'expected_type'.NzUnsupported type for field 'r') rrr_BASIC_TYPE_VALIDATORSr-rZtype_validate_simple_typer/)r)r*rzoriginrSr&rrr type_validator=s rrS.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.NField 'z ' with value z doesn't match any type in z . Errors: z; )rr/rWr^rqrH)r)r*rSerrorstr0rrr _validate_unionLs $rcCs&||vrtd|d|d|dS)zValidate Literal type.rz' expected one of , got N)r/)r)r*rSrrr _validate_literal[src 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 ''N)rZr[r/r|rP enumeraterr)r*rS item_typeiitemr0rrr _validate_listas 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 'rN)rZdictr/r|rPr=r)r)r*rSkey_type value_typer8r9r0rrr _validate_dictos 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 'rNz' expected a tuple of length r) rZtupler/r|rPrcEllipsisrrzip)r)r*rSrrr0expectedrrr _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 'rN)rZsetr/r|rPrrrrrr _validate_sets rc Cs<t||std|d|jdt|jdt|d dS)z&Validate simple type (int, str, etc.).rz ' expected rz (value: rFN)rZr/rPr|rq)r)r*rzrrr r}s (r}rcsdtddffdd }|S)z-Create a type validator function for a field.r*rNcstj|jdSr)rr)r|)r*rrr r&sz)_create_type_validator..validator)r)rr&rrr rXsrXcCst|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)rbrdrer[rfvaluesrckind ParameterPOSITIONAL_OR_KEYWORDPOSITIONAL_ONLYVAR_POSITIONALrnempty)r&rerf parameterrrr r\s"  r\)r!ru Validator_Trrrr)3rd dataclassesrrrrr functoolsrtypingrr r r r r rrrrrrrrrrrrrr!rxruryr^rrrrrrrr|r}rXr\r[rrrr{__all__rrrr s <,   K   +"""""""