django seeding
1.0.0
Ce package aide les développeurs à fill la base de données avec real data au lieu de la remplir manuellement.
Les données peuvent être présentées sous forme CSV File , JSON File ou in-code .
Dependency-Injection également disponible pour injecter votre logique en spécifiant un serializer_class ou en écrivant votre méthode seed personnalisée.
Installation à l'aide de PIP:
pip install django-seeding:
Ajoutez 'django_seeding' à votre paramètre INSTALLED_APPS :
INSTALLED_APPS = [
...
'django_seeding',
]
Jetons un coup d'œil à un exemple rapide de l'utilisation du semence CSVFileModelSeeder de django-seeding pour construire un semence simple pour insérer des données dans la base de données.
django_seeding_example / modèles.py:
from django.db import models
class M1(models.Model):
title = models.CharField(max_length=100)
description = models.TextField()
django_seeding_example / semers.py:
from django_seeding import seeders
from django_seeding.seeder_registry import SeederRegistry
from django_seeding_example.models import M1
@SeederRegistry.register
class M1Seeder(seeders.CSVFileModelSeeder):
model = M1
csv_file_path = 'django_seeding_example/seeders_data/M1Seeder.csv'
django_seeding_example / semers_data / m1seeder.csv:
title,description
t1,d1
t2,d2
Maintenant, il vous suffit d'exécuter cette commande:
python manage.py seed
Allons maintenant plus profondément dans les différents types de semets avec ses détails:
Modèle..seeder a besoin model d'attribut de classe
Serializer..seeder a besoin de serializer_class Class-Attribute
Csvfile..seeder a besoin de csv_file_path -Attribute de classe
Jsonfile..seeder a besoin de json_file_path -Attribute de classe
id: str (donc recommandé)
C'est ce qui sera stocké dans la table AppliedSeeder pour vérifier si un semoir est déjà appliqué ou non
Il est recommandé de le définir comme le nom du semence
Donc, définissez-le et ne le modifiez pas car lorsque la valeur est modifiée, elle sera considérée comme un nouveau semence et il sera appliqué à nouveau même que l'ancien semence avec l'ancien nom est appliqué
Valeur par défaut: str(type(seeder))
priority: int|float
Les sédateurs seront triés en fonction de cet attribut (inférieur-premier)
Valeur par défaut: float('inf')
just_debug: bool
Cet attribut Spécifiez si le Seeder sera appliqué lorsque le serveur est dans le mode de production ou ne dépend pas de la variable de débogage dans le fichier de paramètres
DEBUG=False & just_debug=True -> ne s'applique pas
DEBUG=False & just_debug=False -> Appliquer
DEBUG=True & just_debug=False -> Appliquer
DEBUG=True & just_debug=True -> Appliquer
Valeur par défaut: False
@SeederRegistry.register est le décorateur qui enregistre le semence, donc, si ce décorateur n'est pas appliqué, le semence ne sera pas appliqué
Les semets de modèle utilisent la méthode Bulk_Create, donc, ils sont plus rapides que les Serializer Seedrs
Les tremblements d'enfants utilisent la méthode Bulk_Create avec la mise en cache pour faire aller pour les objets connexes, ils sont donc plus rapides que les Serializer Seedrs
Le lecteur de fichiers CSV utilise des pandas pour de meilleures performances et moins de bugs
L'utilisation de semets de modèle signifie que les noms de champ doivent correspondre aux champs que vous avez définis dans votre modèle
L'utilisation de Serializer Seedrsrs signifie que les noms de champ doivent correspondre aux champs que vous avez définis dans votre sérialiseur
Vous pouvez définir des méthodes de classe get_ au lieu des attributs de classe comme ci-dessous:
python manage.py seed
python manage.py runserver --seed
SEEDING_ON_RUNSERVER = True
SEEDING_ON_RUNSERVER=True dans votre fichier de paramètres, vous pouvez arrêter l'ensemencement dans un serveur RunServer en utilisant un argument --dont-seed python manage.py runserver --dont-seed
Par défaut, la commande Seed utilisera le paramètre de débogage à partir des paramètres de votre projet Django.py. Cependant, vous pouvez remplacer cela en passant explicitement l'option --debug lors de l'exécution de la commande.
Force le débogage à vrai:
python manage.py seed --debug=True
Force le débogage à False:
python manage.py seed --debug=False
Si aucune valeur n'est spécifiée pour - debug, la commande se repliera au paramètre de débogage actuel du projet.
Pour gérer les semets à partir d'un tableau de bord, nous fournissons des API qui offrent un contrôle total sur les opérations de semences.
Route des vues Django-Seeding dans notre application Seeder Url.py:
from rest_framework import routers
from django_seeding.apis.views import AppliedSeederViewSet, RegisteredSeederViewSet
router = routers.DefaultRouter()
router.register('registered-seeders', RegisteredSeederViewSet, 'registered-seeders')
router.register('applied-seeders', AppliedSeederViewSet, 'applied-seeders')
urlpatterns = router.urls
Achetez notre application Seeder dans le projet URLS.py:
from django.urls import include
...
urlpatterns = [
...
path('seeder/', include('django_seeding_example.urls')),
...
]
...
Vous pouvez personnaliser les autorisations ou toute autre logique en héritant des ensembles de visualiers fournis et en remplacement des méthodes nécessaires pour répondre aux exigences de projet spécifiques.
Pour vous permettre de tester plus facilement les API, nous avons fourni une collection Postman contenant tous les points de terminaison de l'API. Vous pouvez télécharger la collection et l'importer dans Postman pour des tests rapides et faciles.
Étapes pour utiliser la collection Postman:
Dans ce package, les classes de semences doivent être enregistrées pour être appliquées. Ce point de terminaison vous permet de:
Énumérez tous les semets enregistrés: cela comprend les sédateurs appliqués et non appliqués.
Obtenez /registered-seeders/
Appliquez des Sepers spécifiques: vous pouvez appliquer tous les semants ou en sélectionner des sédateurs.
Post /registered-seeders/seed-all/
Nous pouvons spécifier le mode de débogage pour l'ensemencement et les ID nécessaires à semer dans le corps comme celui-ci (les deux sont facultatifs - peuvent être nuls):
{
"debug": true,
"ids": [
"id1",
"id2"
]
}
Les semets appliqués sont suivis dans un modèle dédié pour les empêcher d'être appliqués plusieurs fois. Les points de terminaison du semence appliqué fournissent une gestion complète sur les enregistrements de semets appliqués, vous permettant de:
Énumérez tous les semets appliqués: affichez tous les semets qui ont été appliqués.
Get /applied-seeders/
Récupérez un semence appliqué spécifique: afficher les détails d'un semence particulier.
Get /applied-seeders/{id}/
Marquez un semence tel qu'appliqué: créez un enregistrement dans le modèle de semets appliqué pour indiquer qu'il a été appliqué.
Post /applied-seeders/
Corps de demande:
{
"id": "id"
}
Mettez à jour un enregistrement de Seeder: utile pour changer un ID de Seeder.
Put /applied-seeders/{id}/
Corps de demande:
{
"id": "new_id"
}
Supprimer un semence appliqué spécifique: supprime un enregistrement pour marquer le semence non appliqué.
Delete /applied-seeders/{id}/
Supprimez tous les semets appliqués: cela permet à tous les semets d'être appliqués.
Delete /applied-seeders/delete-all/
ID: int (Primary Key)
créé_at: datetime
Updated_at: datetime
Ici, nous irons plus loin dans les classes de Seedrs et ses détails
SEDRER FAST bulk_create
Notez que les titres du csv-file doivent correspondre aux noms de champ dans le model
modèles.py
class M1(models.Model):
title = models.CharField(max_length=100)
description = models.TextField()
stersrs.py
@SeederRegistry.register
class M1Seeder(seeders.CSVFileModelSeeder):
id = 'M1Seeder'
priority = 1
model = M1
csv_file_path = 'django_seeding_example/seeders_data/M1Seeder.csv'
sèche_data / m1seeder.csv
title,description
t1,d1
t2,d2
SEDRER FAST bulk_create
Notez que les clés du json-file doivent correspondre aux noms de champ dans le model
modèles.py
class M2(models.Model):
title = models.CharField(max_length=100)
description = models.TextField()
stersrs.py
@SeederRegistry.register
class M2Seeder(seeders.JSONFileModelSeeder):
id = 'M2Seeder'
priority = 2
model = M2
json_file_path = 'django_seeding_example/seeders_data/M2Seeder.json'
steers_data / m2seeder.json
[
{
"title": "json t1",
"description": "json d1"
},
{
"title": "json t2",
"description": "json d2"
}
]
Seeder bulk-create mis en œuvre avec une stratégie de mise en cache.
Ce semence a été conçu pour semer des modèles d'enfants, c'est-à-dire des modèles qu'au moins un champ est une clé étrangère ( models.ForeignKey ), mais peut également être utilisé à la place de JSONFileModelSeeder pour les modèles généraux.
Notez que les clés du json-file doivent correspondre aux noms de champ dans le model et également la structure. Les modèles parents sont représentés comme des dicts intérieurs.
modèles.py
class Father ( models . Model ):
name = models . TextField ()
class Son ( models . Model ):
name = models . TextField ()
father = models . ForeignKey ( Father , on_delete = models . CASCADE )stersrs.py
@ SeederRegistry . register
class SonSeeder ( seeders . JSONFileChildSeeder ):
id = 'SonSeeder'
model = Son
priority = 10
json_file_path = 'django_seeding_example/seeders_data/SonSeeder.json'Seeders_data / Sonseeder.json
[
{
"name" : " json son 1 " ,
"father" : { "name" : " json father 1 " }
},
{
"name" : " json son 2 " ,
"father" : { "name" : " json father 2 " }
}
]Notez que la priorité de l'enfant doit être supérieure à la priorité des parents pour que le modèle parent soit auparavant classé. Pas un parent d'ensemencement auparavant augmentera les erreurs! Chaque champ qui est un FK doit être un dictionnaire avec des noms de champ identiques à son modèle connexe.
Cette classe de semences peut gérer des relations assez complexes entre les modèles. Élargissons la famille (jeu de mots):
modèles.py
class Mother ( models . Model ):
name = models . TextField ()
class Daughter ( models . Model ):
name = models . TextField ()
father = models . ForeignKey ( Father , on_delete = models . CASCADE )
mother = models . ForeignKey ( Mother , on_delete = models . CASCADE )
class Meta :
constraints = [
UniqueConstraint (
fields = [ 'name' , 'father' , 'mother' ],
name = 'unique_parentage'
)]
class Grandson ( models . Model ):
name = models . TextField ()
parentage = models . ForeignKey ( Daughter , on_delete = models . CASCADE )stersrs.py
@ SeederRegistry . register
class DaughterSeeder ( seeders . JSONFileChildSeeder ):
id = 'DaughterSeeder'
priority = 10
model = Daughter
json_file_path = 'django_seeding_example/seeders_data/DaughterSeeder.json'
@ SeederRegistry . register
class GrandsonSeeder ( seeders . JSONFileChildSeeder ):
id = 'GrandsonSeeder'
model = Grandson
json_file_path = 'django_seeding_example/seeders_data/GrandsonSeeder.json'Seeders_data / Daughterseeder.json
[
{
"name" : " json daughter 1 " ,
"father" : { "name" : " json father 1 " },
"mother" : { "name" : " json mother 1 " }
},
{
"name" : " json daughter 2 " ,
"father" : { "name" : " json father 2 " },
"mother" : { "name" : " json mother 2 " }
}
]Seeders_Data / petit-fils
[
{
"name" : " json grandson 1 " ,
"parentage" : {
"name" : " json daughter 1 " ,
"father" : { "name" : " json father 1 " },
"mother" : { "name" : " json mother 1 " }
}
},
{
"name" : " json grandson 2 " ,
"parentage" : {
"name" : " json daughter 2 " ,
"father" : { "name" : " json father 2 " },
"mother" : { "name" : " json mother 2 " }
}
}
]Sente un à un lent
Notez que les titres du csv-file doivent correspondre aux noms de champ dans le serializer
Ce semence est utilisé pour injecter un sérialiseur pour implémenter une logique de création personnalisée
modèles.py
class M3(models.Model):
title = models.CharField(max_length=100)
description = models.TextField()
serializers.py
class M3Serializer(serializers.ModelSerializer):
class Meta:
model = M3
fields = ['title', 'description']
def create(self, validated_data):
validated_data['title'] = '__' + validated_data['title'] + '__'
validated_data['description'] = '__' + validated_data['description'] + '__'
return super().create(validated_data)
stersrs.py
@SeederRegistry.register
class M3Seeder(seeders.CSVFileSerializerSeeder):
id = 'M3Seeder'
priority = 3
serializer_class = M3Serializer
csv_file_path = 'django_seeding_example/seeders_data/M3Seeder.csv'
sèche_data / m3seeder.csv
title,description
t1,d1
t2,d2
Sente un à un lent
Notez que les clés du json-file doivent correspondre aux noms de champ dans le serializer
Ce semence est utilisé pour injecter un sérialiseur pour implémenter une logique de création personnalisée
modèles.py
class M4(models.Model):
title = models.CharField(max_length=100)
description = models.TextField()
serializers.py
class M4Serializer(serializers.ModelSerializer):
class Meta:
model = M4
fields = ['title', 'description']
def create(self, validated_data):
validated_data['title'] = '__' + validated_data['title'] + '__'
validated_data['description'] = '__' + validated_data['description'] + '__'
return super().create(validated_data)
stersrs.py
@SeederRegistry.register
class M4Seeder(seeders.JSONFileSerializerSeeder):
id = 'M4Seeder'
priority = 4
serializer_class = M4Serializer
json_file_path = 'django_seeding_example/seeders_data/M4Seeder.json'
steers_data / m4seeder.json
[
{
"title": "json t1",
"description": "json d1"
},
{
"title": "json t2",
"description": "json d2"
}
]
SEDRER FAST bulk_create
modèles.py
class M5(models.Model):
title = models.CharField(max_length=100, null=True)
description = models.TextField(null=True)
stersrs.py
@SeederRegistry.register
class M5Seeder(seeders.EmptySeeder):
id = 'M5Seeder'
priority = 5
model = M5
records_count = 2
SEDRER FAST bulk_create
Notez que les clés de l'attribut de classe data doivent correspondre aux noms de champ dans le model
modèles.py
class M6(models.Model):
title = models.CharField(max_length=100)
description = models.TextField()
stersrs.py
@SeederRegistry.register
class M6Seeder(seeders.ModelSeeder):
id = 'M6Seeder'
priority = 6
model = M6
data = [
{
"title": "in-code t1",
"description": "in-code d1"
},
{
"title": "in-code t2",
"description": "in-code d2"
},
]
Sente un à un lent
Notez que les clés de l'attribut de classe data doivent correspondre aux noms de champ dans le serializer
Ce semence est utilisé pour injecter un sérialiseur pour implémenter une logique de création personnalisée
modèles.py
class M7(models.Model):
title = models.CharField(max_length=100)
description = models.TextField()
serializer.py
class M7Serializer(serializers.ModelSerializer):
class Meta:
model = M7
fields = ['title', 'description']
def create(self, validated_data):
validated_data['title'] = '__' + validated_data['title'] + '__'
validated_data['description'] = '__' + validated_data['description'] + '__'
return super().create(validated_data)
stersrs.py
@SeederRegistry.register
class M7Seeder(seeders.SerializerSeeder):
id = 'M7Seeder'
priority = 7
serializer_class = M7Serializer
data = [
{
"title": "in-code t1",
"description": "in-code d1"
},
{
"title": "in-code t2",
"description": "in-code d2"
},
]
Ici, vous pouvez écrire votre logique comme vous le souhaitez dans la méthode des semences
modèles.py
class Post(models.Model):
content = models.TextField()
class Comment(models.Model):
post = models.ForeignKey(Post, on_delete=models.CASCADE)
content = models.TextField()
stersrs.py
@SeederRegistry.register
class CustomSeeder(seeders.Seeder):
id = 'CustomSeeder'
priority = 8
def seed(self):
post1 = Post.objects.create(content='post1')
post2 = Post.objects.create(content='post1')
comment1 = Comment.objects.create(post=post1, content='comment1')
comment2 = Comment.objects.create(post=post1, content='comment2')
comment3 = Comment.objects.create(post=post2, content='comment3')
comment4 = Comment.objects.create(post=post2, content='comment4')
Si vous avez des suggestions sur la façon dont l'ensemencement Django pourrait être amélioré ou si vous souhaitez signaler un bug, ouvrez un problème! Nous aimerions tous et toutes les contributions.
Pour en savoir plus, consultez le guide de contribution.
Suliman Awad - [email protected] - LinkedIn
Lien du projet: https://github.com/suliman-99/django-ceeding
Licence MIT
Copyright (C) 2023 Suliman Awad
Pour en savoir plus, consultez le fichier de licence.
