o $6d@sLUdZddlmZddlZddlZddlZddlZddlmZddlm Z ddlm Z m Z ddl mZddlZddlZddlmZdd lmZmZd d lmZd d lmZmZmZmZmZmZmZd d lm Z d dl m!Z!ej"rwd dl#m$Z$ne!Z%eZ&de'd<Gdddej(ddZ)Gddde)ddZ*Gdddej+Z,ej-ddiej.GdddZ/ej-ddiej.GdddZ0Gdddej(Z1e2ddid d!d"dd#dd$dd%dd&dd'dd(dd)dd*dd+dd,dd-dd.dd/d0d1dd2dd3dd4dd5dd6dd7dd8dd9dd:dd;dddZ3efe&e&e&e&e&e&e&e&e&e&e&e&e&e&e&e&e&e&e&e&e&e&e&e&e&e&e&e&e&d?dedNdOZ e4e5e j6Z7e78dKGdPdQdQej+Z9efddRdfdSdTZ:ej-ddiej.GdUdVdVZ;eeddddd0dXdgd[d\Z?ej>dhd^d\Z? diddddd0ed_djdcd\Z?dS)kzDefining fields on models.) annotationsN)copy)Field)AnyClassVar)warn)PydanticUndefined)LiteralUnpack)types) _decorators_fields _generics_internal_dataclass_repr _typing_extra_utils)PydanticUserError)PydanticDeprecatedSince20)ReprArgsr_Unsetc@seZdZUdZded<ded<ded<ded <d ed <ded <ded <ded<ded<ded<ded<ded<ded<ded<ded<ded<ded<ded<ded<ded<ded<ded<d ed!<ded"<d#ed$<ded%<ded&<d'ed(<ded)<ded*<d+S),_FromFieldInfoInputsz[This class exists solely to add type checking for the `**kwargs` in `FieldInfo.from_field`.type[Any] | None annotationtyping.Callable[[], Any] | Nonedefault_factory str | Nonealias int | Nonealias_priority%str | AliasPath | AliasChoices | Nonevalidation_aliasserialization_aliastitle descriptionlist[Any] | Noneexamples bool | Noneexclude float | Nonegtgeltle multiple_ofstrict min_length max_lengthpattern allow_inf_nan max_digitsdecimal_placesz(Literal['smart', 'left_to_right'] | None union_mode discriminator?dict[str, Any] | typing.Callable[[dict[str, Any]], None] | Nonejson_schema_extrafrozenvalidate_defaultboolreprinit_varkw_onlyN__name__ __module__ __qualname____doc____annotations__rGrGfC:\Users\jesus\OneDrive\Desktop\erpjis_fastapi\backend\jisbackend\Lib\site-packages\pydantic/fields.pyr"s@  rF)totalc@seZdZUdZded<dS)_FieldInfoInputszYThis class exists solely to add type checking for the `**kwargs` in `FieldInfo.__init__`.rdefaultNrArGrGrGrHrJEs  rJc@seZdZUdZded<ded<ded<ded <d ed <d ed <ded<ded<ded<ded<ded<ded<ded<ded<ded<ded<ded<ded<ded<d Zejej ej ej ej ej ejejd!d!d!d!d!d" Zd#ed$<dTd)d*ZeefdUd-d.ZedVd0d1ZedWd2d3ZedXd6d7ZedYd:d;ZedZd=d>Zed[d@dAZdBdCd\dEdFZd]dGdHZd^dIdJZd_dOdPZd`dRdSZ d!S)a FieldInfoavThis class holds information about a field. `FieldInfo` is used for any field definition regardless of whether the [`Field()`][pydantic.fields.Field] function is explicitly used. !!! warning You generally shouldn't be creating `FieldInfo` directly, you'll only need to use it when accessing [`BaseModel`][pydantic.main.BaseModel] `.model_fields` internals. Attributes: annotation: The type annotation of the field. default: The default value of the field. default_factory: The factory function used to construct the default for the field. alias: The alias name of the field. alias_priority: The priority of the field's alias. validation_alias: The validation alias name of the field. serialization_alias: The serialization alias name of the field. title: The title of the field. description: The description of the field. examples: List of examples of the field. exclude: Whether to exclude the field from the model serialization. discriminator: Field name for discriminating the type in a tagged union. json_schema_extra: Dictionary of extra JSON schema properties. frozen: Whether the field is frozen. validate_default: Whether to validate the default value of the field. repr: Whether to include the field in representation of the model. init_var: Whether the field should be included in the constructor of the dataclass. kw_only: Whether the field should be a keyword-only argument in the constructor of the dataclass. metadata: List of metadata constraints. rrrrKrrrrrr r!r"r#r$r%r&r'r(r)r8r9r:r;r<r=r>r?r@ list[Any]metadata)rrKrrr r"r#r$r%r'r)r8r:r;r<r>r?r@rN_attributes_setN) r0r+r,r-r.r/r1r2r3r4r5r6r7z7ClassVar[dict[str, typing.Callable[[Any], Any] | None]]metadata_lookupkwargsUnpack[_FieldInfoInputs]returnNonecKsdd|D|_dd|D}||d\|_}|dt}|tur,t|_n||_|dd|_ |jturD|j durDt d|d d|_ |d d|_ |d d|_ |d d|_td d|j |j |jfD}|ry|ddpxdnd|_|dd|_|dd|_|dd|_|dd|_|dd|_|dd|_|dd|_|dd|_|dd|_|dd|_||||_dS)aThis class should generally not be initialized directly; instead, use the `pydantic.fields.Field` function or one of the constructor classmethods. See the signature of `pydantic.fields.Field` for more details about the expected arguments. cSsi|] \}}|tur||qSrG)r.0kvrGrGrH z&FieldInfo.__init__..cSs(i|]\}}||turt|n|qSrG)r_DefaultValuesgetrUrGrGrHrYs(rrKrN/cannot specify both default and default_factoryr$rr"r#css|]}|duVqdSNrG)rVrrGrGrH z%FieldInfo.__init__..r r%r'r)r8r>Tr:r<r;r?r@)itemsrO_extract_metadatar\rpoprEllipsisrKr TypeErrorr$rr"r#anyr r%r'r)r8r>r:r<r;r?r@_collect_metadatarN)selfrQannotation_metadatarKZ alias_is_setrGrGrH__init__s: zFieldInfo.__init__Unpack[_FromFieldInfoInputs]typing_extensions.SelfcKs"d|vrtd|dd|i|S)a~Create a new `FieldInfo` object with the `Field` function. Args: default: The default value for the field. Defaults to Undefined. **kwargs: Additional arguments dictionary. Raises: TypeError: If 'annotation' is passed as a keyword argument. Returns: A new FieldInfo object with the given parameters. Example: This is how you can create a field with default value like this: ```python import pydantic class MyModel(pydantic.BaseModel): foo: int = pydantic.Field(4) ``` rz9"annotation" is not permitted as a Field keyword argumentrKNrG)rf)clsrKrQrGrGrH from_fieldszFieldInfo.from_field type[Any]c Csd}t|rd}|tjurt|d}t|rct|^}}t|r(d}dd|D}|j|d|i}|rct|}||_|pD|j |_ g}|D]} t | t sW| | qJ| | jqJ||_|S|||phddS) aCreates a `FieldInfo` instance from a bare annotation. Args: annotation: An annotation object. Returns: An instance of the field metadata. Example: This is how you can create a field from a bare annotation like this: ```python import pydantic class MyModel(pydantic.BaseModel): foo: int # <-- like this ``` We also account for the case where the annotation can be an instance of `Annotated` and where one of the (not first) arguments in `Annotated` are an instance of `FieldInfo`, e.g.: ```python import annotated_types from typing_extensions import Annotated import pydantic class MyModel(pydantic.BaseModel): foo: Annotated[int, annotated_types.Gt(42)] bar: Annotated[int, pydantic.Field(gt=42)] ``` FTrcSg|] }t|tr|qSrG isinstancerLrVarGrGrH z-FieldInfo.from_annotation..rN)rr;)r is_finalvartyping_extensionsFinalget_args is_annotatedmerge_field_infosrrr;rsrLappendextendrN) rnrfinal first_arg extra_argsZfield_info_annotations field_infoZnew_field_inforNrurGrGrHfrom_annotations.#       zFieldInfo.from_annotationc sd}t|rd}|tjurt|d}t|rF|\|_}|j|7_|j gfdd|D|Rd|ji}|pB|j |_ |St|t j rd}|t j uratjdkr\tdd}t}n t|t j rld}|j}|}|\|_}|j|7_|j gfd d|D|Rd|ji}|p|j |_ ||_t|d d |_|St|rt|^}}d d|D} j | ||d } g} |D]} t| ts| | q| | jq| | _| S|||pd dS)aCreate `FieldInfo` from an annotation with a default value. Args: annotation: The type annotation of the field. default: The default value of the field. Returns: A field object with the passed values. Example: ```python import annotated_types from typing_extensions import Annotated import pydantic class MyModel(pydantic.BaseModel): foo: int = 4 # <-- like this bar: Annotated[int, annotated_types.Gt(4)] = 4 # <-- or this spam: Annotated[int, pydantic.Field(gt=4)] = 4 # <-- or this ``` FTrcg|] }t|r|qSrGrsrVxrnrGrHrvOrwz6FieldInfo.from_annotated_attribute..r)zBInitVar is not supported in Python 3.7 as type information is lostcrrGrrrrGrHrvbrwr@NcSrqrGrrrtrGrGrHrvmrw)rrK)rrKr;)rrxryrzr{rsrcrrNr}r; dataclassesrInitVarsys version_info RuntimeErrorrtype_from_dataclass_fieldr?getattrr@r|rLr~r) rnrrKrrjr?Zpydantic_fieldrr field_infosrrNrurGrrHfrom_annotated_attribute-sj             z"FieldInfo.from_annotated_attributer overridesc Osg}|D]}|dd|jD||qt|}t|dkr>t|d}|j||D] \}}t |||q1|Si}i}|D]}||j|jD] }t |t s\||t |<qOqD||t di|}t ||_|S)zMerge `FieldInfo` instances keeping only explicitly set attributes. Later `FieldInfo` instances override earlier ones. Returns: FieldInfo: A merged FieldInfo instance. css|] }t|tr|VqdSr^rrrrGrGrHr_sz.FieldInfo.merge_field_infos..r rNrG)rrNr~tuplelenrrOupdaterbsetattrrsrLrlistvalues) rrZflattened_field_infosrrWrXZ new_kwargsrNrrGrGrHr}zs0          zFieldInfo.merge_field_infosdc_fieldDataclassField[Any]cCsX|j}|tjur t}|jtjurd}n|j}dd|jD}td|||jd|S)a]Return a new `FieldInfo` instance from a `dataclasses.Field` instance. Args: dc_field: The `dataclasses.Field` instance to convert. Returns: The corresponding `FieldInfo` instance. Raises: TypeError: If any of the `FieldInfo` kwargs does not match the `dataclass.Field` kwargs. NcSsi|] \}}|tvr||qSrG)_FIELD_ARG_NAMESrUrGrGrHrYrZz3FieldInfo._from_dataclass_field..)rKrr>rG) rKrMISSINGrrrNrbrr>)rnrrKrZdc_field_metadatarGrGrHrs  zFieldInfo._from_dataclass_field"tuple[type[Any] | None, list[Any]]cCs4|durt|rt|^}}|t|fS|gfS)a/Tries to extract metadata/constraints from an annotation if it uses `Annotated`. Args: annotation: The type hint annotation for which metadata has to be extracted. Returns: A tuple containing the extracted metadata type and the list of extra arguments. N)rr|ryr{r)rnrrrrGrGrHrcs   zFieldInfo._extract_metadatadict[str, Any]c Csg}i}t|D],\}}z|j|}Wn tyYq w||=|dur6|dur/|||<q |||q |rD|tjdi||S)aCollect annotations from kwargs. The return type is actually `annotated_types.BaseMetadata | PydanticMetadata`, but it gets combined with `list[Any]` from `Annotated[T, ...]`, hence types. Args: kwargs: Keyword arguments passed to the function. Returns: A list of metadata objects - a combination of `annotated_types.BaseMetadata` and `PydanticMetadata`. NrG)rrbrPKeyErrorr~rZPydanticGeneralMetadata)rnrQrNZgeneral_metadatakeyvaluemarkerrGrGrHrhs"  zFieldInfo._collect_metadataF)call_default_factoryrcCs&|jdur t|jS|r|SdS)aGet the default value. We expose an option for whether to call the default_factory (if present), as calling it may result in side effects that we want to avoid. However, there are times when it really should be called (namely, when instantiating a model via `model_construct`). Args: call_default_factory: Whether to call the default_factory or not. Defaults to `False`. Returns: The default value, calling the default factory if requested or `None` if not set. NrrZsmart_deepcopyrK)rirrGrGrH get_defaults zFieldInfo.get_defaultcCs|jtuo |jduS)zCheck if the argument is required. Returns: `True` if the argument is required, `False` otherwise. N)rKrrrirGrGrH is_requiredszFieldInfo.is_requiredcCs"|js|jStj|jg|jRS)aRebuilds the original annotation for use in function signatures. If metadata is present, it adds it to the original annotation using an `AnnotatedAlias`. Otherwise, it returns the original annotation as is. Returns: The rebuilt annotation. )rNrry AnnotatedrrGrGrHrebuild_annotations zFieldInfo.rebuild_annotation typevars_mapdict[Any, Any] | Nonetypes_namespacedict[str, Any] | NonecCs"t|j|d}t|||_dS)aZApply a `typevars_map` to the annotation. This method is used when analyzing parametrized generic types to replace typevars with their concrete types. This method applies the `typevars_map` to the annotation in place. Args: typevars_map: A dictionary mapping type variables to their concrete types. types_namespace (dict | None): A dictionary containing related types to the annotated type. See Also: pydantic._internal._generics.replace_types is used for replacing the typevars with their concrete types. N)rZeval_type_lenientrrZ replace_types)rirrrrGrGrHapply_typevars_mapszFieldInfo.apply_typevars_maprccsdtt|jfVd|fV|jD]f}|dkrq|dkr#q|dkr+|js+q|dkr5|jdur5q|dkr?|jdur?q|d krJ|j |j krJq|d krU|j |j krUq|d krk|j durkd tt|j fVqt ||}|dur}|tur}||fVqdS) NrrequiredrOrNr>Tr;Fr"r#r)rZ PlainReprZdisplay_as_typerr __slots__rNr>r;r"rr#rrr)risrrGrGrH __repr_args__$s2   zFieldInfo.__repr_args__)rQrRrSrT)rKrrQrlrSrm)rrprSrm)rrprKrrSrm)rrLrrrSrL)rrrSrm)rrrSr)rQrrSrM)rr=rSr)rSr=rSr)rrrrrSrT)rSr)!rBrCrDrErFrr ZStrictannotated_typesGtZGeLtZLeZ MultipleOfZMinLenZMaxLenrPrk classmethodrrorr staticmethodr}rrcrhrrrrrrGrGrGrHrLKsr  ) = L !      rLc@s.eZdZUdZded<dd d Zdd dZdS) AliasPathzUsage docs: https://docs.pydantic.dev/2.2/usage/fields#aliaspath-and-aliaschoices A data class used by `validation_alias` as a convenience to create aliases. Attributes: path: A list of string or integer aliases. zlist[int | str]pathrstrargs str | intrSrTcG|gt||_dSr^)rr)rirrrGrGrHrkKzAliasPath.__init__list[str | int]cCs|jS)zvConverts arguments to a list of string or integer aliases. Returns: The list of aliases. )rrrGrGrHconvert_to_aliasesNszAliasPath.convert_to_aliasesN)rrrrrSrT)rSrrBrCrDrErFrkrrGrGrGrHr?  rc@s.eZdZUdZded<ddd Zdd d Zd S) AliasChoiceszUsage docs: https://docs.pydantic.dev/2.2/usage/fields#aliaspath-and-aliaschoices A data class used by `validation_alias` as a convenience to create aliases. Attributes: choices: A list containing a string or `AliasPath`. zlist[str | AliasPath]choices first_choicestr | AliasPathrSrTcGrr^)rr)rirrrGrGrHrkcrzAliasChoices.__init__list[list[str | int]]cCs:g}|jD]}t|tr||q||gq|S)zConverts arguments to a list of lists containing string or integer aliases. Returns: The list of aliases. )rrsrr~r)rialiasescrGrGrHrfs   zAliasChoices.convert_to_aliasesN)rrrrrSrT)rSrrrGrGrGrHrWrrc@seZdZdZdS) _EmptyKwargsz_This class exists solely to ensure that type checking warns about passing `**extra` in `Field`.N)rBrCrDrErGrGrGrHrusrrK.rrr r"r#r$r%r'r)r8r:r;r<r>Tr?r@r3r0r+r,r-r.r/r4r5r6r1r2)rrr r"r#r$r%r'r)r8r:r;r<r>r?r@r3r0r+r,r-r.r/r4r5r6r1r2r7rrrr!r&r(r9r=r*r7!Literal['smart', 'left_to_right']extraUnpack[_EmptyKwargs]rSc&KsH|dd}|durtddd|dd} | dur'tdt|dtfvr'| }|dd}!|!dur>td t|dtfvr>|!}|d d}"|"durNtd dd|d d}#|#durctd t|#durcd} |dd}$|$durstddd|rtdddd|Ddt| r| tur|} |r|turt|tt t fst d|tdfvrt|tr|}|tdfvr|}|dd}%|%durtdtt j |fid|d|d|d|d|d|d |d!|d"| d#| d$| d%| d&|d'| d(|d)|d*|d+|d,|d-|d.|d/|d0|d1|d2|d3|d4|d5|d6|S)7aVUsage docs: https://docs.pydantic.dev/2.2/usage/fields Create a field for objects that can be configured. Used to provide extra information about a field, either for the model schema or complex validation. Some arguments apply only to number fields (`int`, `float`, `Decimal`) and some apply only to `str`. Note: - Any `_Unset` objects will be replaced by the corresponding value defined in the `_DefaultValues` dictionary. If a key for the `_Unset` object is not found in the `_DefaultValues` dictionary, it will default to `None` Args: default: Default value if the field is not set. default_factory: A callable to generate the default value, such as :func:`~datetime.utcnow`. alias: An alternative name for the attribute. alias_priority: Priority of the alias. This affects whether an alias generator is used. validation_alias: 'Whitelist' validation step. The field will be the single one allowed by the alias or set of aliases defined. serialization_alias: 'Blacklist' validation step. The vanilla field will be the single one of the alias' or set of aliases' fields and all the other fields will be ignored at serialization time. title: Human-readable title. description: Human-readable description. examples: Example values for this field. exclude: Whether to exclude the field from the model serialization. discriminator: Field name for discriminating the type in a tagged union. json_schema_extra: Any additional JSON schema data for the schema property. frozen: Whether the field is frozen. validate_default: Run validation that isn't only checking existence of defaults. This can be set to `True` or `False`. If not set, it defaults to `None`. repr: A boolean indicating whether to include the field in the `__repr__` output. init_var: Whether the field should be included in the constructor of the dataclass. kw_only: Whether the field should be a keyword-only argument in the constructor of the dataclass. strict: If `True`, strict validation is applied to the field. See [Strict Mode](../usage/strict_mode.md) for details. gt: Greater than. If set, value must be greater than this. Only applicable to numbers. ge: Greater than or equal. If set, value must be greater than or equal to this. Only applicable to numbers. lt: Less than. If set, value must be less than this. Only applicable to numbers. le: Less than or equal. If set, value must be less than or equal to this. Only applicable to numbers. multiple_of: Value must be a multiple of this. Only applicable to numbers. min_length: Minimum length for strings. max_length: Maximum length for strings. pattern: Pattern for strings. allow_inf_nan: Allow `inf`, `-inf`, `nan`. Only applicable to numbers. max_digits: Maximum number of allow digits for strings. decimal_places: Maximum number of decimal places allowed for numbers. union_mode: The strategy to apply when validating a union. Can be `smart` (the default), or `left_to_right`. See [Union Mode](../usage/types/unions.md#union-mode) for details. extra: Include extra fields used by the JSON schema. !!! warning Deprecated The `extra` kwargs is deprecated. Use `json_schema_extra` instead. Returns: A new [`FieldInfo`][pydantic.fields.FieldInfo], the return annotation is `Any` so `Field` can be used on type annotated fields without causing a typing error. constNz)`const` is removed, use `Literal` insteadzremoved-kwargs)code min_itemszG`min_items` is deprecated and will be removed, use `min_length` instead max_itemszG`max_items` is deprecated and will be removed, use `max_length` instead unique_itemsz`unique_items` is removed, use `Set` instead(this feature is discussed in https://github.com/pydantic/pydantic-core/issues/296)allow_mutationzH`allow_mutation` is deprecated and will be removed. use `frozen` insteadFTregexz)`regex` is removed. use `pattern` insteadzzUsing extra keyword arguments on `Field` is deprecated and will be removed. Use `json_schema_extra` instead. (Extra keys: z, css|]}|VqdSr^)__repr__)rVrWrGrGrHr_r`zField..)zSInvalid `validation_alias` type. it should be `str`, `AliasChoices`, or `AliasPath`includezS`include` is deprecated and does nothing. It will be removed, use `exclude` insteadrrr r"r#r$r%r'r)r8r:r;r3r<r>r?r@r0r+r,r-r.r/r1r2r4r5r6r7)rdrrDeprecationWarningrjoinkeysrsrrrrfrLro)&rKrrr r"r#r$r%r'r)r8r:r;r<r>r?r@r3r0r+r,r-r.r/r4r5r6r1r2r7rrrrrrrrrGrGrHrs Y                     rc@sVeZdZdZdZefdddd d ZejsdddZ dddZ dddZ d ddZ dS)!ModelPrivateAttra A descriptor for private attributes in class models. Attributes: default: The default value of the attribute if not provided. default_factory: A callable function that generates the default value of the attribute if not provided. rKrNrrKrrrrSrTcCs||_||_dSr^r)rirKrrGrGrHrkcs zModelPrivateAttr.__init__itemrcCs8|dvrt|j|rt|j|Stt|jd|)zThis function improves compatibility with custom descriptors by ensuring delegation happens as expected when the default value of a private attribute is a descriptor. >__set____get__ __delete__z object has no attribute )hasattrrKrAttributeErrorrrB)rirrGrGrH __getattr__ls  zModelPrivateAttr.__getattr__rnrpnamecCs@|jturdSt|jdsdS|jj}t|r|||dSdS)zMPreserve `__set_name__` protocol defined in https://peps.python.org/pep-0487.N __set_name__)rKrrrcallable)rirnrset_namerGrGrHrus  zModelPrivateAttr.__set_name__cCs|jdur t|jS|S)aURetrieve the default value of the object. If `self.default_factory` is `None`, the method will return a deep copy of the `self.default` object. If `self.default_factory` is not `None`, it will call `self.default_factory` and return the value returned. Returns: The default value of the object. NrrrGrGrHrs zModelPrivateAttr.get_defaultotherr=cCs$t||jo|j|jf|j|jfkSr^)rs __class__rKr)rirrGrGrH__eq__szModelPrivateAttr.__eq__)rKrrrrSrT)rrrSr)rnrprrrSrTr)rrrSr=) rBrCrDrErrrktyping TYPE_CHECKINGrrrrrGrGrGrHrXs   rrcCs$|tur |dur tdt||dS)aIndicates that attribute is only used internally and never mixed with regular fields. Private attributes are not checked by Pydantic, so it's up to you to maintain their accuracy. Private attributes are stored in `__private_attributes__` on the model. Args: default: The attribute's default value. Defaults to Undefined. default_factory: Callable that will be called when a default value is needed for this attribute. If both `default` and `default_factory` are set, an error will be raised. Returns: An instance of [`ModelPrivateAttr`][pydantic.fields.ModelPrivateAttr] class. Raises: ValueError: If both `default` and `default_factory` are set. Nr]r)rrfrrrGrGrH PrivateAttrs rc@sVeZdZUdZdZded<ded<ded<d ed <d ed <d ed <d ed<ded<dS)ComputedFieldInfoa+A container for data from `@computed_field` so that we can access it while building the pydantic-core schema. Attributes: decorator_repr: A class variable representing the decorator string, '@computed_field'. wrapped_property: The wrapped computed field property. return_type: The type of the computed field property's return value. alias: The alias of the property to be used during encoding and decoding. alias_priority: priority of the alias. This affects whether an alias generator is used title: Title of the computed field as in OpenAPI document, should be a short summary. description: Description of the computed field as in OpenAPI document. repr: A boolean indicating whether or not to include the field in the __repr__ output. z@computed_fieldz ClassVar[str]decorator_reprpropertyZwrapped_propertyr return_typerrrr r$r%r=r>N)rBrCrDrErrFrGrGrGrHrs   r PropertyTrrr r$r%r>r'typing.Callable[[PropertyT], PropertyT]cCdSr^rGrrGrGrHcomputed_fields r__funccCrr^rG)rrGrGrHrs)rr r$r%r>r__fPropertyT | None3PropertyT | typing.Callable[[PropertyT], PropertyT]cs,dfdd }|dur|S||S)aUsage docs: https://docs.pydantic.dev/2.2/usage/computed_fields/ Decorator to include `property` and `cached_property` when serializing models. If applied to functions not yet decorated with `@property` or `@cached_property`, the function is automatically wrapped with `property`. Args: __f: the function to wrap. alias: alias to use when serializing this computed field, only used when `by_alias=True` alias_priority: priority of the alias. This affects whether an alias generator is used title: Title to used when including this computed field in JSON Schema, currently unused waiting for #4697 description: Description to used when including this computed field in JSON Schema, defaults to the functions docstring, currently unused waiting for #4697 repr: whether to include this computed field in model repr return_type: optional return for serialization logic to expect when serializing to JSON, if included this must be correct, otherwise a `TypeError` is raised. If you don't include a return type Any is used, which does runtime introspection to handle arbitrary objects. Returns: A proxy wrapper for the property. frrScsbt|}dur|jrt|jt|}durpdndt|}t||S)Nra)r Zunwrap_wrapped_functionrEinspectcleandocZensure_propertyrZPydanticDescriptorProxy)rZ unwrappedZdec_inforr r%r>rr$rGrHdecs    zcomputed_field..decN)rrrSrrG)rrr r$r%r>rrrGrrHrs" rG)@rKrrrrrr rr"r!r#rr$rr%rr'r&r)r(r8rr:r9r;r(r<r(r>r=r?r(r@r(r3rr0r(r+r*r,r*r-r*r.r*r/r*r4r(r5rr6rr1rr2rr7rrrrSr)rKrrrrSr)rrrrr rr$rr%rr>r=rSr)rrrSrr^)rrrrr rr$rr%rr>r=rrrSr)@rE __future__rZ _annotationsrrrrrrZDataclassFieldrrwarningsrrryZ pydantic_corerr r r _internalr rrrrrrerrorsrrrZ_internal._reprrrrrF TypedDictrrJZRepresentationrL dataclassZ slots_truerrrdictr[set signature parametersrremoverrrTypeVarroverloadrrGrGrGrHs4      $   #w     "; ;