Skip to main content
skill CX Codex

django-drf · gentleman-programming — Claude Code skill: REST APIs and install

django-drf is a Claude Code skill with patterns for Django REST APIs: ViewSets, serializers, filters, permissions, and tests. The patterns cover starting or extending an API.

Apache-2.0 162 installs ★ 678 updated 2026-03-28

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add Gentleman-Programming/Gentleman-Skills --skill django-drf -a claude-code
Open on GitHub

What django-drf does

This skill gives Django REST Framework patterns for API work. Its examples use a ModelViewSet with separate serializers for reads, creates, and updates, plus a custom activate action, permissions, and a filter set.

It covers serializer fields, password handling, django_filters, page-number pagination, DefaultRouter, and the REST_FRAMEWORK setting. Permission examples check object ownership or allow writes for staff users. The examples are tied to Django models such as User and Post.

Testing uses pytest, APIClient, fixtures, authentication, and response status checks. The skill also lists common manage.py commands. The filter example imports django_filters, so UserFilter depends on that package.

What it helps with

  • design a ViewSet for a REST API
  • separate read, create, and update serializers
  • filter users by email, status, and dates
  • configure API pagination and routes
  • test endpoints with APIClient

Example prompts for the agent

  • Create a UserViewSet with separate serializers for reading, creating, and updating users.
  • Add a UserFilter for email search, is_active, and a created_at date range.
  • Write pytest tests for listing and creating users through APIClient.

How to install django-drf

1Skills CLI (Vercel)

npx skills add Gentleman-Programming/Gentleman-Skills --skill django-drf -a claude-code

2Manually: put the files in place

~/.claude/skills/django-drf/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/django-drf/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about django-drf

How do I install django-drf in Claude Code?

Run npx skills add Gentleman-Programming/Gentleman-Skills --skill django-drf -a claude-code, then check ~/.claude/skills/django-drf/SKILL.md.

What does django-drf do?

It provides Django REST Framework patterns for ViewSets, serializers, filters, permissions, pagination, URL routing, and API tests.

What testing patterns does django-drf include?

The examples use pytest, APIClient, fixtures for authenticated clients, and status checks for listing and creating users.

Source text

SKILL.md · Apache-2.0
---
name: django-drf
description: >
  Django REST Framework patterns.
  Trigger: When building REST APIs with Django - ViewSets, Serializers, Filters.
license: Apache-2.0
metadata:
  author: gentleman-programming
  version: "1.0"
---

## ViewSet Pattern

```python
from rest_framework import viewsets, status
from rest_framework.response import Response
from rest_framework.decorators import action

class UserViewSet(viewsets.ModelViewSet):
    queryset = User.objects.all()
    serializer_class = UserSerializer
    filterset_class = UserFilter
    permission_classes = [IsAuthenticated]

    def get_serializer_class(self):
        if self.action == "create":
            return UserCreateSerializer
        if self.action in ["update", "partial_update"]:
            return UserUpdateSerializer
        return UserSerializer

    @action(detail=True, methods=["post"])
    def activate(self, request, pk=None):
        user = self.get_object()
        user.is_active = True
        user.save()
        return Response({"status": "activated"})
```

## Serializer Patterns

```python
from rest_framework import serializers

# Read Serializer
class UserSerializer(serializers.ModelSerializer):
    full_name = serializers.SerializerMethodField()

    class Meta:
        model = User
        fields = ["id", "email", "full_name", "created_at"]
        read_only_fields = ["id", "created_at"]

    def get_full_name(self, obj):
        return f"{obj.first_name} {obj.last_name}"

# Create Serializer
class UserCreateSerializer(serializers.ModelSerializer):
    password = serializers.CharField(write_only=True)

    class Meta:
        model = User
        fields = ["email", "password", "first_name", "last_name"]

    def create(self, validated_data):
        password = validated_data.pop("password")
        user = User(**validated_data)
        user.set_password(password)
        user.save()
        return user

# Update Serializer
class UserUpdateSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ["first_name", "last_name"]
```

## Filters

```python
from django_filters import rest_framework as filters

class UserFilter(filters.FilterSet):
    email = filters.CharFilter(lookup_expr="icontains")
    is_active = filters.BooleanFilter()
    created_after = filters.DateTimeFilter(
        field_name="created_at",
        lookup_expr="gte"
    )
    created_before = filters.DateTimeFilter(
        field_name="created_at",
        lookup_expr="lte"
    )

    class Meta:
        model = User
        fields = ["email", "is_active"]
```

## Permissions

```python
from rest_framework.permissions import BasePermission

class IsOwner(BasePermission):
    def has_object_permission(self, request, view, obj):
        return obj.owner == request.user

class IsAdminOrReadOnly(BasePermission):
    def has_permission(self, request, view):
        if request.method in ["GET", "HEAD", "OPTIONS"]:
            return True
        return request.user.is_staff
```

## Pagination

```python
from rest_framework.pagination import PageNumberPagination

class StandardPagination(PageNumberPagination):
    page_size = 20
    page_size_query_param = "page_size"
    max_page_size = 100

# settings.py
REST_FRAMEWORK = {
    "DEFAULT_PAGINATION_CLASS": "api.pagination.StandardPagination",
}
```

## URL Routing

```python
from rest_framework.routers import DefaultRouter

router = DefaultRouter()
router.register(r"users", UserViewSet, basename="user")
router.register(r"posts", PostViewSet, basename="post")

urlpatterns = [
    path("api/v1/", include(router.urls)),
]
```

## Testing

```python
import pytest
from rest_framework import status
from rest_framework.test import APIClient

@pytest.fixture
def api_client():
    return APIClient()

@pytest.fixture
def authenticated_client(api_client, user):
    api_client.force_authenticate(user=user)
    return api_client

@pytest.mark.django_db
class TestUserViewSet:
    def test_list_users(self, authenticated_client):
        response = authenticated_client.get("/api/v1/users/")
        assert response.status_code == status.HTTP_200_OK

    def test_create_user(self, authenticated_client):
        data = {"email": "[email protected]", "password": "pass123"}
        response = authenticated_client.post("/api/v1/users/", data)
        assert response.status_code == status.HTTP_201_CREATED
```

## Commands

```bash
python manage.py runserver
python manage.py makemigrations
python manage.py migrate
python manage.py createsuperuser
python manage.py shell
```

## Keywords
django, drf, rest framework, viewset, serializer, api, rest api

© gentleman-programming · Apache-2.0 · Gentleman-Programming/Gentleman-Skills

Similar skills

All skills for Backend and APIs →

django-drf by other authors comes first.

From the same set20

The whole set →

Project sponsors

Companies that keep this analytics open