Cómo Comenzar Con Las Vistas Asíncronas De Django

Escribir código asíncrono le brinda la capacidad de acelerar su aplicación con poco esfuerzo. Las versiones de Django >= 3.1 admiten vistas asíncronas, middleware y pruebas. Si aún no ha experimentado con vistas asíncronas, ahora es un buen momento para obtenerlas en su haber.

Este tutorial analiza cómo comenzar con las vistas asíncronas de Django.

Si está interesado en obtener más información sobre el poder detrás del código asíncrono junto con las diferencias entre subprocesos, multiprocesamiento y asíncrono en Python, consulte mi artículo Acelerando Python con concurrencia, paralelismo y asyncio .

Objetivos

Al final de este tutorial, debería ser capaz de:

  1. Escribir una vista asíncrona en Django
  2. Realice una solicitud HTTP sin bloqueo en una vista de Django
  3. Simplifique las tareas básicas en segundo plano con las vistas asíncronas de Django
  4. Úselo sync_to_asyncpara realizar una llamada síncrona dentro de una vista asíncrona
  5. Explique cuándo debe y no debe usar vistas asíncronas

También debe ser capaz de responder a las siguientes preguntas:

  1. ¿Qué sucede si realiza una llamada síncrona dentro de una vista asíncrona?
  2. ¿Qué sucede si realiza una llamada síncrona y asíncrona dentro de una vista asíncrona?
  3. ¿Sigue siendo necesario Celery con las vistas asíncronas de Django?

requisitos previos

Siempre que esté familiarizado con Django, agregar funcionalidad asíncrona a vistas no basadas en clases es extremadamente sencillo.

dependencias

  1. Pitón >= 3.10
  2. Django >= 4.0
  3. uvicornio
  4. HTTPX

¿Qué es ASGI?

ASGI significa Interfaz de puerta de enlace de servidor asíncrono. Es el seguimiento moderno y asíncrono de WSGI , que proporciona un estándar para crear aplicaciones web asíncronas basadas en Python.

Otra cosa que vale la pena mencionar es que ASGI es compatible con versiones anteriores de WSGI, lo que lo convierte en una buena excusa para cambiar de un servidor WSGI como Gunicorn o uWSGI a un servidor ASGI como Uvicorn o Daphne , incluso si no está listo para cambiar a escribir aplicaciones asincrónicas. .

Crear la aplicación

Cree un nuevo directorio de proyectos junto con un nuevo proyecto de Django:

$ mkdir django-async-views && cd django-async-views
$ python3.10 -m venv env
$ source env/bin/activate

(env)$ pip install django
(env)$ django-admin startproject hello_async .

Siéntete libre de cambiar virtualenv y Pip por Poetry o Pipenv . Para obtener más información, revise Entornos modernos de Python .

Django ejecutará sus vistas asíncronas si está utilizando el servidor de desarrollo integrado, pero en realidad no las ejecutará de forma asíncrona, por lo que ejecutaremos Django con Uvicorn.

Instalarlo:

(env)$ pip install uvicorn

Para ejecutar su proyecto con Uvicorn, use el siguiente comando desde la raíz de su proyecto:

uvicorn {name of your project}.asgi:application

En nuestro caso, esto sería:

(env)$ uvicorn hello_async.asgi:application

A continuación, creemos nuestra primera vista asíncrona. Agregue un nuevo archivo para mantener sus vistas en la carpeta "hello_async" y luego agregue la siguiente vista:

# hello_async/views.py

from django.http import HttpResponse


async def index(request):
    return HttpResponse("Hello, async Django!")

Crear vistas asíncronas en Django es tan simple como crear una vista síncrona: todo lo que necesita hacer es agregar la asyncpalabra clave.

Actualice las URL:

# hello_async/urls.py

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

from hello_async.views import index


urlpatterns = [
    path("admin/", admin.site.urls),
    path("", index),
]

Ahora, en una terminal, en su carpeta raíz, ejecute:

(env)$ uvicorn hello_async.asgi:application --reload

La --reloadbandera le dice a Uvicorn que mire sus archivos en busca de cambios y que los vuelva a cargar si encuentra alguno. Eso probablemente se explica por sí mismo.

Abra http://localhost:8000/ en su navegador web favorito:

Hello, async Django!

No es lo más emocionante del mundo, pero bueno, es un comienzo. Vale la pena señalar que ejecutar esta vista con un servidor de desarrollo incorporado de Django dará como resultado exactamente la misma funcionalidad y salida. Esto se debe a que en realidad no estamos haciendo nada asíncrono en el controlador.

HTTPX

Vale la pena señalar que el soporte asíncrono es totalmente compatible con versiones anteriores, por lo que puede combinar vistas asíncronas y sincronizadas, middleware y pruebas. Django ejecutará cada uno en el contexto de ejecución adecuado.

Para demostrar esto, agregue algunas vistas nuevas:

# hello_async/views.py

import asyncio
from time import sleep

import httpx
from django.http import HttpResponse


# helpers

async def http_call_async():
    for num in range(1, 6):
        await asyncio.sleep(1)
        print(num)
    async with httpx.AsyncClient() as client:
        r = await client.get("https://httpbin.org/")
        print(r)


def http_call_sync():
    for num in range(1, 6):
        sleep(1)
        print(num)
    r = httpx.get("https://httpbin.org/")
    print(r)


# views

async def index(request):
    return HttpResponse("Hello, async Django!")


async def async_view(request):
    loop = asyncio.get_event_loop()
    loop.create_task(http_call_async())
    return HttpResponse("Non-blocking HTTP request")


def sync_view(request):
    http_call_sync()
    return HttpResponse("Blocking HTTP request")

Actualice las URL:

# hello_async/urls.py

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

from hello_async.views import index, async_view, sync_view


urlpatterns = [
    path("admin/", admin.site.urls),
    path("async/", async_view),
    path("sync/", sync_view),
    path("", index),
]

Instalar HTTPX :

(env)$ pip install httpx

Con el servidor en ejecución, vaya a http://localhost:8000/async/ . Inmediatamente debería ver la respuesta:

Non-blocking HTTP request

En tu terminal deberías ver:

INFO:     127.0.0.1:60374 - "GET /async/ HTTP/1.1" 200 OK
1
2
3
4
5
<Response [200 OK]>

Aquí, la respuesta HTTP se devuelve antes de la primera llamada de suspensión.

A continuación, navegue hasta http://localhost:8000/sync/ . Debería tomar alrededor de cinco segundos obtener la respuesta:

Blocking HTTP request

Gire a la terminal:

1
2
3
4
5
<Response [200 OK]>
INFO:     127.0.0.1:60375 - "GET /sync/ HTTP/1.1" 200 OK

Aquí, la respuesta HTTP se envía después del ciclo y la solicitud se https://httpbin.org/completa.

Fumar algunas carnes

Para simular más un escenario del mundo real de cómo aprovecharía la sincronización, veamos cómo ejecutar varias operaciones de forma asíncrona, agregar los resultados y devolverlos a la persona que llama.

De vuelta en la URLconf de su proyecto, cree una nueva ruta en smoke_some_meats:

# hello_async/urls.py

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

from hello_async.views import index, async_view, sync_view, smoke_some_meats


urlpatterns = [
    path("admin/", admin.site.urls),
    path("smoke_some_meats/", smoke_some_meats),
    path("async/", async_view),
    path("sync/", sync_view),
    path("", index),
]

De vuelta en sus vistas, cree una nueva función auxiliar asincrónica llamada smoke. Esta función toma dos parámetros: una lista de cadenas llamadas smokablesy una cadena llamada flavor. Estos por defecto son una lista de carnes fumables y "Sweet Baby Ray's", respectivamente.

# hello_async/views.py

async def smoke(smokables: List[str] = None, flavor: str = "Sweet Baby Ray's") -> List[str]:
    """ Smokes some meats and applies the Sweet Baby Ray's """

    for smokable in smokables:
        print(f"Smoking some {smokable}...")
        print(f"Applying the {flavor}...")
        print(f"{smokable.capitalize()} smoked.")

    return len(smokables)

El ciclo for aplica asincrónicamente el sabor (léase: Sweet Baby Ray's) a los ahumables (léase: carnes ahumadas).

No olvides la importación:

from typing import List

Listse utiliza para capacidades adicionales de escritura. Esto no es obligatorio y se puede omitir fácilmente (simplemente elimine la : List[str]siguiente declaración del parámetro "smokables").

A continuación, agregue dos ayudantes asíncronos más:

async def get_smokables():
    print("Getting smokeables...")

    await asyncio.sleep(2)
    async with httpx.AsyncClient() as client:
        await client.get("https://httpbin.org/")

        print("Returning smokeable")
        return [
            "ribs",
            "brisket",
            "lemon chicken",
            "salmon",
            "bison sirloin",
            "sausage",
        ]


async def get_flavor():
    print("Getting flavor...")

    await asyncio.sleep(1)
    async with httpx.AsyncClient() as client:
        await client.get("https://httpbin.org/")

        print("Returning flavor")
        return random.choice(
            [
                "Sweet Baby Ray's",
                "Stubb's Original",
                "Famous Dave's",
            ]
        )

Asegúrate de agregar la importación:

import random

Cree la vista asíncrona que usa las funciones asíncronas:

# hello_async/views.py

async def smoke_some_meats(request):
    results = await asyncio.gather(*[get_smokables(), get_flavor()])
    total = await asyncio.gather(*[smoke(results[0], results[1])])
    return HttpResponse(f"Smoked {total[0]} meats with {results[1]}!")

Esta vista llama a las funciones get_smokablesy al get_flavormismo tiempo. Dado smokeque depende de los resultados de ambos get_smokablesy get_flavor, solíamos gatheresperar a que se completara cada tarea asíncrona.

Tenga en cuenta que en una vista de sincronización regular, get_smokablesy get_flavorse manejaría uno a la vez. Además, la vista asincrónica producirá la ejecución y permitirá que se procesen otras solicitudes mientras se procesan las tareas asincrónicas, lo que permite que el mismo proceso maneje más solicitudes en un período de tiempo determinado.

Finalmente, se devuelve una respuesta para informar al usuario que su deliciosa comida BBQ está lista.

Excelente. Guarde el archivo, luego regrese a su navegador y navegue hasta http://localhost:8000/smoke_some_meats/ . Debería tomar unos segundos obtener la respuesta:

Smoked 6 meats with Sweet Baby Ray's!

En su consola, debería ver:

Getting smokeables...
Getting flavor...
Returning flavor
Returning smokeable

Smoking some ribs...
Applying the Stubb's Original...
Ribs smoked.
Smoking some brisket...
Applying the Stubb's Original...
Brisket smoked.
Smoking some lemon chicken...
Applying the Stubb's Original...
Lemon chicken smoked.
Smoking some salmon...
Applying the Stubb's Original...
Salmon smoked.
Smoking some bison sirloin...
Applying the Stubb's Original...
Bison sirloin smoked.
Smoking some sausage...
Applying the Stubb's Original...
Sausage smoked.
INFO:     127.0.0.1:57501 - "GET /smoke_some_meats/ HTTP/1.1" 200 OK

Tome nota del orden de las siguientes declaraciones impresas:

Getting smokeables...
Getting flavor...
Returning flavor
Returning smokeable

Esta es la asincronía en el trabajo: mientras la get_smokablesfunción duerme, la get_flavorfunción termina de procesar.

Carnes Quemadas

sincronizar llamada

P: ¿Qué sucede si realiza una llamada síncrona dentro de una vista asíncrona?

Lo mismo que sucedería si llamara a una función no asíncrona desde una vista no asíncrona.

--

Para ilustrar esto, cree una nueva función de ayuda en sus vistas.py llamada oversmoke:

# hello_async/views.py

def oversmoke() -> None:
    """ If it's not dry, it must be uncooked """
    sleep(5)
    print("Who doesn't love burnt meats?")

Muy sencillo: solo estamos esperando sincrónicamente durante cinco segundos.

Cree la vista que llama a esta función:

# hello_async/views.py

async def burn_some_meats(request):
    oversmoke()
    return HttpResponse(f"Burned some meats.")

Por último, conecte la ruta en la URLconf de su proyecto:

# hello_async/urls.py

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

from hello_async.views import index, async_view, sync_view, smoke_some_meats, burn_some_meats


urlpatterns = [
    path("admin/", admin.site.urls),
    path("smoke_some_meats/", smoke_some_meats),
    path("burn_some_meats/", burn_some_meats),
    path("async/", async_view),
    path("sync/", sync_view),
    path("", index),
]

Visite la ruta en el navegador en http://localhost:8000/burn_some_meats :

Burned some meats.

Observe cómo tardó cinco segundos en obtener finalmente una respuesta del navegador. También debería haber recibido la salida de la consola al mismo tiempo:

Who doesn't love burnt meats?
INFO:     127.0.0.1:40682 - "GET /burn_some_meats HTTP/1.1" 200 OK

Posiblemente valga la pena señalar que sucederá lo mismo independientemente del servidor que esté utilizando, ya sea basado en WSGI o ASGI.

Llamadas sincronizadas y asíncronas

P: ¿Qué sucede si realiza una llamada síncrona y asíncrona dentro de una vista asíncrona?

No hagas esto.

Las vistas sincrónicas y asincrónicas tienden a funcionar mejor para diferentes propósitos. Si tiene la funcionalidad de bloqueo en una vista asíncrona, en el mejor de los casos no será mejor que simplemente usar una vista síncrona.

Sincronizar a asíncrono

Si necesita realizar una llamada síncrona dentro de una vista asíncrona (como interactuar con la base de datos a través de Django ORM, por ejemplo), use sync_to_async ya sea como contenedor o decorador.

Ejemplo:

# hello_async/views.py

async def async_with_sync_view(request):
    loop = asyncio.get_event_loop()
    async_function = sync_to_async(http_call_sync, thread_sensitive=False)
    loop.create_task(async_function())
    return HttpResponse("Non-blocking HTTP request (via sync_to_async)")

¿Te diste cuenta de que configuramos el thread_sensitiveparámetro en False? Esto significa que la función síncrona http_call_sync, se ejecutará en un nuevo subproceso. Revise los documentos para obtener más información.

Agregue la importación a la parte superior:

from asgiref.sync import sync_to_async

Agregue la URL:

# hello_async/urls.py

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

from hello_async.views import (
    index,
    async_view,
    sync_view,
    smoke_some_meats,
    burn_some_meats,
    async_with_sync_view
)


urlpatterns = [
    path("admin/", admin.site.urls),
    path("smoke_some_meats/", smoke_some_meats),
    path("burn_some_meats/", burn_some_meats),
    path("sync_to_async/", async_with_sync_view),
    path("async/", async_view),
    path("sync/", sync_view),
    path("", index),
]

Pruébelo en su navegador en http://localhost:8000/sync_to_async/ .

En tu terminal deberías ver:

INFO:     127.0.0.1:61365 - "GET /sync_to_async/ HTTP/1.1" 200 OK
1
2
3
4
5
<Response [200 OK]>

Con sync_to_async, la llamada síncrona de bloqueo se procesó en un subproceso en segundo plano, lo que permitió que la respuesta HTTP se devolviera antes de la primera llamada de suspensión.

Vistas de apio y asíncronas

P: ¿Sigue siendo necesario Celery con las vistas asíncronas de Django?

Eso depende.

Las vistas asíncronas de Django ofrecen una funcionalidad similar a una tarea o cola de mensajes sin la complejidad. Si está usando (o está considerando) Django y quiere hacer algo simple (y no le importa la confiabilidad), las vistas asíncronas son una excelente manera de lograr esto de manera rápida y sencilla. Si necesita realizar procesos en segundo plano mucho más pesados ​​​​y de larga duración, aún querrá usar Celery o RQ.

Cabe señalar que para usar las vistas asíncronas de manera efectiva, solo debe tener llamadas asíncronas en la vista. Las colas de tareas, por otro lado, usan trabajadores en procesos separados y, por lo tanto, son capaces de ejecutar llamadas síncronas en segundo plano, en múltiples servidores.

Por cierto, de ninguna manera debe elegir entre vistas asíncronas y una cola de mensajes; puede usarlas fácilmente en conjunto. Por ejemplo: podría usar una vista asíncrona para enviar un correo electrónico o hacer una modificación única de la base de datos, pero hacer que Celery limpie su base de datos a una hora programada todas las noches o generar y enviar informes de clientes.

Cuándo usar

Para proyectos totalmente nuevos, si lo suyo es asincrónico, aproveche las vistas asincrónicas y escriba sus procesos de E/S de la forma más asincrónica posible. Dicho esto, si la mayoría de sus vistas solo necesitan hacer llamadas a una base de datos y hacer un procesamiento básico antes de devolver los datos, no verá un gran aumento (si lo hay) en comparación con las vistas sincronizadas.

Para proyectos brownfield, si tiene pocos o ningún proceso de E/S, quédese con las vistas sincronizadas. Si tiene varios procesos de E/S, calcule lo fácil que será reescribirlos de forma asíncrona. Reescribir la E/S sincronizada a asíncrona no es fácil, por lo que probablemente querrá optimizar su E/S sincronizada y sus vistas antes de intentar reescribir a asíncrona. Además, nunca es una buena idea mezclar procesos de sincronización con sus vistas asíncronas.

En producción, asegúrese de usar Gunicorn para administrar Uvicorn con el fin de aprovechar tanto la simultaneidad (a través de Uvicorn) como el paralelismo (a través de los trabajadores de Gunicorn):

gunicorn -w 3 -k uvicorn.workers.UvicornWorker hello_async.asgi:application

Conclusión

En conclusión, aunque este fue un caso de uso simple, debería darle una idea aproximada de las posibilidades que abren las vistas asincrónicas de Django. Algunas otras cosas que puede probar en sus vistas asíncronas son enviar correos electrónicos, llamar a API de terceros y leer o escribir en archivos.

Fuente:  https://testdriven.io

#django #async 

What is GEEK

Buddha Community

Cómo Comenzar Con Las Vistas Asíncronas De Django
Ahebwe  Oscar

Ahebwe Oscar

1620177818

Django admin full Customization step by step

Welcome to my blog , hey everyone in this article you learn how to customize the Django app and view in the article you will know how to register  and unregister  models from the admin view how to add filtering how to add a custom input field, and a button that triggers an action on all objects and even how to change the look of your app and page using the Django suit package let’s get started.

Database

Custom Titles of Django Admin

Exclude in Django Admin

Fields in Django Admin

#django #create super user django #customize django admin dashboard #django admin #django admin custom field display #django admin customization #django admin full customization #django admin interface #django admin register all models #django customization

Ahebwe  Oscar

Ahebwe Oscar

1620185280

How model queries work in Django

How model queries work in Django

Welcome to my blog, hey everyone in this article we are going to be working with queries in Django so for any web app that you build your going to want to write a query so you can retrieve information from your database so in this article I’ll be showing you all the different ways that you can write queries and it should cover about 90% of the cases that you’ll have when you’re writing your code the other 10% depend on your specific use case you may have to get more complicated but for the most part what I cover in this article should be able to help you so let’s start with the model that I have I’ve already created it.

**Read More : **How to make Chatbot in Python.

Read More : Django Admin Full Customization step by step

let’s just get into this diagram that I made so in here:

django queries aboutDescribe each parameter in Django querset

we’re making a simple query for the myModel table so we want to pull out all the information in the database so we have this variable which is gonna hold a return value and we have our myModel models so this is simply the myModel model name so whatever you named your model just make sure you specify that and we’re gonna access the objects attribute once we get that object’s attribute we can simply use the all method and this will return all the information in the database so we’re gonna start with all and then we will go into getting single items filtering that data and go to our command prompt.

Here and we’ll actually start making our queries from here to do this let’s just go ahead and run** Python manage.py shell** and I am in my project file so make sure you’re in there when you start and what this does is it gives us an interactive shell to actually start working with our data so this is a lot like the Python shell but because we did manage.py it allows us to do things a Django way and actually query our database now open up the command prompt and let’s go ahead and start making our first queries.

#django #django model queries #django orm #django queries #django query #model django query #model query #query with django

Cómo Comenzar Con Las Vistas Asíncronas De Django

Escribir código asíncrono le brinda la capacidad de acelerar su aplicación con poco esfuerzo. Las versiones de Django >= 3.1 admiten vistas asíncronas, middleware y pruebas. Si aún no ha experimentado con vistas asíncronas, ahora es un buen momento para obtenerlas en su haber.

Este tutorial analiza cómo comenzar con las vistas asíncronas de Django.

Si está interesado en obtener más información sobre el poder detrás del código asíncrono junto con las diferencias entre subprocesos, multiprocesamiento y asíncrono en Python, consulte mi artículo Acelerando Python con concurrencia, paralelismo y asyncio .

Objetivos

Al final de este tutorial, debería ser capaz de:

  1. Escribir una vista asíncrona en Django
  2. Realice una solicitud HTTP sin bloqueo en una vista de Django
  3. Simplifique las tareas básicas en segundo plano con las vistas asíncronas de Django
  4. Úselo sync_to_asyncpara realizar una llamada síncrona dentro de una vista asíncrona
  5. Explique cuándo debe y no debe usar vistas asíncronas

También debe ser capaz de responder a las siguientes preguntas:

  1. ¿Qué sucede si realiza una llamada síncrona dentro de una vista asíncrona?
  2. ¿Qué sucede si realiza una llamada síncrona y asíncrona dentro de una vista asíncrona?
  3. ¿Sigue siendo necesario Celery con las vistas asíncronas de Django?

requisitos previos

Siempre que esté familiarizado con Django, agregar funcionalidad asíncrona a vistas no basadas en clases es extremadamente sencillo.

dependencias

  1. Pitón >= 3.10
  2. Django >= 4.0
  3. uvicornio
  4. HTTPX

¿Qué es ASGI?

ASGI significa Interfaz de puerta de enlace de servidor asíncrono. Es el seguimiento moderno y asíncrono de WSGI , que proporciona un estándar para crear aplicaciones web asíncronas basadas en Python.

Otra cosa que vale la pena mencionar es que ASGI es compatible con versiones anteriores de WSGI, lo que lo convierte en una buena excusa para cambiar de un servidor WSGI como Gunicorn o uWSGI a un servidor ASGI como Uvicorn o Daphne , incluso si no está listo para cambiar a escribir aplicaciones asincrónicas. .

Crear la aplicación

Cree un nuevo directorio de proyectos junto con un nuevo proyecto de Django:

$ mkdir django-async-views && cd django-async-views
$ python3.10 -m venv env
$ source env/bin/activate

(env)$ pip install django
(env)$ django-admin startproject hello_async .

Siéntete libre de cambiar virtualenv y Pip por Poetry o Pipenv . Para obtener más información, revise Entornos modernos de Python .

Django ejecutará sus vistas asíncronas si está utilizando el servidor de desarrollo integrado, pero en realidad no las ejecutará de forma asíncrona, por lo que ejecutaremos Django con Uvicorn.

Instalarlo:

(env)$ pip install uvicorn

Para ejecutar su proyecto con Uvicorn, use el siguiente comando desde la raíz de su proyecto:

uvicorn {name of your project}.asgi:application

En nuestro caso, esto sería:

(env)$ uvicorn hello_async.asgi:application

A continuación, creemos nuestra primera vista asíncrona. Agregue un nuevo archivo para mantener sus vistas en la carpeta "hello_async" y luego agregue la siguiente vista:

# hello_async/views.py

from django.http import HttpResponse


async def index(request):
    return HttpResponse("Hello, async Django!")

Crear vistas asíncronas en Django es tan simple como crear una vista síncrona: todo lo que necesita hacer es agregar la asyncpalabra clave.

Actualice las URL:

# hello_async/urls.py

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

from hello_async.views import index


urlpatterns = [
    path("admin/", admin.site.urls),
    path("", index),
]

Ahora, en una terminal, en su carpeta raíz, ejecute:

(env)$ uvicorn hello_async.asgi:application --reload

La --reloadbandera le dice a Uvicorn que mire sus archivos en busca de cambios y que los vuelva a cargar si encuentra alguno. Eso probablemente se explica por sí mismo.

Abra http://localhost:8000/ en su navegador web favorito:

Hello, async Django!

No es lo más emocionante del mundo, pero bueno, es un comienzo. Vale la pena señalar que ejecutar esta vista con un servidor de desarrollo incorporado de Django dará como resultado exactamente la misma funcionalidad y salida. Esto se debe a que en realidad no estamos haciendo nada asíncrono en el controlador.

HTTPX

Vale la pena señalar que el soporte asíncrono es totalmente compatible con versiones anteriores, por lo que puede combinar vistas asíncronas y sincronizadas, middleware y pruebas. Django ejecutará cada uno en el contexto de ejecución adecuado.

Para demostrar esto, agregue algunas vistas nuevas:

# hello_async/views.py

import asyncio
from time import sleep

import httpx
from django.http import HttpResponse


# helpers

async def http_call_async():
    for num in range(1, 6):
        await asyncio.sleep(1)
        print(num)
    async with httpx.AsyncClient() as client:
        r = await client.get("https://httpbin.org/")
        print(r)


def http_call_sync():
    for num in range(1, 6):
        sleep(1)
        print(num)
    r = httpx.get("https://httpbin.org/")
    print(r)


# views

async def index(request):
    return HttpResponse("Hello, async Django!")


async def async_view(request):
    loop = asyncio.get_event_loop()
    loop.create_task(http_call_async())
    return HttpResponse("Non-blocking HTTP request")


def sync_view(request):
    http_call_sync()
    return HttpResponse("Blocking HTTP request")

Actualice las URL:

# hello_async/urls.py

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

from hello_async.views import index, async_view, sync_view


urlpatterns = [
    path("admin/", admin.site.urls),
    path("async/", async_view),
    path("sync/", sync_view),
    path("", index),
]

Instalar HTTPX :

(env)$ pip install httpx

Con el servidor en ejecución, vaya a http://localhost:8000/async/ . Inmediatamente debería ver la respuesta:

Non-blocking HTTP request

En tu terminal deberías ver:

INFO:     127.0.0.1:60374 - "GET /async/ HTTP/1.1" 200 OK
1
2
3
4
5
<Response [200 OK]>

Aquí, la respuesta HTTP se devuelve antes de la primera llamada de suspensión.

A continuación, navegue hasta http://localhost:8000/sync/ . Debería tomar alrededor de cinco segundos obtener la respuesta:

Blocking HTTP request

Gire a la terminal:

1
2
3
4
5
<Response [200 OK]>
INFO:     127.0.0.1:60375 - "GET /sync/ HTTP/1.1" 200 OK

Aquí, la respuesta HTTP se envía después del ciclo y la solicitud se https://httpbin.org/completa.

Fumar algunas carnes

Para simular más un escenario del mundo real de cómo aprovecharía la sincronización, veamos cómo ejecutar varias operaciones de forma asíncrona, agregar los resultados y devolverlos a la persona que llama.

De vuelta en la URLconf de su proyecto, cree una nueva ruta en smoke_some_meats:

# hello_async/urls.py

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

from hello_async.views import index, async_view, sync_view, smoke_some_meats


urlpatterns = [
    path("admin/", admin.site.urls),
    path("smoke_some_meats/", smoke_some_meats),
    path("async/", async_view),
    path("sync/", sync_view),
    path("", index),
]

De vuelta en sus vistas, cree una nueva función auxiliar asincrónica llamada smoke. Esta función toma dos parámetros: una lista de cadenas llamadas smokablesy una cadena llamada flavor. Estos por defecto son una lista de carnes fumables y "Sweet Baby Ray's", respectivamente.

# hello_async/views.py

async def smoke(smokables: List[str] = None, flavor: str = "Sweet Baby Ray's") -> List[str]:
    """ Smokes some meats and applies the Sweet Baby Ray's """

    for smokable in smokables:
        print(f"Smoking some {smokable}...")
        print(f"Applying the {flavor}...")
        print(f"{smokable.capitalize()} smoked.")

    return len(smokables)

El ciclo for aplica asincrónicamente el sabor (léase: Sweet Baby Ray's) a los ahumables (léase: carnes ahumadas).

No olvides la importación:

from typing import List

Listse utiliza para capacidades adicionales de escritura. Esto no es obligatorio y se puede omitir fácilmente (simplemente elimine la : List[str]siguiente declaración del parámetro "smokables").

A continuación, agregue dos ayudantes asíncronos más:

async def get_smokables():
    print("Getting smokeables...")

    await asyncio.sleep(2)
    async with httpx.AsyncClient() as client:
        await client.get("https://httpbin.org/")

        print("Returning smokeable")
        return [
            "ribs",
            "brisket",
            "lemon chicken",
            "salmon",
            "bison sirloin",
            "sausage",
        ]


async def get_flavor():
    print("Getting flavor...")

    await asyncio.sleep(1)
    async with httpx.AsyncClient() as client:
        await client.get("https://httpbin.org/")

        print("Returning flavor")
        return random.choice(
            [
                "Sweet Baby Ray's",
                "Stubb's Original",
                "Famous Dave's",
            ]
        )

Asegúrate de agregar la importación:

import random

Cree la vista asíncrona que usa las funciones asíncronas:

# hello_async/views.py

async def smoke_some_meats(request):
    results = await asyncio.gather(*[get_smokables(), get_flavor()])
    total = await asyncio.gather(*[smoke(results[0], results[1])])
    return HttpResponse(f"Smoked {total[0]} meats with {results[1]}!")

Esta vista llama a las funciones get_smokablesy al get_flavormismo tiempo. Dado smokeque depende de los resultados de ambos get_smokablesy get_flavor, solíamos gatheresperar a que se completara cada tarea asíncrona.

Tenga en cuenta que en una vista de sincronización regular, get_smokablesy get_flavorse manejaría uno a la vez. Además, la vista asincrónica producirá la ejecución y permitirá que se procesen otras solicitudes mientras se procesan las tareas asincrónicas, lo que permite que el mismo proceso maneje más solicitudes en un período de tiempo determinado.

Finalmente, se devuelve una respuesta para informar al usuario que su deliciosa comida BBQ está lista.

Excelente. Guarde el archivo, luego regrese a su navegador y navegue hasta http://localhost:8000/smoke_some_meats/ . Debería tomar unos segundos obtener la respuesta:

Smoked 6 meats with Sweet Baby Ray's!

En su consola, debería ver:

Getting smokeables...
Getting flavor...
Returning flavor
Returning smokeable

Smoking some ribs...
Applying the Stubb's Original...
Ribs smoked.
Smoking some brisket...
Applying the Stubb's Original...
Brisket smoked.
Smoking some lemon chicken...
Applying the Stubb's Original...
Lemon chicken smoked.
Smoking some salmon...
Applying the Stubb's Original...
Salmon smoked.
Smoking some bison sirloin...
Applying the Stubb's Original...
Bison sirloin smoked.
Smoking some sausage...
Applying the Stubb's Original...
Sausage smoked.
INFO:     127.0.0.1:57501 - "GET /smoke_some_meats/ HTTP/1.1" 200 OK

Tome nota del orden de las siguientes declaraciones impresas:

Getting smokeables...
Getting flavor...
Returning flavor
Returning smokeable

Esta es la asincronía en el trabajo: mientras la get_smokablesfunción duerme, la get_flavorfunción termina de procesar.

Carnes Quemadas

sincronizar llamada

P: ¿Qué sucede si realiza una llamada síncrona dentro de una vista asíncrona?

Lo mismo que sucedería si llamara a una función no asíncrona desde una vista no asíncrona.

--

Para ilustrar esto, cree una nueva función de ayuda en sus vistas.py llamada oversmoke:

# hello_async/views.py

def oversmoke() -> None:
    """ If it's not dry, it must be uncooked """
    sleep(5)
    print("Who doesn't love burnt meats?")

Muy sencillo: solo estamos esperando sincrónicamente durante cinco segundos.

Cree la vista que llama a esta función:

# hello_async/views.py

async def burn_some_meats(request):
    oversmoke()
    return HttpResponse(f"Burned some meats.")

Por último, conecte la ruta en la URLconf de su proyecto:

# hello_async/urls.py

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

from hello_async.views import index, async_view, sync_view, smoke_some_meats, burn_some_meats


urlpatterns = [
    path("admin/", admin.site.urls),
    path("smoke_some_meats/", smoke_some_meats),
    path("burn_some_meats/", burn_some_meats),
    path("async/", async_view),
    path("sync/", sync_view),
    path("", index),
]

Visite la ruta en el navegador en http://localhost:8000/burn_some_meats :

Burned some meats.

Observe cómo tardó cinco segundos en obtener finalmente una respuesta del navegador. También debería haber recibido la salida de la consola al mismo tiempo:

Who doesn't love burnt meats?
INFO:     127.0.0.1:40682 - "GET /burn_some_meats HTTP/1.1" 200 OK

Posiblemente valga la pena señalar que sucederá lo mismo independientemente del servidor que esté utilizando, ya sea basado en WSGI o ASGI.

Llamadas sincronizadas y asíncronas

P: ¿Qué sucede si realiza una llamada síncrona y asíncrona dentro de una vista asíncrona?

No hagas esto.

Las vistas sincrónicas y asincrónicas tienden a funcionar mejor para diferentes propósitos. Si tiene la funcionalidad de bloqueo en una vista asíncrona, en el mejor de los casos no será mejor que simplemente usar una vista síncrona.

Sincronizar a asíncrono

Si necesita realizar una llamada síncrona dentro de una vista asíncrona (como interactuar con la base de datos a través de Django ORM, por ejemplo), use sync_to_async ya sea como contenedor o decorador.

Ejemplo:

# hello_async/views.py

async def async_with_sync_view(request):
    loop = asyncio.get_event_loop()
    async_function = sync_to_async(http_call_sync, thread_sensitive=False)
    loop.create_task(async_function())
    return HttpResponse("Non-blocking HTTP request (via sync_to_async)")

¿Te diste cuenta de que configuramos el thread_sensitiveparámetro en False? Esto significa que la función síncrona http_call_sync, se ejecutará en un nuevo subproceso. Revise los documentos para obtener más información.

Agregue la importación a la parte superior:

from asgiref.sync import sync_to_async

Agregue la URL:

# hello_async/urls.py

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

from hello_async.views import (
    index,
    async_view,
    sync_view,
    smoke_some_meats,
    burn_some_meats,
    async_with_sync_view
)


urlpatterns = [
    path("admin/", admin.site.urls),
    path("smoke_some_meats/", smoke_some_meats),
    path("burn_some_meats/", burn_some_meats),
    path("sync_to_async/", async_with_sync_view),
    path("async/", async_view),
    path("sync/", sync_view),
    path("", index),
]

Pruébelo en su navegador en http://localhost:8000/sync_to_async/ .

En tu terminal deberías ver:

INFO:     127.0.0.1:61365 - "GET /sync_to_async/ HTTP/1.1" 200 OK
1
2
3
4
5
<Response [200 OK]>

Con sync_to_async, la llamada síncrona de bloqueo se procesó en un subproceso en segundo plano, lo que permitió que la respuesta HTTP se devolviera antes de la primera llamada de suspensión.

Vistas de apio y asíncronas

P: ¿Sigue siendo necesario Celery con las vistas asíncronas de Django?

Eso depende.

Las vistas asíncronas de Django ofrecen una funcionalidad similar a una tarea o cola de mensajes sin la complejidad. Si está usando (o está considerando) Django y quiere hacer algo simple (y no le importa la confiabilidad), las vistas asíncronas son una excelente manera de lograr esto de manera rápida y sencilla. Si necesita realizar procesos en segundo plano mucho más pesados ​​​​y de larga duración, aún querrá usar Celery o RQ.

Cabe señalar que para usar las vistas asíncronas de manera efectiva, solo debe tener llamadas asíncronas en la vista. Las colas de tareas, por otro lado, usan trabajadores en procesos separados y, por lo tanto, son capaces de ejecutar llamadas síncronas en segundo plano, en múltiples servidores.

Por cierto, de ninguna manera debe elegir entre vistas asíncronas y una cola de mensajes; puede usarlas fácilmente en conjunto. Por ejemplo: podría usar una vista asíncrona para enviar un correo electrónico o hacer una modificación única de la base de datos, pero hacer que Celery limpie su base de datos a una hora programada todas las noches o generar y enviar informes de clientes.

Cuándo usar

Para proyectos totalmente nuevos, si lo suyo es asincrónico, aproveche las vistas asincrónicas y escriba sus procesos de E/S de la forma más asincrónica posible. Dicho esto, si la mayoría de sus vistas solo necesitan hacer llamadas a una base de datos y hacer un procesamiento básico antes de devolver los datos, no verá un gran aumento (si lo hay) en comparación con las vistas sincronizadas.

Para proyectos brownfield, si tiene pocos o ningún proceso de E/S, quédese con las vistas sincronizadas. Si tiene varios procesos de E/S, calcule lo fácil que será reescribirlos de forma asíncrona. Reescribir la E/S sincronizada a asíncrona no es fácil, por lo que probablemente querrá optimizar su E/S sincronizada y sus vistas antes de intentar reescribir a asíncrona. Además, nunca es una buena idea mezclar procesos de sincronización con sus vistas asíncronas.

En producción, asegúrese de usar Gunicorn para administrar Uvicorn con el fin de aprovechar tanto la simultaneidad (a través de Uvicorn) como el paralelismo (a través de los trabajadores de Gunicorn):

gunicorn -w 3 -k uvicorn.workers.UvicornWorker hello_async.asgi:application

Conclusión

En conclusión, aunque este fue un caso de uso simple, debería darle una idea aproximada de las posibilidades que abren las vistas asincrónicas de Django. Algunas otras cosas que puede probar en sus vistas asíncronas son enviar correos electrónicos, llamar a API de terceros y leer o escribir en archivos.

Fuente:  https://testdriven.io

#django #async 

Ananya Gupta

Ananya Gupta

1597123834

Main Pros and Cons of Django As A Web Framework for Python Developers

Django depicts itself as “the web system for fussbudgets with cutoff times”. It was intended to help Python engineers take applications from idea to consummation as fast as could be expected under the circumstances.

It permits fast turn of events on the off chance that you need to make a CRUD application with batteries included. With Django, you won’t need to rehash an already solved problem. It just works and lets you center around your business rationale and making something clients can utilize.

Pros of Django

“Batteries included” theory

The standard behind batteries-included methods normal usefulness for building web applications accompanies the system, not as isolated libraries.

Django incorporates much usefulness you can use to deal with normal web advancement undertakings. Here are some significant level functionalities that Django gives you, which else you need to stay together if you somehow happened to utilize a small scale structure:

ORM

Database relocations

Client validation

Administrator board

Structures

Normalized structure

Django as a system proposes the right structure of an undertaking. That structure helps designers in making sense of how and where to execute any new component.

With a generally acknowledged venture structure that is like numerous tasks, it is a lot simpler to discover online good arrangements or approach the network for help. There are numerous energetic Python designers who will assist you with comprehending any issue you may experience.

Django applications

Django applications (or applications for short) permit designers to separate a task into numerous applications. An application is whatever is introduced by putting in settings.INSTALLED_APPS. This makes it simpler for engineers to add usefulness to the web application by coordinating outer Django applications into the venture.

There are many reusable modules and applications to accelerate your turn of events learn through Online Django Class and Check the Django website.

Secure of course

Django gives great security assurance out of the crate and incorporates avoidance components for basic assaults like SQL Injection (XSS) and Cross-site Request Forgery (CSRF). You can discover more subtleties in the official security diagram control.

REST structure for building APIs

Django REST Framework, commonly condensed “DRF”, is a Python library for building APIs. It has secluded and adaptable engineering that functions admirably for both straightforward and complex web APIs.

DRF gives a lot of verification and authorization strategies out of the case. It is an adaptable, full-included library with measured and adjustable engineering. It accompanies nonexclusive classes for CRUD tasks and an implicit API program for testing API endpoints.

GraphQL structure for building APIs

Huge REST APIs regularly require a lot of solicitations to various endpoints to recover every single required datum. GraphQL it’s a question language that permits us to share related information in a lot simpler design. For a prologue to GraphQL and an outline of its ideas, if it’s not too much trouble allude to the authority GraphQL documentation.

Graphene-Django gives reflections that make it simple to add GraphQL usefulness to your Django venture. Ordinary Django models, structures, validation, consent arrangements, and different functionalities can be reused to manufacture GraphQL blueprint. It additionally gives an implicit API program for testing API endpoints.

Cons of Django

Django ORM

Django ORM, made before SQLAlchemy existed, is currently much sub-par compared to SQLAlchemy. It depends on the Active Record design which is more regrettable than the Unit of Work design embraced by SQLAlchemy. This implies, in Django, models can “spare” themselves and exchanges are off as a matter of course, they are a bit of hindsight. Peruse more in Why I kind of aversion Django.

Django advances course popularity increses day by day:

Django is huge and is viewed as strong bit of programming. This permits the network to create several reusable modules and applications yet has additionally restricted the speed of advancement of the Django. On head of that Django needs to keep up in reverse similarity, so it advances gradually.

Rundown - Should I use Django as a Python designer?

While Django ORM isn’t as adaptable as SQLAlchemy and the enormous environment of reusable modules and applications hinders structure advancement - plainly Django ought to be the best option web system for Python engineers.

Elective, light systems, similar to Flask, while offering a retreat from Django huge biological system and designs, in the long haul can require substantially more additional libraries and usefulness, in the end making many experienced Python engineers winding up wishing they’d began with Django.

Django undertaking’s security and network have become enormously over the previous decade since the system’s creation. Official documentation and instructional exercises are probably the best anyplace in programming advancement. With each delivery, Django keeps on including huge new usefulness.

#django online training #django online course #online django course #django course #django training #django certification course

Marget D

Marget D

1626077187

4 key Features of Django Framework that Make it the Best Amongst all!

Django is one of the popular python based open-source web frameworks mainly used by the developers who like to have rapid development along with the clean pragmatic design.

Read this blog to know the various Django Features with details.

#django framework #django web development #django development company #django development services #python django development company #python django development