jdZddlZddlZddlZddlZddlmZddlmZddl m Z m Z ddl m Z ddlmZddlmZdd lmZdd lmZdd lmZdd lmZmZdd lmZm Z ddlm Z ddl!m"Z"ddl#m$Z$m%Z%m&Z&ddl'm(Z(m)Z)m*Z*m+Z+m,Z,ddl-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3ddl4m5Z5m6Z6m7Z7m8Z8ddlm9Z9m:Z:m;Z;mZ>m?Z?m@Z@mAZAmBZBmZmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUddlVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]ddlm^Z^m_Z_m`Z`maZaddlVmbZbmcZcdZddZedZfGddeZgGddehZidZjGd d!egei"ZkGd#d$egZld%ZmGd&d'ekZnGd(d)enZodS)*a Serializers and ModelSerializers are similar to Forms and ModelForms. Unlike forms, they are not constrained to dealing with HTML output, and form encoded input. Serialization in REST framework is a two-phase process: 1. Serializers marshal between complex types like model instances, and python primitives. 2. The process of marshaling between python primitives and request and response content is handled by parsers and renderers. N) defaultdict)Mapping)FieldDoesNotExistImproperlyConfigured)ValidationError)models)Field)timezone)cached_property) gettext_lazy)!get_referenced_base_fields_from_qpostgres_fields) ErrorDetailr)get_error_detail) api_settings)html model_metarepresentation)ClassLookupDictget_field_kwargsget_nested_relation_kwargsget_relation_kwargsget_url_kwargs) BindingDict BoundFieldJSONBoundFieldNestedBoundField ReturnDict ReturnList)UniqueForDateValidatorUniqueForMonthValidatorUniqueForYearValidatorUniqueTogetherValidator)BigIntegerField BooleanField CharField ChoiceField DateField DateTimeField DecimalField DictField DurationField EmailFieldr FileField FilePathField FloatField HiddenField HStoreFieldIPAddressField ImageField IntegerField JSONField ListField ModelFieldMultipleChoiceField ReadOnlyField RegexFieldSerializerMethodField SlugField TimeFieldURLField UUIDField)HyperlinkedIdentityFieldHyperlinkedRelatedFieldManyRelatedFieldPrimaryKeyRelatedField RelatedFieldSlugRelatedFieldStringRelatedField)CreateOnlyDefaultCurrentUserDefault SkipFieldempty) Hyperlink PKOnlyObject) read_only write_onlyrequireddefaultinitialsourcelabel help_textstyleerror_messages allow_emptyinstancedatapartialcontext allow_null max_length min_length)rXr_r^__all__ceZdZdZdeffd ZfdZdZedZ dZ dZ d Z d Z d Zd d dZedZedZedZxZS)BaseSerializera The BaseSerializer class provides a minimal class which may be used for writing custom serializer implementations. Note that we strongly restrict the ordering of operations/properties that may be used on the serializer in order to enforce correct usage. In particular, if a `data=` argument is passed then: .is_valid() - Available. .initial_data - Available. .validated_data - Only available after calling `is_valid()` .errors - Only available after calling `is_valid()` .data - Only available after calling `is_valid()` If a `data=` argument is not passed then: .is_valid() - Not available. .initial_data - Not available. .validated_data - Not available. .errors - Not available. .data - Available. Nc ||_|tur||_|dd|_|di|_|ddt jdi|dS)Nr[Fr\many)rYrK initial_datapopr[_contextsuper__init__)selfrYrZkwargs __class__s i/var/www/finuniver-perm.ru/html/portfolio/venv/lib/python3.11/site-packages/rest_framework/serializers.pyrjzBaseSerializer.__init__rs~  u   $D zz)U33  9b11  64   ""6"""""c|ddr |j|i|Stj|g|Ri|S)NrdF)rg many_initri__new__)clsargsrlrms rnrrzBaseSerializer.__new__{sX ::fe $ $ 2 3=$1&11 1uwws4T444V444roc|SNre)rsrtrls rn__class_getitem__z BaseSerializer.__class_getitem__s roc*i}tD]}||d}||||< ||i||d<|d|Dt |dd}t |dt }||i|S)a This method implements the creation of a `ListSerializer` parent class when `many=True` is used. You can customize it if you need to control which keyword arguments are passed to the parent, and which are passed to the child. Note that we're over-cautious in passing most arguments to both parent and child classes in order to try to cover the general case. If you're overriding this method you'll probably want something much simpler, eg: @classmethod def many_init(cls, *args, **kwargs): kwargs['child'] = cls() return CustomListSerializer(*args, **kwargs) Nchildc,i|]\}}|tv||Sre)LIST_SERIALIZER_KWARGS.0keyvalues rn z,BaseSerializer.many_init..s4   %3,,, ,,,roMetalist_serializer_class)LIST_SERIALIZER_KWARGS_REMOVErgupdateitemsgetattrListSerializer)rsrtrl list_kwargsr~rmetars rnrqzBaseSerializer.many_inits" 0 ) )CJJsD))E #( C "sD3F33 G  )/      sFD)) '.E~ V V$$d:k:::roc td)Nz*`to_internal_value()` must be implemented.NotImplementedErrorrkrZs rnto_internal_valuez BaseSerializer.to_internal_value!"NOOOroc td)Nz*`to_representation()` must be implemented.r)rkrYs rnto_representationz BaseSerializer.to_representationrroc td)Nz`update()` must be implemented.rrkrYvalidated_datas rnrzBaseSerializer.update!"CDDDroc td)Nz`create()` must be implemented.rrkrs rncreatezBaseSerializer.createrroc t|ds Jd|jr Jdd|vs Jdt|dr Jdi|j|}|j2||j||_|j Jdn+|||_|j Jd |jS) N_errorsz5You must call `.is_valid()` before calling `.save()`.zz.sM---%j#U++-:uyy445---roc|djS)N)_creation_counter)xs rnz:SerializerMetaclass._get_declared_fields.."s !A$"8ro)r~c2||Srv)add)nameknowns rnvisitz7SerializerMetaclass._get_declared_fields..visit)s IIdOOOKrocg|]B}t|dr0|jD]\}}|v ||fCS)_declared_fields)rrr)r}baserfrrs rnrz.-sv   /A!B!B  06688  aD.QsG   U *UT7O<<I5'   ro) rrDjangoValidationErrorrrrrrrNON_FIELD_ERRORS_KEY)rrs rnas_serializer_errorr:s cO-BC D DDDD#,--!#&&&'""    $llnn     FD ! !   -v  )F8 roceZdZdediZdZedZedZ edZ dZ dZ d Z d Zefd Zd Zfd ZdZdZdZdZdZdZefdZefdZxZS) Serializerinvalidz8Invalid data. Expected a dictionary, but got {datatype}.c|s||dS|ddD]}||vri||<||}|||d<dS)aI Similar to Python's built in `dictionary[key] = value`, but takes a list of nested keys instead of a single key. set_value({'a': 1}, [], {'b': 2}) -> {'a': 1, 'b': 2} set_value({'a': 1}, ['x'], 2) -> {'a': 1, 'x': 2} set_value({'a': 1}, ['x', 'y'], 2) -> {'a': 1, 'x': {'y': 2}} N)r)rk dictionarykeysrr~s rn set_valuezSerializer.set_valueeso    e $ $ $ F9 ) )C*$$"$ 3#CJJ$ 48roct|}|D] \}}|||< |S)z? A dictionary of {field_name: field_instance}. )r get_fieldsr)rkrr~rs rnrzSerializer.fieldsysJT""//++1133  JCF3KK roc#XK|jD] }|js|VdSrv)rvaluesrNrkfields rn_writable_fieldszSerializer._writable_fieldssA[''))  E?    roc#XK|jD] }|js|VdSrv)rrrOrs rn_readable_fieldszSerializer._readable_fieldssB[''))  E#    roc4tj|jS)zG Returns a dictionary of {field_name: field_instance}. )copydeepcopyrrks rnrzSerializer.get_fieldss}T2333roclt|dd}t|dd}|rt|ngS)z8 Returns a list of validator callables. rN validators)rr)rkrrs rnget_validatorszSerializer.get_validatorss> tVT**T<66 #-5tJ25roctdrAtjtsiSfdjDSdjDS)Nrfci|]H\}}|jtu&|j-||jISre) get_valuerfrKrN)r}rrrks rnrz*Serializer.get_initial..s]%JOOD$566eCCODEOOD,=>>CCCrocPi|]#}|j |j|$Sre)rNrrr}rs rnrz*Serializer.get_initial..sA   ?  e//11   ro)rrrfrrrrrs`rnrzSerializer.get_initials 4 ( ( d/99  )-):):)<)<   ++--    roctj|r"tj||jptS||jtS)N)prefix)r is_html_inputparse_html_dictrrKgetrkrs rnrzSerializer.get_valuesK  j ) ) U' 4?KKKTu T~~dou555rocD||\}}|r|S||} ||||}| Jdn6#tt f$r"}t t |d}~wwxYw|Sz We override the default `run_validation`, because the validation performed by validators and the `.validate()` method should be coerced into an error dictionary with a 'non_fields_error' key. Nz,.validate() should return the validated data)rvalidate_empty_valuesrrun_validatorsvalidaterrrrkrZis_empty_valuerrs rnrzSerializer.run_validation "&!;!;D!A!A  K&&t,, C    & & &MM%((E$$&T$$$$!67 C C C!).sU    &+mu&<&<5 Dict of primitive datatypes. N)r get_attributerJrrMpkrr)rkrYr%rr attributecheck_for_nones rnrzSerializer.to_representations& K KE !//99     .8 <-P-P_Y\\V_N%(,E$%%(-(?(? (J(JE$%% s % 22c|Srvrerkrs rnr zSerializer.validate, roc.tj|dSNr)indent)rserializer_reprrs rn__repr__zSerializer.__repr__/s-d1====roc#`K|jD]}||jVdSrv)rrrrs rn__iter__zSerializer.__iter__6sD['')) ) )Eu'( ( ( ( ( ) )rocb|j|}|j|}t|dr|j|nd}t |t rt|||St |trt|||St|||S)Nr) rrZrrrrrrr6rr)rkr~rrerrors rn __getitem__zSerializer.__getitem__:s C  c""(/i(@(@J $$$d eZ ( ( 9#E5%88 8 eY ' ' 7!%66 6%...rocLtj}t||SN serializer)rirZrrkr%rms rnrZzSerializer.dataG!ggl#$////roctj}t|trNt |dkr;t |ddddkr t dd}tj|gi}t||SNrrrnullzNo data providedrr=) rirrrlenrrrrrrkr%rrms rnrzSerializer.errorsLsggn c4  @SXX]]ws1vvt7T7TX^7^7^!!3&AAAF4vh?C#$////ro)rrr_default_error_messagesrr rrrrrrrrrKrrr rrr r5r7r:rZrrrs@rnrr`s11OPP%%%(  _ X X 444666   &666#(( , , , , ,###J4>>>)))///0000X00000X00000ror) metaclassceZdZdZdZededededdZfdZd Zd Z e fd Z d Z d Z dZdZdZdZdZdddZdZefdZefdZxZS)rNTz5Expected a list of items but got type "{input_type}".zThis list may not be empty.z9Ensure this field has no more than {max_length} elements.z5Ensure this field has at least {min_length} elements.) not_a_listrKr^r_c|dtj|j|_|dd|_|dd|_|dd|_|j Jdtj|jr Jdtj |i||j d| dS) NryrXTr^r_z`child` is a required argument.z"`child` has not been instantiated.)rparent) rgrrryrXr^r_inspectisclassrirjbind)rkrtrlrms rnrjzListSerializer.__init__esZZtz)B)BCC !::mT:: **\488 **\488z%%'H%%%?4:..TT0TTTT$)&))) 2d33333rocZt|dr||jSgS)Nrf)rrrfrs rnrzListSerializer.get_initialos0 4 ( ( =))$*;<< < roctj|r!tj||jtS||jtS)zE Given the input dictionary, return the field value. )rrQ)rrparse_html_listrrKrrs rnrzListSerializer.get_valuetsI  j ) ) [' 4?TYZZZ Z~~dou555rocD||\}}|r|S||} ||||}| Jdn6#tt f$r"}t t |d}~wwxYw|Sr r rs rnrzListSerializer.run_validation~rrc6|j|S)a% Run validation on child serializer. You may need to override this method to support multiple updates. For example: self.child.instance = self.instance.get(pk=data['id']) self.child.initial_data = data return super().run_child_validation(data) )ryrrs rnrun_child_validationz#ListSerializer.run_child_validationsz((...rocltj|rtj|g}t|tsQ|jdt|j}ttj |gid|j s>t|dkr+|jd}ttj |gid|j\t||jkrD|jd|j }ttj |gid|j\t||jkrD|jd |j }ttj |gid g}g}|D]s} ||}|||iC#t$r$}||jYd}~ld}~wwxYwt'|rt||S) zY List of dicts of native values <- List of dicts of primitive datatypes. rQrJ) input_typerrrKNr^)r^r_)r_)rrrSrrrWr!r"rrrrrXrDr^r_rVappendrany)rkrZr$r%ritem validatedrs rnrz ListSerializer.to_internal_valuesu  d # # :'b999D$%% "),7>>::.?G"1G9# """ " CIINN)'2G!1G9#  ? &3t99t+F+F),7>>$/>ZZG!1G9# """ " ? &3t99t+F+F),7>>$/>ZZG!1G9# """ " " "D " 55d;;  9%%% b!!!! # * * * cj)))))))) * v;; *!&)) ) s%G%% H/HHct|tjjr|n|}fd|DS)zS List of object instances -> List of dicts of primitive datatypes. cDg|]}j|Sre)ryr)r}r\rks rnrz4ListSerializer.to_representation..s6   37DJ ( ( . .   ro)rrmanager BaseManagerall)rkrZiterables` rnrz ListSerializer.to_representationsV ",D&.2L!M!MW488:::SW    ;C    roc|Srvrer/s rnr zListSerializer.validater0roc td)Na'Serializers with many=True do not support multiple update by default, only multiple create. For updates it is unclear how to deal with insertions and deletions. If you need to support multiple update, use a `ListSerializer` class and override `.update()` so you can specify the behavior exactly.rrs rnrzListSerializer.updates! C   roc fd|DS)NcDg|]}j|Sre)ryr)r}rrks rnrz)ListSerializer.create..s6   ).DJ  e $ $   rorers` rnrzListSerializer.creates.    2@    roc dvs Jdfd|jD}|j2||j||_|j Jdn+|||_|j Jd|jS)z= Save and return a list of object instances. rrcg|]}i| Srere)r}rrls rnrz'ListSerializer.save..s1   $) u     roNrr)rrYrrrs ` rnrzListSerializer.saves v%%% C&%%    -1-@    = $ KK ~FFDM=,,?-,,,!KK77DM=,,?-,,}roFrc^t|ds Jdt|dsR ||j|_g|_n*#t $r}g|_|j|_Yd}~nd}~wwxYw|jr|rt |jt|j Srrrs rnrzListSerializer.is_valid st^,,   A   t.// " "'+':':4;L'M'M$ " # * * *')$"z  * < /O /!$+.. . %%%%rc.tj|dSr2)r list_reprrs rnr5zListSerializer.__repr__!s'Q7777rocLtj}t||Sr<)rirZrr?s rnrZzListSerializer.data'r@roc^tj}t|trNt |dkr;t |ddddkr t dd}tj|gi}t|trt||St||SrB) rirrrrDrrrrrrrrEs rnrzListSerializer.errors,sggn c4  @SXX]]ws1vvt7T7TX^7^7^!!3&AAAF4vh?C c4  4cd333 3#$////ro)rrrryrdrFrGrjrrrKrrVrrr rrrrr5rrZrrrs@rnrrZs E DaOPP011aSTTaOPP 44444 666#(( / / /000d          >+0&&&&&,888 0000X0 0 0 0 0X 0 0 0 0 0rorc|jj}tj|t fd|jDr4Jd||jj|jj t fd|jDr4Jd||jj|jj dS)a Enforce explicit handling of writable nested and dotted-source fields. This helper raises clear and actionable errors when a serializer attempts to perform writable nested updates or creates using the default `ModelSerializer` behavior. Writable nested relationships and dotted-source fields are intentionally unsupported by default due to ambiguous persistence semantics. Developers must either: - Override the `.create()` / `.update()` methods explicitly, or - Mark nested serializers as `read_only=True` This check is invoked internally by default `ModelSerializer.create()` and `ModelSerializer.update()` implementations. Eg. Suppose we have a `UserSerializer` with a nested profile. How should we handle the case of an update, where the `profile` relationship does not exist? Any of the following might be valid: * Raise an application error. * Silently ignore the nested part of the update. * Automatically create a profile instance. c3K|]W}t|to=|jvo4|jjvo&t|jtt fVXdSrv)rrbrS relationsrrr}rmodel_field_infors rn z0raise_errors_on_nested_writes..]s  5.)) ?  ' ? )3 3 ? >%,/$>> rozThe `.{method_name}()` method does not support writable nested fields by default. Write an explicit `.{method_name}()` method for serializer `{module}.{class_name}`, or set `read_only=True` on nested serializer fields.) method_namemodule class_namec3K|]l}t|jdkoO|jdvo@|jdjvo,t|jdtt fVmdS)rrN)rDr#rqrrrrrs rnrtz0raise_errors_on_nested_writes..|s  E !# H  A . 0 H  A "2"< < H >%"4Q"784,GG rozThe `.{method_name}()` method does not support writable dotted-source fields by default. Write an explicit `.{method_name}()` method for serializer `{module}.{class_name}`, or set `read_only=True` on dotted-source serializer fields.N) rmodelrget_field_infor[rr!rmrr)rur>r ModelClassrss ` @rnraise_errors_on_nested_writesr|<s;2&J!0<<  0  $%+F#'2!+4%+% % >  0  +,26#'2!+4,2, , roceZdZdZiejeejeejeej e ej e ej e ej e ej e ejeejeejeejeejeejeejeejeeje ejeejeejeejeeje ejeejeejeeje ej!e!i Z"e#edr e$e"ej$<e%re&e"e%j&<e'e"e%j(<e$e"e%j$<e)Z*e+Z,e-Z.e/Z0dZ1dZ2dZ3dZ4dZ5dZ6d Z7d Z8d Z9d Z:d Z;dZdZ?dZ@dZAdZBdZCdZDdZEdZFdS)ModelSerializera A `ModelSerializer` is just a regular `Serializer`, except that: * A set of default fields are automatically populated. * A set of default validators are automatically populated. * Default `.create()` and `.update()` implementations are provided. The process of automatically determining a set of serializer fields based on the model fields is reasonably complex, but you almost certainly don't need to dig into the implementation. If the `ModelSerializer` class *doesn't* generate the set of fields that you need you should either declare the extra/differing fields explicitly on the serializer class, or simply use a `Serializer` class. r6Nc rtd|||jj}tj|}i}|jD](\}}|jr||vr||||<) |j j di|}nl#t$r_tj }d|jd|j jd|jd|j jd|jjd| } t| wxYw|r?|D]*\}} t#||} | | +|S)aj We have a bit of extra checking around this in order to provide descriptive messages when something goes wrong, but this method is essentially just: return ExampleModel.objects.create(**validated_data) If there are many to many fields present on the instance then they cannot be set until the model is instantiated, in which case the implementation is like so: example_relationship = validated_data.pop('example_relationship') instance = ExampleModel.objects.create(**validated_data) instance.example_relationship = example_relationship return instance The default implementation also does not handle nested relationships. If you want to support writable nested relationships you'll need to write an explicit `.create()` method. rz Got a `TypeError` when calling `rzs.create()`. This may be because you have a writable field on the serializer class that is not a valid argument to `zF.create()`. You may need to make the field read-only, or override the zD.create() method to handle this correctly. Original exception was: re)r|rryrrzrqrto_manyrg_default_managerr TypeError traceback format_excrrrmrr) rkrr{info many_to_manyr relation_inforYtbrrrs rnrzModelSerializer.creates* &hnEEEY_ (44 )-)=)=)?)? J J %J $ J**F*F+9+=+=j+I+I Z( !9z29KKNKKHH ! ! !%''BB'''/444'''/444N+++B   C.. % !*  !%1%7%7%9%9 ! !! E*55 %    s 7B A)C3ctd||tj|}g}|D]I\}}||jvr*|j|jr|||f8t|||J||D]*\}}t||}| |+|S)Nr) r|rrzrrqrrZsetattrrrr)rkrYrr m2m_fieldsattrrrs rnrzModelSerializer.updates%hnEEE(22  )//11 / /KD%t~%%$.*>*F%!!4-0000$....  &  KD%Hd++E IIe    roc|jtj|_t|ds(Jd|jjt|jds(Jd|jjtj |jj rtdtj |j}t|jd}t|jdd }| |d ks Jd |d ks Jd tj|}|||}|}||||\}}i}|D]J} | |jvr?|j| jr-|| j td | d|jjdK|D]} | |vr || || <|| i} | dd} | dkr| } || |||\} } || | } | di| || <|||S)z Return the dict of field names -> field instances that should be used for `self.fields` when instantiating the serializer. Nrz1Class {serializer_class} missing "Meta" attributeserializer_classryz7Class {serializer_class} missing "Meta.model" attributez0Cannot use ModelSerializer with Abstract Models.depthrz'depth' may not be negative. z#'depth' may not be greater than 10.z The field 'z' on serializer 'z@' is a ManyToMany field and cannot have a default value of None.rSrre)url_field_namerURL_FIELD_NAMErr!rmrrris_abstract_modelry ValueErrorrrrrrzget_field_namesget_extra_kwargsget_uniqueness_extra_kwargsrrqrrQr build_fieldinclude_extra_kwargsr)rkdeclared_fieldsryrr field_names extra_kwargs hidden_fieldsrrextra_field_kwargsrS field_class field_kwargss rnrzModelSerializer.get_fields,s    &"."=D tV$$  ? F F!%!8 G     ty'**  E L L!%!8 M      '  8 8 B -(=>> 7++ 7A..  A:::=:::B;;; E;;;(//**?DAA ,,.. &*&F&F ,' ' # m *..00  JT^++z0J0R+WfgqWrWzXC Y*YYt~?VYYY& = =J_,,%4Z%@z"!-!1!1*b!A!A '++Hc::F}}#)-(8(8eU)) %K  440L "-!>>>2V#-)-)@ ?>>"V+++117#-)-)@2822,++ j)))) roc|jjgt|zt|jzt|jzSz Return the default list of field names that will be used if the `Meta.fields` option is not specified. )r+rrrforward_relationsrkr model_infos rnrz'ModelSerializer.get_default_field_namessL ]   ! ! " " # # $ - . . / roc||jvr#|j|}|||S||jvr<|j|}|s|||S||||St ||r|||S||jkr|||S| ||S)zW Return a two tuple of (cls, kwargs) to build a serializer field with. ) fields_and_pkbuild_standard_fieldrqbuild_relational_fieldbuild_nested_fieldrbuild_property_fieldrbuild_url_fieldbuild_unknown_field)rkrr model_class nested_depth model_fieldrs rnrzModelSerializer.build_fields + + +,Z8K,,ZEE E 4> ) ) N:6M X22:}MMM..z=,WWW [* - - A,,ZEE E 4. . .'' K@@ @'' K@@@roct|j}||}t||}|jr|jr|j}|jj|d<d|vr6|j}hd}t|D]}||vr| |t|ts| ddt|ts+t|ts| ddtt dot#|t j}t&rt#|t&js|r*t)|dd|d<|rt)|d d|d <t&rEt#|t&jr+|j} |d | \} } | d i| |d <||fS) z. Create regular model fields. querysetchoices>rTrVrSrrQrRrPrUrNr]rrO allow_blankrWrNrr6encoderdecoderryre)rserializer_field_mappingr one_to_one primary_keyserializer_related_field related_modelobjectsserializer_choice_fieldrrg issubclassr8r&r'rrrr6rr ArrayField base_fieldr) rkrr field_mappingrr valid_kwargsr~is_django_jsonfieldchild_model_fieldchild_field_classchild_field_kwargss rnrz$ModelSerializer.build_standard_fields((EFF #K0 ' K@@   ! Ik&= I7K'2'@'HL $  $ $6KLL)) * *l** $$S)))+z22 2   ]D 1 1 1+y11 2*[R]:^:^ 2   ]D 1 1 1%fk::hz+W]Wg?h?h  P ;8Q R R PWj P'.k9d&K&KL #" P*1+y$*O*O Y'  Lz+7QRR L!, 6 484M4M*55 1 1%6$5$K$K8J$K$KL !L((roc,|j}t||}|dd}|r7|js0|jj|js ||d<|j}t|ts|dd||fS)zF Create fields for forward and reverse relationships. to_fieldN slug_field view_name) rrrgreverser_meta get_fieldrserializer_related_to_fieldrrB)rkrrrrrs rnrz&ModelSerializer.build_relational_field=s3 *:}EE ##J55  ;M1 ;-:U:[:e:efn:o:o:{ ;)1L &:K+'>?? 0   [$ / / /L((roc\Gfddt}|}t}||fS)M Create nested fields for forward and reverse relationships. c0eZdZGfddZdS).NestedSerializerc,eZdZjZdz ZdZdS)AModelSerializer.build_nested_field..NestedSerializer.Metarr`NrrrrryrrrrsrnrrT&%3$q("rorNrrrrrsrnNestedSerializerrSL # # # # # # # # # # # # #ror)r~rrkrrrrrrs `` rnrz"ModelSerializer.build_nested_fieldOs\ # # # # # # # # # # # ' 1-@@ L((roct}i}||fS)zL Create a read only field for model methods and properties. )r:rkrrrrs rnrz$ModelSerializer.build_property_field^s$  L((roc6|j}t|}||fS)zC Create a field representing the object's own URL. )serializer_url_fieldrrs rnrzModelSerializer.build_url_fieldgs$/ %k22 L((roc ltd|d|jd|jjd|jjd )z7 Raise an error on any unknown fields. z Field name `z` is not valid for model `z` in `rz`.)rrrmr)rkrrs rnrz#ModelSerializer.build_unknown_fieldpsK#" ZZ---t~/H/H/H$.JaJaJa c   roc|ddrdD]}||d|dr,|ddur|d|d|ddr|dd|||S)z Include any 'extra_kwargs' that have been included for this field, possibly removing any incompatible existing keyword arguments. rNF) rPrQrr_r^ min_value max_valuerrNrQrP)rrgr)rkrlrrs rnrz$ModelSerializer.include_extra_kwargsys   K / / ' ' ' 4&&&&   I & & #6::j+A+AU+J+J JJz " " "   KK)G)G H H /   Z . . . l### roctjt|jdi}t|jdd}|ft |t t fs$tdt|j z|D]"}| |i}d|d<|||<#n:t|jdr%Jd|j j d |j j d |S) zr Return a dictionary mapping field names to a dictionary of additional keyword arguments. rread_only_fieldsNz>The `read_only_fields` option must be a list or tuple. Got %s.TrNreadonly_fieldsz Serializer `rzY` has field `readonly_fields`; the correct spelling for the option is `read_only_fields`.)rrrrrrrrr"rrrrmr)rkrrrrls rnrz ModelSerializer.get_extra_kwargss }WTY%K%KLL "49.@$GG  '.u >>  $%5 6 6 ?@/ 2 2 %))*b99&*{#+1 Z(( 2ty*;<<   ***DN,C,C,CE    roc#K|gt|jjzD]}|jjD]}||jgdfV|jjD]v}t |tjrZt|j dkrB|j g}n!tt|j }|j |j||j fVwdS)z Returns iterator of (fields, queryset, condition_fields, condition), each entry describes an unique together constraint on `fields` in `queryset` with respect of constraint's `condition`. Nr) rrparentsunique_togetherr constraintsrrUniqueConstraintrDr conditionr )rkry parent_classr constraintcondition_fieldss rnget_unique_together_constraintsz/ModelSerializer.get_unique_together_constraintss #Gd5;+>&?&?? n nL#/#5#E H H%u'=r4GGGGG*0< n n j&*ABBns:K\G]G]`aGaGa!+3+-((+/0QR\Rf0g0g+h+h(%,e.DFVXbXlmmmm  n n nroc(t|jdd|ifSt|jd}||||}t}|D]}||j|j|jhz}|dhz}t|}| |D]@\} } } } t| t| z} | | r|| z}Ai}i}|D]}|j |}t|ddrttj}nKt|ddr tj}n-|r|j}n|jrd}nt&}||vr|t&urddi||<d|i||<|t&urt)| ||<|D])\}}||vr||||||<*||fS) z Return any additional field options that need to be included as a result of uniqueness constraints on the model. This is returned as a two-tuple of: ('dict of updated extra kwargs', 'mapping of hidden fields') rNry auto_now_addauto_nowrPTrQrX)rr_get_model_fieldsrrunique_for_dateunique_for_monthunique_for_yearrr issupersetrrrHr now has_defaultrQrCrKr1rr)rkrrrry model_fieldsunique_constraint_namesrmodel_fields_namesunique_together_listrrr)unique_together_list_and_condition_fieldsruniqueness_extra_kwargsunique_constraint_nameunique_constraint_fieldrQr~rs rnrz+ModelSerializer.get_uniqueness_extra_kwargss 49lD 1 1 = "% % 7++-- ,  #&%%'..00 E EK # (C[Ea(3(C(E E # # D6) !2!2!4!455LPKoKopuKvKv U U G (, 'model field'. Used internally by `get_uniqueness_field_options`. ryrSrrN) rrrSKeyError contextlibsuppressrrrrDjangoModelField) rkrrrryrrrrSs rnrz!ModelSerializer._get_model_fields s@ 7++ % 1 1J_,,' 33()*5h?FF((('FFF(f}}# $%677 1 1 --f55e%5661+0L( 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 s#A AA85B99B= B= ctt|dddd}|t|S||zS)zW Determine the set of validators to use when instantiating serializer. rNr)rrget_unique_together_validatorsget_unique_for_date_validators)rkrs rnrzModelSerializer.get_validators0s_ WT6488,MM  ! ## #  / / 1 1  / / 1 1 2 roc`|}|jd|jiz}||krdS|S)z~ Returns the violation error message for the UniqueConstraint, or None if the message is the default. rN)get_violation_error_messagedefault_violation_error_messager)rkrviolation_error_messagedefault_error_messages rn'_get_constraint_violation_error_messagez7ModelSerializer._get_constraint_violation_error_message?sD #-"H"H"J"J * JfV`VeMf f "&; ; ;4&&roc d|jD}|d|jDt t |D] \}}||!dg|jj j j |jj RD}g}| |jj D]c\}}}} t|t|z} t| sJ| D]n}t|dksSJd|jj j|jj|d|ot)fd|D} |t)|} | r|| nd } t/|| t)fd |D| | t1| d d  }||e|S) z\ Determine a default set of validators for any unique_together constraints. cPi|]#}|jdk d|jv|j|j$Sr)rSrrs rnrzBModelSerializer.get_unique_together_validators..RsB   /4 ###U\*A*A  el*A*A*Aroc~i|]:}|jr1|jtk|jdk$d|jv-|j|j;Sr)rNrQrKrSrrs rnrzBModelSerializer.get_unique_together_validators..Xs\   /4 &+mu&<&<5.ds\' ' ' 'o9' ' *f&=>> '  z' ' ' ' rora Unable to create `UniqueTogetherValidator` for `{model}.{field}` as `{serializer}` has multiple fields ({fields}) that map to this model field. Either remove the extra fields, or override `Meta.validators` with a `UniqueTogetherValidator` using the desired field names.z, )ryr>rrc34K|]}|dVdSrNrer}r source_maps rnrtzAModelSerializer.get_unique_together_validators..s,JJQ 1 a 0JJJJJJroNc34K|]}|dVdSr rer!s rnrtzAModelSerializer.get_unique_together_validators..s,&R&RAz!}Q'7&R&R&R&R&R&Rroviolation_error_code)rrrrr$r)rrrrrrrrZrryrrrrrrDr!rrmjoinrrrr#r)rk field_sourcesrrSunique_constraint_by_fieldsrrrrr$unique_together_and_condition_fieldsrrr validatorr"s @rnrz.ModelSerializer.get_unique_together_validatorsJs  8<8M     8< 8J8J8L8L      !&& )//11 , ,LD& v  % %d + + + +' ' Nty4<NdioNN' ' ' # FJFjFjkoktkzF{F{# )# ) BOX'7363G3G#N^J_J_3_ 0z??--.RSS >  :f-..!3335 V"io6#'>#:$#yyF);<< 4333 JJJJ/JJJJJK4889O9OPPJbl&vd&R&RS]&^&^&^rv #/!"!&&R&R&R&RAQ&R&R&R!R!R#/Z)?FF I   i ( ( ( (roc6tj|jj}|jjj}d|jD}g}|jD]\}}|j r0||vr,t|||j }| ||j r0||vr,t|||j }| ||jr0||vr,t|||j}| ||S)z Determine a default set of validators for the following constraints: * unique_for_date * unique_for_month * unique_for_year cg|] }|j Sre)rSrs rnrzBModelSerializer.get_unique_for_date_validators..sFFFu|FFFro)rr date_field)rrzrryrrrrrrr rZrr!rr")rkrdefault_managerrrrrr)s rnrz.ModelSerializer.get_unique_for_date_validatorssU(99)/:FF1C1C1E1EFFF  !%!3!9!9!;!; - - J$ -{)B)B2,$$4 !!),,,% -* *C*C3,$$5 !!),,,$ -{)B)B2,$$4 !!),,,ro)Grrrrr AutoFieldr5 BigAutoFieldr$r%r&CommaSeparatedIntegerFieldr(r)r*r,r-r r8r.r0r4NullBooleanFieldPositiveIntegerFieldPositiveSmallIntegerFieldr=SmallIntegerField TextFieldr>r?r@GenericIPAddressFieldr3r/rrr6rr2r7rrDrrFrrArr'rrrrrrrrrrrrrrrrrrrrrrrrerornr~r~sE , _    \   )   )9   )  m  \  m  :   j  )  :  :  \! " # $ #\(,) ,)))$nm7  :wv{##?5> !12H@K !<=?H !;<>G !:;5"23)N>>>@8OOOfZZZx    AAA.;););)z)))$ ) ) )))))))   0<nnn"K+K+K+ZF     ' ' 'HHHT'''''ror~c"eZdZdZeZdZdZdS)HyperlinkedModelSerializera  A type of `ModelSerializer` that uses hyperlinked relationships instead of primary key relationships. Specifically: * A 'url' field is included instead of the 'id' field. * Relationships to other instances are hyperlinks, instead of primary keys. c|jgt|zt|jzt|jzSr)rrrrrs rnrz2HyperlinkedModelSerializer.get_default_field_namessJ  !  ! ! " " # # $ - . . / roc\Gfddt}|}t}||fS)rc0eZdZGfddZdS)GHyperlinkedModelSerializer.build_nested_field..NestedSerializerc,eZdZjZdz ZdZdS)LHyperlinkedModelSerializer.build_nested_field..NestedSerializer.Metarr`Nrrsrnrr>rrorNrrsrnrr<rror)r8rrs `` rnrz-HyperlinkedModelSerializer.build_nested_fields] # # # # # # # #9 # # # ' 1-@@ L((roN)rrrrrBrrrrerornr8r8sD 7     ) ) ) ) )ror8)prrrrNr collectionsrcollections.abcrdjango.core.exceptionsrrrr django.dbrdjango.db.models.fieldsr r django.utilsr django.utils.functionalr django.utils.translationr rFrest_framework.compatr rrest_framework.exceptionsrrest_framework.fieldsrrest_framework.settingsrrest_framework.utilsrrr"rest_framework.utils.field_mappingrrrrr'rest_framework.utils.serializer_helpersrrrrrrrest_framework.validatorsr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=r>r?r@rest_framework.relationsrArBrCrDrErFrGrHrIrJrKrLrMr{rrrbr"rrrrr|r~r8rerornrPs   ############JJJJJJJJKKKKKK======!!!!!!333333666666CBBBBBBB222222000000AAAAAAAAAA =<<<<<<< !L  u$u$u$u$u$Uu$u$u$v#8#8#8#8#8$#8#8#8L###Lt0t0t0t0t0+>t0t0t0t0t\0\0\0\0\0^\0\0\0DOOOdm m m m m jm m m `#)#)#)#)#)#)#)#)#)#)ro