JSON:API support for Django REST framework

Overview

JSON:API and Django REST framework

Tests Read the docs PyPi Version

Overview

JSON:API support for Django REST framework

By default, Django REST framework will produce a response like:

{
    "count": 20,
    "next": "http://example.com/api/1.0/identities/?page=3",
    "previous": "http://example.com/api/1.0/identities/?page=1",
    "results": [{
        "id": 3,
        "username": "john",
        "full_name": "John Coltrane"
    }]
}

However, for an identity model in JSON:API format the response should look like the following:

{
    "links": {
        "prev": "http://example.com/api/1.0/identities",
        "self": "http://example.com/api/1.0/identities?page=2",
        "next": "http://example.com/api/1.0/identities?page=3",
    },
    "data": [{
        "type": "identities",
        "id": "3",
        "attributes": {
            "username": "john",
            "full-name": "John Coltrane"
        }
    }],
    "meta": {
        "pagination": {
          "count": 20
        }
    }
}

Goals

As a Django REST framework JSON:API (short DJA) we are trying to address following goals:

  1. Support the JSON:API spec to compliance

  2. Be as compatible with Django REST framework as possible

    e.g. issues in Django REST framework should be fixed upstream and not worked around in DJA

  3. Have sane defaults to be as easy to pick up as possible

  4. Be solid and tested with good coverage

  5. Be performant

Requirements

  1. Python (3.6, 3.7, 3.8, 3.9)
  2. Django (2.2, 3.0, 3.1, 3.2)
  3. Django REST framework (3.12)

We highly recommend and only officially support the latest patch release of each Python, Django and REST framework series.

Generally Python and Django series are supported till the official end of life. For Django REST framework the last two series are supported.

Installation

Install using pip...

$ pip install djangorestframework-jsonapi
$ # for optional package integrations
$ pip install djangorestframework-jsonapi['django-filter']
$ pip install djangorestframework-jsonapi['django-polymorphic']
$ pip install djangorestframework-jsonapi['openapi']

or from source...

$ git clone https://github.com/django-json-api/django-rest-framework-json-api.git
$ cd django-rest-framework-json-api
$ pip install -e .

and add rest_framework_json_api to your INSTALLED_APPS setting below rest_framework.

INSTALLED_APPS = [
    ...
    'rest_framework',
    'rest_framework_json_api',
    ...
]

Running the example app

It is recommended to create a virtualenv for testing. Assuming it is already installed and activated:

$ git clone https://github.com/django-json-api/django-rest-framework-json-api.git
$ cd django-rest-framework-json-api
$ pip install -Ur requirements.txt
$ django-admin migrate --settings=example.settings
$ django-admin loaddata drf_example --settings=example.settings
$ django-admin runserver --settings=example.settings

Browse to

Usage

rest_framework_json_api assumes you are using class-based views in Django REST framework.

Settings

One can either add rest_framework_json_api.parsers.JSONParser and rest_framework_json_api.renderers.JSONRenderer to each ViewSet class, or override settings.REST_FRAMEWORK

REST_FRAMEWORK = {
    'PAGE_SIZE': 10,
    'EXCEPTION_HANDLER': 'rest_framework_json_api.exceptions.exception_handler',
    'DEFAULT_PAGINATION_CLASS':
        'rest_framework_json_api.pagination.JsonApiPageNumberPagination',
    'DEFAULT_PARSER_CLASSES': (
        'rest_framework_json_api.parsers.JSONParser',
        'rest_framework.parsers.FormParser',
        'rest_framework.parsers.MultiPartParser'
    ),
    'DEFAULT_RENDERER_CLASSES': (
        'rest_framework_json_api.renderers.JSONRenderer',
        'rest_framework_json_api.renderers.BrowsableAPIRenderer',
    ),
    'DEFAULT_METADATA_CLASS': 'rest_framework_json_api.metadata.JSONAPIMetadata',
    'DEFAULT_FILTER_BACKENDS': (
        'rest_framework_json_api.filters.QueryParameterValidationFilter',
        'rest_framework_json_api.filters.OrderingFilter',
        'rest_framework_json_api.django_filters.DjangoFilterBackend',
        'rest_framework.filters.SearchFilter',
    ),
    'SEARCH_PARAM': 'filter[search]',
    'TEST_REQUEST_RENDERER_CLASSES': (
        'rest_framework_json_api.renderers.JSONRenderer',
    ),
    'TEST_REQUEST_DEFAULT_FORMAT': 'vnd.api+json'
}

This package provides much more including automatic inflection of JSON keys, extra top level data (using nested serializers), relationships, links, paginators, filters, and handy shortcuts. Read more at http://django-rest-framework-json-api.readthedocs.org/

Comments
  • Query explosion even on simple models with no included serializers

    Query explosion even on simple models with no included serializers

    I love the idea of this module but it seems like it's impossible to build fast APIs with it.

    Let's say I have Books and Authors. I fetch a list of books, even with no "included" specified I get a query for each author, just to display the FK?

    As a broader issue, as Author increases in complexity developers will add more included_serializers to that serialiser, which inadvertently affects my Books viewset with a query explosion.

    Could we define a lambda for each included_serializer to alter the query? Anything more robust than magic.

    bug enhancement 
    opened by aidanlister 79
  • Added the ability to specify a resource_name on Models

    Added the ability to specify a resource_name on Models

    I mentioned this yesterday on issue #74 and figured I would just open a PR to get opinions on this change.

    This would allow a resource_name to be specified on the model. This was required in certain cases (relations: this line) where no serializer or view could have overridden the resource_name. This would allow the resource_name of a model to be overridden globally for that model.

    I haven't written any tests yet as I uncovered a lot of places the model __name__ property is used, hence WIP.

    EDIT: Test TODOs:

    • [x] Model resource_name used on a relation
    • [x] Model resource_name in included document
    • [x] Serializer resource_name override over Model resource_name
    • [x] View resource_name override over Model resource_name
    opened by scottfisk 39
  • OAS 3.0 schema generation

    OAS 3.0 schema generation

    Fixes #604 Fixes #644

    Description of the Change

    Extends DRF >= 3.12's generateschema to produce a jsonapi-formatted OAS schema document. Builds on @n2ygk's work in https://github.com/django-json-api/django-rest-framework-json-api/pull/689

    • Updated to latest DJA version

    Checklist

    • [x] PR only contains one change (considered splitting up PR)
    • [x] unit-test added
    • [x] documentation updated
    • [x] CHANGELOG.md updated (only for user relevant changes)
    • [x] author name in AUTHORS
    opened by keyz182 38
  • Support polymorphic models

    Support polymorphic models

    Handles polymorphic resources with the correct models types. This is transparent: no extra configuration is needed.

    Should be tested a little bit more (typically on inverse relations, coming in the few next days), but I opened the PR to let anybody play with this and eventually get some feedback.

    opened by leo-naeka 34
  • initial implementation of OAS 3.0 generateschema

    initial implementation of OAS 3.0 generateschema

    Fixes #604 (replaces #669)

    Description of the Change

    Extends DRF >= 3.10's generateschema to produce a jsonapi-formatted OAS schema document.

    Checklist

    • [x] PR only contains one change (considered splitting up PR)
    • [x] unit-test added
    • [x] documentation updated
    • [x] CHANGELOG.md updated (only for user relevant changes)
    • [x] author name in AUTHORS
    opened by n2ygk 27
  • Improvements for pagination, sorting, filtering, and exception h…

    Improvements for pagination, sorting, filtering, and exception h…

    …andling

    • Pagination updates:
      • Improve existing documentation of pagination, mixins
        • Document LimitOffsetPagination
        • Describe how to override pagination class query parameter names.
        • Remove reference to PAGINATE_BY_PARAM which was deprecated in DRF 3.2.
        • Document SparseFieldsetsMixin
      • Add new default settings for pagination query parameters and maximum size.
    • Add combinable mixins for filter and sort query parameters and make MultiplIDMixin combinable.
    • Exceptions updates:
      • Document JSON_API_UNIFORM_EXCEPTIONS setting.
      • handle missing fields exception thrown by new filter and sort Mixins as a 400 error.
      • Catch all exceptions not caught by DRF and format as JSON API error objects instead of returning HTML error pages.
    opened by n2ygk 23
  • Allow `format` through GET validation filtering

    Allow `format` through GET validation filtering

    Issue

    The guides on https://django-rest-framework-json-api.readthedocs.io/en/stable/usage.html#configuration recommend including the rest_framework_json_api.filters.QueryParameterValidationFilter in initial configuration which is good advice, but by default, the Django REST Framework UI provides a dropdown which allows you to pick format=api or format=vnd.api+json

    screenshot at 2018-12-28 15-10-51

    Without allowing the format parameter through you get the following error:

    HTTP 400 Bad Request
    Allow: GET, POST, HEAD, OPTIONS
    Content-Type: application/vnd.api+json
    Vary: Accept
    
    {
        "errors": [
            {
                "detail": "invalid query parameter: format",
                "source": {
                    "pointer": "/data"
                },
                "status": "400"
            }
        ]
    }
    

    Description of the Change

    This change adds format to query_regex

    Checklist

    • [x] PR only contains one change (considered splitting up PR)
    • [ ] unit-test added
    • [x] documentation updated
    • [ ] changelog entry added to CHANGELOG.md
    • [ ] author name in AUTHORS
    opened by serenecloud 22
  • Request for new maintainer

    Request for new maintainer

    I picked up the maintainer torch about a year ago when the project seemed to be stuck. I was using DJA on a side project, and I needed to fix a bug and get a new release out. Today, I'm no longer working on the side project and my interest in maintaining DJA has waned significantly.

    As I'm not being a great steward for the project, I'd like to request that someone else pick it up. This is very much a community effort and code contributions come from a wide variety of contributors. The new maintainer would be most involved with:

    1. Review of new Pull Requests and Issues.
    2. Deploying new releases to PyPI.

    I hope that I've added the right tools that can make management of this project easier for a future maintainer. Static code analysis has removed a lot of friction that might come up as a primary PR reviewer.

    If you're in a decent place to step into the maintainer role, please let me know and I can work to transition over project handling to you. I'm happy to help with a bit of training if needed or improving release documentation.

    help wanted 
    opened by mblayman 19
  • UnboundLocalError in renderers.py

    UnboundLocalError in renderers.py

    I recently upgraded my project to Django 1.10 and to DRF JSON API 2.1.0, and I am now seeing an error every time I try to make a simple GET call on one of my resources. The error remains if I use Django 1.10 or Django 1.9. Here is a piece of the error page:

    UnboundLocalError at /api/abonnes_fichier/
    local variable 'relation_instance' referenced before assignment
    Request Method: GET
    Request URL:    http://localhost:9000/api/abonnes_fichier/
    Django Version: 1.9.9
    Exception Type: UnboundLocalError
    Exception Value:    
    local variable 'relation_instance' referenced before assignment
    Exception Location: .../site-packages/rest_framework_json_api/renderers.py in extract_relationships, line 202
    

    The error comes from the function extract_relationships in the class JSONRenderer. I'm still a newbie to Django and DRF so I'm having a hard time debugging the function. I think the problematic commit might be b96d79d49995c0faac6174ecdd1715a2b1121d3d.

    opened by daveslab 19
  • Missing permission checks in RelatedMixin views

    Missing permission checks in RelatedMixin views

    No object level or model level permissions appear to be checked for related models in RelatedMixin views.

    Expected behavior: The related fields should be empty in a response object if the user doesn't have view permission to the related field. Alternatively, if a response must render the related object, a permissions error should be raised.

    Observed behavior: Currently, if the user has permission for a model but not related models (e.g. via a foreign key relation), they are still able to view the related object if a RelatedMixin view's serializer has a ResourceRelatedField. This seems to merit at least some documentation warning users about the potential for leaking data, but preferably this issue could be fixed by enabling permissions checking.

    Reproducing the issue requires a project that checks that a user has read (or "view") permissions for models they try to access (e.g. using extended versions of DjangoObjectPermissions and DjangoModelPermissions classes mentioned in the django-rest-framework permissions documentation). In such a project, for any RelatedMixin view that uses a serializer with a ResourceRelatedField, grant the user permission to the serializer's model object, but do not grant the user access to the related model. If the user requests the object, they will still be able to access the related field. I'm happy to add a test case for this issue.

    Perhaps object level or even model level permissions checking is out of scope for the django-rest-framework-json-api project, but it seems like both should be supported. After all, django-rest-framework supports and advertises both via the DjangoObjectPermissions and DjangoModelPermissions classes. In a project I'm working on, we use django-guardian with a similar class to check object-level permissions. Perhaps I can override RelatedMixin.get_related_instance() in the meantime as a stopgap solution, but a solution via configuration flag or a default in this library would be preferable.

    Best, Luc

    needs-information 
    opened by lcary 18
  • Add tests using default DRF classes

    Add tests using default DRF classes

    Fixes #283

    Description of the Change

    Checklist

    • [x] PR only contains one change (considered splitting up PR)
    • [x] unit-test added
    • [ ] documentation updated
    • [ ] changelog entry added to CHANGELOG.md
    • [x] author name in AUTHORS
    opened by Alig1493 18
  • JSON API 1.1: return included array even if nothing is included

    JSON API 1.1: return included array even if nothing is included

    Description of feature request

    Currently, when there are no included resources, there is no included key. However, as of JSON API 1.1 this is required and in older versions it is certainly allowed.

    The check here should be changed to whether there are included resources and not whether there are actual included resources.

    Checklist

    • [x] Raised initially as discussion #1092
    • [x] This cannot be dealt with as a third party library. (We prefer new functionality to be in the form of third party libraries where feasible.)
    • [x] I have reduced the issue to the simplest possible case.
    enhancement good first issue 
    opened by sliverc 0
  • Order

    Order

    Fixes #

    Try python dict instead of OrderedDict

    Checklist

    • [ ] PR only contains one change (considered splitting up PR)
    • [ ] unit-test added
    • [ ] documentation updated
    • [ ] CHANGELOG.md updated (only for user relevant changes)
    • [ ] author name in AUTHORS
    opened by auvipy 3
  • Allow polymorphic serializer to be defined as dotted string in PolymorphicResourceRelatedField

    Allow polymorphic serializer to be defined as dotted string in PolymorphicResourceRelatedField

    PolymorphicResourceRelatedField serializer throws 'str' object has no attribute 'get_polymorphic_types', if the referenced serializer is declared before the referencing serializer.

    class ASerializer(ModelSerializer):
        ...
    
    class BSerializer(ModelSerializer):
        A = PolymorphicResourceRelatedField(
            'module.serializers.ASerializer',
        ) # <- this one raises  'str' object has no attribute 'get_polymorphic_types', to avoid it we have to reference the class directly ASerializer
    
        C = PolymorphicResourceRelatedField(
            'module.serializers.ASerializer', # <- this one does not raise error
        )
        
    class CSerializer(ModelSerializer):
        ...
    

    'module.serializers.ASerializer' should be the preferred way of referencing other serializers to avoid circular imports.

    good first issue 
    opened by Elawphant 7
  • OpenAPI Schema generation fails with generic APIViews

    OpenAPI Schema generation fails with generic APIViews

    Description of the Bug Report

    class LogoutView(APIView):
         pass
    
    

    Errors when accessing documents

    AttributeError: 'LogoutView' object has no attribute 'get_serializer'

    Is fault tolerance possible when the program has api in other formats

    Checklist

    • [x] Certain that this is a bug (if unsure or you have a question use discussions instead)
    • [ ] Code snippet or unit test added to reproduce bug
    bug 
    opened by qianxuanyon 3
  • SparseFieldsetsMixin does not use the correct configured JSON_API_FORMAT_FIELD_NAMES

    SparseFieldsetsMixin does not use the correct configured JSON_API_FORMAT_FIELD_NAMES

    Description of the Bug Report

    SparseFieldsetsMixin does not adjust field_names by configured format.

    Fix:

    class SparseFieldsetsMixin:
        """
        A serializer mixin that adds support for sparse fieldsets through `fields` query parameter.
    
        Specification: https://jsonapi.org/format/#fetching-sparse-fieldsets
        """
    
        def __init__(self, *args, **kwargs):
            super().__init__(*args, **kwargs)
            context = kwargs.get("context")
            request = context.get("request") if context else None
    
            if request:
                sparse_fieldset_query_param = "fields[{}]".format(
                    get_resource_type_from_serializer(self)
                )
                try:
                    param_name = next(
                        key
                        for key in request.query_params
                        if sparse_fieldset_query_param == key
                    )
                except StopIteration:
                    pass
                else:
                    fieldset = request.query_params.get(param_name).split(",")
                    # iterate over a *copy* of self.fields' underlying OrderedDict, because we may
                    # modify the original during the iteration.
                    # self.fields is a `rest_framework.utils.serializer_helpers.BindingDict`
                    for field_name, field in self.fields.fields.copy().items():
                        if (
                            field_name == api_settings.URL_FIELD_NAME
                        ):  # leave self link there
                            continue
                        # missing format_value()
                        correct_field_name = format_value(field_name, json_api_settings.FORMAT_FIELD_NAMES)
                        if correct_field_name not in fieldset:
                            self.fields.pop(field_name)
    

    Checklist

    • [x] Certain that this is a bug (if unsure or you have a question use discussions instead)
    • [x] Code snippet or unit test added to reproduce bug
    bug good first issue 
    opened by jokiefer 1
  • differs correctly between `meta` properties and `attribute` propertie…

    differs correctly between `meta` properties and `attribute` propertie…

    …s in component schemas.

    Fixes #

    Description of the Change

    Checklist

    • [x] PR only contains one change (considered splitting up PR) ~- [ ] unit-test added~ ~- [ ] documentation updated~
    • [x] CHANGELOG.md updated (only for user relevant changes)
    • [x] author name in AUTHORS
    opened by jokiefer 1
Releases(v6.0.0)
  • v6.0.0(Sep 24, 2022)

  • v5.0.0(Jan 3, 2022)

  • v4.3.0(Dec 10, 2021)

  • v4.2.1(Jul 6, 2021)

  • v4.2.0(May 12, 2021)

  • v4.1.0(Mar 8, 2021)

  • v4.0.0(Oct 30, 2020)

  • v3.2.0(Aug 26, 2020)

  • v3.1.0(Feb 11, 2020)

  • v3.0.0(Oct 13, 2019)

  • v2.8.0(Jun 24, 2019)

  • v2.7.0(Jan 14, 2019)

  • v2.6.0(Sep 20, 2018)

  • v2.5.0(Jul 11, 2018)

    • Add new pagination classes based on JSON:API query parameter recommendations:
      • JsonApiPageNumberPagination and JsonApiLimitOffsetPagination. See usage docs.
      • Deprecates PageNumberPagination and LimitOffsetPagination
    • Add ReadOnlyModelViewSet extension with prefetch mixins
    • Add support for Django REST Framework 3.8.x
    • Introduce JSON_API_FORMAT_FIELD_NAMES option replacing JSON_API_FORMAT_KEYS but in comparison preserving values from being formatted as attributes can contain any json value.
      • JSON_API_FORMAT_KEYS still works as before (formatting all json value keys also nested) but is marked as deprecated
    • Performance improvement when rendering included data
    • Allow overwriting of get_queryset() in custom ResourceRelatedField
    Source code(tar.gz)
    Source code(zip)
  • v2.4.0(Jul 11, 2018)

    • Add support for Django REST Framework 3.7.x.
    • Add support for Django 2.0.
    • Drop support for Django 1.8 - 1.10 (EOL)
    • Drop support for Django REST Framework < 3.6.3 (3.6.3 is the first to support Django 1.11)
    • Drop support for Python 3.3 (EOL)
    Source code(tar.gz)
    Source code(zip)
  • v2.3.0(Jul 11, 2018)

    • Added support for polymorphic models
    • When JSON_API_FORMAT_KEYS is False (the default) do not translate request attributes and relations to snake_case format. This conversion was unexpected and there was no way to turn it off.
    • Fix for apps that don't use django.contrib.contenttypes.
    • Fix resource_name support for POST requests and nested serializers
    • Enforcing flake8 linting
    • Added nested included serializer support for remapped relations
    Source code(tar.gz)
    Source code(zip)
  • v2.2.0(Apr 21, 2017)

  • v2.1.1(Sep 26, 2016)

    • Avoid setting id to None in the parser simply because it's missing
    • Fixed out of scope relation_instance variable in renderer
    • Allow default DRF serializers to operate even when mixed with DRF-JA serializers
    • Fixed wrong resource type for reverse foreign keys
    • Fixed documentation typos
    Source code(tar.gz)
    Source code(zip)
  • v2.1.0(Aug 18, 2016)

    • Parse meta in JSONParser
    • Added code coverage reporting and updated Django versions tested against
    • Fixed Django 1.10 compatibility
    • Added support for regular non-ModelSerializers
    • Added performance enhancements to reduce the number of queries in related payloads
    • Fixed bug where related SerializerMethodRelatedField fields were not included even if in include
    • Convert include field names back to snake_case
    • Documented built in url field for generating a self link in the links key
    • Fixed bug that prevented fields = () in a serializer from being valid
    • Fixed stale data returned in PATCH to-one relation
    • Raise a ParseError if an id is not included in a PATCH request
    Source code(tar.gz)
    Source code(zip)
  • v2.0.1(May 2, 2016)

  • v2.0.0(Apr 29, 2016)

    Since v2.0.0-beta.2

    • Fixed bug where write_only fields still had their keys rendered
    • Exception handler can now easily be used on DRF-JA views alongside regular DRF views
    • Added get_related_field_name for views subclassing RelationshipView to override
    • Renamed JSON_API_FORMAT_RELATION_KEYS to JSON_API_FORMAT_TYPES to match what it was actually doing
    • Renamed JSON_API_PLURALIZE_RELATION_TYPE to JSON_API_PLURALIZE_TYPES
    • Documented ResourceRelatedField and RelationshipView
    • Added LimitOffsetPagination
    • Support deeply nested ?includes=foo.bar.baz without returning intermediate models (bar)
    • Allow a view's serializer_class to be fetched at runtime via get_serializer_class
    • Added support for get_root_meta on list serializers

    Before v2.0.0-beta.2

    • Pretty much everything.

    This package started life as rest_framework_ember before jsonapi.org existed. v2.0.0 is the first release after the name change and JSON API compatibility.

    Source code(tar.gz)
    Source code(zip)
  • v2.0.0-beta.1(Jan 7, 2016)

    All repository collaborators are using this package in production and we no longer consider it alpha.

    Compatible with Django 1.7 to 1.9 and Django REST Framework 3.1 to 3.4 using Python 2.7 to 3.5.

    Source code(tar.gz)
    Source code(zip)
  • v1.1.0(Dec 17, 2014)

    This release adds support for Django REST Framework v3.0.x and also adds support for camelCase <-> snake_case converting and key pluralization for new versions of Ember Data.

    Source code(tar.gz)
    Source code(zip)
  • v1.0.4(Dec 16, 2014)

  • v1.0.1(Jul 19, 2014)

Django-rest-auth provides a set of REST API endpoints for Authentication and Registration

This app makes it extremely easy to build Django powered SPA's (Single Page App) or Mobile apps exposing all registration and authentication related functionality as CBV's (Class Base View) and REST (JSON)

Tivix 2.4k Dec 29, 2022
Country-specific Django helpers, to use in Django Rest Framework

django-rest-localflavor Country-specific serializers fields, to Django Rest Framework Documentation (soon) The full documentation is at https://django

Gilson Filho 19 Aug 30, 2022
simple api build with django rest framework

Django Rest API django-rest-framework Employees management simple API in this project wrote test suites for endpoints wrote simple doc string for clas

OMAR.A 1 Mar 31, 2022
Simple Crud Api With Django Rest Framework

SIMPLE CRUD API WITH DJANGO REST FRAMEWORK Django REST framework is a powerful and flexible toolkit for building Web APIs. Requirements Python 3.6 Dja

kibet hillary 1 May 3, 2022
BloodDonors: Built using Django REST Framework for the API backend and React for the frontend

BloodDonors By Daniel Yuan, Alex Tian, Aaron Pan, Jennifer Yuan As the pandemic raged, one of the side effects was an urgent shortage of blood donatio

Daniel Yuan 1 Oct 24, 2021
RESTler is the first stateful REST API fuzzing tool for automatically testing cloud services through their REST APIs and finding security and reliability bugs in these services.

RESTler is the first stateful REST API fuzzing tool for automatically testing cloud services through their REST APIs and finding security and reliability bugs in these services.

Microsoft 1.8k Jan 4, 2023
Mlflow-rest-client - Python client for MLflow REST API

Python Client for MLflow Python client for MLflow REST API. Features: Minimal de

MTS 35 Dec 23, 2022
Authentication for Django Rest Framework

Dj-Rest-Auth Drop-in API endpoints for handling authentication securely in Django Rest Framework. Works especially well with SPAs (e.g React, Vue, Ang

Michael 1.1k Dec 28, 2022
Automated generation of real Swagger/OpenAPI 2.0 schemas from Django REST Framework code.

drf-yasg - Yet another Swagger generator Generate real Swagger/OpenAPI 2.0 specifications from a Django Rest Framework API. Compatible with Django Res

Cristi Vîjdea 3k Jan 6, 2023
Introduction to Django Rest Framework

Introduction to Django Rest Framework This is the repository of the video series Introduction to Django Rest Framework published on YouTube. It is a s

Simple is Better Than Complex 20 Jul 14, 2022
DRF-extensions is a collection of custom extensions for Django REST Framework

Django REST Framework extensions DRF-extensions is a collection of custom extensions for Django REST Framework Full documentation for project is avail

Gennady Chibisov 1.3k Dec 28, 2022
Generate Views, Serializers, and Urls for your Django Rest Framework application

DRF Generators Writing APIs can be boring and repetitive work. Don't write another CRUDdy view in Django Rest Framework. With DRF Generators, one simp

Tobin Brown 332 Dec 17, 2022
Swagger Documentation Generator for Django REST Framework: deprecated

Django REST Swagger: deprecated (2019-06-04) This project is no longer being maintained. Please consider drf-yasg as an alternative/successor. I haven

Marc Gibbons 2.6k Dec 23, 2022
Document Web APIs made with Django Rest Framework

DRF Docs Document Web APIs made with Django Rest Framework. View Demo Contributors Wanted: Do you like this project? Using it? Let's make it better! S

Manos Konstantinidis 626 Nov 20, 2022
Recursive Serialization for Django REST framework

djangorestframework-recursive Overview Recursive Serialization for Django REST framework This package provides a RecursiveField that enables you to se

null 336 Dec 28, 2022
Dropdown population implementation for Django REST Framework

drf-dropdown Dropdown population implementation for Django REST Framework Usage Add DropdownView to API URL # urls.py import dropdown urlpatterns = [

Preeti Yuankrathok 4 Dec 6, 2022
Built on Django Rest Framework, to provide with command execution on linux terminal

Built on Django Rest Framework, to provide with command execution on linux terminal

null 1 Oct 31, 2021
Django REST API with React BoilerPlate

This is a setup of Authentication and Registration Integrated with React.js inside the Django Templates for web apps

Faisal Nazik 91 Dec 30, 2022