Python 3.7.5 : About Django REST framework.

First, let's activate my Python virtual environment:

[mythcat@desk django]$ source env/bin/activate

I update my django version 3.0 up to 3.0.1.

(env) [mythcat@desk django]$ pip3 install --upgrade django --user
Collecting django
...
      Successfully uninstalled Django-3.0
Successfully installed django-3.0.1

The next step comes with installation of Python modules for Django and Django REST:

(env) [mythcat@desk django]$ pip3 install djangorestframework --user
Collecting djangorestframework
...
Installing collected packages: djangorestframework
Successfully installed djangorestframework-3.11.0

Into my folder mysite I run this commands

(env) [mythcat@desk django]$ cd mysite/
(env) [mythcat@desk mysite]$ python3 manage.py makemigrations
No changes detected
(env) [mythcat@desk mysite]$ python3 manage.py migrate
Operations to perform:
  Apply all migrations: admin, auth, contenttypes, sessions, test001
Running migrations:
  No migrations to apply.

To pass information over to an HTTP GET request, the information object must be translated into valid response data.
The Django implements serializers for this.
Serializers provide deserialization, allowing parsed data to be converted back into complex types and allow complex data such as querysets and model instances to be converted to native Python datatypes that can then be easily rendered into JSON, XML or other content types.
Let's create the mysite/serializers.py:

(env) [mythcat@desk mysite]$ cd mysite/
(env) [mythcat@desk mysite]$ vim serializers.py 

The code for this python script is this:

from django.contrib.auth.models import User, Group
from rest_framework import serializers

class UserSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = User
        fields = ['url', 'username', 'email', 'groups']

class GroupSerializer(serializers.HyperlinkedModelSerializer):
    class Meta:
        model = Group
        fields = ['url', 'name']

The next changes will be on urls.py and views.py.
My urls.py file from the Django-chart project is this:

from django.contrib import admin
from django.urls import path
from test001.views import home_page
from test001.views import Test001ChartView
#
from django.urls import include, path
from rest_framework import routers
from test001 import views

router = routers.DefaultRouter()
router.register(r'users', views.UserViewSet)
router.register(r'groups', views.GroupViewSet)

app_name = 'test001'
urlpatterns = [
    path('admin/', admin.site.urls),
    #path('', home_page, name ='home'),
    path('', Test001ChartView.as_view(), name = 'home'), 
    # Use automatic URL routing
    # Can also include login URLs for the browsable API
    path('', include(router.urls)),
    path('api-auth/', include('rest_framework.urls', namespace='rest_framework'))
]

My views.py file is this:

from django.http import HttpResponse
from django.shortcuts import render
# snippet 
from django.shortcuts import get_object_or_404
# for chart 
from django.views.generic import TemplateView
from .models import Test001, Snippet
#
#def home_page(request):
#    return HttpResponse('Home page!')

# django framework
from django.contrib.auth.models import User, Group
from rest_framework import viewsets
from mysite.serializers import UserSerializer, GroupSerializer

def home_page(request):
    return render(request, 'test001/home.html',{
        'name':'CGF',
        'html_items': ['a','b','c','d','e']
    })


# define view for chart 
class Test001ChartView(TemplateView):
    template_name = 'test001/chart.html'

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["qs"] = Test001.objects.all()
        return context


def snippet_detail(request, id):
    snippet = get_object_or_404(Snippet, id=id)
    return render(request, 'test001/snippets_detail.html', {'snippet': snippet})

class UserViewSet(viewsets.ModelViewSet):
    """
    API endpoint  allows users to be viewed or edited.
    """
    queryset = User.objects.all().order_by('-date_joined')
    serializer_class = UserSerializer

class GroupViewSet(viewsets.ModelViewSet):
    """
    API endpoint  allows groups to be viewed or edited.
    """
    queryset = Group.objects.all()
    serializer_class = GroupSerializer

The settings module for this my project is stored in mysite/settings.py and I add this:

INSTALLED_APPS = [
    ...
    'rest_framework',
]

I run the django project and works well:

python3 manage.py runserver

The http://127.0.0.1:8000/users/ page come with this output:

Django REST framework - part 001.

Today I will introduce you a tutorial to fix some of the necessary elements presented in the old tutorial.
The manage tool shell can also give us some info:

C:\Python373\Scripts\example>python manage.py shell
Python 3.7.3 (v3.7.3:ef4ec6ed12, Mar 25 2019, 22:22:05) [MSC v.1916 64 bit (AMD6
4)] on win32
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)
>>> from test001.models import test
>>> from django.db.models import Count, Min, Max, Avg
>>> out = test.objects.all
>>> out
...

One note about error method, do not use like this:

>>> out = test.objects.all
>>> out[0]
Traceback (most recent call last):
  File "", line 1, in 
TypeError: 'method' object is not subscriptable

The correct way method is:

>>> out = test.objects.all()
>>> out
]>
>>> out[0]

>>> vars(out[0])
{'_state': , 'id'
: 1, 'first_name': 'Cătălin George', 'last_name': 'Feștilă'}

We can use the annotate.
This issue can solve it into this way:

>>> minimal = test.objects.annotate(Min('last_name'))
>>> minimal
]>
>>> minimal[0]

>>> vars(minimal[0])
{'_state': , 'id'
: 1, 'first_name': 'Cătălin George', 'last_name': 'Feștilă', 'last_name__min': '
Feștilă'}

See the result of the annotate add the last_name__min value.
I created another class named city with just one field named city_name and I fill with one value:
All changes are posted at the end of this tutorial.
Let's test with the shell some of these new changes:

C:\Python373\Scripts\example>python manage.py shell
Python 3.7.3 (v3.7.3:ef4ec6ed12, Mar 25 2019, 22:22:05) [MSC v.1916 64 bit 
(AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)
>>> from test001.models import test,city
>>> from django.db.models import Count, Min, Max, Avg
>>> out_test = test.objects.all()
>>> out_city = city.objects.all()
>>> out_test
]>
>>> out_city
]>
>>> vars(out_city[0])
{'_state': , 'id'
: 1, 'city_name': 'Fălticeni'}

We can easy test the new example:

>>> minimal = test.objects.annotate(Min('last_name'))
>>> minimal
]>
>>> vars(minimal[0])
{'_state': , 'id'
: 1, 'first_name': 'Cătălin George', 'last_name': 'Feștilă', 'last_name__min': '
Feștilă'}
>>> minimal = city.objects.annotate(Min('city_name'))
>>> minimal
]>
>>> vars(minimal[0])
{'_state': , 'id'
: 1, 'city_name': 'Fălticeni', 'city_name__min': 'Fălticeni'}
>>> filter_test = test.objects.filter(id = 1)
>>> vars(filter_test)
{'model': , '_db': None, '_hints': {}, 'query': 
, '_result_cache': 
None, '_sticky_filter': False, '_for_write': False, '_prefetch_related_lookups':
(), '_prefetch_done': False, '_known_related_objects': {}, '_iterable_class': , '_fields': None}
>>> vars(filter_test[0])
{'_state': , 'id'
: 1, 'first_name': 'Cătălin George', 'last_name': 'Feștilă'}

Feel free to test with my old and the new example:

# models.py
from django.db import models

class test(models.Model):
    first_name = models.CharField(max_length=30)
    last_name = models.CharField(max_length=30)
    
class city(models.Model):
    city_name = models.CharField(max_length=30)
#admin.py
from django.contrib import admin
from .models import test, city
admin.site.register(test)
admin.site.register(city)
#serializers.py
from rest_framework import serializers
from .models import test, city

class test_serializer(serializers.ModelSerializer):
    class Meta:
        model = test
        fields = ('id', 'first_name', 'last_name')

class city_serializer(serializers.ModelSerializer):        
    class Meta:
        model = city
        fields = ('id', 'city_name')
#views.py
from django.shortcuts import render
from rest_framework import viewsets
from .models import test, city
from .serializers import test_serializer, city_serializer

class test_view(viewsets.ModelViewSet):
    #query to get all information from database
    queryset = test.objects.all()
    serializer_class = test_serializer

class city_view(viewsets.ModelViewSet):
    #query to get all information from database
    queryset = city.objects.all()
    serializer_class = city_serializer
#urls.py
from django.urls import path, include
from . import views
from rest_framework import routers

router = routers.DefaultRouter()
router.register('test001', views.test_view)
router.register('city', views.city_view)
#add to path 
urlpatterns = [
    path('', include(router.urls))
]

Python 3.7.3 and Django REST framework.

Today I tested something simpler for beginners: Django REST framework.
Once you understand how it works then it's simple to use.
This tutorial does not address the security issues generated by the REST, Django framework.
The official webpage comes with many information and technical specifications for this API:
Django REST framework is a powerful and flexible toolkit for building Web APIs.
The example I've submitted is built into the Scripts folder because I did not use the virtual environment.
Let's start installing the python module.

C:\Python373\> cd Scripts
C:\Python373\Scripts\>pip install djangorestframework
C:\Python373\Scripts\>django-admin startproject example
C:\Python373\Scripts\>cd example 
C:\Python373\Scripts\>python manage.py migrate 
C:\Python373\Scripts\>python manage.py createsuperuser
C:\Python373\Scripts\>python manage.py startapp test001

In the example folder we will make changes.
First is the settings.py file:

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

The next file is the urls.py:

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('test001.urls'))
]

Also make changes in the test001 folder
You must create a python script and call it urls.py:

from django.urls import path, include

# this urlpatterns will fill later 
urlpatterns = []

You make changes to the file models.py and create a named class test.
This class will have two fields that we will update.

from django.db import models

class test(models.Model):
    first_name = models.CharField(max_length=30)
    last_name = models.CharField(max_length=30)

44/5000
The following commands will synchronize the database:

C:\Python373\Scripts\example>python manage.py makemigrations
...
  test001\migrations\0001_initial.py
    - Create model test
C:\Python373\Scripts\example>python manage.py migrate
...
Running migrations:
...

Another step is to add the test into admin.py script:

from django.contrib import admin
from .models import test
admin.site.register(test)

Serializers allow complex data such as querysets and model instances to be converted to native Python datatypes that can then be easily rendered into JSON , XML or other content types.
Let's create an serializers.py python script into test001 folder and use this code:

from rest_framework import serializers
from .models import test

class test_serializer(serializers.ModelSerializer):
    class Meta:
        model = test
        fields = ('id', 'first_name', 'last_name')

Also is need to update the views.py python script:

from django.shortcuts import render
from rest_framework import viewsets
from .models import test
from .serializers import test_serializer

class test_view(viewsets.ModelViewSet):
    #query to get all information from database
    queryset = test.objects.all()
    serializer_class = test_serializer

Now because is all create the last step is to fix the urls.py from test001 folder with the routers.
The REST framework adds support for automatic URL routing to Django.

from django.urls import path, include
from . import views
from rest_framework import routers

router = routers.DefaultRouter()
router.register('test001', views.test_view)
#add to path 
urlpatterns = [
    path('', include(router.urls))
]

Now you can test it with:

C:\Python373\Scripts\example>python manage.py runserver

If you want to make changes into models.py then you will need to use the commands to synchronize the database after these use"commands
makemigrations and migrate to fix errors.
If you encounter such run-time errors
"GET /static/assets/js/docs.min.js HTTP/1.1" 404 1667..."
These errors can be the result of settings like DEBUG, STATICFILES_DIRS or STATIC_ROOT from file settings.py.
Then you need to execute python manage.py collectstatic and Django goes through all directories where static files can be found and places them in your static root.
The result of this tutorial can be see on my youtube channel: