tessl/pypi-djangorestframework

Web APIs for Django, made easy.

—

Pending

Overview

Eval results

Files

Views and ViewSets

Name: tessl/pypi-djangorestframework
Author: tessl

Class-based views and ViewSets for handling HTTP requests in Django REST Framework. Provides everything from basic APIView for custom logic to full CRUD ViewSets with automatic URL routing.

Capabilities

Base API View

Foundation view class providing core DRF functionality including authentication, permissions, content negotiation, and exception handling.

class APIView(View):
    """
    Base class for all DRF views providing core API functionality.
    """
    # Class attributes for configuration
    authentication_classes = []  # List of authentication classes
    permission_classes = []      # List of permission classes  
    parser_classes = []          # List of parser classes
    renderer_classes = []        # List of renderer classes
    throttle_classes = []        # List of throttle classes
    content_negotiation_class = None  # Content negotiation class
    
    def dispatch(self, request, *args, **kwargs):
        """
        Main entry point for handling requests.
        
        Args:
            request: Django request object (enhanced to DRF Request)
            *args: URL arguments
            **kwargs: URL keyword arguments
            
        Returns:
            Response: DRF Response object
        """
    
    def initial(self, request, *args, **kwargs):
        """
        Perform authentication, permissions, and throttling checks.
        """
    
    def handle_exception(self, exc):
        """
        Handle any exception that occurs during request processing.
        
        Args:
            exc: Exception that occurred
            
        Returns:
            Response: Error response
        """
    
    def get_permissions(self):
        """
        Instantiate and return permission classes for this view.
        
        Returns:
            list: Permission class instances
        """
    
    def get_authenticators(self):
        """
        Instantiate and return authentication classes for this view.
        
        Returns:
            list: Authentication class instances
        """
    
    def get_parsers(self):
        """
        Instantiate and return parser classes for this view.
        
        Returns:
            list: Parser class instances
        """
    
    def get_renderers(self):
        """
        Instantiate and return renderer classes for this view.
        
        Returns:
            list: Renderer class instances
        """

Generic API View

Base class for generic views providing common functionality like queryset handling, serializer management, and pagination.

class GenericAPIView(APIView):
    """
    Base class for generic views with queryset and serializer support.
    """
    queryset = None           # Base queryset for the view
    serializer_class = None   # Serializer class to use
    lookup_field = 'pk'       # Field for object lookup
    lookup_url_kwarg = None   # URL kwarg for lookup
    filter_backends = []      # List of filter backend classes
    pagination_class = None   # Pagination class
    
    def get_queryset(self):
        """
        Get the queryset for this view.
        
        Returns:
            QuerySet: Filtered queryset
        """
    
    def get_object(self):
        """
        Get single object based on lookup parameters.
        
        Returns:
            Model instance
            
        Raises:
            Http404: If object not found
        """
    
    def get_serializer(self, *args, **kwargs):
        """
        Get serializer instance with current context.
        
        Returns:
            Serializer: Configured serializer instance
        """
    
    def get_serializer_class(self):
        """
        Get serializer class for this view.
        
        Returns:
            Serializer class
        """
    
    def get_serializer_context(self):
        """
        Get context data for serializer.
        
        Returns:
            dict: Context dictionary
        """
    
    def paginate_queryset(self, queryset):
        """
        Paginate queryset if pagination is configured.
        
        Args:
            queryset: QuerySet to paginate
            
        Returns:
            list or None: Paginated results
        """
    
    def get_paginated_response(self, data):
        """
        Get paginated response for data.
        
        Args:
            data: Serialized data
            
        Returns:
            Response: Paginated response
        """
    
    def filter_queryset(self, queryset):
        """
        Apply filtering backends to queryset.
        
        Args:
            queryset: Base queryset
            
        Returns:
            QuerySet: Filtered queryset
        """

Concrete Generic Views

Pre-built views for common API patterns providing standard CRUD operations.

class CreateAPIView(GenericAPIView):
    """Handle POST requests to create new objects."""
    def post(self, request, *args, **kwargs): ...

class ListAPIView(GenericAPIView):
    """Handle GET requests to list objects.""" 
    def get(self, request, *args, **kwargs): ...

class RetrieveAPIView(GenericAPIView):
    """Handle GET requests to retrieve single object."""
    def get(self, request, *args, **kwargs): ...

class DestroyAPIView(GenericAPIView):
    """Handle DELETE requests to delete objects."""
    def delete(self, request, *args, **kwargs): ...

class UpdateAPIView(GenericAPIView):
    """Handle PUT/PATCH requests to update objects."""
    def put(self, request, *args, **kwargs): ...
    def patch(self, request, *args, **kwargs): ...

# Combined views
class ListCreateAPIView(GenericAPIView):
    """Handle GET (list) and POST (create) requests."""
    def get(self, request, *args, **kwargs): ...
    def post(self, request, *args, **kwargs): ...

class RetrieveUpdateAPIView(GenericAPIView):
    """Handle GET (retrieve) and PUT/PATCH (update) requests."""
    def get(self, request, *args, **kwargs): ...
    def put(self, request, *args, **kwargs): ...
    def patch(self, request, *args, **kwargs): ...

class RetrieveDestroyAPIView(GenericAPIView):
    """Handle GET (retrieve) and DELETE (destroy) requests."""
    def get(self, request, *args, **kwargs): ...
    def delete(self, request, *args, **kwargs): ...

class RetrieveUpdateDestroyAPIView(GenericAPIView):
    """Handle GET (retrieve), PUT/PATCH (update), and DELETE (destroy)."""
    def get(self, request, *args, **kwargs): ...
    def put(self, request, *args, **kwargs): ...
    def patch(self, request, *args, **kwargs): ...
    def delete(self, request, *args, **kwargs): ...

ViewSets

ViewSet classes that group related view logic and can generate URL patterns automatically.

class ViewSet(ViewSetMixin, APIView):
    """
    Basic ViewSet class providing action-based routing.
    """
    def list(self, request):
        """Handle GET requests to list objects."""
    
    def create(self, request):
        """Handle POST requests to create objects."""
    
    def retrieve(self, request, pk=None):
        """Handle GET requests to retrieve single object."""
    
    def update(self, request, pk=None):
        """Handle PUT requests to update objects."""
    
    def partial_update(self, request, pk=None):
        """Handle PATCH requests to partially update objects."""
    
    def destroy(self, request, pk=None):
        """Handle DELETE requests to destroy objects."""

class GenericViewSet(ViewSetMixin, GenericAPIView):
    """
    Generic ViewSet with queryset and serializer support.
    """

class ReadOnlyModelViewSet(GenericViewSet):
    """
    ViewSet providing read-only operations (list and retrieve).
    """
    def list(self, request, *args, **kwargs): ...
    def retrieve(self, request, *args, **kwargs): ...

class ModelViewSet(GenericViewSet):
    """
    Full CRUD ViewSet with all standard operations.
    """
    def list(self, request, *args, **kwargs): ...
    def create(self, request, *args, **kwargs): ...
    def retrieve(self, request, *args, **kwargs): ...
    def update(self, request, *args, **kwargs): ...
    def partial_update(self, request, *args, **kwargs): ...
    def destroy(self, request, *args, **kwargs): ...

View Mixins

Modular functionality that can be mixed into views for specific behaviors.

class CreateModelMixin:
    """Provide create functionality for views."""
    def create(self, request, *args, **kwargs):
        """
        Create new model instance.
        
        Returns:
            Response: 201 Created with serialized data
        """
    
    def perform_create(self, serializer):
        """Save the object during creation."""
        serializer.save()
    
    def get_success_headers(self, data):
        """Get headers for successful creation response."""

class ListModelMixin:
    """Provide list functionality for views."""
    def list(self, request, *args, **kwargs):
        """
        List model instances with pagination and filtering.
        
        Returns:
            Response: 200 OK with serialized data list
        """

class RetrieveModelMixin:
    """Provide retrieve functionality for views."""
    def retrieve(self, request, *args, **kwargs):
        """
        Retrieve single model instance.
        
        Returns:
            Response: 200 OK with serialized data
        """

class UpdateModelMixin:
    """Provide update functionality for views."""
    def update(self, request, *args, **kwargs):
        """
        Update model instance (full update).
        
        Returns:
            Response: 200 OK with serialized data  
        """
    
    def partial_update(self, request, *args, **kwargs):
        """
        Partially update model instance.
        
        Returns:
            Response: 200 OK with serialized data
        """
    
    def perform_update(self, serializer):
        """Save the object during update."""
        serializer.save()

class DestroyModelMixin:
    """Provide destroy functionality for views."""
    def destroy(self, request, *args, **kwargs):
        """
        Delete model instance.
        
        Returns:
            Response: 204 No Content
        """
    
    def perform_destroy(self, instance):
        """Delete the object."""
        instance.delete()

Usage Examples

Function-Based View

from rest_framework.decorators import api_view, permission_classes
from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response
from rest_framework import status

@api_view(['GET', 'POST'])
@permission_classes([IsAuthenticated])
def book_list(request):
    if request.method == 'GET':
        books = Book.objects.all()
        serializer = BookSerializer(books, many=True)
        return Response(serializer.data)
    
    elif request.method == 'POST':
        serializer = BookSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

Class-Based APIView

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticated

class BookListView(APIView):
    permission_classes = [IsAuthenticated]
    
    def get(self, request):
        books = Book.objects.all()
        serializer = BookSerializer(books, many=True)
        return Response(serializer.data)
    
    def post(self, request):
        serializer = BookSerializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

Generic Views

from rest_framework.generics import ListCreateAPIView, RetrieveUpdateDestroyAPIView
from rest_framework.permissions import IsAuthenticatedOrReadOnly

class BookListCreateView(ListCreateAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSerializer
    permission_classes = [IsAuthenticatedOrReadOnly]
    
    def perform_create(self, serializer):
        serializer.save(owner=self.request.user)

class BookDetailView(RetrieveUpdateDestroyAPIView):
    queryset = Book.objects.all()
    serializer_class = BookSerializer
    permission_classes = [IsAuthenticatedOrReadOnly]

ViewSets with Custom Actions

from rest_framework.viewsets import ModelViewSet
from rest_framework.decorators import action
from rest_framework.response import Response

class BookViewSet(ModelViewSet):
    queryset = Book.objects.all()
    serializer_class = BookSerializer
    permission_classes = [IsAuthenticatedOrReadOnly]
    
    @action(detail=True, methods=['post'])
    def set_favorite(self, request, pk=None):
        book = self.get_object()
        # Custom logic for favoriting
        return Response({'status': 'favorite set'})
    
    @action(detail=False, methods=['get'])
    def recent_books(self, request):
        recent = Book.objects.filter(created__gte=timezone.now() - timedelta(days=7))
        serializer = self.get_serializer(recent, many=True)
        return Response(serializer.data)

Utility Functions

def get_view_name(view):
    """
    Get textual name for view class.
    
    Args:
        view: View class or instance
        
    Returns:
        str: Human-readable view name
    """

def get_view_description(view, html=False):
    """
    Get description for view from docstring.
    
    Args:
        view: View class or instance
        html (bool): Return HTML formatted description
        
    Returns:
        str: View description text
    """

def exception_handler(exc, context):
    """
    Default exception handler for DRF views.
    
    Args:
        exc: Exception that occurred
        context (dict): Context information
        
    Returns:
        Response or None: Error response or None to use default
    """

Install with Tessl CLI

npx tessl i tessl/pypi-djangorestframework

docs

auth-permissions.md

content-negotiation.md

pagination-filtering.md