o ȳg$@s^ddlmZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl mZddlmZmZmZmZddlmZddlmZmZmZddlmZmZmZddlmZ dd l!m"Z"m#Z#dd l$m%Z%m&Z&e j'rdd l(m)Z*dd l+m,Z,m-Z-gd Z.GdddeZ/Gddde/Z0Gddde/Z1Gddde1Z2Gddde/Z3Gddde/Z4Gddde/Z5Gddde5Z6e 7dZ8Gdd d e/e j9e8Z:Gd!d"d"e:e;ZGd%d&d&e:ej?Z?Gd'd(d(e/Z@Gd)d*d*e/ZAGd+d,d,eAZBGd-d.d.eAZCGd/d0d0eAZDGd1d2d2eAZEGd3d4d4e/ZFGd5d6d6e/ZGd7d8d8eZGGd9d:d:e5ZHGd;d<dd>e/ZJGd?d@d@eJZKGdAdBdBeJZLGdCdDdDe/ZMGdEdFdFeMZNGdGdHdHeMZOGdIdJdJe/Z)GdKdLdLe/ZPGdMdNdNe/ZQGdOdPdPe/ZRGdQdRdRe/ZSeHZTe5ZUe@ZVeZ d^d_d@dAZd`dEdFZdadGdHZdbdIdJZe dcdLdMZe dNdOZejdPdOZe dQdRZejdSdRZd S)dr#a Base field from which other fields inherit. :param dump_default: If set, this value will be used during serialization if the input value is missing. If not set, the field will be excluded from the serialized output if the input value is missing. May be a value or a callable. :param load_default: Default deserialization value for the field if the field is not found in the input data. May be a value or a callable. :param data_key: The name of the dict key in the external representation, i.e. the input of `load` and the output of `dump`. If `None`, the key will match the name of the field. :param attribute: The name of the key/attribute in the internal representation, i.e. the output of `load` and the input of `dump`. If `None`, the key/attribute will match the name of the field. Note: This should only be used for very specific use cases such as outputting multiple fields for a single attribute, or using keys/attributes that are invalid variable names, unsuitable for field names. In most cases, you should use ``data_key`` instead. :param validate: Validator or collection of validators that are called during deserialization. Validator takes a field's input value as its only parameter and returns a boolean. If it returns `False`, an :exc:`ValidationError` is raised. :param required: Raise a :exc:`ValidationError` if the field value is not supplied during deserialization. :param allow_none: Set this to `True` if `None` should be considered a valid value during validation/deserialization. If set to `False` (the default), `None` is considered invalid input. If ``load_default`` is explicitly set to `None` and ``allow_none`` is unset, `allow_none` is implicitly set to ``True``. :param load_only: If `True` skip this field during serialization, otherwise its value will be present in the serialized data. :param dump_only: If `True` skip this field during deserialization, otherwise its value will be present in the deserialized object. In the context of an HTTP API, this effectively marks the field as "read-only". :param error_messages: Overrides for `Field.default_error_messages`. :param metadata: Extra information to be stored as field metadata. .. versionchanged:: 3.0.0b8 Add ``data_key`` parameter for the specifying the key in the input and output data. This parameter replaced both ``load_from`` and ``dump_to``. .. versionchanged:: 3.13.0 Replace ``missing`` and ``default`` parameters with ``load_default`` and ``dump_default``. .. versionchanged:: 3.24.0 `Field ` should no longer be used as a field within a `Schema `. Use `Raw ` or another `Field ` subclass instead. Tz Missing data for required field.zField may not be null.zInvalid value.)requirednullvalidator_failedzdict[str, str]default_error_messagesNF) load_defaultr dump_defaultdefaultdata_key attributerr: allow_none load_only dump_onlyerror_messagesmetadatar> typing.Anyrr?r@rA str | NonerBr9types.Validator | typing.Iterable[types.Validator] | Noner:boolrC bool | NonerDrErFdict[str, str] | NonerG&typing.Mapping[str, typing.Any] | NonereturnNonec Ks|jtur tjdtdd|turtjdtdd|tur|}|tur1tjdtdd|tur1|}||_||_||_ ||_ ||_ |durHg|_ nt |rQ|g|_ nt|r\t||_ ntd| durh|dun| |_| |_| |_|dur}|tur}td||_| pi} i| ||_|rtjd |tddi}t|jjD] }|t|d iq|| pi||_d|_d|_d|_dS) NzX`Field` should not be instantiated. Use `fields.Raw` or another field subclass instead. stacklevelzKThe 'default' argument to fields is deprecated. Use 'dump_default' instead.zKThe 'missing' argument to fields is deprecated. Use 'load_default' instead.zIThe 'validate' parameter must be a callable or a collection of callables.Tz3'load_default' must not be set for required fields.zPassing field metadata as keyword arguments is deprecated. Use the explicit `metadata=...` argument instead. Additional metadata: r=) __class__r#warningswarnrmissing_rr?r>rBrAr validatorscallableris_iterable_but_not_stringlist ValueErrorrCrDrEr:rGreversed__mro__updategetattrrFparentnameroot)selfr>rr?r@rArBrr:rCrDrErFrGadditional_metadatamessagesclsrhN/var/www/html/chatdoc2/venv/lib/python3.10/site-packages/marshmallow/fields.py__init__sx      zField.__init__strcCsXd|jjd|jd|jd|jd|jd|jd|jd|jd |j d |j d S) Nz) rT__name__r?rBrr:rDrEr>rCrFrdrhrhri__repr__s$zField.__repr__cCs t|SN)copy)rdmemorhrhri __deepcopy__ zField.__deepcopy__objattraccessorAtyping.Callable[[typing.Any, str, typing.Any], typing.Any] | NonecCs*|ptj}|jdur |n|j}||||S)aNReturn the value for a given key from an object. :param obj: The object to get the value from. :param attr: The attribute/key in `obj` to get the value from. :param accessor: A callable used to retrieve the value of `attr` from the object `obj`. Defaults to `marshmallow.utils.get_value`. N)r get_valuerB)rdrtrurvr@ accessor_func check_keyrhrhrirxs  zField.get_valuevaluecCs||dS)zpPerform validation on ``value``. Raise a :exc:`ValidationError` if validation does not succeed. N) _validate_allrdr{rhrhri _validateszField._validate#typing.Callable[[typing.Any], None]cCst|jd|jdiS)Nerrorr<)rrXrFrmrhrhrir|szField._validate_allkeyr c Ksrz|j|}Wnty%}z|jj}d|d|d}t||d}~wwt|ttfr5|jdi|}t |S)znHelper method to make a `ValidationError` with an error message from ``self.error_messages``. zValidationError raised by `z`, but error key `z4` does not exist in the `error_messages` dictionary.Nrh) rFKeyErrorrTrlAssertionError isinstancerkbytesformatr )rdrkwargsmsgr class_namemessagerhrhri make_errors zField.make_errorcKs,tjd|dtdd|jdd|i|)zHelper method that raises a `ValidationError` with an error message from ``self.error_messages``. .. deprecated:: 3.0.0 Use `make_error ` instead. z8`Field.fail` is deprecated. Use `raise self.make_error("z", ...)` instead.rQrRrNrh)rUrVrr)rdrrrhrhrifail+s  z Field.failcCs8|tur |jr |d|dur|js|ddSdS)zqValidate missing values. Raise a :exc:`ValidationError` if `value` should be considered missing. r:Nr;)rWr:rrCr}rhrhri_validate_missing9s   zField._validate_missingcKs^|jr"|j|||d}|tur|j}t|r|n|}|tur!|Snd}|j|||fi|S)azPulls the value for the given key from the object, applies the field's formatting and returns the result. :param attr: The attribute/key to get from the object. :param obj: The object to access the attribute/key from. :param accessor: Function used to access values from ``obj``. :param kwargs: Field-specific keyword arguments. )rvN)_CHECK_ATTRIBUTErxrWr?rY _serialize)rdrurtrvrr{r@rhrhri serializeBszField.serializedatacKs`|||tur|j}t|r|S|S|jr|durdS|j|||fi|}|||S)aDeserialize ``value``. :param value: The value to deserialize. :param attr: The attribute/key in `data` to deserialize. :param data: The raw input data passed to `Schema.load `. :param kwargs: Field-specific keyword arguments. :raise ValidationError: If an invalid value is passed or if a required value is missing. N)rrWr>rYrC _deserializer~)rdr{rurr_missoutputrhrhri deserialize^s  zField.deserialize field_nameschemaSchema | FieldcCsD|jp||_|jp ||_|jpt|jtr|jj|_dS|j|_dS)zUpdate field with values from its parent schema. Called by `Schema._bind_field `. :param field_name: Field name set in schema. :param schema: Parent object. N)rarbrcrrrdrrrhrhri_bind_to_schema|s  zField._bind_to_schemacK|S)aSerializes ``value`` to a basic Python datatype. Noop by default. Concrete :class:`Field` classes should implement this method. Example: :: class TitleCase(Field): def _serialize(self, value, attr, obj, **kwargs): if not value: return "" return str(value).title() :param value: The value to be serialized. :param attr: The attribute or key on the object to be serialized. :param obj: The object the value was pulled from. :param kwargs: Field-specific keyword arguments. :return: The serialized value rhrdr{rurtrrhrhrirszField._serializecKr)a1Deserialize value. Concrete :class:`Field` classes should implement this method. :param value: The value to be deserialized. :param attr: The attribute/key in `data` to be deserialized. :param data: The raw input data passed to the `Schema.load `. :param kwargs: Field-specific keyword arguments. :raise ValidationError: In case of formatting or validation failure. :return: The deserialized value. .. versionchanged:: 3.0.0 Added ``**kwargs`` to signature. rhrdr{rurrrhrhrirszField._deserialize dict | NonecCs|jr|jjSdS)zDThe context dictionary for the parent `Schema `.N)racontextrmrhrhrirsz Field.contextcCtjdtdd|jSNzLThe 'default' attribute of fields is deprecated. Use 'dump_default' instead.rQrRrUrVrr?rmrhrhrir@ z Field.defaultcCtjdtdd||_dSrrr}rhrhrir@  cCrNzLThe 'missing' attribute of fields is deprecated. Use 'load_default' instead.rQrRrUrVrr>rmrhrhrirrz Field.missingcCrrrr}rhrhrirr)r>rHrrHr?rHr@rHrArIrBrIrrJr:rKrCrLrDrKrErKrFrMrGrNrOrPrOrk)rtrHrurkrvrwr@rH)r{rH)rOr)rrkrOr )rrkr{rHrOrPro)rurkrtrHrvrwNN)r{rHrurIrrNrrkrrrOrP)r{rHrurIrtrHrOrH)r{rHrurIrrNrOrH)rOr)rl __module__ __qualname____doc__rr=__annotations__rWrjrnrrrxr~propertyr|rrrrrrrrrr@setterrrhrhrhrir#Tsd 2  ]               r#c@seZdZdZdS)r3z!Field that applies no formatting.N)rlrrrrhrhrhrir3sr3cseZdZdZddiZeedddddd/fddZed0ddZd1ddZ d d!Z d2d$d%Z d3d4d(d)Z d3d5d-d.Z ZS)6r0aAllows you to nest a :class:`Schema ` inside a field. Examples: :: class ChildSchema(Schema): id = fields.Str() name = fields.Str() # Use lambda functions when you need two-way nesting or self-nesting parent = fields.Nested(lambda: ParentSchema(only=("id",)), dump_only=True) siblings = fields.List( fields.Nested(lambda: ChildSchema(only=("id", "name"))) ) class ParentSchema(Schema): id = fields.Str() children = fields.List( fields.Nested(ChildSchema(only=("id", "parent", "siblings"))) ) spouse = fields.Nested(lambda: ParentSchema(only=("id",))) When passing a `Schema ` instance as the first argument, the instance's ``exclude``, ``only``, and ``many`` attributes will be respected. Therefore, when passing the ``exclude``, ``only``, or ``many`` arguments to `fields.Nested`, you should pass a `Schema ` class (not an instance) as the first argument. :: # Yes author = fields.Nested(UserSchema, only=("id", "name")) # No author = fields.Nested(UserSchema(), only=("id", "name")) :param nested: `Schema ` instance, class, class name (string), dictionary, or callable that returns a `Schema ` or dictionary. Dictionaries are converted with `Schema.from_dict `. :param exclude: A list or tuple of fields to exclude. :param only: A list or tuple of fields to marshal. If `None`, all fields are marshalled. This parameter takes precedence over ``exclude``. :param many: Whether the field is a collection of objects. :param unknown: Whether to exclude, include, or raise an error for unknown fields in the data. Use `EXCLUDE`, `INCLUDE` or `RAISE`. :param kwargs: The same keyword arguments that :class:`Field` receives. typez Invalid type.NrhF)r?r@onlyexcludemanyunknownnestedjSchema | SchemaMeta | str | dict[str, Field] | typing.Callable[[], Schema | SchemaMeta | dict[str, Field]]r?rHr@rtypes.StrSequenceOrSet | Nonertypes.StrSequenceOrSetrrKrrIc  s|dur t|s tdt|std|dkr tjdtdd||_||_||_||_||_ d|_ t j d||d|dS) Nz)"only" should be a collection of strings.z,"exclude" should be a collection of strings.rdzVPassing 'self' to `Nested` is deprecated. Use `Nested(lambda: MySchema(...))` instead.rQrR)r@r?rh) r r rUrVrrrrrr_schemasuperrj) rdrr?r@rrrrrrTrhrirj s&zNested.__init__rOrc Cs|jst|jdi}t|jrt|jts|}ntd|j}ddl m }t|t r1| |}t||rt ||_|jj|ttt|jj}|jdurn|jjdur]|jj}n|jj}||j||@|j_|jr|jj}||j||B|j_|j|jSt|trt||r|}n$t|ttfstd|jd|dkrt||jj}ntj|d d }||j|j|j|| d | d d |_|jS)zThe nested `Schema ` object. .. versionchanged:: 1.0.0 Renamed from ``serializer`` to ``schema``. rrr)rNz/`Nested` fields must be passed a `Schema`, not .rdF)allrDrE)rrrrrDrE)!rr`rarYrrrtypingcastmarshmallow.schemardict from_dictrprr_set set_classrfieldskeysr _init_fields issubclassrkrr\rTrcr get_classr_nested_normalized_option)rdrrrroriginal schema_classrhrhrirHsT           z Nested.schema option_namerk list[str]cs*|jdfddt|j|tDS)Nrcs&g|]}|r|ddqS) startswithsplit).0field nested_fieldrhri s z4Nested._nested_normalized_option..)rbr`rcr)rdrrhrrirs  z Nested._nested_normalized_optioncKs,|j}|dur dS|jp|j}|j||dS)N)r)rrdump)rd nested_objrurtrrrrhrhrirs  zNested._serializer{rPcCs8|jjp|j}|rt|s|jd||jjddSdS)Nr)inputr)rrrr rrTrl)rdr{rrhrhri_test_collectionszNested._test_collectionpartial$bool | types.StrSequenceOrSet | Nonec CsFz |jj||j|d}W|Sty"}z t|j|jd|d}~ww)N)rr valid_data)rloadrr rfr)rdr{rrrrhrhri_loadsz Nested._loadrurrNcKs|||j||dS)aSame as :meth:`Field._deserialize` with additional ``partial`` argument. :param partial: For nested schemas, the ``partial`` parameter passed to `marshmallow.Schema.load`. .. versionchanged:: 3.0.0 Add ``partial`` parameter. r)rrrdr{rurrrrhrhrirs zNested._deserialize)rrr?rHr@rHrrrrrrKrrI)rOr)rrkrOrrro)r{rHrr) r{rHrurIrrNrrrOrH)rlrrrr=rWrjrrrrrrr __classcell__rhrhrrir0s&1 (  8  r0csNeZdZdZddddfd dZedddZfddZdddZZ S)r2a Allows you to replace nested data with one of the data's fields. Example: :: from marshmallow import Schema, fields class ArtistSchema(Schema): id = fields.Int() name = fields.Str() class AlbumSchema(Schema): artist = fields.Pluck(ArtistSchema, "id") in_data = {"artist": 42} loaded = AlbumSchema().load(in_data) # => {'artist': {'id': 42}} dumped = AlbumSchema().dump(loaded) # => {'artist': 42} :param nested: The Schema class or class name (string) to nest, or ``"self"`` to nest the `Schema ` within itself. :param field_name: The key to pluck a value from. :param kwargs: The same keyword arguments that :class:`Nested` receives. FN)rrr7Schema | SchemaMeta | str | typing.Callable[[], Schema]rrkrrKrrIc s(tj|f|f||d|||_dS)N)rrr)rrjr)rdrrrrrrrhrirjs  zPluck.__init__rOcCs|jj|j}|jp |jSro)rrrrA)rd only_fieldrhrhri_field_data_keys zPluck._field_data_keyc sDtj|||fi|}|durdS|jrtj||jdS||jS)N)r)rrrrpluckr)rdrrurtrretrrhrirs  zPluck._serializec s<|jrfdd|D}nj|i}j||dS)Ncsg|]}j|iqSrh)r)rvrmrhrirsz&Pluck._deserialize..r)rrrrrrhrmrirs  zPluck._deserialize)rrrrkrrKrrIrro) rlrrrrjrrrrrrhrhrrir2s  r2cLeZdZdZddiZdfdd Zdfdd ZdddZdddZZ S)r-alA list field, composed with another `Field` class or instance. Example: :: numbers = fields.List(fields.Float()) :param cls_or_instance: A field class or instance. :param kwargs: The same keyword arguments that :class:`Field` receives. .. versionchanged:: 3.0.0rc9 Does not serialize scalar values to single-item lists. invalidzNot a valid list.cls_or_instanceField | type[Field]c sltjdi|zt||_Wnty!}ztd|d}~wwt|jtr4|jj|_|jj |_ dSdS)NzNThe list elements must be a subclass or instance of marshmallow.base.FieldABC.rh) rrjrinnerr r\rr0rr)rdrrrrrhrirjs  z List.__init__rrkrrrOrPcsRt||t|j|_|j||t|jtr'|j|j_|j|j_dSdSro) rrrpdeepcopyrrr0rrrrrhrirs  zList._bind_to_schemalist[typing.Any] | Nonec s$|durdSfdd|DS)Ncs$g|]}jj|fiqSrh)rrreachrurrtrdrhrirs$z#List._serialize..rhrrhrrirszList._serializelist[typing.Any]c Kst|s |dg}i}t|D]8\}}z||jj|fi|WqtyJ} z| jdur8|| j| || j iWYd} ~ qd} ~ ww|rSt||d|SNrr) rr r enumerateappendrrr rr_rf) rdr{rurrresulterrorsidxrrrhrhrir!s     zList._deserialize)rrr)rOr)rOr rlrrrr=rjrrrrrhrhrrir-s r-cr)r8aGA tuple field, composed of a fixed number of other `Field` classes or instances Example: :: row = Tuple((fields.String(), fields.Integer(), fields.Float())) .. note:: Because of the structured nature of `collections.namedtuple` and `typing.NamedTuple`, using a Schema within a Nested field for them is more appropriate than using a `Tuple` field. :param tuple_fields: An iterable of field classes or instances. :param kwargs: The same keyword arguments that :class:`Field` receives. .. versionadded:: 3.0.0rc4 rzNot a valid tuple. tuple_fields5typing.Iterable[Field] | typing.Iterable[type[Field]]c srtjdi|t|stdz dd|D|_Wnty-}ztd|d}~wwtt|jd|_ dS)Nz?tuple_fields must be an iterable of Field classes or instances.cSsg|]}t|qSrh)r)rrrhrhrirVsz"Tuple.__init__..zXElements of "tuple_fields" must be subclasses or instances of marshmallow.base.FieldABC.)equalrh) rrjrr r\rr rlenvalidate_length)rdrrrrrhrirjJs$  zTuple.__init__rrkrrrOrPcsHt||g}|jD]}t|}|||||q ||_dSro)rrrrprr)rdrrnew_tuple_fieldsr new_fieldrrhrirbs     zTuple._bind_to_schema tuple | Nonec s.|durdStfddt|j|DS)Nc3s*|]\}}|j|fiVqdSro)r)rrrrurrtrhri ps  z#Tuple._serialize..)tupleziprrrhrrirls  zTuple._serializer c Kst|s |d||g}i}tt|j|D]9\}\}} z||j| fi|Wqt yT} z| j durB|| j | || j iWYd} ~ qd} ~ ww|r]t ||dt |Sr)rr rrrr rrrr rr_rfr ) rdr{rurrrrrrrrrhrhrirus"      zTuple._deserialize)rrr)rOr)rOr rrhrhrrir83s  r8c@s.eZdZdZdddZd ddZdd d Zd S)r5zaA string field. :param kwargs: The same keyword arguments that :class:`Field` receives. zNot a valid string.zNot a valid utf-8 string.)r invalid_utf8rOrIcKs|durdSt|Sro)rensure_text_typerrhrhrirs zString._serializerHc KsJt|ttfs |dzt|WSty$}z|d|d}~ww)Nrr )rrkrrrr UnicodeDecodeErrorrdr{rurrrrhrhrirs   zString._deserializeNrOrI)rOrH)rlrrrr=rrrhrhrhrir5s r5c@s,eZdZdZddiZd ddZd dd Zd S) rz A UUID field. invalid_uuidzNot a valid UUID.rOuuid.UUID | Nonec Csx|durdSt|tjr|Szt|tr!t|dkr!tj|dWSt|WStttfy;}z|d|d}~ww)FFormat the value or raise a :exc:`ValidationError` if an error occurs.N)rr) ruuidrrrr\AttributeError TypeErrorrrdr{rrhrhri _validateds   zUUID._validatedcK ||SrorrrhrhrirrszUUID._deserializeN)rOr)rlrrrr=rrrhrhrhrirs   r_NumTypecsreZdZUdZeZded<dddZdddfd d ZdddZ d ddZ d!ddZ d"ddZ d#ddZ ZS)$r1aBase class for number fields. :param as_string: If `True`, format the serialized value as a string. :param kwargs: The same keyword arguments that :class:`Field` receives. .. versionchanged:: 3.24.0 `Number ` should no longer be used as a field within a `Schema `. Use `Integer `, `Float `, or `Decimal ` instead. rnum_typezNot a valid number.zNumber too large.)r too_largeF) as_stringrrKc s6|jtur tjdtdd||_tjdi|dS)NzX`Number` field should not be instantiated. Use `Integer`, `Float`, or `Decimal` instead.rQrRrh)rTr1rUrVrrrrj)rdrrrrhrirjs zNumber.__init__rOrcCr)zAReturn the number value for value, given this field's `num_type`.)rr}rhrhri _format_nums zNumber._format_numr{rHc Cs~|dus|dur|jd|dz||WSttfy+}z|jd|d|d}~wty>}z|jd|d|d}~ww)rTFrrNr)rrrr\ OverflowErrorrrhrhrirs zNumber._validatedrkcCst|Sro)rkr}rhrhri _to_stringszNumber._to_stringstr | _NumType | NonecKs*|durdS||}|jr||S|S)zSReturn a string if `self.as_string=True`, otherwise return this field's `num_type`.N)rrr")rdr{rurtrrrhrhrirs zNumber._serialize_NumType | NonecKrrorrrhrhrirrszNumber._deserialize)rrK)rOr)r{rHrOr)r{rrOrk)rOr#)rOr$)rlrrrfloatrrr=rjrrr"rrrrhrhrrir1s    r1csBeZdZdZeZddiZdddfdd Zdfdd ZZ S)r,zAn integer field. :param strict: If `True`, only integer types are valid. Otherwise, any value castable to `int` is valid. :param kwargs: The same keyword arguments that :class:`Number` receives. rzNot a valid integer.F)strictr&rKc s||_tjdi|dSNrh)r&rrj)rdr&rrrhrirjszInteger.__init__r{rHrOintcs,|jrt|tjs|jd|dt|S)Nrr )r&rnumbersIntegralrrrr}rrhrir s zInteger._validated)r&rK)r{rHrOr() rlrrrr(rr=rjrrrhrhrrir,s r,csDeZdZdZeZddiZddddfd d Zdfdd ZZ S)r$a\A double as an IEEE-754 double precision string. :param allow_nan: If `True`, `NaN`, `Infinity` and `-Infinity` are allowed, even though they are illegal according to the JSON specification. :param as_string: If `True`, format the value as a string. :param kwargs: The same keyword arguments that :class:`Number` receives. special;Special numeric values (nan or infinity) are not permitted.F allow_nanrr.rKrc s ||_tjdd|i|dS)Nrrh)r.rrj)rdr.rrrrhrirj"szFloat.__init__r{rHrOr%csFt|}|jdur!t|s|tdks|tdkr!|d|S)NFinfz-infr+)rrr.mathisnanr%rrdr{numrrhrir&s  " zFloat._validated)r.rKrrK)r{rHrOr%) rlrrrr%rr=rjrrrhrhrrir$sr$cs^eZdZdZejZddiZ  dddddfddZddZ dfdd Z dddZ Z S)r aA field that (de)serializes to the Python ``decimal.Decimal`` type. It's safe to use when dealing with money values, percentages, ratios or other numbers where precision is critical. .. warning:: This field serializes to a `decimal.Decimal` object by default. If you need to render your data as JSON, keep in mind that the `json` module from the standard library does not encode `decimal.Decimal`. Therefore, you must use a JSON library that can handle decimals, such as `simplejson`, or serialize to a string by passing ``as_string=True``. .. warning:: If a JSON `float` value is passed to this field for deserialization it will first be cast to its corresponding `string` value before being deserialized to a `decimal.Decimal` object. The default `__str__` implementation of the built-in Python `float` type may apply a destructive transformation upon its input data and therefore cannot be relied upon to preserve precision. To avoid this, you can instead pass a JSON `string` to be deserialized directly. :param places: How many decimal places to quantize the value. If `None`, does not quantize the value. :param rounding: How to round the value during quantize, for example `decimal.ROUND_UP`. If `None`, uses the rounding value from the current thread's context. :param allow_nan: If `True`, `NaN`, `Infinity` and `-Infinity` are allowed, even though they are illegal according to the JSON specification. :param as_string: If `True`, serialize to a string instead of a Python `decimal.Decimal` type. :param kwargs: The same keyword arguments that :class:`Number` receives. .. versionadded:: 1.2.0 r+r,NFr-places int | NoneroundingrIr.rKrc sF|dur tdd| fnd|_||_||_tjdd|i|dS)Nrrrrh)decimalr r4r6r.rrj)rdr4r6r.rrrrhrirjZs  zDecimal.__init__cCsNtt|}|jr|rtdS|jdur%|r%|j|j|jd}|S)NNaN)r6) r7r rkr.is_nanr4 is_finitequantizer6r2rhrhrirks zDecimal._format_numr{rHrOdecimal.Decimalc s\zt|}Wntjy}z|d|d}~ww|js,|s'|r,|d|S)Nrr+)rrr7InvalidOperationrr.r9 is_infinite)rdr{r3rrrhrirus  zDecimal._validatedrkcCs t|dS)Nf)rr}rhrhrir"rszDecimal._to_stringr)r4r5r6rIr.rKrrK)r{rHrOr<)r{r<rOrk) rlrrrr7r rr=rjrrr"rrhrhrrir .s$  r csTeZdZdZhdZhdZddiZddddfd d ZdddZddZ Z S)raA boolean field. :param truthy: Values that will (de)serialize to `True`. If an empty set, any non-falsy value will deserialize to `True`. If `None`, `marshmallow.fields.Boolean.truthy` will be used. :param falsy: Values that will (de)serialize to `False`. If `None`, `marshmallow.fields.Boolean.falsy` will be used. :param kwargs: The same keyword arguments that :class:`Field` receives. >1TYtyONOnonYESYesyesTRUETruetruer>0FNr?nNONonoOFFOffoffFALSEFalsefalserrzNot a valid boolean.N)truthyfalsyr[typing.Iterable | Noner\c s>tjdi||durt||_|durt||_dSdSr')rrjrr[r\)rdr[r\rrrhrirjs  zBoolean.__init__r{rHrurIrtcKsP|durdSz||jvrWdS||jvrWdSWt|Sty'Yt|Sw)NTF)r[r\rrKrrhrhrirs   zBoolean._serializec Ksj|jst|Sz||jvrWdS||jvrWdSWnty-}z|jd|d|d}~ww|jd|d)NTFrr )r[rKr\rrrrhrhrirs  zBoolean._deserialize)r[r]r\r])r{rHrurIrtrH) rlrrrr[r\r=rjrrrrhrhrrirs  rcseZdZUdZejejejejejejdZ de d<ej ej ej ej ej ejdZde d<dZdZd Zd d d d Zdd fdd ZfddZd!ddZd"ddZed"ddZZS)#raA formatted datetime string. Example: ``'2014-12-22T03:12:58.019077+00:00'`` :param format: Either ``"rfc"`` (for RFC822), ``"iso"`` (for ISO8601), ``"timestamp"``, ``"timestamp_ms"`` (for a POSIX timestamp) or a date format string. If `None`, defaults to "iso". :param kwargs: The same keyword arguments that :class:`Field` receives. .. versionchanged:: 3.0.0rc9 Does not modify timezone information on (de)serialization. .. versionchanged:: 3.19 Add timestamp as a format. )isoiso8601rfcrfc822 timestamp timestamp_msz5dict[str, typing.Callable[[typing.Any], str | float]]SERIALIZATION_FUNCSz-dict[str, typing.Callable[[str], typing.Any]]DESERIALIZATION_FUNCSr^datetimedatetimeformatzNot a valid {obj_type}.z#Not a valid {awareness} {obj_type}.z."{input}" cannot be formatted as a {obj_type}.)rinvalid_awarenessrNrrIrOrPc stjdi|||_dSr')rrjr)rdrrrrhrirjs zDateTime.__init__cs0t|||jpt|jj|jp|j|_dSro)rrrr`rcoptsSCHEMA_OPTS_VAR_NAMEDEFAULT_FORMATrrrhrirs zDateTime._bind_to_schemastr | float | NonecKs:|durdS|jp |j}|j|}|r||S||Sro)rrkrdgetstrftime)rdr{rurtr data_format format_funcrhrhrir$s   zDateTime._serialize dt.datetimec Ksh|jp|j}|j|}z|r||WS|||WStttfy3}z |jd||j d|d}~ww)Nr)robj_type) rrkrerm_make_object_from_formatrrr\rOBJ_TYPE)rdr{rurrrofuncrrhrhrir-s   zDateTime._deserializecCstj||Sro)dtrfstrptimer{rorhrhrirs9sz!DateTime._make_object_from_formatro)rrIrOrP)rOrlrOrq)rlrrrr isoformat rfcformatrbrcrdrfrom_iso_datetimefrom_rfcfrom_timestampfrom_timestamp_msrerkrtrjr=rjrrr staticmethodrsrrhrhrrirs:       rc>eZdZdZdZ ddddfd d Zdfdd ZZS)r/aA formatted naive datetime string. :param format: See :class:`DateTime`. :param timezone: Used on deserialization. If `None`, aware datetimes are rejected. If not `None`, aware datetimes are converted to this timezone before their timezone information is removed. :param kwargs: The same keyword arguments that :class:`Field` receives. .. versionadded:: 3.0.0rc9 naiveN)timezonerrIrdt.timezone | NonerOrPc  tjdd|i|||_dSNrrh)rrjr)rdrrrrrhrirjM zNaiveDateTime.__init__rqc sVtj|||fi|}t|r)|jdur|jd|j|jd||jjdd}|SNrh) awarenessrr)tzinfo) rrr rr AWARENESSrt astimezonereplacerdr{rurrrrrhrirWs zNaiveDateTime._deserializero)rrIrrrOrPryrlrrrrrjrrrhrhrrir/>s  r/cr)racA formatted aware datetime string. :param format: See :class:`DateTime`. :param default_timezone: Used on deserialization. If `None`, naive datetimes are rejected. If not `None`, naive datetimes are set this timezone. :param kwargs: The same keyword arguments that :class:`Field` receives. .. versionadded:: 3.0.0rc9 awareN)default_timezonerrIrdt.tzinfo | NonerOrPc rr)rrjr)rdrrrrrhrirjrrzAwareDateTime.__init__rqc sPtj|||fi|}t|s&|jdur|jd|j|jd|j|jd}|Sr)rrr rrrrtrrrrhrir|s zAwareDateTime._deserializero)rrIrrrOrPryrrhrhrrirds  rc@sDeZdZdZejejdZejejdZdZ dZ dZ e ddZ dS) r6zA formatted time string. Example: ``'03:12:58.019077'`` :param format: Either ``"iso"`` (for ISO8601) or a date format string. If `None`, defaults to "iso". :param kwargs: The same keyword arguments that :class:`Field` receives. r^r_r^time timeformatcCtj||Sro)rvrfrwrrxrhrhrirszTime._make_object_from_formatN)rlrrrr to_iso_timerd from_iso_timererkrtrjrrsrhrhrhrir6s r6c@sNeZdZdZdddZejejdZejejdZ dZ dZ dZ e d d Zd S) rzISO8601-formatted date string. :param format: Either ``"iso"`` (for ISO8601) or a date format string. If `None`, defaults to "iso". :param kwargs: The same keyword arguments that :class:`Field` receives. zNot a valid date.z("{input}" cannot be formatted as a date.rrrr^date dateformatcCrro)rvrfrwrrxrhrhrirsrzDate._make_object_from_formatN)rlrrrr=r to_iso_daterd from_iso_datererkrtrjrrsrhrhrhrirs rcs^eZdZdZdZdZdZdZdZdZ dZ d d d Z ee fdfdd Z ddZddZZS)r7aA field that (de)serializes a :class:`datetime.timedelta` object to an integer or float and vice versa. The integer or float can represent the number of days, seconds or microseconds. :param precision: Influences how the integer or float is interpreted during (de)serialization. Must be 'days', 'seconds', 'microseconds', 'milliseconds', 'minutes', 'hours' or 'weeks'. :param serialization_type: Whether to (de)serialize to a `int` or `float`. :param kwargs: The same keyword arguments that :class:`Field` receives. Integer Caveats --------------- Any fractional parts (which depends on the precision used) will be truncated when serializing using `int`. Float Caveats ------------- Use of `float` when (de)serializing may result in data precision loss due to the way machines handle floating point values. Regardless of the precision chosen, the fractional part when using `float` will always be truncated to microseconds. For example, `1.12345` interpreted as microseconds will result in `timedelta(microseconds=1)`. .. versionchanged:: 3.17.0 Allow (de)serialization to `float` through use of a new `serialization_type` parameter. `int` is the default to retain previous behaviour. daysseconds microseconds millisecondsminuteshoursweekszNot a valid period of time.z-{input!r} cannot be formatted as a timedelta.r precisionrkserialization_typetype[int | float]c s|}|j|j|j|j|j|j|jf}||vr0dd dd|ddD|d}t ||t t fvr:t d||_ ||_tjdi|dS)Nz!The precision must be {} or "{}"., cSsg|]}d|dqS)"rhrrhrhrirsz&TimeDelta.__init__..z2The serialization type must be one of int or floatrh)lowerDAYSSECONDS MICROSECONDS MILLISECONDSMINUTESHOURSWEEKSrjoinr\r(r%rrrrj)rdrrrunitsrrrhrirjs&   zTimeDelta.__init__cKsf|durdStjdi|jdi}|jtur$t|}t|}||S|jtus+J||S)Nrrh) rv timedeltarrr(rtimedelta_to_microsecondsr% total_seconds)rdr{rurtr base_unitdeltaunitrhrhrir s   zTimeDelta._serializec Kszz||}Wnttfy}z|d|d}~ww|j|i}z tjdi|WSty<}z|d|d}~ww)Nrrh)rrr\rrrvrr!rrhrhrirs   zTimeDelta._deserialize)rrkrr)rlrrrrrrrrrrr=r(rjrrrrhrhrrir7s" r7csPeZdZdZeZddiZ  ddfdd Zfd d Zd d Z ddZ Z S)raAn abstract class for objects with key-value pairs. This class should not be used within schemas. :param keys: A field class or instance for dict keys. :param values: A field class or instance for dict values. :param kwargs: The same keyword arguments that :class:`Field` receives. .. note:: When the structure of nested data is not known, you may omit the `keys` and `values` arguments to prevent content validation. .. versionadded:: 3.0.0rc4 .. versionchanged:: 3.24.0 `Mapping ` should no longer be used as a field within a `Schema `. Use `Dict ` instead. rzNot a valid mapping type.NrField | type[Field] | Nonevaluesc s|jtur tjdtddtjdi||durd|_nzt||_Wnt y6}zt d|d}~ww|dur@d|_ dSzt||_ Wnt yX}zt d|d}~wwt |j t rk|j j|_|j j|_dSdS)Nz?`Mapping` field should not be instantiated. Use `Dict` instead.rQrRzC"keys" must be a subclass or instance of marshmallow.base.FieldABC.zE"values" must be a subclass or instance of marshmallow.base.FieldABC.rh)rTrrUrVrrrj key_fieldrr r\ value_fieldrr0rr)rdrrrrrrhrirj:sF    zMapping.__init__cszt|||jrt|j|_|j||t|jtr(|j|j_|j|j_|j r;t|j |_ |j ||dSdSro) rrrrprrr0rrrrrrhrir`s   zMapping._bind_to_schemac  s|durdSjsjs|Sjdurdd|D}n fdd|D}}jdurF|D]\}}||vrC||||<q5|S|D]\}}jj|ddfi|||<qJ|S)NcSi|]}||qSrhrhrkrhrhri tz&Mapping._serialize..cs&i|]}|jj|ddfiqSro)rrrrrdrhrirvs)rr mapping_typeitemsr) rdr{rurtrrrrrrhrrirls&      "zMapping._serializec Kst|ts |d|js|js||Stt}|jdur'dd|D}n.i}|D])}z|jj |fi|||<Wq+t yT}z |j ||d<WYd}~q+d}~ww|} |jdurr| D]\} } | |vrp| | || <qbnI| D]D\}} z |jj | fi|} Wn)t y}z|j ||d<|j dur||vr|j | ||<WYd}~qvd}~ww||vr| | ||<qv|rt || d| S)NrcSrrhrhrrhrhrirrz(Mapping._deserialize..rr{r)r_Mappingrrrr collections defaultdictrrr rfrr)rdr{rurrrrrrrrrval deser_valrhrhrirsJ          zMapping._deserializer)rrrr) rlrrrrrr=rjrrrrrhrhrrir$s & rc@seZdZdZeZdS)r!a1A dict field. Supports dicts and dict-like objects. Extends Mapping with dict as the mapping_type. Example: :: numbers = fields.Dict(keys=fields.Str(), values=fields.Float()) :param kwargs: The same keyword arguments that :class:`Mapping` receives. .. versionadded:: 2.1.0 N)rlrrrrrrhrhrhrir!s r!cs6eZdZdZddiZddddddfddZZS)r9aAn URL field. :param default: Default value for the field if the attribute is not set. :param relative: Whether to allow relative URLs. :param absolute: Whether to allow absolute URLs. :param require_tld: Whether to reject non-FQDN hostnames. :param schemes: Valid schemes. By default, ``http``, ``https``, ``ftp``, and ``ftps`` are allowed. :param kwargs: The same keyword arguments that :class:`String` receives. rzNot a valid URL.FTN)relativeabsoluteschemes require_tldrrKrrrrc sVtjdi|||_||_||_tj|j|j||j|jdd}|j d|dS)Nr)rrrrrrrh) rrjrrrrrrFrXinsert)rdrrrrr validatorrrhrirjs z Url.__init__)rrKrrKrrrrKrlrrrr=rjrrhrhrrir9s r9cs*eZdZdZddiZdfdd ZZS) r"zAn email field. :param args: The same positional arguments that :class:`String` receives. :param kwargs: The same keyword arguments that :class:`String` receives. rzNot a valid email address.rOrPcs6tj|i|tj|jdd}|jd|dS)Nr)rr)rrjrr"rFrXr)rdargsrrrrhrirjszEmail.__init__)rOrPrrhrhrrir"sr"csPeZdZUdZddiZdZded<ddfd d Zdd dZdddZ Z S)rzA IP address field. :param exploded: If `True`, serialize ipv6 address in long form, ie. with groups consisting entirely of zeros included. .. versionadded:: 3.8.0 invalid_ipzNot a valid IP address.N type | NoneDESERIALIZATION_CLASSFexplodedctj|i|||_dSrorrjrrdrrrrrhrirj z IP.__init__rOrIcK|durdS|jr |jS|jSror compressedrrhrhrir  z IP._serialize4ipaddress.IPv4Address | ipaddress.IPv6Address | Nonec KN|durdSz |jp tjt|WSttfy&}z|d|d}~ww)Nr)r ipaddress ip_addressrr r\rrrrhrhrir  zIP._deserializer)rOr rlrrrr=rrrjrrrrhrhrrirs   rc@eZdZdZddiZejZdS)r'z7A IPv4 address field. .. versionadded:: 3.8.0 rzNot a valid IPv4 address.N)rlrrrr=r IPv4Addressrrhrhrhrir' r'c@r)r)z7A IPv6 address field. .. versionadded:: 3.8.0 rzNot a valid IPv6 address.N)rlrrrr=r IPv6Addressrrhrhrhrir)*rr)csReZdZUdZddiZdZded<dddfd d ZdddZdddZ Z S)r&aA IPInterface field. IP interface is the non-strict form of the IPNetwork type where arbitrary host addresses are always accepted. IPAddress and mask e.g. '192.168.0.2/24' or '192.168.0.2/255.255.255.0' see https://python.readthedocs.io/en/latest/library/ipaddress.html#interface-objects :param exploded: If `True`, serialize ipv6 interface in long form, ie. with groups consisting entirely of zeros included. invalid_ip_interfacezNot a valid IP interface.NrrFrrrKcrrorrrrhrirjGrzIPInterface.__init__rOrIcKrrorrrhrhrirKrzIPInterface._serialize:None | (ipaddress.IPv4Interface | ipaddress.IPv6Interface)c Kr)Nr)rr ip_interfacerr r\rrrrhrhrirRrzIPInterface._deserialize)rrKr)rOrrrhrhrrir&5s   r&c@r)r(zA IPv4 Network Interface field.rzNot a valid IPv4 interface.N)rlrrrr=rr(rrhrhrhrir(_ r(c@r)r*zA IPv6 Network Interface field.rzNot a valid IPv6 interface.N)rlrrrr=rr*rrhrhrhrir*grr*cs@eZdZdZddiZdddfd d Zd d ZddZZS)ra#An Enum field (de)serializing enum members by symbol (name) or by value. :param enum: Enum class :param by_value: Whether to (de)serialize by value or by name, or Field class or instance to use to (de)serialize by value. Defaults to False. If `by_value` is `False` (default), enum members are (de)serialized by symbol (name). If it is `True`, they are (de)serialized by value using :class:`Raw`. If it is a field instance or class, they are (de)serialized by value using this field. .. versionadded:: 3.18.0 rzMust be one of: {choices}.F)by_valueenumtype[EnumType]rbool | Field | type[Field]c stjdi||_|_|dur't_dfdd|jD_dS|dur0t _nzt |_Wnt yH}zt d|d}~wwdfdd|D_dS) NFrc3s$|] }tj|ddVqdSro)rkrrrmrmrhrirs z Enum.__init__..TzX"by_value" must be either a bool or a subclass or instance of marshmallow.base.FieldABC.c3s&|]}tj|jddVqdSro)rkrrr{rrmrhrirs rh) rrjrrr5rr __members__ choices_textr3rr r\)rdrrrrrrmrirjs. z Enum.__init__cKs8|durdS|jr |j}n|j}|jj|||fi|Sro)rr{rbrr)rdr{rurtrrrhrhrirs zEnum._serializec Ks|jj|||fi|}|jr+z||WSty*}z |jd|jd|d}~wwzt|j|WStyG}z |jd|jd|d}~ww)Nr)choices) rrrrr\rrr`r)rdr{rurrrrrhrhrirs zEnum._deserialize)rrrr) rlrrrr=rjrrrrhrhrriros! rcsHeZdZdZdZ  ddfdd Zfd d Zd d Zd dZZ S)r.aA field that takes the value returned by a `Schema ` method. :param serialize: The name of the Schema method from which to retrieve the value. The method must take an argument ``obj`` (in addition to self) that is the object to be serialized. :param deserialize: Optional name of the Schema method for deserializing a value The method must take a single argument ``value``, which is the value to deserialize. .. versionchanged:: 2.3.0 Deprecated ``method_name`` parameter in favor of ``serialize`` and allow ``serialize`` to not be passed at all. .. versionchanged:: 3.0.0 Removed ``method_name`` parameter. FNrrIrc sZt|ot| |d<t|ot| |d<tjdi|||_||_d|_d|_dSNrErDrh)rKrrjserialize_method_namedeserialize_method_name_serialize_method_deserialize_methodrdrrrrrhrirjs zMethod.__init__csF|jr tt||j|_|jrtt||j|_t||dSro) rrcallable_or_raiser`rrrrrrrrhrirs  zMethod._bind_to_schemacKs|jdur ||StSro)rrWrrhrhrir  zMethod._serializecKs|jdur ||S|Sro)rrrhrhrirrzMethod._deserializer)rrIrrI) rlrrrrrjrrrrrhrhrrir.s  r.csDeZdZdZdZ  ddfdd Zd d Zd d Zd dZZ S)r%aA field that takes the value returned by a function. :param serialize: A callable from which to retrieve the value. The function must take a single argument ``obj`` which is the object to be serialized. It can also optionally take a ``context`` argument, which is a dictionary of context variables passed to the serializer. If no callable is provided then the ```load_only``` flag will be set to True. :param deserialize: A callable from which to retrieve the value. The function must take a single argument ``value`` which is the value to be deserialized. It can also optionally take a ``context`` argument, which is a dictionary of context variables passed to the deserializer. If no callable is provided then ```value``` will be passed through unchanged. .. versionchanged:: 2.3.0 Deprecated ``func`` parameter in favor of ``serialize``. .. versionchanged:: 3.0.0a1 Removed ``func`` parameter. FNrbtyping.Callable[[typing.Any], typing.Any] | typing.Callable[[typing.Any, dict], typing.Any] | Nonerc sbt|ot| |d<t|ot| |d<tjdi||o%t||_|o-t||_dSr)rKrrjrrserialize_funcdeserialize_funcrrrhrirj s zFunction.__init__cKs||j||Sro)_call_or_raiserrrhrhrir!szFunction._serializecKs|jr ||j||S|Sro)rrrrhrhrir$szFunction._deserializecCsFtt|dkr|jjdurd|}t||||jjS||S)Nrz(No context available for Function field )rr get_func_argsrarr )rdrur{rurrhrhrir)s   zFunction._call_or_raiser)rrrr) rlrrrrrjrrrrrhrhrrir%sr%cs6eZdZdZdZd fdd ZddZd d ZZS) raA field that (de)serializes to a preset constant. If you only want the constant added for serialization or deserialization, you should use ``dump_only=True`` or ``load_only=True`` respectively. :param constant: The constant to return for the field attribute. FconstantrHc s(tjdi|||_||_||_dSr')rrjrr>r?)rdrrrrhrirj<s zConstant.__init__cO|jSrorrdr{rrrhrhrirBzConstant._serializecOrrorr rhrhrirEr zConstant._deserialize)rrH) rlrrrrrjrrrrhrhrrir2s rcs,eZdZdZfddZfddZZS)InferredzA field that infers how to serialize, based on the value type. .. warning:: This class is treated as private API. Users should not need to use this class directly. csti|_dSro)rrj _field_cachermrrhrirjRs  zInferred.__init__c sl|jjt|}|durt}n|j|}|dur+|}||j|j||j|<|j |||fi|Sro) rc TYPE_MAPPINGrmrrr rrbrar)rdr{rurtr field_clsrrrhrirXs  zInferred._serialize)rlrrrrjrrrhrhrrir Is r )X __future__rrrprfrvr7rr0r)rrrUcollections.abcrr marshmallowrrrrmarshmallow.basermarshmallow.exceptionsr r r marshmallow.utilsr r rrrWmarshmallow.validaterrmarshmallow.warningsrr TYPE_CHECKINGrrEnumTyperrr__all__r#r3r0r2r-r8r5rTypeVarrGenericr1r(r,r%r$r rrr/rr6rr7r!r9r"rr'r)r&r(r*r.r%rr rr4rr+rhrhrhris     )K?>X ;UcX&%e(%  *I;?