Le besoin de données devient plus important lorsque vous complétez votre première version de site Web à l'aide de Django ou de l'API REST à l'aide de Django Rest Framework (DRF). Pour un problème similaire, j'ai écrit mon article précédent, dans lequel j'ai discuté d'une approche directe de dumping des données JSON dans le modèle Django en les insérant directement dans la base de données et les tables SQLite. Cependant, j'ai également mentionné que Django dispose de loaddata, dumpdata et de luminaires pour des problèmes similaires, mais qui nécessitent un peu plus de compréhension du framework.

Aujourd'hui, je vais parcourir cette courbe d'apprentissage et discuter de la façon de convertir vos données JSON normales en un appareil, puis d'utiliser loaddata pour vider les données JSON dans un modèle spécifique. De même, si vous avez des données pour les modèles (peuvent être ajoutées via la page d'administration, etc.), comment les vider en tant qu'appareils à utiliser avec un autre modèle ou dans un autre projet.

L'article précédent comprend deux parties : la première partie est la configuration normale requise pour le vidage des données et la deuxième partie concerne le script Python pour vider les données JSON dans le modèle. Alors, gardez l'article court, dans cet article, je commencerai par la deuxième partie et vous pourrez suivre la partie I de l'article précédent pour suivre cet article. Donc, en supposant que vous ayez une application de livre et dans laquelle il y a un modèle de livre dans models.py, de la même manière, les points de terminaison de l'API sont prêts, tels que (dépôt Github du post précédent) :
http://127.0.0.1:8000/api/books/1

ou vous souhaitez simplement charger des données dans le modèle Book pour un site Web basé sur Django. Vous pouvez suivre le code du référentiel git suivant.
Dumping de données JSON vers le modèle

Étant donné deux référentiels, vous pouvez utiliser n'importe qui pour suivre l'article à partir d'ici, vous avez juste besoin des éléments suivants :

1. Un projet Django fonctionnel ayant un modèle Book avec ou sans fonctionnalités API
2. Un fichier json contenant des informations sur le livre selon le modèle Book.

Exemple 1 : Le modèle de livre dans 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

books.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"
  }
]

Exemple 2 : Le modèle Book de l'article précédent

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

Vous pouvez trouver le fichier data.json ici.

Dumping de données vers le modèle

Nous avons un projet Django fonctionnel avec un modèle Book et un fichier JSON supplémentaire contenant des informations sur les livres. Alors maintenant, quel est le problème ?
Nous souhaitons transférer les données JSON dans le modèle afin qu'elles puissent être soit utilisées avec le site Web Django (par exemple, en transmettant des données au modèle pour les afficher à l'utilisateur), soit en fournissant des données via une API au frontend.

Django a des données de chargement, des appareils et des données de vidage, ainsi qu'une page d'administration (vous pouvez enregistrer votre modèle et insérer des données) et un shell (pour manipuler directement la base de données à l'aide de SQL ou ORM). Cependant, charger des données via des appareils semble préférable si vous souhaitez fusionner des données volumineuses ou si vous souhaitez le faire plusieurs fois (souvent un cas d'utilisation lors du développement et des tests).

Commençons par expliquer ces outils, puis nous plongerons dans le script Python pour réaliser la tâche de vidage des données.

Charger les données

$django-admin loaddata 

Calendrier

Un appareil est une collection de fichiers contenant le contenu sérialisé de la base de données. Chaque appareil a un nom unique et les fichiers qui composent l'appareil peuvent être distribués dans plusieurs répertoires, dans plusieurs applications. [source]

Passons à la prochaine partie de l'article et jetons un œil aux rendez-vous des livres.

[
  {
    "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 vous avez jeté un œil au fichier de luminaire, vous avez dû constater qu'il s'agit simplement d'un autre fichier JSON avec plus de paires clé-valeur et que ce sont des métadonnées pour les modèles/tables Django. Donc, oui, vous avez raison et notre objectif est de convertir notre format books.json au format luminaire afin que l'outil d'administration de Django le reconnaisse et vide les données dans une ou plusieurs tables appropriées.

Maintenant, pour créer un appareil, vous pouvez avoir deux situations : 1) vous avez des données dans les modèles et vous souhaitez créer un appareil pour une utilisation ou des tests futurs, etc.
2) Vous n'avez pas de données dans les modèles/tables mais vous avez des données dans des sources externes comme json, csv ou tout autre format et vous souhaitez charger ces données dans Django via la commande discutée précédemment loaddata .( Ceci L'article traite de cette situation, mais vers la fin, nous utiliserons dumpdata pour comparer la sortie manuelle et la sortie dumpdata.)

Avant d'utiliser le script Python pour convertir le fichier json normal au format de luminaire, comprenons comment Django recherche le fichier de luminaire et comment l'utiliser.

Il y a trois points d'intérêt et ordre [source] :

1. Dans le répertoire des appareils de chaque application installée : ceci est similaire à la recommandation pour d'autres répertoires comme un modèle, un média ou un dossier statique organisé dans un projet Django. Cependant, vous pouvez également indiquer un chemin direct comme mentionné ci-dessous.

2. Dans n'importe quel répertoire répertorié dans le paramètre FIXTURE_DIRS

3. Dans le chemin littéral nommé par l'appareil : fonctionne avec un projet ou une application plus petit, mais il est préférable d'avoir un emplacement recommandé approprié pour les appareils afin qu'il soit facile à utiliser avec les tests ou le débogage, etc.

Remarque : L'un des principaux avantages de l'utilisation des appareils est d'appliquer et d'utiliser la compression sur les appareils.

Données de vidage

Il s'agit d'une commande Django-admin permettant d'afficher toutes les données de la table sur la sortie standard.

Remarque 1 : affiche en sortie standard toutes les données de la base de données associée à la ou aux applications nommées.
Note 2 : La sortie de dumpdata peut être utilisée comme entrée pour loaddata. (comme luminaire)

django-admin dumpdata [app_label[.ModelName] 

vous pouvez en savoir plus à partir de ce lien.

Script Python du simple json vers Django Luminaires.

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()  

Une fois votre appareil créé en tant que books.json. Il est temps de le déplacer/copier vers un emplacement approprié (book/fixtures/book/) afin que Django Manager puisse le trouver facilement, puis exécuter la commande loaddata pour vider toutes les données vers le modèle Book.

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

Vous pouvez également utiliser un script similaire pour écrire directement des données dans la méthode sing .save() du modèle. Vous trouverez ci-dessous la méthode create_book() qui peut être utilisée pour insérer un ou plusieurs enregistrements de données (en boucle) dans le modèle Book.

# 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.')

Vous pouvez également consulter Dumpscript à partir des extensions Django pour une tâche similaire.

J'espère que cela sera utile.

Remarque : L'article n'a pas été correctement relu et formaté en raison de contraintes de temps. Veuillez donc l'utiliser avec précaution et laisser des commentaires ci-dessous pour toute erreur, commentaire ou question. Je répondrai et modifierai l'article au fil du temps.