Issue with fields.py>Field>get_default() throwing error 'request' while parsing CurrentUserDefault()

[aupi0]

Not sure if I'm doing something wrong or whether this is actually an issue but adding it here for now.

While running serializer.is_valid() I get an error thrown 'request'.
Chasing the error it seems to be occurring within fields.py>Field>get_default() with return self.default(self) (with the exact line being 516 in fields.py) while processing the field HiddenField(default=serializers.CurrentUserDefault(), write_only=True)

Below is an example view and serializers which reproduce this issue.

from rest_framework import serializers

from .models import ExampleModel


class SerializerOne(serializers.ModelSerializer):
    performed_by = serializers.HiddenField(
        default=serializers.CurrentUserDefault(),
        write_only=True,
    )

    class Meta:
        model = ExampleModel
        fields = ('first_name', 'performed_by',)
    
    def create(self, validated_data):
        performed_by = validated_data.pop('performed_by')
        # .... code to create audit with performed_by

        return super().create(validated_data)


class SerializerTwo(serializers.ModelSerializer):
    """
    Serializer used for example response
    in drf_spectacular schema
    """
    deleted_example_model= SerializerOne()

    class Meta:
        model = ExampleModel
        fields = ('deleted_example_model',)

class ExampleModelDelete(APIView):
    queryset = ExampleModel.objects.all()
    
    @extend_schema(
        responses={
            200: SerializerTwo,
        }
    )
    def delete(self, request, *args, **kwargs):
        try:
            example_model = ExampleModel.objects.get(
                first_name=self.kwargs['first_name'],
            )

            example_model.delete()
            # Code to create desired response
            deleted_example_model = SerializerOne(example_model).data
            response_serializer = SerializerTwo(data={
                'deleted_example_model': deleted_example_model,
            })
            response_serializer.is_valid()  # This fails

            return Response(
                response_serializer.data,
            )
        except Exception as e:
            print ('e = ', e)  # This will return "e = 'request'"
            return Response(
                {'error': 'Unable to delete example model'},
                status=400,
            )

I'm not sure if I'm doing something DRF does not support here, the idea was that drf-spectacular requires a serializer to display the desired response so I would reuse that serializer, rather then recreate the desired response manually as shown below.

            example_model.delete()
            # Code to create desired response
            deleted_example_model = SerializerOne(example_model).data

            return Response(
                {'deleted_example_model': deleted_example_model},
            )

I'm almost certain all this effort is not worth not adding 'deleted_example_model' twice (within view and serializer).
Despite this I'm still curious where the error is coming from and what 'request' is trying to say, any help/insight would be appreciated.

[aupi0]

Something interesting is that I can get the error to go away and get the desired response without changing anything within the serializers or the view.
If you copy HiddenField, Field and empty from rest_framework.fields (as shown below) into the code shown above (and change performed by to refer to local HiddenField rather than serializer.HiddenField), then the error goes away despite the code being exactly the same as that found within DRF.

import warnings
from rest_framework.fields import Field as packageField
from rest_framework.fields import SkipField
from rest_framework import RemovedInDRF313Warning

class empty:
    """
    This class is used to represent no data being provided for a given input
    or output value.

    It is required because `None` may be a valid input or output value.
    """
    pass

class Field(packageField):
    def run_validation(self, data=empty):
        (is_empty_value, data) = self.validate_empty_values(data)
        if is_empty_value:
            return data
        value = self.to_internal_value(data)
        self.run_validators(value)
        return value

class HiddenField(Field):
    def __init__(self, **kwargs):
        assert 'default' in kwargs, 'default is a required argument.'
        kwargs['write_only'] = True
        super().__init__(**kwargs)

    def get_value(self, dictionary):
        # We always use the default value for `HiddenField`.
        # User input is never provided or accepted.
        return empty

    def to_internal_value(self, data):
        return data

If you comment out the entirety of class Empty: and replace it with from rest_framework.fields import empty the error comes back, despite the empty shown above being a copy of empty within DRF. And it's at this point I'm confused.

Chasing the error further (into validation_empty_values -> get_default), if you copy these functions from DRF into the Field class above then the error returns. e.g.

class Field(packageField):
    def run_validation(self, data=empty):
        (is_empty_value, data) = self.validate_empty_values(data)
        if is_empty_value:
            return data
        value = self.to_internal_value(data)
        self.run_validators(value)
        return value

    def validate_empty_values(self, data):
        if self.read_only:
            return (True, self.get_default())

        if data is empty:
            if getattr(self.root, 'partial', False):
                raise SkipField()
            if self.required:
                self.fail('required')
            return (True, self.get_default())

        if data is None:
            if not self.allow_null:
                self.fail('null')
            # Nullable `source='*'` fields should not be skipped when its named
            # field is given a null value. This is because `source='*'` means
            # the field is passed the entire object, which is not null.
            elif self.source == '*':
                return (False, None)
            return (True, None)

        return (False, data)
    
    def get_default(self):
        if self.default is empty or getattr(self.root, 'partial', False):
            # No default, or this is a partial update.
            raise SkipField()
        if callable(self.default):
            if hasattr(self.default, 'set_context'):
                warnings.warn(
                    "Method `set_context` on defaults is deprecated and will "
                    "no longer be called starting with 3.13. Instead set "
                    "`requires_context = True` on the class, and accept the "
                    "context as an additional argument.",
                    RemovedInDRF313Warning, stacklevel=2
                )
                self.default.set_context(self)

            if getattr(self.default, 'requires_context', False):
                return self.default(self)
            else:
                return self.default()

        return self.default

From this the line that seems to be throwing the error is return self.default(self) within if getattr in get_default.
If you change return self.default(self) to return self.default the error goes away again and the desired response is returned.

Sorry I realise that's the opposite of concise but I'm not sure how else to describe the issue and my observations.