django seeding

django播种

目录

• 介绍
• 安装
• 简单示例
• 完整的用法文档
  • 播种机清单
  • 属性列表
  • 运行方法
• 内置的Restfull API用于管理
• 完整的例子
  • csvfilemodelseeder（推荐）
  • jsonfilemodelseeder（推荐）
  • jsonfilechildseeder（推荐）
  • csvfileserializeeder
  • JSONFILESERIALIZESEEDER
  • 排出者（推荐）
  • 模型分子（推荐）
  • SerializeSeeder
  • 播种机
• 贡献
• 接触
• 执照

介绍

该软件包可帮助开发人员用real data fill数据库，而不是手动填充数据库。

数据可以作为CSV File ， JSON File或in-code表示。

还可以通过指定Dependency-Injection或编写自定义seed方法serializer_class注入逻辑。

安装

使用PIP安装：

 pip install django-seeding:

将'django_seeding'添加到您的INSTALLED_APPS设置：

 INSTALLED_APPS = [
    ...
    'django_seeding',
]

简单示例

让我们看一下从django-seeding使用CSVFileModelSeeder Seeder的快速示例，以构建一个简单的播种机来插入数据库中的数据。

django_seeding_example/models.py：

 from django.db import models


class M1(models.Model):
    title = models.CharField(max_length=100)
    description = models.TextField()

django_seeding_example/seeders.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/seeders_data/m1seeder.csv：

 title,description
t1,d1
t2,d2

现在，您只需要运行此命令：

 python manage.py seed

完整用法文档：

现在，让我们深入了解不同的播种机类型的细节：

播种机列表：

• csvfilemodelseeder（推荐）
• jsonfilemodelseeder（推荐）
• jsonfilechildseeder（推荐）
• csvfileserializeeder
• JSONFILESERIALIZESEEDER
• 排出者（推荐）
• 模型分子（推荐）
• SerializeSeeder
• 播种机

属性列表

通常，有一种方法可以知道如何轻松处理这些播种机：

模型..种子需求model类属性

serializer..seeder需要serializer_class class-attribute

csvfile..seeder需要csv_file_path class-attribute

jsonfile..seeder需要json_file_path class-attribute

所有播种机都可以采用这些可选的类属性：

• id: str （推荐）

  这是将存储在应用程序表中以检查播种机是否已经应用的东西

  建议将其设置为播种机名称

  因此，将其设置并且不要更改它，因为当值更改时，它将被视为新的播种机，即使应用了带有旧名称的旧播种机，也将再次应用它

  默认值： str(type(seeder))

• priority: int|float

  播种机将根据此属性（第一个）进行排序

  默认值： float('inf')

• just_debug: bool

  此属性指定服务器在生产模式中时是否会在设置文件中的调试变量中应用

  DEBUG=False ＆ just_debug=True >不应用

  DEBUG=False ＆ just_debug=False >应用

  DEBUG=True ＆ just_debug=False >应用

  DEBUG=True ＆ just_debug=True >应用

  默认值： False

注意：

• @SeederRegistry.register是注册播种机的装饰器，因此，如果不应用此装饰器，则不会应用播种机

• 模型播种机使用Bulk_Create方法，因此，它们比串行器播种机快

• 儿童播种机使用bulk_create方法与相关对象的缓存获取，因此，它们比串行器播种机快

• CSV文件读取器正在使用pandas来获得更好的性能和更少的错误

• 使用模型播种机意味着字段名称必须与您在模型中定义的字段匹配

• 使用串行器播种机意味着字段名称必须匹配您在序列化器中定义的字段

• 您可以定义get_ class-hethods，而不是以下类：

  • get_model
  • get_serializer_class
  • get_csv_file_path
  • get_json_file_path
  • get_id
  • get_priority
  • get_just_debug

运行方法：

• 用手动命令种子（推荐）：

 python manage.py seed

• 用runserver手动播种，只需在runserver命令中添加“ - 种子”：

 python manage.py runserver --seed

• 要在Runserver上播种自动设置您的项目设置：

 SEEDING_ON_RUNSERVER = True

自动播种：

• 如果您在设置文件中设置SEEDING_ON_RUNSERVER=True则可以使用--dont-seed参数停止在runserver中播种

 python manage.py runserver --dont-seed

使用种子命令管理调试模式：

默认情况下，SEED命令将使用您的Django Project的设置中的调试设置。但是，您可以在运行命令时明确传递-Debug选项来覆盖此问题。

强制调试到真实：

 python manage.py seed --debug=True

强迫调试到错误：

 python manage.py seed --debug=False

如果未为 - 示例指定值，则该命令将返回到项目当前的调试设置。

内置的Restfull API用于管理

为了从仪表板管理播种机，我们提供对播种机操作的完全控制的API。

用法：

我们的SEEDER应用程序urls.py中的Django-seeding视图：

 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 

在项目urls.py中路由我们的播种机应用程序：

 from django.urls import include
...
urlpatterns = [
    ...
    path('seeder/', include('django_seeding_example.urls')),
    ...
]
...

自定义：

您可以通过继承提供的视图集并覆盖必要的方法来自定义权限或任何其他逻辑，以满足您的特定项目要求。

API测试的Postman Collection：

为了使您更容易测试API，我们提供了一个包含所有API端点的Postman集合。您可以下载该集合并将其导入到Postman中，以进行快速简便的测试。

使用Postman集合的步骤：

• 从此链接下载邮递员集合。
• 打开Postman，单击“导入”，然后选择您刚下载的.json文件。
• 现在，您将预先配置所有API端点，并准备在Postman中进行测试。

注册的播种机端点：

在此软件包中，必须注册播种机类才能应用。此终点使您可以：

• 列出所有注册的播种机：这包括应用和未应用的播种机。

  获取/registered-seeders/

• 应用特定的播种机：您可以使用所有播种机或选择特定的播种机。

  邮寄/registered-seeders/seed-all/

  我们可以指定播种的调试模式，并像这样将所需的ID在体内播种（它们都是可选的 - 可以为null）：

   {
      "debug": true,
      "ids": [
          "id1",
          "id2"
      ]
  }
  

施加的播种机端点：

在专用模型中跟踪应用的播种机，以防止它们多次应用。应用的播种机端点可在应用的播种机记录上提供完整的管理，使您可以：

• 列出所有施加的播种机：查看已应用的所有播种机。

  获取/applied-seeders/

• 检索特定的施加播种机：查看特定播种机的详细信息。

  get /applied-seeders/{id}/

• 将播种机标记为应用：在应用的播种机模型中创建记录以表明已应用。

  邮政/applied-seeders/

  请求主体：

   {
      "id": "id"
  }
  

• 更新播种机记录：可用于更改播种机的ID。

  put /applied-seeders/{id}/

  请求主体：

   {
      "id": "new_id"
  }
  

• 删除特定的施加播种机：删除记录以将播种机标记为未施加的播种机。

  删除/applied-seeders/{id}/

• 删除所有施加的播种机：这允许将所有播种机重新应用。

  删除/applied-seeders/delete-all/

应用的播种机表格架：

• id： int (Primary Key)

• create_at： datetime

• UPDATED_AT： datetime

完整的播种机例子：

在这里，我们将在播种机课程及其细节中更深入

csvfilemodelseeder（推荐）：

快速bulk_create播种机

请注意， csv-file中的标题必须匹配model中的字段名称

模型

 class M1(models.Model):
    title = models.CharField(max_length=100)
    description = models.TextField()

播种机

 @SeederRegistry.register
class M1Seeder(seeders.CSVFileModelSeeder):
    id = 'M1Seeder'
    priority = 1
    model = M1
    csv_file_path = 'django_seeding_example/seeders_data/M1Seeder.csv'

SEEDERS_DATA/M1SEEDER.CSV

 title,description
t1,d1
t2,d2

jsonfilemodelseeder（推荐）：

快速bulk_create播种机

请注意， json-file中的键必须匹配model中的字段名称

模型

 class M2(models.Model):
    title = models.CharField(max_length=100)
    description = models.TextField()

播种机

 @SeederRegistry.register
class M2Seeder(seeders.JSONFileModelSeeder):
    id = 'M2Seeder'
    priority = 2
    model = M2
    json_file_path = 'django_seeding_example/seeders_data/M2Seeder.json'

SEEDERS_DATA/M2SEEDER.JSON

 [
    {
        "title": "json t1",
        "description": "json d1"
    },
    {
        "title": "json t2",
        "description": "json d2"
    }
]

JSONFILECHILDSEEDER（推荐）：

通过缓存策略实现的眨眼及其bulk-create播种机。

该播种机被构想为种子儿童模型，即至少一个字段是外键（ models.ForeignKey ），但也可以用于常规模型而不是JSONFileModelSeeder 。

请注意， json-file中的键必须匹配model中的字段名称以及结构。父模型表示为内部模型。

模型

 class Father ( models . Model ):
    name = models . TextField ()

class Son ( models . Model ):
    name = models . TextField ()
    father = models . ForeignKey ( Father , on_delete = models . CASCADE )

播种机

 @ 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 " }
    }
]

请注意，以便在父母模型之前，必须将儿童优先级大于父母的优先级。以前不播种父母会引起错误！ fk的每个字段都必须是字段名称与其相关模型相同的字典。

这个播种机类可以处理模型之间的相当复杂的关系。让我们扩大家庭（双关语）：

模型

 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 )

播种机

 @ 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/GRANDSONSEEDER.JSON

[
    {
        "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 " }
        }
    }
]

csvfileserializereeder：

缓慢的一对一播种机

请注意， csv-file中的标题必须匹配serializer中的字段名称

此播种机用于注入序列化器来实现自定义创建逻辑

模型

 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)

播种机

 @SeederRegistry.register
class M3Seeder(seeders.CSVFileSerializerSeeder):
    id = 'M3Seeder'
    priority = 3
    serializer_class = M3Serializer
    csv_file_path = 'django_seeding_example/seeders_data/M3Seeder.csv'

SEEDERS_DATA/M3SEEDER.CSV

 title,description
t1,d1
t2,d2

JSONFILESERIALIZESEEDER：

缓慢的一对一播种机

请注意， json-file中的键必须匹配serializer中的字段名称

此播种机用于注入序列化器来实现自定义创建逻辑

模型

 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)

播种机

 @SeederRegistry.register
class M4Seeder(seeders.JSONFileSerializerSeeder):
    id = 'M4Seeder'
    priority = 4
    serializer_class = M4Serializer
    json_file_path = 'django_seeding_example/seeders_data/M4Seeder.json'

SEEDERS_DATA/M4SEEDER.JSON

 [
    {
        "title": "json t1",
        "description": "json d1"
    },
    {
        "title": "json t2",
        "description": "json d2"
    }
]

排出者（推荐）：

快速bulk_create播种机

模型

 class M5(models.Model):
    title = models.CharField(max_length=100, null=True)
    description = models.TextField(null=True)

播种机

 @SeederRegistry.register
class M5Seeder(seeders.EmptySeeder):
    id = 'M5Seeder'
    priority = 5
    model = M5
    records_count = 2

模型分子（推荐）：

快速bulk_create播种机

请注意， data类别中的键必须匹配model中的字段名称

模型

 class M6(models.Model):
    title = models.CharField(max_length=100)
    description = models.TextField()

播种机

 @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"
        },
    ]

SerializEreeder：

缓慢的一对一播种机

请注意， data类别中的键必须匹配serializer中的字段名称

此播种机用于注入序列化器来实现自定义创建逻辑

模型

 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)

播种机

 @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"
        },
    ]

播种机：

在这里，您可以按照种子方法写下逻辑

模型

 class Post(models.Model):
    content = models.TextField()


class Comment(models.Model):
    post = models.ForeignKey(Post, on_delete=models.CASCADE)
    content = models.TextField()

播种机

 @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')

贡献

如果您对如何改善Django播种有建议，或者想报告错误，请打开问题！我们希望所有的贡献。

有关更多信息，请查看贡献指南。

接触

Suliman Awad [email protected] LinkedIn

项目链接：https：//github.com/suliman-99/django-seeding

执照

麻省理工学院许可证

版权（C）2023 Suliman Awad

有关更多信息，请查看许可证文件。