Problems with Django structuring when entering models, views and serializers in folders?

Hello I am learning to program in Django and I have a database of 22 tables, as you can see making all the models in a single class would be very cumbersome and messy to find or make corrections, the same thing happens to me with serializers and views.

How would it be the right thing to create as separate modules to the base project or to make backend/api/models ... backend/api/views ... backend/api/serializers/init.py?

enter image description here

I created something basic serializer and view but when I join it to the urls.py I get compilation problems.

I was told that inside each folder create the init.py and integrate there the from of what is created in that folder, but when I start to spread it to the other modules it generates error.

Example:
Folder Models

Models/__init__.py
from . import Service

Folder Serializers

Serializers/__init__.py
from . import ServiceSerializer

The default models, serializers and views files that are created by default are blank, is that the problem?

Views/__init__.py
from . import service_view

Views/service_view.py
from models.Service import Service
from rest_framework import generics
from rest_framework.response import Response
from rest_framework.decorators import api_view
from serializers.service_serializer import ServiceSerializer

# Listar servicios
class ServiceListApiView(generics.ListCreateAPIView):
    queryset = Service.objects.all()
    serializer_class = ServiceSerializer

service_list_create_view = ServiceListApiView.as_view()

I hope someone can guide me on how to import parts of the project more easily or tell me how to do it when you work with 22 or more tables and views.

I would suggest creating multiple apps within your Django project. In each app, place the models, views, and serializers relevant to that app.

The structure I use is the following:

.
├── accounts
│   ├── __init__.py
│   ├── admin.py
│   ├── api
│   │   ├── __init__.py
│   │   ├── routers.py
│   │   ├── serializers.py
│   │   └── views.py
│   ├── apps.py
│   ├── migrations
│   ├── models.py
│   └── tests
├── config
│   ├── __init__.py
│   ├── asgi.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
├── manage.py
├── products
│   ├── __init__.py
│   ├── admin.py
│   ├── api
│   │   ├── __init__.py
│   │   ├── routers.py
│   │   ├── serializers.py
│   │   └── views.py
│   ├── apps.py
│   ├── migrations
│   ├── models.py
│   └── tests

Here you can see that I have two apps accounts and products. In each of these apps, it's placed the api package, which holds the serializer, the views, and the routers that create the relevant endpoints for the app.

This approach helps to keep a cleaner project and makes debugging easier, it also makes the project suitable for scaling as microservices in the cloud.