La necesidad de datos se vuelve más importante cuando completa su primera versión del sitio web usando Django o REST API usando Django Rest Framework (DRF). Para un problema similar, escribí mi artículo anterior, en el que analicé un enfoque directo para volcar datos JSON en el modelo Django insertándolos directamente en la base de datos y tablas SQLite. Sin embargo, también mencioné que Django tiene datos de carga, datos de volcado y accesorios para problemas similares, pero que necesitan un poco más de comprensión del marco.

Hoy, voy a recorrer esa curva de aprendizaje y discutiré cómo convertir tus datos JSON normales en un dispositivo y luego usar loaddata para volcar datos JSON en un modelo específico. De manera similar, si tiene algunos datos para los modelos (se pueden agregar a través de la página de administración, etc.), entonces cómo volcarlos como accesorios para usarlos con otro modelo o usarlos en otro proyecto.

El artículo anterior tiene dos partes: la primera parte es la configuración normal requerida para el volcado de datos y la segunda parte trata sobre el script Python para volcar datos JSON en el modelo. Por lo tanto, mantenga el artículo breve. En este artículo, comenzaré desde la segunda parte y usted puede seguir la Parte I del artículo anterior para seguir este artículo. Entonces, suponiendo que tiene una aplicación de libro y en la que hay un modelo de libro dentro de models.py, de manera similar, los puntos finales de API están listos, como (repositorio de Github de la publicación anterior):
http://127.0.0.1:8000/api/books/1

o simplemente desea cargar datos en el modelo de libro para un sitio web basado en Django. Puede seguir el código del siguiente repositorio de git.
Volcado de datos JSON al modelo

Dados dos repositorios, puedes usar cualquiera para seguir el artículo desde aquí, solo necesitas lo siguiente:

1. Un proyecto Django en funcionamiento que tiene un modelo de Libro con o sin funciones API
2. Un archivo json que contiene información del libro según el modelo de libro.

Ejemplo 1: El modelo de libro en book/models.py

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.CharField(max_length=100)    
    isbn = models.CharField(max_length=13, unique=True)
    pages = models.PositiveIntegerField()   
    language = models.CharField(max_length=30)

    def __str__(self):
        return self.title

libros.json

[
  {
    "title": "Example Book 1",
    "author": "John Doe",
    "isbn": "1234567890123",
    "pages": 350,
    "language": "English"
  },
  {
    "title": "Example Book 2",
    "author": "Kumar Ajit",
    "isbn": "9876543210987",
    "pages": 280,
    "language": "Hindi"
  }
]

Ejemplo 2: El modelo de Libro del artículo anterior

from django.db import models

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.CharField(max_length=100)
    price = models.DecimalField(max_digits=6, decimal_places=2)

    def __str__(self):
        return self.title

Puedes encontrar el archivo data.json aquí.

Volcado de datos al modelo

Tenemos un proyecto Django en funcionamiento con un modelo Libro y un archivo JSON adicional que contiene información de libros. Entonces, ¿cuál es ahora el problema?
Queremos volcar los datos JSON en el modelo para que puedan usarse con el sitio web de Django (por ejemplo, pasar datos a la plantilla para mostrarlos al usuario) o entregar datos a través de API a la interfaz.

Django tiene datos de carga, accesorios y datos de volcado, junto con la página de administración (puede registrar su modelo e insertar datos) y el shell (para manipular directamente la base de datos usando SQL u ORM). Sin embargo, cargar datos a través de dispositivos parece mejor si desea fusionar datos grandes o desea hacerlo muchas veces (a menudo un caso de uso durante el desarrollo y las pruebas).

Comencemos explicando estas herramientas y luego profundizaremos en el script de Python para realizar la tarea de volcado de datos.

cargar datos

$django-admin loaddata 

Accesorios

Un dispositivo es una colección de archivos que contienen el contenido serializado de la base de datos. Cada dispositivo tiene un nombre único y los archivos que lo componen se pueden distribuir en múltiples directorios, en múltiples aplicaciones. [fuente]

Pasemos a la parte futura del artículo y echemos un vistazo a los accesorios de libros.

[
  {
    "model": "book.book",
    "pk": 40,
    "fields": {
      "title": "Example Book 1",
      "author": "John Doe",
      "isbn": "123456734890123",
      "pages": 350,
      "language": "English"
    }
  },
  {
    "model": "book.book",
    "pk": 41,
    "fields": {
      "title": "Example Book 2",
      "author": "Kumar Ajit",
      "isbn": "9876543455210987",
      "pages": 280,
      "language": "Hindi"
    }
  }
]

Si echaste un vistazo al archivo de fijación, debes haber descubierto que es solo otro archivo JSON con más pares clave-valor y esos son metadatos para modelos/tablas de Django. Entonces, sí, tiene razón y nuestro objetivo es convertir nuestro formato books.json al formato de dispositivo para que la herramienta de administración de Django lo reconozca y descargue los datos en las tablas adecuadas.

Ahora, para crear un dispositivo, puedes tener dos situaciones: 1) tienes datos en modelos y deseas crear un dispositivo para uso o pruebas futuras, etc.
2) No tiene datos en modelos/tablas, pero tiene datos en fuentes externas como json, csv o cualquier otro formato y desea cargar esos datos en Django mediante el comando loaddata discutido anteriormente. (Esto El artículo trata sobre esta situación, pero hacia el final usaremos dumpdata para comparar la salida manual y la de dumpdata.)

Antes de pasar al script de Python para convertir un archivo json normal al formato de dispositivo, comprendamos cómo busca Django el archivo de dispositivo y cómo usarlo.

Hay tres puntos de interés y orden [fuente]:

1. En el directorio de accesorios de cada aplicación instalada: esto es similar a la recomendación para otro directorio como plantilla o medios o carpeta estática organizada dentro de un proyecto Django. Sin embargo, también puede proporcionar una ruta directa como se menciona a continuación.

2. En cualquier directorio listado en la configuración FIXTURE_DIRS

3. En la ruta literal nombrada por el dispositivo: funciona con proyectos o aplicaciones más pequeños, pero es mejor tener una ubicación recomendada adecuada para los dispositivos para que sea fácil de usar con pruebas o depuración, etc.

Nota: Uno de los principales beneficios de utilizar dispositivos es aplicar y utilizar compresión en los dispositivos.

Datos de volcado

Este es el comando django-admin para generar todos los datos de la tabla en la salida estándar.

Nota 1: Genera en la salida estándar todos los datos de la base de datos asociados con las aplicaciones nombradas.
Nota 2: La salida de dumpdata se puede utilizar como entrada para loaddata (como dispositivo)

django-admin dumpdata [app_label[.ModelName] 

puedes leer más en este enlace.

Secuencia de comandos de Python desde json simple hasta accesorios Django.

from django.apps import apps
import django
import os
import json


# Set the Django settings module
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'dataloading.settings')
django.setup()

# get all models
models = apps.get_models()

# Get the model names
for model in models:
    print(model)
    print(model.__name__)

# Choose Model to create fixtures
from book.models import Book 

# Get all field names
field_names = [field.name for field in Book._meta.get_fields()]
fixture_name = "books.json"

#read the data file json, csv etc.

with open('data.json','r') as fp:
    books= json.load(fp)


books_fixture =[]
# get the pk value from model , if there is data
pk=1 
# iterate all the books in json file
for book in books:
    book_fixture={}
    # Add model name (most important for fixture)
    book_fixture['model']= 'book.book'
    pk =1
    book_fixture['pk']=pk
    # assuming the data has same fields name as model else mapping is required
    book_fixture['fields']=book
    books_fixture.append(book_fixture)
# Writing converted Json as file for fixture

with open(fixture_name,'w') as fp:
    json.dump(books_fixture,fp)

# print(field_names)
# if __name__ =='__main__' :
    #create_book()  

Una vez que su dispositivo se haya creado como books.json. Es hora de moverlo/copiarlo a una ubicación adecuada (libro/accesorios/libro/) para que el administrador de Django pueda encontrarlo fácilmente y luego ejecutar el comando loaddata para volcar todos los datos al modelo de libro.

$mv books.json book/fixtures/book/
$python manage.py loaddata book/fixtures/book/books.json

También puede utilizar un script similar para escribir datos directamente en el método sing .save() del modelo. A continuación se muestra el método create_book() que se puede utilizar para insertar uno o más registros de datos (en bucle) en el modelo de libro.

# def create_book():
#     book = Book(
#         title="This is from script",
#         author ="ajit",
#         isbn = "2024-0809",
#         pages=300,
#         language ='English'
#     )
#     book.save()
#     print(f'Book {book.title} by {book.author} created.')

También puedes buscar en Dumpscript de las extensiones de Django una tarea similar.

Espero que sea útil.

Nota: El artículo no se ha revisado ni formateado correctamente debido a limitaciones de tiempo. Por lo tanto, utilícelo con cuidado y deje comentarios a continuación para cualquier error, duda o pregunta. Responderé y editaré el artículo con el tiempo.