Vidage de données JSON vers des modèles Django : utilisation de la configuration et des commandes de Django

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 comporte 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 permettant de 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 <fixture label>

Calendrier

Un appareil est une collection de fichiers qui contiennent 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 livres luminaires.

[
  {
    "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 d'ordre [source] :

1. Dans le répertoire luminaires 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 donner un chemin direct comme mentionné ci-dessous.

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

3. In the literal path named by the fixture: Works with smaller project or app but it is better to have a proper recommended location for fixtures so it will easy to use with testing or debugging etc.

Note:One major benefit of using fixture is to apply and use compression on fixtures.

Dumpdata

This is django-admin command to output all data of table to standard output.

Note 1: Outputs to standard output all data in the database associated with the named application(s).
Note 2 : The output of dumpdata can be used as input for loaddata.(as fixture )

django-admin dumpdata [app_label[.ModelName] 

you can read more from this link.

Python script from simple json to Django Fixtures.

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

Once your fixture is created as books.json. It time to move it /copy to suitable location (book/fixtures/book/) so that Django manager can find it easily and then run loaddata command to dump all data to Book model.

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

You can also use similar script to directly write data to model sing .save() method. Below is create_book() method that can be use to insert one or more (looping) data records into Book model.

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

You can also look into Dumpscript from Django-extensions for similar task.

I hope it will be helpful.

Note: The article in not properly proofread and formatted because of time constraint. So, please use it carefully and leave comments below for any errors, dobuts or questions. I will reply and edit the article overtime.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!