"""Exception handler with support for nested serializers."""
import inspect
from django.http import Http404
from rest_framework import exceptions
from rest_framework_json_api import utils
from rest_framework_json_api.exceptions import rendered_with_json_api
from rest_framework_json_api.settings import json_api_settings
def format_drf_errors(response, context, exc):
 """Format the drf error as a JSON:API error."""
 errors = []
 context["view"].resource_name = "errors"
 # handle generic errors. ValidationError('test') in a view for example
 if isinstance(response.data, list):
 for message in response.data:
 errors.append(utils.format_error_object(message, "/data", response))
 response.data = errors
 return errors
 # handle all errors thrown from serializers
 for field, error in response.data.items():
 errors.extend(_handle_error_value(response, exc, field, error))
 response.data = errors
 return response
def _handle_error_value(response, exc, field, error, key_prefix=None) -> list:
 field = utils.format_value(field)
 if key_prefix is None:
 key_prefix = "/data/attributes"
 pointer = f"{key_prefix}/{field}"
 if isinstance(error, dict):
 errors = []
 for nested_field, nested_error in error.items():
 errors.extend(
 _handle_error_value(response, exc, nested_field, nested_error, pointer)
 )
 return errors
 if isinstance(exc, Http404) and isinstance(error, str):
 # 404 errors don't have a pointer
 return [utils.format_error_object(error, None, response)]
 if isinstance(error, str):
 classes = inspect.getmembers(exceptions, inspect.isclass)
 # DRF sets the `field` to 'detail' for its own exceptions
 if isinstance(exc, tuple(x[1] for x in classes)):
 pointer = "/data"
 return [utils.format_error_object(error, pointer, response)]
 if isinstance(error, list):
 return [
 utils.format_error_object(message, pointer, response) for message in error
 ]
 return [utils.format_error_object(error, pointer, response)]
def exception_handler(exc, context):
 """Return errors from DJA views formatted as per JSON:API spec."""
 # Import this here to avoid potential edge-case circular imports, which
 # crashes with:
 # "ImportError: Could not import 'rest_framework_json_api.parsers.JSONParser' for API setting
 # 'DEFAULT_PARSER_CLASSES'. ImportError: cannot import name 'exceptions'.'"
 #
 # Also see: https://github.com/django-json-api/django-rest-framework-json-api/issues/158
 from rest_framework.views import exception_handler as drf_exception_handler
 # Render exception with DRF
 response = drf_exception_handler(exc, context)
 if not response:
 return response
 # Use regular DRF format if not rendered by DRF JSON API and not uniform
 is_json_api_view = rendered_with_json_api(context["view"])
 is_uniform = json_api_settings.UNIFORM_EXCEPTIONS
 if not is_json_api_view and not is_uniform:
 return response
 # Convert to DRF JSON API error format
 response = format_drf_errors(response, context, exc)
 # Add top-level 'errors' object when not rendered by DRF JSON API
 if not is_json_api_view:
 response.data = utils.format_errors(response.data)
 return response