def __new__()

in src/wagtail_localize_smartling/api/serializers.py [0:0]

• 34 lines of code
• 12 McCabe index (conditional complexity)

    def __new__(cls, name, bases, attrs, **kwargs):
        if any(isinstance(b, ResponseSerializerMetaclass) for b in bases):
            # Identify whether this is a subclass requiring nullable `data`

            # This a ResponseSerializer subclass, so loop over attrs and strip
            # off any fields and nested serializers
            data_serializer_fields: dict[str, serializers.Field] = {}
            for attr_name, attr in list(attrs.items()):
                if isinstance(attr, serializers.Field):
                    data_serializer_fields[attr_name] = attrs.pop(attr_name)

            # Determine the base classes for a new data serializer class
            data_serializer_bases = tuple(
                b._data_serializer_class
                for b in bases
                if hasattr(b, "_data_serializer_class")
            )
            if not data_serializer_bases:
                data_serializer_bases = (serializers.Serializer,)

            # Create the new data serializer class with the fields we stripped off above
            data_serializer_class = type(
                f"{name}__DataSerializer",
                data_serializer_bases,
                data_serializer_fields,
            )

            # Create a new InnerResponseSerializer subclass whose "data" field
            # is an instance the new data serializer subclass that we just created
            inner_response_serializer_class = type(
                f"{name}__InnerResponseSerializer",
                (InnerResponseSerializer,),
                {"data": data_serializer_class(required=False)},
            )

            # Finally, create and return the new ResponseSerializer subclass
            # with its "response" field declared as an instance of the
            # InnerResponseSerializer subclass we just created. Also attach a
            # reference to the data serializer class we just created so we can
            # use it when subclassing subclasses.
            return super().__new__(
                cls,
                name,
                bases,
                {
                    **attrs,
                    "response": inner_response_serializer_class(),
                    "_data_serializer_class": data_serializer_class,
                },
            )

        return super().__new__(cls, name, bases, attrs)