U ڲg@s|dZddlZddlZddlZddlZddlmZddlmZddl m Z m Z ddl m Z ddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZm Z ddlmZddl 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.m/Z/m0Z0m1Z1m2Z2ddl3m4Z4m5Z5m6Z6m7Z7ddlm8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@mZmAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSddlTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[ddlm\Z\m]Z]m^Z^m_Z_ddlTm`Z`maZadZbdZcdZdGdddeZeGdddefZgdd ZhGd!d"d"eeegd#ZiGd$d%d%eeZjd&d'ZkGd(d)d)eiZlGd*d+d+elZmdS),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 marshalling 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)postgres_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) 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)rUr\r[__all__cseZdZdZdeffdd ZfddZddZed d Z d d Z d dZ ddZ ddZ ddZddddZeddZeddZeddZZS)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 sN||_|tk r||_|dd|_|di|_|ddtjf|dS)NrXFrYmany)rVrH initial_datapoprX_contextsuper__init__)selfrVrWkwargs __class__>/tmp/pip-unpacked-wheel-11h17kvo/rest_framework/serializers.pyrdps zBaseSerializer.__init__cs,|ddr|j||Stj|f||S)Nr_F)ra many_initrc__new__clsargsrfrgrirjrlys  zBaseSerializer.__new__cOs|SNrirmririrj__class_getitem__sz BaseSerializer.__class_getitem__cOsri}tD] }||d}|dk r|||<q||||d<|dd|Dt|dd}t|dt}|||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) NchildcSsi|]\}}|tkr||qSri)LIST_SERIALIZER_KWARGS.0keyvalueririrj sz,BaseSerializer.many_init..Metalist_serializer_class)LIST_SERIALIZER_KWARGS_REMOVEraupdateitemsgetattrListSerializer)rnrorfZ list_kwargsrvrwmetarzririrjrks     zBaseSerializer.many_initcCs tddS)Nz*`to_internal_value()` must be implemented.NotImplementedErrorrerWririrjto_internal_valuesz BaseSerializer.to_internal_valuecCs tddS)Nz*`to_representation()` must be implemented.r)rerVririrjto_representationsz BaseSerializer.to_representationcCs tddS)Nz`update()` must be implemented.rrerVvalidated_dataririrjr|szBaseSerializer.updatecCs tddS)Nz`create()` must be implemented.rrerririrjcreateszBaseSerializer.createcKst|dstd|jr tdd|ks0tdt|drBtd|j|}|jdk rz||j||_|jdk stdn|||_|jdk std |jS) N_errorsz5You must call `.is_valid()` before calling `.save()`.zs z.cSs |djS)N)Z_creation_counter)xririrj z:SerializerMetaclass._get_declared_fields..)rvcs||Srp)add)name)knownrirjvisit's z7SerializerMetaclass._get_declared_fields..visitcs>g|]6}t|dr|jD]\}}|kr||fqqS)_declared_fields)rrr})rubaserf)rrrirjr+s   )listr}sortsetdict)rnbasesrfieldsZ base_fieldsri)rrrrj_get_declared_fieldss    z(SerializerMetaclass._get_declared_fieldscs"||||d<t||||S)Nr)rrcrl)rnrrrrgrirjrl3szSerializerMetaclass.__new__)rrrrrrrlrririrgrjrs rcCsht|ttfstt|tr&t|}n|j}t|trHdd|DSt|tr\t j |iSt j |giS)NcSs*i|]"\}}|t|ttfr |n|gqSri)rrrrtririrjrxCsz'as_serializer_error..) rrDjangoValidationErrorrrrrr}rrNON_FIELD_ERRORS_KEY)rrririrjas_serializer_error8s    rcseZdZdediZddZeddZeddZ ed d Z d d Z d dZ ddZ ddZefddZddZfddZddZddZddZdd Zd!d"Zd#d$Zefd%d&Zefd'd(ZZS)) Serializerinvalidz8Invalid data. Expected a dictionary, but got {datatype}.cCsL|s||dS|ddD]}||kr2i||<||}q|||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|)re dictionarykeysrwrvririrj set_valueWs   zSerializer.set_valuecCs*t|}|D]\}}|||<q|S)z? A dictionary of {field_name: field_instance}. )r get_fieldsr})rerrvrwririrjrks zSerializer.fieldsccs |jD]}|js |Vq dSrp)rvaluesrKrefieldririrj_writable_fieldsxszSerializer._writable_fieldsccs |jD]}|js |Vq dSrp)rrrLrririrj_readable_fields~szSerializer._readable_fieldscCs t|jS)zG Returns a dictionary of {field_name: field_instance}. )copydeepcopyrreririrjrszSerializer.get_fieldscCs(t|dd}t|dd}|r$t|SgS)z8 Returns a list of validator callables. ryN validators)r~r)rerrririrjget_validatorss  zSerializer.get_validatorscsFtdr2tjtsiSfddjDSddjDS)Nr`cs4i|],\}}|jtk r|js||jqSri) get_valuer`rHrK)rurrrrirjrxs z*Serializer.get_initial..cSsi|]}|js|j|qSri)rKrrrurririrjrxs)rrr`rrr}rrrirrjrs   zSerializer.get_initialcCs,t|rtj||jdptS||jtS)N)prefix)r is_html_inputZparse_html_dictrrHgetrerririrjrs zSerializer.get_valuec Cs||\}}|r|S||}z(||||}|dk sFtdWn4ttfk r|}ztt|dW5d}~XYnX|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)rZvalidate_empty_valuesrrun_validatorsvalidaterrrrrerWZis_empty_valuerwrririrjrs    zSerializer.run_validationc CsVdd|jD}i}|D]4}z |}Wntk rDYqYnX|||j<q|S)NcSs4g|],}|jr|jtkr|jdkrd|jkr|qS*.)rKrNrHrPrririrjrs  z2Serializer._read_only_defaults..)rr get_defaultrGrP)rerdefaultsrrNririrj_read_only_defaultss   zSerializer._read_only_defaultscs2t|tr|}||n|}t|dS)zX Add read_only fields with defaults to value before running validators. N)rrrr|rcr)rerwZ to_validatergrirjrs   zSerializer.run_validatorsc Cst|ts6|jdjt|jd}ttj|giddi}i}|j }|D]}t |d|j d}| |}z| |} |dk r|| } Wnntk r} z| j||j <W5d} ~ XYqHtk r} zt| ||j <W5d} ~ XYqHtk rYqHX|||j| qH|rt||S)zG Dict of native values <- Dict of primitive datatypes. r)datatypecodeZ validate_N)rrrTformattyperrrrrr~rrrrrrrGr source_attrs) rerWmessageretrrrZvalidate_methodZprimitive_valueZvalidated_valuerririrjrs<     zSerializer.to_internal_valuec Csxi}|j}|D]d}z||}Wntk r8YqYnXt|trJ|jn|}|dkrbd||j<q||||j<q|S)zA Object instance -> Dict of primitive datatypes. N)rZ get_attributerGrrJpkrr)rerVrrr attributeZcheck_for_noneririrjrs  zSerializer.to_representationcCs|SrprirerririrjrszSerializer.validatecCstj|ddSNr)indent)rZserializer_reprrririrj__repr__!szSerializer.__repr__ccs |jD]}||jVq dSrp)rrrrririrj__iter__(szSerializer.__iter__cCsh|j|}|j|}t|dr,|j|nd}t|trFt|||St|tr\t |||St |||S)Nr) rrWrrrrrrr3rr)rervrrwerrorririrj __getitem__,s      zSerializer.__getitem__cstj}t||dSN serializer)rcrWrrerrgrirjrW9szSerializer.datacsVtj}t|trJt|dkrJt|ddddkrJtddd}tj|gi}t ||dSNrrrnullzNo data providedrr) rcrrrlenr~r rrrrerrrgrirjr>s *  zSerializer.errors)rrr_default_error_messagesrr rrrrrrrrrHrrrrrrrrrrWrrririrgrjrRs6       % r) metaclasscseZdZdZdZededededdZfdd Zd d Zd d Z e fddZ ddZ ddZ ddZddZddZddZddZddd d!Zd"d#Zefd$d%Zefd&d'ZZS)(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_listrHr[r\cs|dt|j|_|dd|_|dd|_|dd|_|jdk sRtdt |jrftdt j |||jj d|d dS) NrrrUTr[r\z`child` is a required argument.z"`child` has not been instantiated.)rparent) rarrrrrUr[r\rinspectisclassrcrdbind)rerorfrgrirjrdWszListSerializer.__init__cCst|dr||jSgS)Nr`)rrr`rririrjras  zListSerializer.get_initialcCs*t|rtj||jtdS||jtS)zE Given the input dictionary, return the field value. )rrN)rrparse_html_listrrHrrririrjrfs zListSerializer.get_valuec Cs||\}}|r|S||}z(||||}|dk sFtdWn4ttfk r|}ztt|dW5d}~XYnX|Srrrririrjrps    zListSerializer.run_validationcCs |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) )rrrrririrjrun_child_validations z#ListSerializer.run_child_validationc Cs|t|rtj|gd}t|tsN|jdjt|jd}t t j |gidd|j s~t |dkr~|jd}t t j |gidd|jdk rt ||jkr|jdj|jd }t t j |gidd|jdk rt ||jkr|jd j|jd }t t j |gid dg}g}|D]Z}z||}Wn0t k rL}z||jW5d}~XYnX|||iq t|rxt ||S) zY List of dicts of native values <- List of dicts of primitive datatypes. rNr)Z input_typerrrHNr[)r[r\)r\)rrr rrrTrrrrrrrUrr[r\r appendrany)rerWrrritemZ validatedrririrjrs`      z ListSerializer.to_internal_valuecs,t|tjjr|n|}fdd|DS)zS List of object instances -> List of dicts of primitive datatypes. csg|]}j|qSri)rrr)rurrrirjrsz4ListSerializer.to_representation..)rrmanagerZ BaseManagerall)rerWiterablerirrjrs z ListSerializer.to_representationcCs|SrprirririrjrszListSerializer.validatecCs tddS)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.rrririrjr|szListSerializer.updatecsfdd|DS)Ncsg|]}j|qSri)rrrrurrrirjrsz)ListSerializer.create..rirrirrjrs zListSerializer.createc svdkstdfdd|jD}|jdk rR||j||_|jdk sptdn|||_|jdk sptd|jS)z= Save and return a list of object instances. rrcsg|] }|qSririrrfrirjrsz'ListSerializer.save..Nrr)rrrVr|rrrirrjrs       zListSerializer.saveFrc Cst|dstdt|dsfz||j|_Wn0tk r^}zg|_|j|_W5d}~XYnXg|_|jrz|rzt|jt |j Srrrririrjrs    zListSerializer.is_validcCstj|ddSr)rZ list_reprrririrjrszListSerializer.__repr__cstj}t||dSr)rcrWrrrgrirjrWszListSerializer.datacsltj}t|trJt|dkrJt|ddddkrJtddd}tj|gi}t|t r`t ||dSt ||dSr) rcrrrrr~r rrrrrrrgrirjrs*    zListSerializer.errors)rrrrrr_rrrdrrrHrr rrrr|rrrrrrWrrririrgrjrLs0   2  rcs|jj}t|tfdd|jDrHtdj||jj |jj dtfdd|jDr~tdj||jj |jj ddS)a Give explicit errors when users attempt to pass writable nested data. If we don't do this explicitly they'd get a less helpful error when calling `.save()` on the serializer. We don't *automatically* support these sorts of nested writes because there are too many ambiguities to define a default behavior. 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. c3sB|]:}t|to8|jko8|jjko8t|jttfVqdSrp)rr^rP relationsrrrZmodel_field_inforrirj Hs  z0raise_errors_on_nested_writes..zThe `.{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_namec3sR|]J}t|jdkoH|jdkoH|jdjkoHt|jdttfVqdS)rrN)rrrrrrrrrirjrgs zThe `.{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) rymodelrget_field_infor rrrrhrr)rrr ModelClassrirrjraise_errors_on_nested_writes.s(   rc4@seZdZdZejeejeejeej e ej e ej e ej e ej e ejeejeejeejeejeejeejeejeejeejeejeejeeje ejeejeejeejeej e iZ!e"edre#e!ej#<e$re%e!e$j%<e&e!e$j'<e#e!e$j#<e(Z)e*Z+e,Z-e.Z/dZ0ddZ1ddZ2dd Z3d d Z4d d Z5ddZ6ddZ7ddZ8ddZ9ddZ:ddZ;ddZd d!Z?d"d#Z@d$d%ZAd&d'ZBd(d)ZCd*d+ZDdS),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. r3Nc Cstd|||jj}t|}i}|jD]$\}}|jr,||kr,||||<q,z|j j f|}WnHt k rt }d|j|j j|j|j j|jj|f} t | YnX|r|D]\}} t||} | | q|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. ra+Got a `TypeError` when calling `%s.%s.create()`. This may be because you have a writable field on the serializer class that is not a valid argument to `%s.%s.create()`. You may need to make the field read-only, or override the %s.create() method to handle this correctly. Original exception was: %s)rryrrrrr}to_manyra_default_managerr TypeError traceback format_excrrrhr~r) rerrinfoZ many_to_manyr relation_inforVtbrrwrririrjrs6    zModelSerializer.createcCstd||t|}g}|D]:\}}||jkrP|j|jrP|||fq"t|||q"||D]\}}t ||}| |qj|S)Nr|) rrrr}rrr setattrrr~r)rerVrr$Z m2m_fieldsattrrwrririrjr|s     zModelSerializer.updatecCsl|jdkrtj|_t|ds0tdj|jjdt|jdsPtdj|jjdt |jj rft dt |j}t|jd}t|jdd }|dk r|d kstd |d kstd t |}|||}|}||||\}}i}|D]p} | |kr|| || <q|| i} | d d} | dkr.| } || |||\} } || | } | f| || <q|||S)z Return the dict of field names -> field instances that should be used for `self.fields` when instantiating the serializer. Nryz1Class {serializer_class} missing "Meta" attributeserializer_classrz7Class {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.rPr)url_field_namerZURL_FIELD_NAMErrrrhrryrZis_abstract_modelr ValueErrorrrrr~rget_field_namesget_extra_kwargsget_uniqueness_extra_kwargsr build_fieldinclude_extra_kwargsr|)redeclared_fieldsrr+r$ field_names extra_kwargs hidden_fieldsrrZextra_field_kwargsrP field_class field_kwargsririrjrsh            zModelSerializer.get_fieldscCst|jdd}t|jdd}|rH|tkrHt|ttfsHtdt|j|rlt|ttfsltdt|j|r|rt dj |j jd|dkr|dkrt dj |j jdf|tkrd}|dk rt |}|j j D]}|t t|d g8}q|D]"}||kst d j ||j jd q|S|||}|dk r|D]R}||jksZt d j ||j jd ||kszt d j ||j jd ||q4|S)a Returns the list of all field names that should be created when instantiating this serializer class. This is based on the default set of fields, but also takes into account the `Meta.fields` or `Meta.exclude` options if they have been specified. rNexcludezAThe `fields` option must be a list or tuple or "__all__". Got %s.z5The `exclude` option must be a list or tuple. Got %s.zPCannot set both 'fields' and 'exclude' options on serializer {serializer_class}.r)zCreating a ModelSerializer without either the 'fields' attribute or the 'exclude' attribute has been deprecated since 3.3.0, and is now disallowed. Add an explicit fields = '__all__' to the {serializer_class} serializer.rzyThe field '{field_name}' was declared on serializer {serializer_class}, but has not been included in the 'fields' option.)rr*zCannot both declare the field '{field_name}' and include it in the {serializer_class} 'exclude' option. Remove the field or, if inherited from a parent serializer, disable with `{field_name} = None`.zThe field '{field_name}' was included on serializer {serializer_class} in the 'exclude' option, but does not match any model field.)r~ry ALL_FIELDSrrtupler!rrrrrhr __bases__get_default_field_namesrremove)rer4r$rr:Zrequired_field_namesrnrririrjr/bsn        zModelSerializer.get_field_namescCs&|jjgt|t|jt|jSz Return the default list of field names that will be used if the `Meta.fields` option is not specified. )rrrrforward_relationsrer4Z model_inforirirjr>sz'ModelSerializer.get_default_field_namescCs||jkr |j|}|||S||jkrT|j|}|sD|||S||||Sn,t||rj|||S||jkr|||S| ||S)zW Return a two tuple of (cls, kwargs) to build a serializer field with. ) fields_and_pkbuild_standard_fieldrbuild_relational_fieldbuild_nested_fieldrbuild_property_fieldr-build_url_fieldbuild_unknown_field)rerr$ model_class nested_depth model_fieldr%ririrjr2s          zModelSerializer.build_fieldc CsPt|j}||}t||}|jr:|jr:|j}|jj|d<d|kr|j}ddddddd d d d d dddh}t |D]}||krp| |qpt |t s| ddt |t st |ts| ddttdot|tj}trt|tjs|rt|dd|d<|rt|dd|d<trHt|tjrH|j} |d| \} } | f| |d<||fS)z. Create regular model fields. querysetchoicesrKrLrMrNrOrPrQrRrSrTrrZ allow_blankrLNr3encoderdecoderrr)rserializer_field_mappingrZ one_to_one primary_keyserializer_related_field related_modelZobjectsserializer_choice_fieldrra issubclassr5r#r$rrrr3r r~ ArrayFieldZ base_fieldrD) rerrLZ field_mappingr8r9Z valid_kwargsrvZis_django_jsonfieldZchild_model_fieldZchild_field_classZchild_field_kwargsririrjrDsV         z$ModelSerializer.build_standard_fieldcCsb|j}t||}|dd}|rD|jsD|jj|jsD||d<|j}t |t sZ|dd||fS)zF Create fields for forward and reverse relationships. to_fieldNZ slug_fieldZ view_name) rTrrareverserU_meta get_fieldrSserializer_related_to_fieldrWr?)rerr%r8r9rYririrjrE s    z&ModelSerializer.build_relational_fieldcs*Gfdddt}|}t}||fS)M Create nested fields for forward and reverse relationships. cs eZdZGfdddZdS)z.NestedSerializercseZdZjZdZdZdS)zAModelSerializer.build_nested_field..NestedSerializer.Metarr]NrrrrUrr+rrirKr%rirjry7sryNrrrryrir`rirjNestedSerializer6srb)rrrerr%rKrbr8r9rir`rjrF2sz"ModelSerializer.build_nested_fieldcCst}i}||fS)zL Create a read only field for model methods and properties. )r7rerrJr8r9ririrjrGAsz$ModelSerializer.build_property_fieldcCs|j}t|}||fS)zC Create a field representing the object's own URL. )serializer_url_fieldrrdririrjrHJszModelSerializer.build_url_fieldcCs"td||j|jj|jjfdS)z7 Raise an error on any unknown fields. z7Field name `%s` is not valid for model `%s` in `%s.%s`.N)rrrhr)rerrJririrjrISs z#ModelSerializer.build_unknown_fieldcCsr|ddr"dD]}||dq|drD|ddkrD|d|d|ddrd|dd|||S)z Include any 'extra_kwargs' that have been included for this field, possibly removing any incompatible existing keyword arguments. rKF) rMrNrOr\r[Z min_valueZ max_valuerrMNrNrM)rrar|)rerfr6r(ririrjr3\s    z$ModelSerializer.include_extra_kwargscCstt|jdi}t|jdd}|dk rrt|ttfsJtdt|j |D] }| |i}d|d<|||<qNn$t |jdrt d|j j|j j f|S) zr Return a dictionary mapping field names to a dictionary of additional keyword arguments. r6read_only_fieldsNz>The `read_only_fields` option must be a list or tuple. Got %s.TrKZreadonly_fieldszjSerializer `%s.%s` has field `readonly_fields`; the correct spelling for the option is `read_only_fields`.)rrr~ryrrr<r!rrrrrrhr)rer6rfrrfririrjr0ts&  z ModelSerializer.get_extra_kwargsccs|gt|jjD]l}|jjD]}||jfVq|jjD]D}t|tjr8t |j dkr8|j |j dkrj|jn |j |j fVq8qdS)z Returns iterator of (fields, queryset), each entry describes an unique together constraint on `fields` in `queryset`. rN) rr[parentsunique_togetherr  constraintsrrZUniqueConstraintrr conditionfilter)rerZ parent_classrh constraintririrjget_unique_together_constraintss   z/ModelSerializer.get_unique_together_constraintscCstt|jdddk r|ifSt|jd}||||}t}|D]}||j|j|jhO}qB|dh8}||D]"\}} t| |rp|t|O}qpi} i} |D]} |j | } t| ddrt t j}n(t| ddrt j}n| r| j}nt}| |kr |tkrddi| | <n d|i| | <q|tk rt|d | | <q| D]*\}}||kr`||||||<q@|| 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') rNrZ auto_now_addZauto_nowrMTrNr )r~ry_get_model_fieldsrrunique_for_dateunique_for_monthunique_for_yearrm issupersetr[r\rEr nowZ has_defaultrNrHr.r}r|)rer5r4r6r model_fieldsZunique_constraint_namesrLZunique_together_listrMr7Zuniqueness_extra_kwargsZunique_constraint_nameZunique_constraint_fieldrNrvrwririrjr1sN            z+ModelSerializer.get_uniqueness_extra_kwargsc Cst|jd}i}|D]}||kr4||}|jp0|}n*z||d}Wntk r\|}YnXd|ks|dkrpqtt$|j|}t |t r|||<W5QRXq|S)z Returns all the model fields that are being mapped to by fields on the serializer class. Returned as a dict of 'model field name' -> 'model field'. Used internally by `get_uniqueness_field_options`. rrPrr) r~ryrPKeyError contextlibsuppressrr[r\rDjangoModelField) rer5r4r6rrtrrrPririrjrns"      z!ModelSerializer._get_model_fieldscCs4tt|dddd}|dk r$t|S||S)zW Determine the set of validators to use when instantiating serializer. ryNr)r~rget_unique_together_validatorsget_unique_for_date_validators)rerririrjrszModelSerializer.get_validatorsc sdd|jD}|dd|jDtt|D]\}}||q:g}||j j D]\}}t  |s|qd|D]>}t |dkstdj|j j j|jj|d|dqtfdd |D}t||d }||qd|S) z\ Determine a default set of validators for any unique_together constraints. cSs*i|]"}|jdkrd|jkr|j|jqSr)rPrrririrjrx&s  zBModelSerializer.get_unique_together_validators..cSs:i|]2}|jr|jtkr|jdkrd|jkr|j|jqSr)rKrNrHrPrrririrjrx,s ra 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, )rrrrc3s|]}|dVqdS)rNri)rurZ source_maprirjrPszAModelSerializer.get_unique_together_validators..)rMr)rr|rrrrr}r rmryrrrrrrrrrhjoinr<r!) reZ field_sourcesrrPrrhrMr5 validatorrir{rjrys:   z.ModelSerializer.get_unique_together_validatorscCst|jj}|jjj}dd|jD}g}|jD]\}}|j rj||krjt |||j d}| ||j r||krt |||j d}| ||jr:||kr:t|||jd}| |q:|S)z Determine a default set of validators for the following constraints: * unique_for_date * unique_for_month * unique_for_year cSsg|] }|jqSri)rPrririrjrbszBModelSerializer.get_unique_for_date_validators..)rMrZ date_field)rrryrr rrrCr}rorr rprrqr )rer$Zdefault_managerr5rrrr}ririrjrzXs6    z.ModelSerializer.get_unique_for_date_validators)ErrrrrZ AutoFieldr2ZBigIntegerFieldr"r#ZCommaSeparatedIntegerFieldr%r&r'r)r*rr5r+r-r1ZNullBooleanFieldZPositiveIntegerFieldZPositiveSmallIntegerFieldr:ZSmallIntegerFieldZ TextFieldr;r<r=ZGenericIPAddressFieldr0r,rRrr3r r/r4rXrArTrCr]r>rer$rVr-rr|rr/r>r2rDrErFrGrHrIr3r0rmr1rnrryrzriririrjrys      @L\=   I#:rc@s$eZdZdZeZddZddZdS)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. cCs$|jgt|t|jt|jSr@)r-rrrArBririrjr>sz2HyperlinkedModelSerializer.get_default_field_namescs*Gfdddt}|}t}||fS)r^cs eZdZGfdddZdS)zGHyperlinkedModelSerializer.build_nested_field..NestedSerializercseZdZjZdZdZdS)zLHyperlinkedModelSerializer.build_nested_field..NestedSerializer.Metarr]Nr_rir`rirjrysryNrarir`rirjrbsrb)r~rrcrir`rjrFsz-HyperlinkedModelSerializer.build_nested_fieldN)rrrrr?rTr>rFriririrjr~s r~)nrrvrrr" collectionsrcollections.abcrZdjango.core.exceptionsrrrrZ django.dbrZdjango.db.models.fieldsrrxZ django.utilsr Zdjango.utils.functionalr Zdjango.utils.translationr rZrest_framework.compatr Zrest_framework.exceptionsr Zrest_framework.fieldsrZrest_framework.settingsrZrest_framework.utilsrrrZ"rest_framework.utils.field_mappingrrrrrZ'rest_framework.utils.serializer_helpersrrrrrrZrest_framework.validatorsrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7r8r9r:r;r<r=Zrest_framework.relationsr>r?r@rArBrCrDrErFrGrHrIrJrsr{r;r^rrrrrrrr~riririrjsZ              |$<&{cK