How to add permissions in an API Django REST framework

REST_FRAMEWORK  ={
# anyone can visit it and input data
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.AllowAny'
   ]
}

REST_FRAMEWORK  ={
# or allow read-only access for unauthenticated users.
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.IsAuthenticated'
    ]
}

```py
REST_FRAMEWORK  ={
# or allow read-only access for unauthenticated users.
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.IsAuthenticatedOrReadOnly'
    ]
}
```

REST_FRAMEWORK  ={
# only staff users can see the data and input data
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.IsAdminUser'
    ]
}

# Application definition
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    #the app
    'languages',
    #restframework
    'rest_framework',
]
# adding the permission class
# it will serve as default permission class
REST_FRAMEWORK  ={
#Authenticated or allow read-only access for unauthenticated users.
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.IsAuthenticatedOrReadOnly'
    ]
}

from django.db import models
# Create your models here.
# to know the paradigm of the programming language(e.g OOP)
class Paradigm(models.Model):
  name = models.CharField(max_length=50)
  def __str__(self):
      return self.name
# the programming language
class Language(models.Model):
  name = models.CharField(max_length=50)
  #referencing the Paradigm Model
  # models.CASCADE means if the Paradigm is deleted
  # the Language model data related to the  partcular deleted paradigm will also be deleted 
  paradigm = models.ForeignKey(Paradigm , on_delete=models.CASCADE)
  def __str__(self):
      return self.name
# name of any programmer
class Programmer(models.Model):
  name = models.CharField(max_length=50)
  # referencing the Langauge Model
  # ManyToManyField allows a user to select more than one programming language
  languages = models.ManyToManyField(Language)
  def __str__(self):
      return self.name

from django.contrib import admin
from .models import Language, Programmer,Paradigm
admin.site.register(Language)
admin.site.register(Programmer)
admin.site.register(Paradigm)

from rest_framework import serializers
from .models import Language,Paradigm,Programmer
#hyperlinkedmodelserializer makes it possbile for it to have a url link
class LanguageSerializer(serializers.HyperlinkedModelSerializer):
    # used to change the behaviour of a class or Model
    class Meta:
        # referencing the language model
        model = Language
        # listing the fields that will be displayed
        fields = [
            "id",
            'url',
            "name",
            "paradigm"
        ]
class ParadigmSerializer(serializers.HyperlinkedModelSerializer):
    # used to change the behaviour of a class or Model
    class Meta:
        # referencing the paradigm model
        model = Paradigm
        # listing the fields that will be displayed
        fields = [
            "id",
            'url',
            "name",
        ]
class ProgrammerSerializer(serializers.HyperlinkedModelSerializer):
    # used to change the behaviour of a class or Model
    class Meta:
        # referencing the programmer model
        model = Programmer
        # listing the fields that will be displayed
        fields = [
            "id",
            'url',
            "name",
            "languages"
        ]

from django.shortcuts import render
# import the serializers class
from .serializer import LanguageSerializer, ParadigmSerializer, ProgrammerSerializer
from rest_framework import viewsets, permissions
from .models import Language, Paradigm,Programmer
# Create your views here.
class LanguageView(viewsets.ModelViewSet):
    queryset = Language.objects.all()
    # initializing the serializer
    serializer_class = LanguageSerializer
    #it will automately overide the default permissions that is in settings.py
    permission_classes = (permissions.AllowAny,)
class ParadigmView(viewsets.ModelViewSet):
    queryset = Paradigm.objects.all()
    # initializing the serializer
    serializer_class = ParadigmSerializer
    #it will automately overide the default permissions that is in settings.py
    permission_classes = [permissions.IsAdminUser]
class ProgrammerView(viewsets.ModelViewSet):
    queryset = Programmer.objects.all()
    # initializing the serializer
    serializer_class = ProgrammerSerializer

from django.contrib import admin
from django.urls import path, include
urlpatterns = [
    path('admin/', admin.site.urls),
    # including the codebase urls.py file
    path('', include('codebase.urls'))
]

from django.urls import path, include
#import django restframework  router
from  rest_framework import routers
from . import views
# initializing the router
router = routers.DefaultRouter()
# register each views or route
router.register('languages', views.LanguageView)
router.register('paradigms', views.ParadigmView)
router.register('programmers', views.ProgrammerView)
urlpatterns = [
    path('api-auth', include('rest_framework.urls', namespace='rest_framework')),
    path('', include(router.urls)),
]