Exploring Django's Third-Party Packages: Top Libraries You Should Know
Tags: django, python, programming, tutorial
Published: 2023-07-08 18:03:47

Django is a high-level, open-source Python web framework designed to help developers build web applications efficiently. It is maintained by the Django Software Foundation.

Django encourages the use of reusable modules and follows the "batteries included" approach, offering a comprehensive suite of features and functionalities out of the box. Django also follows the model-view-controller (MVC) architectural pattern, emphasizing the reusability, maintainability, and rapid development of web applications.

In this article, we will look at the top libraries that should be known. So, let's embark on a journey to explore Django's third-party packages and discover the top libraries that will elevate our Django development experience to new heights.

## Django Packages: An Overview

[Django Packages](https://djangopackages.org/) play a significant role in expanding the capabilities of the Django web framework. They are third-party libraries or modules that developers can integrate into their Django projects to enhance functionality, streamline development, and save time.  These packages are built by the Django community and provide additional features, tools, and utilities that complement the core Django framework.

The Django Packages community is a central hub for discovering, evaluating, and sharing these third-party packages.

Categories of Django packages include and are not limited to Authentication, API Integration, Content Management, Form Handling, Search, Database, Testing, and Deployment.

## Top Django Third-Party Packages

**Django REST Framework (DRF)**
[Django REST Framework](https://www.django-rest-framework.org/) [](https://www.django-rest-framework.org/)is a famous, powerful, and flexible toolkit for building Web APIs in Django. It provides a set of reusable components and tools to simplify API development, including serialization, authentication, permissions, and view sets.

DRF is suitable for developing RESTful APIs with Django, enabling easy creation and management of API endpoints. It supports various authentication schemes, including token authentication, session authentication, and OAuth2.

DRF offers features like serialization, content negotiation, pagination, filtering, and validation, making API development efficient and consistent. To install this package using `pip` :


    pip install djangorestframework

After installing, add `'rest_framework'` to the `INSTALLED_APPS` list in the Django project's base settings.


    # settings.py
    INSTALLED_APPS = [
        ...
        'rest_framework',
        ...
    ]
    
    REST_FRAMEWORK = {
        'DEFAULT_AUTHENTICATION_CLASSES': [
            'rest_framework.authentication.TokenAuthentication',
            'rest_framework.authentication.SessionAuthentication',
        ],
        'DEFAULT_PERMISSION_CLASSES': [
            'rest_framework.permissions.IsAuthenticated',
        ],
    }

**DJ-Database-URL**
[DJ-Database-URL](https://pypi.org/project/dj-database-url/) is a package that allows easy configuration of database settings in Django projects using environment variables or URLs. It provides a convenient way to manage database settings, especially in production environments where URLs typically provide database connections.

The package supports popular database backends, including PostgreSQL, MySQL, SQLite, and others. Run the following command to install the package using pip:


    pip install dj-database-url

After installing the package, set the `DATABASE_URL` environment variable or provide the database URL directly in the Django project's `settings.py`. Then import and use `dj_database_url.config()` to parse the database URL and configure the database settings. Below is an example


    # settings.py
    import dj_database_url
    
    DATABASES = {
        'default': dj_database_url.config(default='sqlite:///:memory:')
    }

**WhiteNoise**
[WhiteNoise](http://whitenoise.evans.io/) is a package that allows the efficient serving of static files in Django applications. It replaces the default Django development server for serving static files, providing better performance and caching.

WhiteNoise is suitable for deploying Django applications to production, where serving static files efficiently is essential. It also helps handle high-traffic situations by serving static files directly from the application server, reducing the need for additional infrastructure.


    pip install whitenoise

After installing, add `'whitenoise.middleware.WhiteNoiseMiddleware'` to the `MIDDLEWARE` list in `settings.py`.


    # settings.py
    MIDDLEWARE = [
        ...
        'whitenoise.middleware.WhiteNoiseMiddleware',
        ...
    ]
    
    STATIC_URL = '/static/'
    STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles')
    STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'

**Django Cors Headers**
[Django Cors Headers](https://pypi.org/project/django-cors-headers/) is a package that enables Cross-Origin Resource Sharing ([CORS](https://en.wikipedia.org/wiki/Cross-origin_resource_sharing)) headers in Django applications. It is useful when building APIs or web applications that need to handle requests from different domains. It also helps overcome the browser's same-origin policy and allows communication between front-end applications and backend APIs hosted on different domains.

By configuring CORS headers, access permissions can be controlled and the security of our Django application is ensured. To get started with this package,


    pip install django-cors-headers

After installing, add `'corsheaders'` to the `INSTALLED_APPS` list in the Django project's settings. Also, add `'corsheaders.middleware.CorsMiddleware'` to the `MIDDLEWARE` list in settings.py. For example


    # settings.py
    INSTALLED_APPS = [
        ...
        'corsheaders',
        ...
    ]
    
    MIDDLEWARE = [
        ...
        'corsheaders.middleware.CorsMiddleware',
        ...
    ]
    
    CORS_ORIGIN_ALLOW_ALL = False
    CORS_ORIGIN_WHITELIST = [
        'http://example.com',
        'https://example.com',
    ]

**Django Filter**
[Django Filter](https://django-filter.readthedocs.io/) is a package that simplifies the process of filtering querysets in Django based on user-defined parameters. It provides a set of filter backends and filter fields to easily create customizable filters for model-based querysets.

Django Filter is useful when building applications that require advanced filtering options, such as search functionality or filtering based on specific model fields. The package offers various filter options including exact matches, range queries, lookup filters, and custom filter methods. To install,


    pip install django-filter

Then add `'django_filters'` to the `INSTALLED_APPS` list in the Django project's settings.


    # settings.py
    INSTALLED_APPS = [
        ...
        'django_filters',
        ...
    ]

To configure or use, we will need to define filter classes by subclassing `django_filters.FilterSet` and specify the model and fields to filter. For example,


    # models.py
    from django.db import models
    
    class Book(models.Model):
        title = models.CharField(max_length=100)
        author = models.CharField(max_length=100)
        publication_date = models.DateField()
    
    # filters.py
    import django_filters
    
    class BookFilter(django_filters.FilterSet):
        title = django_filters.CharFilter(lookup_expr='icontains')
        author = django_filters.CharFilter(lookup_expr='icontains')
        publication_date = django_filters.DateFromToRangeFilter()
    
        class Meta:
            model = Book
            fields = ['title', 'author', 'publication_date']
    
    # views.py
    from django_filters.rest_framework import DjangoFilterBackend
    from rest_framework import filters
    
    class BookListAPIView(generics.ListAPIView):
        queryset = Book.objects.all()
        serializer_class = BookSerializer
        filter_backends = [DjangoFilterBackend, filters

**Djoser**
[Djoser](https://djoser.readthedocs.io/) is a powerful authentication package for Django that provides a set of RESTful API endpoints for user registration, login, password reset, and more. It offers features like email verification, token-based authentication, and customizable user endpoints.

This package offers flexibility, allowing customization and extension to suit specific project requirements. To install,


    pip install djoser

Thereafter, add `'djoser'` to the `INSTALLED_APPS` list in the Django project's settings and configure authentication settings and URLs in `settings.py`. An example of its usage is


    # settings.py
    INSTALLED_APPS = [
        ...
        'djoser',
        ...
    ]
    
    AUTHENTICATION_BACKENDS = [
        'django.contrib.auth.backends.ModelBackend',
    ]
    
    DJOSER = {
    # configuring urls
        'PASSWORD_RESET_CONFIRM_URL': '#/password/reset/confirm/{uid}/{token}',
        'USERNAME_RESET_CONFIRM_URL': '#/username/reset/confirm/{uid}/{token}',
    }

**Django REST Framework SimpleJWT**
[Django REST Framework SimpleJWT](https://django-rest-framework-simplejwt.readthedocs.io/) provides JSON Web Token (JWT) authentication for Django REST Framework APIs. It enables secure and stateless token-based authentication, allowing clients to authenticate and access protected endpoints.

Django REST Framework SimpleJWT is suitable for projects that require lightweight and efficient token-based authentication. It also offers features like token generation, token refreshing, token-based authentication views, flexibility in configuring token expiration, token signing algorithms, and customizing the token response. To install,


    pip install djangorestframework_simplejwt

After installing, add `'rest_framework_simplejwt'` to the `INSTALLED_APPS` list in the Django project's settings and configure authentication and token settings in settings.py.


    # settings.py
    INSTALLED_APPS = [
        ...
        'rest_framework_simplejwt',
        ...
    ]
    
    REST_FRAMEWORK = {
        'DEFAULT_AUTHENTICATION_CLASSES': [
            'rest_framework_simplejwt.authentication.JWTAuthentication',
        ],
    }
    
    SIMPLE_JWT = {
        'ACCESS_TOKEN_LIFETIME': timedelta(minutes=60),
        'REFRESH_TOKEN_LIFETIME': timedelta(days=1),
        'ALGORITHM': 'HS256',
        'SIGNING_KEY': SECRET_KEY,
    }

**Django AllAuth**
[Django AllAuth](https://django-allauth.readthedocs.io/) is a powerful authentication package for Django that provides a comprehensive set of features for handling user authentication, registration, and account management.

It supports various authentication methods, including email, username, social authentication, and many more. This package provides seamless integration with Django's built-in user model and works well with Django REST Framework for API authentication. To install `django-allauth`,use the command below


    pip install django-allauth

After installing, the next step is to configure it in the `settings.py` file.


    # settings.py
    INSTALLED_APPS = [
        ...
        'allauth',
        'allauth.account',
        ...
    ]
    
    AUTHENTICATION_BACKENDS = [
        'django.contrib.auth.backends.ModelBackend',
        'allauth.account.auth_backends.AuthenticationBackend',
    ]
    
    EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
    EMAIL_HOST = 'your-email-host'
    EMAIL_PORT = 587
    EMAIL_HOST_USER = 'your-email@example.com'
    EMAIL_HOST_PASSWORD = 'your-email-password'
    EMAIL_USE_TLS = True
    
    ACCOUNT_EMAIL_VERIFICATION = 'mandatory'
    ACCOUNT_AUTHENTICATION_METHOD = 'username_email'

**Django Redis**
[Django Redis](https://pypi.org/project/django-redis/) is a package that integrates Django and Redis, an in-memory data store. It allows us to leverage the power and speed of Redis to enhance various aspects of our Django application, such as caching, session storage, and task queue management.

It offers features like caching query results, storing session data in Redis for faster access, and using Redis as a task queue backend. To install this package,


    pip install django-redis

After installing, add `'django_redis'` to the `INSTALLED_APPS` list in the Django project's settings. Then, configure the cache backend, session engine, and other Redis settings in `settings.py`. An example of its usage is


    # settings.py
    INSTALLED_APPS = [
        ...
        'django_redis',
        ...
    ]
    
    CACHES = {
        'default': {
            'BACKEND': 'django_redis.cache.RedisCache',
            'LOCATION': 'redis://localhost:6379/1',
            'OPTIONS': {
                'CLIENT_CLASS': 'django_redis.client.DefaultClient',
            }
        }
    }
    
    SESSION_ENGINE = 'django.contrib.sessions.backends.cache'
    SESSION_CACHE_ALIAS = 'default'

**Django AnyMail**
[Django AnyMail](https://anymail.dev/en/stable/) is a package that provides a simple and flexible email integration for Django projects. It allows us to easily send emails using different email service providers or protocols, such as SMTP, Mailgun, SendGrid, Amazon SES, and more.

It offers multiple email backend support, template rendering, attachment handling, and error reporting. The package provides a unified interface for sending emails, making it easy to switch between different email service providers without changing the code. To install this package,


    pip install django-anymail

To configure, add `'anymail'` to the `INSTALLED_APPS` list in the Django project's settings. Then include the email backend settings in `settings.py`, specifying the credentials and options for the desired email service provider. For example, we will be using Sendgrid


    # settings.py
    INSTALLED_APPS = [
        ...
        'anymail',
        ...
    ]
    
    EMAIL_BACKEND = 'anymail.backends.sendgrid.EmailBackend'
    ANYMAIL = {
        'SENDGRID_API_KEY': 'your-sendgrid-api-key',
    }

**Django CMS**
[Django CMS](https://django-cms.readthedocs.io/) is a powerful and popular content management system built on top of Django. It provides a user-friendly interface and robust features for creating, managing, and publishing website content.

Its key features include drag-and-drop page editing, multi-language support, SEO optimization, and customizable templates. To install this package,


    pip install django-cms

After installing, add `'cms'` and `'menus'` to the `INSTALLED_APPS` list in the Django project's settings. Then, configure the CMS settings, database, and URL patterns in `settings.py`. An example of its configuration is below


    # settings.py
    INSTALLED_APPS = [
        ...
        'cms',
        'menus',
        ...
    ]
    
    CMS_TEMPLATES = [
        {
            'NAME': 'Default Template',
            'DIRS': [os.path.join(BASE_DIR, 'templates')],
            'APP_DIRS': True,
            'OPTIONS': {
                'context_processors': [
                    'django.template.context_processors.debug',
                    'django.template.context_processors.request',
                    'django.contrib.auth.context_processors.auth',
                    'django.contrib.messages.context_processors.messages',
                    'cms.context_processors.cms_settings',
                ],
            },
        },
    ]
    
    CMS_LANGUAGES = {
        1: [
            {
                'code': 'en',
                'name': 'English',
                'fallbacks': ['de'],
                'public': True,
                'hide_untranslated': False,
                'redirect_on_fallback': True,
            },
        ],
        'default': {
            'fallbacks': ['en', 'de'],
            'redirect_on_fallback': True,
            'public': True,
            'hide_untranslated': False,
        },
    }

**Django Crispy Forms**
[Django Crispy Forms](https://django-crispy-forms.readthedocs.io/) is a package that helps easily build and customize elegant forms in Django. It provides a powerful layout system and a collection of pre-defined form layouts to simplify form rendering and styling.

It offers features like flexible form layout customization, easy integration with popular CSS frameworks like Bootstrap, and support for dynamic form rendering. To install this package,


    pip install django-crispy-forms

After installing, add `'crispy_forms'` to the `INSTALLED_APPS` list in the Django project's settings. Optionally, configure the crispy form's settings, such as the default form layout and CSS framework integration.


    # settings.py
    INSTALLED_APPS = [
        ...
        'crispy_forms',
        ...
    ]
    
    CRISPY_TEMPLATE_PACK = 'bootstrap4'

**Djongo**
[Djongo](https://pypi.org/project/djongo/) is a Django database connector for MongoDB, allowing for the use of MongoDB as the backend database for our Django applications.

It translates Django ORM queries into MongoDB queries, enabling us to leverage the power and flexibility of MongoDB while working with Django's familiar object-relational mapping (ORM) syntax. To install Djongo,


    pip install djongo

Once installed, we configure Djongo in the Django project's `settings.py` file. Locate the `DATABASES` section at the bottom of the file and update the ENGINE value to '`djongo`':


    DATABASES = {
        'default': {
            'ENGINE': 'djongo',
            'NAME': 'your_database_name',
            'HOST': 'your_mongodb_host',
            'PORT': 'your_mongodb_port',
            'USER': 'your_mongodb_username',
            'PASSWORD': 'your_mongodb_password',
        }
    }

**Django Storages**
[Django Storages](https://django-storages.readthedocs.io/) is a collection of storage backends for Django that support various file storage and retrieval systems. It offers a unified interface for managing files and media assets in Django projects, allowing for seamless switching between different storage providers without changing any code.

Django Storages supports popular cloud storage services like Amazon S3, Google Cloud Storage, Microsoft Azure Storage, and more, as well as local file system storage. To install,


    pip install django-storages

Once installed, we need to configure Django Storages in our Django project's `settings.py` file. First, add '`storages`' to the `INSTALLED_APPS` list:


    # settings.py
    INSTALLED_APPS = [
        ...
        'storages',
        ...
    ]

Next, we configure the storage backend to be used. For example, to use Amazon S3 as our storage provider, we add the following to our `settings.py` file:


    DEFAULT_FILE_STORAGE = 'storages.backends.s3boto3.S3Boto3Storage'
    AWS_ACCESS_KEY_ID = 'your_aws_access_key_id'
    AWS_SECRET_ACCESS_KEY = 'your_aws_secret_access_key'
    AWS_STORAGE_BUCKET_NAME = 'your_s3_bucket_name'

**Graphene-Django**
[Graphene-Django](https://docs.graphene-python.org/projects/django/en/latest/) is a powerful library that integrates the GraphQL query language with Django, allowing for the development of flexible and efficient APIs. It seamlessly combines the expressive power of GraphQL with the simplicity and elegance of Django, enabling us to design APIs that fetch only the data the clients need.

To get started with this package:


    pip install graphene-django

After installation, we need to configure Graphene-Django in the Django project's `settings.py` file. Add '`graphene_django`' to the `INSTALLED_APPS` list:


    # settings.py
    INSTALLED_APPS = [
        ...
        'graphene_django',
        ...
    ]

Also, we need to define a URL endpoint for GraphQL queries in the project's `urls.py` file:


    from django.urls import path
    from graphene_django.views import GraphQLView
    
    urlpatterns = [
        # Other URL patterns...
        path('graphql/', GraphQLView.as_view(graphiql=True)),
    ]

Below is a table listing various resources for all the listed packages above:

| Package                         | Pypi                                                                            | Djangoprojects                                                                                          | Readthedocs                                                                                  | Repository                                                                                 |
| ------------------------------- | ------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------ |
| Django REST Framework (DRF)     | [DRF - PyPI](https://pypi.org/project/djangorestframework/)                     | [DRF - Django Projects](https://djangopackages.org/packages/p/django-rest-framework/)                   | [DRF - ReadTheDocs](https://www.django-rest-framework.org/)                                  | [DRF - GitHub](https://github.com/encode/django-rest-framework)                            |
| DJ-Database-URL                 | [DJ-Database-URL - PyPI](https://pypi.org/project/dj-database-url/)             | [DJ-Database-URL - Django Projects](https://djangopackages.org/packages/p/dj-database-url/)             |                                                                                              | [DJ-Database-URL - GitHub](https://github.com/jazzband/dj-database-url)                    |
| WhiteNoise                      | [WhiteNoise - PyPI](https://pypi.org/project/whitenoise/)                       | [WhiteNoise - Django Projects](https://djangopackages.org/packages/p/whitenoise/)                       | [WhiteNoise - ReadTheDocs](http://whitenoise.evans.io/)                                      | [WhiteNoise - GitHub](https://github.com/evansd/whitenoise)                                |
| Django Cors Headers             | [Django Cors Headers - PyPI](https://pypi.org/project/django-cors-headers/)     | [Django Cors Headers - Django Projects](https://djangopackages.org/packages/p/django-cors-headers/)     |                                                                                              | [Django Cors Headers - GitHub](https://github.com/adamchainz/django-cors-headers)          |
| Django Filter                   | [Django Filter - PyPI](https://pypi.org/project/django-filter/)                 | [Django Filter - Django Projects](https://djangopackages.org/packages/p/django-filter/)                 | [Django Filter - ReadTheDocs](https://django-filter.readthedocs.io/)                         | [Django Filter - GitHub](https://github.com/carltongibson/django-filter)                   |
| Djoser                          | [Djoser - PyPI](https://pypi.org/project/djoser/)                               | [Djoser - Django Projects](https://djangopackages.org/packages/p/djoser/)                               | [Djoser - ReadTheDocs](https://djoser.readthedocs.io/)                                       | [Djoser - GitHub](https://github.com/sunscrapers/djoser)                                   |
| Django REST Framework SimpleJWT | [DRF SimpleJWT - PyPI](https://pypi.org/project/djangorestframework-simplejwt/) | [DRF SimpleJWT - Django Projects](https://djangopackages.org/packages/p/djangorestframework-simplejwt/) | [DRF SimpleJWT - ReadTheDocs](https://django-rest-framework-simplejwt.readthedocs.io/)       | [DRF SimpleJWT - GitHub](https://github.com/jazzband/djangorestframework-simplejwt)        |
| Django AllAuth                  | [Django AllAuth - PyPI](https://pypi.org/project/django-allauth/)               | [Django AllAuth - Django Projects](https://djangopackages.org/packages/p/django-allauth/)               | [Django AllAuth - ReadTheDocs](https://django-allauth.readthedocs.io/)                       | [Django AllAuth - GitHub](https://github.com/pennersr/django-allauth)                      |
| Django Redis                    | [Django Redis - PyPI](https://pypi.org/project/django-redis/)                   | [Django Redis - Django Projects](https://djangopackages.org/packages/p/django-redis/)                   |                                                                                              | [Django Redis - GitHub](https://github.com/jazzband/django-redis)                          |
| Django AnyMail                  | [Django AnyMail - PyPI](https://pypi.org/project/django-anymail/)               | [Django AnyMail - Django Projects](https://djangopackages.org/packages/p/django-anymail/)               | [Django AnyMail - ReadTheDocs](https://anymail.dev/en/stable/)                               | [Django AnyMail - GitHub](https://github.com/anymail/django-anymail)                       |
| Django CMS                      | [Django CMS - PyPI](https://pypi.org/project/django-cms/)                       | [Django CMS - Django Projects](https://djangopackages.org/packages/p/django-cms/)                       | [Django CMS - ReadTheDocs](https://django-cms.readthedocs.io/)                               | [Django CMS - GitHub](https://github.com/divio/django-cms)                                 |
| Django Crispy Forms             | [Django Crispy Forms - PyPI](https://pypi.org/project/django-crispy-forms/)     | [Django Crispy Forms - Django Projects](https://djangopackages.org/packages/p/django-crispy-forms/)     | [Django Crispy Forms - ReadTheDocs](https://django-crispy-forms.readthedocs.io/)             | [Django Crispy Forms - GitHub](https://github.com/django-crispy-forms/django-crispy-forms) |
| Djongo                          | [Djongo - PyPI](https://pypi.org/project/djongo/)                               | [Djongo - Django Projects](https://djangopackages.org/packages/p/djongo/)                               | [Djongo - ReadTheDocs](https://www.djongomapper.com/)                                        | [Djongo - GitHub](https://github.com/nesdis/djongo)                                        |
| Django Storages                 | [Django Storages - PyPI](https://pypi.org/project/django-storages/)             | [Django Storages - Django Packages](https://djangopackages.org/packages/p/django-storages/)             | [Django Storages - ReadTheDocs](https://django-storages.readthedocs.io/)                     | [Django Storages - GitHub](https://github.com/jschneier/django-storages)                   |
| Graphene-Django                 | [Graphene-Django - PyPI](https://pypi.org/project/graphene-django/)             | [Graphene-Django - Django Packages](https://djangopackages.org/packages/p/graphene-django/)             | [Graphene-Django - ReadTheDocs](https://docs.graphene-python.org/projects/django/en/latest/) | [Graphene-Django - GitHub](https://github.com/graphql-python/graphene-django)              |

## Conclusion

Django's ecosystem of third-party packages offers a wealth of additional functionality and convenience for Django developers. These packages enhance the capabilities of Django, simplify common tasks, and provide solutions for various development needs.

By carefully selecting and incorporating these packages into any Django projects, we can streamline development, save time, and leverage the expertise of the Django community.



## Resources

Here are some resources that can be helpful for exploring several Django's third-party packages:

- [Django Project Official Website](https://www.djangoproject.com/) - The official website of the Django web framework provides comprehensive documentation, tutorials, and resources for getting started with Django.
- [Django Packages](https://djangopackages.org/) - Django Packages is a directory of reusable Django apps, packages, and projects.
- [PyPI - Python Package Index](https://pypi.org/) - PyPI is the official Python Package Index, where Python packages can be found and downloaded, including Django packages.
- [ReadTheDocs](https://readthedocs.org/) - ReadTheDocs hosts documentation for many Django packages. It provides easy access to comprehensive documentation, including installation instructions, configuration guides, and usage examples.
- [GitHub](https://github.com/) - GitHub is a popular platform for hosting open-source projects. Source code, documentation, and issue trackers for various Django packages can be found on GitHub.