Building & Consuming REST APIs in Python with Django

This video gives an overview of this section.                       

In this video, we look at a demo of the final product after the  three sections, including a templated Django response and browsing a  Django REST Framework API.                         

• Look at HTML response

• Look at REST API server

In this video, we will install Python, Django and the Django REST Framework onto our development computer                         

• Install Python 3 based on the Operating System of our computer. Create a Virual Environment

• Use Pip to install Django and the Django REST framework

• Use pip requirements.txt to identify installed python components in a development environment

In this video, we will install PostgreSQL, create a new database and configure Python support                         

• Install PostgreSQL into our development environment

• Use Psql to check our installation and create a new database

• Use pip to install PostgreSQL support into Python

In this video, we will create a new Django project and then create an application within that project.                         

• Create a project directory and use django-admin startproject

• Use manage.py startapp to create a Django application

• Review Django external application publishing guidelines

In this video, we will use the development environment we have  setup in previous videos to show the Django initial success web page.                         

• Introduce settings.py and configuring our database

• Highlight the DEBUG flag and placing sensitive information in settings.py

• Use Django’s development webserver via the manage.py runserver command and seeing the Django initial default page

This video gives an overview of MVC and MVT Framework.                         

• Look at the concept of MVC and MVT Framework.

• Look at Django models

• Look at Django template

In this video, we will discuss Django models, create our first model, create methods on our models and test them.                         

• Introduce Django model and how relationships between Models can be used.

• Create a Django model

• Create methods on Django models and test them

In this video, we will apply migrations to our Django models,  which keep our database structure up to date. We will perform queries on  our database.                         

• Consider what Django migrations are and have Django create schema migrations

• Consider what data migrations are and create one, and then apply all migrations created so far in this video

• Perform some simple queries against our database

In this video, we will create a simple “Hello World” view,  consider Django class based views, perform URL configuration and add a  parameter to our view.                         

• Discuss Django class based views and use view to create a simple view that returns a hard coded response

• Perform URL configuration or routing at  both the Project and App level to make our new view accessible. Access  the view in a browser

• Make use of URL querystring and kwarg parameters. Discuss the pros and cons of each approach

In this video, we will discuss how Django handles requests,  Django’s URL routing, matching URLs with path and re_path and HTTP  methods.                         

• Discuss how Django handles requests from  the request in to middleware, then URL config, then view and then the  reverse for the response

• Review URL configuration from previous video and discuss use of path() and re_path()

• Cover methods (verbs) of Http Requests including Get and Post requests. How Http methods then translate to class methods

In this video, we will cover Django Templates and the  TemplateView. We will cover Django’s template inheritance system, how to  pass data to templates, where to place template files and template tags  and filters.                         

• Explain how hardcoded responses are undesirable. Introduce Django’s TemplateView

• Learn about using base templates and view  specific templates that extend base templates. Learn how to make data  available within templates.
  Review template settings in settings.py and see our first set of templates in action

• Explain how templates should not perform core logic, however we can use template tags and filters to perform presentation logic

In this video we will consider why we should test, the core tools  Django provides for testing, how to configure PostgreSQL for testing and  some integration and unit tests.                         

• Learn how we need to use automated testing tools and how we can write test cases that place our code under test

• Make use of pqsl to configure PostgreSQL for testing

• Develop Integration tests that make use of the Django test client.
  Develop unit tests that test specific view functions using a RequestFactory as well as class attributes

This video gives an overview of the entire section and then  considers what is an API, what is REST, REST resources, methods and CRUD  operations and HTTP Status codes.                         

• Explain the difference between traditional web responses and API responses. Learn how REST provides an API on HTTP

• Learn what Resources, HTTP Methods and CRUD operations are

• Explain how a result of an API request is communicated via a status code

In this video, we will create an API end point by configuring a  URL endpoint for a view that generates JSON output. We will also accept  input and perform simple validation.                         

• Make use of a URL pattern configuration to give access to our API view

• Define a View using the base View class that uses JsonResponse to return an API response

• Include in our View definition  validation of a name parameter and return an error if this is equal to  fred. Show results in a browser

In this video, we will discuss why we use the DRF, what key parts  of the DRF are, who uses it and the web browsable API feature of the  DRF.                         

• Learn how the DRF helps us in providing code that we would otherwise have to provide ourselves many times over

• Learn what the key parts of the DRF are,  including serializers, DRF views, routers and authentication and  permissioning. Learn how these relate to CRUD operations

• Explore who uses the DRF and see the web browsable feature of the DRF

In this video, we will learn about DRF serializers. We will first  look at manually defining a serializer and then use ModelSerializer to  base a definition on an existing model.                         

• Review our existing models with focus on the Bookmark Model, then we will define a serializer with create and update methods

• Using the Python console, we will create  some initial data in the database and then demonstrate what our  serializers do with this data along with simulated received data

• We will define a serializer based on Bookmark using a ModelSerializer.
  We will then demonstrate how this serializer can be used with a list of Bookmarks in the Python console

In this video, we will combine our learnings from the previous two  videos with DRF views by building a Bookmarks list and a Bookmarks  detail view.                         

• Learn about basic DRF view URL configuration, including format suffixes.
  Define a Bookmark List view that can build a list and create new Bookmarks

• Learn about basic DRF detail view URL  configuration. Define a Bookmark detail view that can get detail, update  a Bookmark and delete a Bookmark

• Watch a demonstration of all of the  functionality previously developed in this video, including listing  existing Bookmarks, creating new Bookmarks, updating existing Bookmarks  and deleting them.

In this video, we will replace our views from the previous video  by exploiting pre-built functionality of the DRF for common CRUD  operations.                         

• Make use of ListCreate-APIView for Bookmark listing and new Bookmark creation

• Make use of RetriveUpdate-APIView for Bookmark detail queries, updating a Bookmark and deleting a Bookmark

• Take advantage of the ModelViewset that combines all the functionality seen earlier in this video in one convenient package.

In this video we will use DRF routers to clean up our URL configuration and create a specialised API action.                         

• Learn about  Hyperlinked-Model-Serializers and how they can create related links in  our API. Significantly simplify our URL configuration with a DRF router

• Create a specialised viewset action that  can add a like to a Bookmark. Learn how to define this in the viewset  and ensure the DRF router is aware of it. See how it is accessed from  the browser

• Consider each of the view strategies covered in this and previous videos and scenarios where each would be the best fit

In this video we will consider how we can use DRF automated testing tools to perform integration and unit tests of our API.                         

• Learn how to write an integration test of a DRF based viewset and place different actions under test

• Learn how to write a unit test of  specific methods of a DRF based viewset, how to isolate dependencies via  patching and using mocks to test each operation of the code

• See how the Django test runner is used in combination with DRF test tools