def get_attribute(self, instance):
     # We customize `get_attribute` here for performance reasons.
     # For relationships the instance will already have the pk of
     # the related object. We return this directly instead of returning the
     # object itself, which would require a database lookup.
     try:
         instance = get_attribute(instance, self.source_attrs[:-1])
         return PKOnlyObject(pk=instance.serializable_value(self.source_attrs[-1]))
     except AttributeError:
         return get_attribute(instance, self.source_attrs)

    def get_attribute(self, instance):
        if self.use_pk_only_optimization() and self.source_attrs:
            # Optimized case, return a mock object only containing the pk attribute.
            try:
                instance = get_attribute(instance, self.source_attrs[:-1])
                return PKOnlyObject(pk=instance.serializable_value(self.source_attrs[-1]))
            except AttributeError:
                pass

        # Standard case, return the object instance.
        return get_attribute(instance, self.source_attrs)

    def get(self, request):
        user = request.user

        forms_context_dict = {}
        form_class_context_key_user_field_tuples = [
            [InstituteAddressForm, 'insti_address_form', ('insti_address',)],
            [ProgramForm, 'program_form', ('program',)],
            [SexUpdateForm, 'sex_update_form', ('userprofile', 'sex',)],
        ]

        for form_class, context_key, user_attr in form_class_context_key_user_field_tuples:
            try:
                form = form_class(initial=attr_to_dict(get_attribute(user, user_attr), key=user_attr[-1]))
            except (AttributeError, ObjectDoesNotExist):
                form = form_class()
            forms_context_dict[context_key] = form

        mobile_numbers = ContactNumber.objects.all().filter(user=user).order_by('-id')
        secondary_emails = SecondaryEmail.objects.all().filter(user=user).order_by('-id')
        user_profile = user.userprofile
        gpo_email = user.email
        ldap_number = user_profile.mobile
        roll_number = user_profile.roll_number

        request_context = {
            'mobile_numbers': mobile_numbers,
            'secondary_emails': secondary_emails,
            'gpo_email': gpo_email,
            'ldap_number': ldap_number,
            'roll_number': roll_number,
            'user_profile_picture': model_field_media_url(user.userprofile.profile_picture),
        }
        request_context.update(forms_context_dict)

        return render(request, 'user_resources/home.html', request_context)

    def get_attribute(self, instance):
        if self.use_pk_only_optimization() and self.source_attrs:
            # Optimized case, return a mock object only containing the pk attribute.
            try:
                instance = get_attribute(instance, self.source_attrs[:-1])
                value = instance.serializable_value(self.source_attrs[-1])
                if is_simple_callable(value):
                    # Handle edge case where the relationship `source` argument
                    # points to a `get_relationship()` method on the model
                    value = value().pk
                return PKOnlyObject(pk=value)
            except AttributeError:
                pass

        # Standard case, return the object instance.
        return get_attribute(instance, self.source_attrs)

    def get_attribute(self, instance):
        # Can't have any relationships if not created
        if not instance.pk:
            return []

        relationship = get_attribute(instance, self.source_attrs)
        return relationship.all() if (hasattr(relationship, "all")) else relationship

 def get_url(self, obj, view_name, request, format):
     if hasattr(obj, 'pk') and obj.pk is None:
         return None
     lookup_url_kwargs = {}
     for lookup_field, lookup_url_kwarg in zip(self.lookup_fields, self.lookup_url_kwargs):
         lookup_value = get_attribute(obj, lookup_field.replace('__', '.').split('.'))
         lookup_url_kwargs[lookup_url_kwarg] = lookup_value
     return self.reverse(view_name, kwargs=lookup_url_kwargs, request=request, format=format)

 def get_attribute(self, instance):
     """
     Given the *outgoing* object instance, return the primitive value
     that should be used for this field.
     """
     try:
         return fields.get_attribute(instance, self.source_attrs)
     except (KeyError, AttributeError) as exc:
         return None if self.default == fields.empty else self.default

    def get_url(self, obj, view_name, request, format):
        url = super().get_url(obj, view_name, request, format)

        if url and self.__query_params:
            get = lambda x: x(obj) if callable(x) else get_attribute(obj, x.split('.'))
            params = [(key, get(value)) for key, value in self.__query_params.items()]
            url = url + '?' + urlencode(params)

        return url

    def get_attribute(self, instance):
        # Can't have any relationships if not created.
        if hasattr(instance, 'pk') and instance.pk is None:
            return []

        queryset = self.queryset
        if hasattr(queryset, '__call__'):
            queryset = queryset(self.child_relation, instance)
        else:
            relationship = get_attribute(instance, self.source_attrs)
            queryset = relationship.all() if (hasattr(relationship, 'all')) else relationship
        return queryset

    def get_related_instance(self):
        parent_obj = self.get_object()
        parent_serializer = self.serializer_class(parent_obj)
        field_name = self.get_related_field_name()
        field = parent_serializer.fields.get(field_name, None)

        if field is not None:
            try:
                instance = field.get_attribute(parent_obj)
            except SkipField:
                instance = get_attribute(parent_obj, field.source_attrs)
            else:
                if isinstance(instance, PKOnlyObject):
                    # need whole object
                    instance = get_attribute(parent_obj, field.source_attrs)
            return instance
        else:
            try:
                return getattr(parent_obj, field_name)
            except AttributeError:
                raise NotFound

 def get_attribute(self, obj, requested_language=None):
     source = self.source or self.field_name
     field = fields.get_attribute(obj, source.split("."))
     if not field:
         return None
     request = self.context.get("request", None)
     if requested_language is None:
         if request and request.method == "GET" and "lang" in request.GET:
             requested_language = request.GET["lang"]
     if requested_language:
         return self.fetch_single_translation(obj, source, field, requested_language)
     else:
         return self.fetch_all_translations(obj, source, field)

    def get_attribute(self, obj):
        source = self.source or self.field_name
        field = fields.get_attribute(obj, source.split('.'))

        if not field:
            return None

        requested_language = None

        request = self.context.get('request', None)
        if request and request.method == 'GET' and 'lang' in request.GET:
            requested_language = request.GET['lang']

        if requested_language:
            return self.fetch_single_translation(obj, source, field,
                                                 requested_language)
        else:
            return self.fetch_all_translations(obj, source, field)

 def get_attribute(self, instance):
     return get_attribute(instance, self.source_attrs)

    def extract_relationships(fields, resource, resource_instance):
        # Avoid circular deps
        from rest_framework_json_api.relations import ResourceRelatedField

        data = OrderedDict()

        # Don't try to extract relationships from a non-existent resource
        if resource_instance is None:
            return

        for field_name, field in six.iteritems(fields):
            # Skip URL field
            if field_name == api_settings.URL_FIELD_NAME:
                continue

            # Skip fields without relations
            if not isinstance(field, (relations.RelatedField, relations.ManyRelatedField, BaseSerializer)):
                continue

            source = field.source
            try:
                relation_instance_or_manager = get_attribute(resource_instance, source.split('.'))
            except AttributeError:
                # if the field is not defined on the model then we check the serializer
                # and if no value is there we skip over the field completely
                serializer_method = getattr(field.parent, source, None)
                if serializer_method and hasattr(serializer_method, '__call__'):
                    relation_instance_or_manager = serializer_method(resource_instance)
                else:
                    continue

            # relation_type = utils.get_related_resource_type(field)

            if isinstance(field, relations.HyperlinkedIdentityField):
                relation_type = utils.get_related_resource_type(field)
                # special case for HyperlinkedIdentityField
                relation_data = list()

                # Don't try to query an empty relation
                relation_queryset = relation_instance_or_manager.all() \
                    if relation_instance_or_manager is not None else list()

                for related_object in relation_queryset:
                    relation_data.append(
                            OrderedDict([('type', relation_type), ('id', encoding.force_text(related_object.pk))])
                    )

                data.update({field_name: {
                    'links': {
                        "related": resource.get(field_name)},
                    'data': relation_data,
                    'meta': {
                        'count': len(relation_data)
                    }
                }})
                continue

            if isinstance(field, ResourceRelatedField):
                # special case for ResourceRelatedField
                relation_data = {
                    'data': resource.get(field_name)
                }

                field_links = field.get_links(resource_instance)
                relation_data.update(
                        {'links': field_links}
                        if field_links else dict()
                )
                data.update({field_name: relation_data})
                continue

            if isinstance(field, (relations.PrimaryKeyRelatedField, relations.HyperlinkedRelatedField)):
                relation_id = relation_instance_or_manager.pk if resource.get(field_name) else None
                relation_type = utils.get_related_resource_type(field)

                relation_data = {
                    'data': (
                        OrderedDict([('type', relation_type), ('id', encoding.force_text(relation_id))])
                        if relation_id is not None else None)
                }

                relation_data.update(
                        {'links': {'related': resource.get(field_name)}}
                        if isinstance(field, relations.HyperlinkedRelatedField) and resource.get(field_name) else dict()
                )
                data.update({field_name: relation_data})
                continue

            if isinstance(field, relations.ManyRelatedField):

                if isinstance(field.child_relation, ResourceRelatedField):
                    # special case for ResourceRelatedField

                    if field_name not in resource:
                        continue


                    relation_data = {
                        'data': resource.get(field_name)
                    }
#.........这里部分代码省略.........

    def extract_included(fields, resource, resource_instance, included_resources):
        # this function may be called with an empty record (example: Browsable Interface)
        if not resource_instance:
            return

        included_data = list()
        current_serializer = fields.serializer
        context = current_serializer.context
        include_config = utils.get_included_configuration(current_serializer)
        included_resources = copy.copy(included_resources)

        for field_name, field in six.iteritems(fields):
            # Skip URL field
            if field_name == api_settings.URL_FIELD_NAME:
                continue

            # Skip fields without relations or serialized data
            if not isinstance(field, (relations.RelatedField, relations.ManyRelatedField, BaseSerializer)):
                continue

            # Skip disabled fields
            if include_config[field_name] == False:
                continue

            try:
                included_resources.remove(field_name)
            except ValueError:
                # Skip fields not in requested included resources
                continue

            try:
                relation_instance_or_manager = get_attribute(resource_instance, field.source.split('.'))
            except AttributeError:
                try:
                    # For ManyRelatedFields if `related_name` is not set we need to access `foo_set` from `source`
                    relation_instance_or_manager = get_attribute(resource_instance, field.child_relation.source.split('.'))
                except AttributeError:
                    if not hasattr(current_serializer, field.source):
                        continue
                    serializer_method = get_attribute(current_serializer, field.source.split('.'))
                    relation_instance_or_manager = serializer_method(resource_instance)

            new_included_resources = [key.replace('%s.' % field_name, '', 1)
                                      for key in included_resources
                                      if field_name == key.split('.')[0]]
            serializer_data = resource.get(field_name)

            serializer_instances = []

            if isinstance(field, relations.ManyRelatedField):
                # # serializer_class = include_config.get(field_name)
                # serializer_class = utils.get_serializer_from_instance_and_serializer()
                # serializer_instance = serializer_class(relation_instance_or_manager.all(), many=True, context=context)

                if isinstance(current_serializer.instance, Iterable):
                    iterable = []
                    for obj in current_serializer.instance:
                        iterable += field.get_attribute(obj)
                else:
                    iterable = field.get_attribute(current_serializer.instance)

                for item in iterable:
                    serializer_class = utils.get_serializer_from_instance_and_serializer(item,
                                                                                         current_serializer,
                                                                                         field_name)
                    serializer_instance = serializer_class(item, context=context)
                    serializer_instances.append(serializer_instance)

            if isinstance(field, relations.RelatedField):
                # serializer_class = include_config.get(field_name)
                if relation_instance_or_manager is None:
                    continue

                serializer_class = utils.get_serializer_from_instance_and_serializer(relation_instance_or_manager, current_serializer, field_name)
                serializer_instance = serializer_class(relation_instance_or_manager, context=context)
                serializer_instances.append(serializer_instance)

            for serializer_instance in serializer_instances:

                serializer_data = serializer_instance.data

                relation_type = utils.get_resource_type_from_serializer(serializer_instance.__class__)

                # Get the serializer fields
                serializer_fields = utils.get_serializer_fields(serializer_instance)
                if serializer_data:
                    included_data.append(
                            JSONRenderer.build_json_resource_obj(
                                    serializer_fields, serializer_data,
                                    serializer_instance.instance, relation_type)
                    )
                    included_data.extend(
                            JSONRenderer.extract_included(
                                    serializer_fields, serializer_data, serializer_instance.instance, new_included_resources
                            )
                    )

        return utils.format_keys(included_data)

 def get_iterable(self, instance, source):
     relationship = get_attribute(instance, [source])
     return relationship.all() if (hasattr(relationship, 'all')) else relationship

def zip_instance_extra_with_iterable(instance, iterable, extra):
    extra_attrs = dict(
        (key, get_attribute(instance, attrs.split('.')))
        for key, attrs in extra.items()
    )
    return (AttributeProxy(item, **extra_attrs) for item in iterable)

 def get_attribute(self, instance):
     if instance.is_tax_known:
         return super(TaxIncludedDecimalField, self).get_attribute(instance)
     if self.excl_tax_field:
         return get_attribute(instance, (self.excl_tax_field, ))
     return self.excl_tax_value