What a fascinating and new python framework!

The URL https://django-ninja.dev/ is the official website of Django-Ninja, a Python web framework for building APIs with Django and Python 3.6+ type hints.

This post is based on the official website of Django Ninja:

Key Features:

Easy: Designed to be easy to use and intuitive.

FAST execution: Very high performance thanks to Pydantic and async support.

Fast to code: Type hints and automatic docs lets you focus only on business logic.

Standards-based: Based on the open standards for APIs: OpenAPI (previously known as
Swagger) and JSON Schema.

Django friendly: (obviously) has good integration with the Django core and ORM.

Production ready: Used by multiple companies on live projects (If you use Django Ninja and
would like to publish your feedback, please email ppr.vitaly@gmail.com).

Other key features:

Async support :Django-Ninja integrates
acync operations, allowing your application to handle multiple requests concurrently. This results in improved performance, scalability, and responsiveness.
Django compatibility: Django-Ninja is built on top of Django and inherits many of its features, such as an
ORM, template engine, and authentication system. This means you can leverage the existing knowledge
and ecosystem of Django.
Micro-architecture: Django-Ninja adopts a micro-architecture approach, which means that your
application is broken down into smaller, independent components (services). This leads to more
maintainable, scalable, and flexible code.
Type-safe APIs: Django-Ninja uses type-safe APIs, which ensures that your code is more robust and easier
to maintain. You can define your API endpoints with specific types, making it easier to catch errors and
improve code quality.

Benefits:

Improved performance: With asyncio support, your application can handle multiple requests concurrently,
reducing the load on your server and improving response times.
Better scalability: By using async/await syntax, you can write asynchronous code that's more efficient
and easier to maintain.
Easier development: Django-Ninja's micro-architecture approach makes it easier to develop and maintain
your application, with smaller, more focused components.
Type-safe APIs: The type-safe API ensures that your code is more robust and easier to maintain.
Who should use Django-Ninja?

Django-Ninja is suitable for developers who:

Already have experience with Django or Python web development.

Are looking for a more modern and efficient alternative to traditional Python web frameworks.

More about Type-safe APIs!

Type-safe APIs are a crucial aspect of Django-Ninja, and they're essential for building robust, maintainable,
and scalable applications. In this section, I'll dive deeper into what type-safe APIs are and how they benefit
your development process.

What are Type-Safe APIs?

Type-safe APIs are a way to define the structure of your API endpoints, including the types of data they
expect and return. In other words, you can specify the types of data that will be sent or received at each
endpoint, ensuring that your code is more robust and easier to maintain.
In Django-Ninja, type-safe APIs are achieved through the use of Python's type hinting system, which allows
you to specify the expected types of function parameters and return values. This enables static type
checking, which can help catch errors early in the development process.

Benefits of Type-Safe APIs:

Improved Code Quality: Type-safe APIs ensure that your code is more robust and easier to maintain. By specifying the expected types of data, you can catch errors early in the development process, reducing the risk of bugs and crashes.
Better Error Handling: With type-safe APIs, you can handle errors more effectively. When an error occurs, you can pinpoint the exact location and type of error, making it easier to debug and fix issues.
Faster Development: Type-safe APIs enable faster development by providing a clear understanding of the expected data structures and formats. This reduces the time spent on debugging and troubleshooting.
Easier Collaboration: When working with a team, type-safe APIs make it easier to collaborate and share code. Everyone can quickly understand the expected data structures and formats, reducing misunderstandings and errors.
Improved Documentation: Type-safe APIs provide a clear and concise documentation of your API endpoints. This makes it easier for developers to understand how to use your API, reducing the need for additional documentation.

How do Type-Safe APIs work in Django-Ninja?

In Django-Ninja, you can define type-safe APIs using Python's type hinting system. You can specify the
expected types of function parameters and return values.
For example:

Retrieving Single object
Suppose we defined a model Employee.
Now to get employee we will define a schema that will describe what our responses will look like.

class EmployeeOut(Schema):
    id: int
    first_name: str
    last_name: str
    department_id: int = None
    birthdate: date = None

Defining response schemas are not really required, but when you do define it you will get results validation,
documentation and automatic ORM objects to JSON conversions.

We will use this schema as the response type for our GET employee view:

   @api.get("/employees/{employee_id}", response=EmployeeOut)
   def get_employee(request, employee_id: int):
       employee = get_object_or_404(Employee, id=employee_id)
       return employee

Notice that we simply returned an employee ORM object, without a need to convert it to a dict.
The response schema does automatic result validation and conversion to JSON:

@api.get("/employees/{employee_id}", response=EmployeeOut)
def get_employee(request, employee_id: int):
    employee = get_object_or_404(Employee, id=employee_id)
    return employee

List of objects
To output a list of employees, we can reuse the same EmployeeOut schema. We will just set the
response schema to a List of EmployeeOut .

from typing import List
@api.get("/employees", response=List[EmployeeOut])
def list_employees(request):
    qs = Employee.objects.all()
    return qs

Another cool trick - notice we just returned a Django ORM queryset:
It automatically gets evaluated, validated and converted to a JSON list!

   @api.get("/employees", response=List[EmployeeOut])
   def list_employees(request):
       qs = Employee.objects.all()
       return qs

In summary, you declare the types of parameters, body, etc. once only, as function parameters.
You do that with standard modern Python types.

You don't have to learn a new syntax, the methods or classes of a specific library, etc.
Just standard Python 3.6+.
For example, for an int :

   a: int

or, for a more complex Item model:

class Item(Schema):
    foo: str
    bar: float
def operation(a: Item):

... and with that single declaration you get:

Editor support, including:
Completion
Type checks
Validation of data:
Automatic and clear errors when the data is invalid
Validation, even for deeply nested JSON objects

Conversion of input data coming from the network, to Python data and types, and reading from:
JSON
Path parameters
Query parameters
Cookies
Headers
Forms
Files
Automatic, interactive API documentation

What's new in Django Ninja 1.0

Support for Pydantic2
Pydantic version 2 is re-written in Rust and includes a lot of improvements and features like:
Safer types.
Better extensibility.
Better performance

Conclusion:
Django-Ninja is an exciting project that brings together the best of simplicity,
robustness ,power and flexibility. If you're interested in building high-
performance web applications with real-time updates or concurrent processing, Django-Ninja is definitely
worth exploring.