Skip to content

seeder

django_spire.contrib.seeding.field.django.seeder

DjangoFieldLlmSeeder

Bases: BaseFieldSeeder

Source code in django_spire/contrib/seeding/field/base.py 
17
18
19
20
21
22
23
24
def __init__(
    self,
    fields: dict | None = None,
    default_to: str = 'llm'
) -> None:

    self.fields = self._normalize_fields(fields or {})
    self.default_to = default_to

keyword = FieldSeederTypesEnum.LLM class-attribute instance-attribute

field_prompt property

seed

Source code in django_spire/contrib/seeding/field/django/seeder.py 
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
def seed(self, model_seeder: Any, count: int = 1) -> list[dict]:

    include_fields = list(self.seeder_fields.keys())

    seed_intel_class = django_to_pydantic_model(
        model_class=model_seeder.model_class,
        base_class=BaseIntel,
        include_fields=include_fields
    )

    class SeedingIntel(BaseIntel):
        items: list[seed_intel_class]

        def __iter__(self):
            return iter(self.items)

    # Base parts of the prompt that are common between batches
    base_prompt = (
        Prompt()
        .heading('General Seeding Rules')
        .list(['Create data for each field provided.'])
        .heading('Field Rules & Context')
        .prompt(self.field_prompt)
    )

    # Instantiate the bot once
    bot = LlmFieldSeedingBot()

    if count <= 25:
        # Create a prompt for the full count since it's within a single batch
        prompt = (
            Prompt()
            .heading('Seed Count')
            .text(f'Create {count} {model_seeder.model_class.__name__}')
            .prompt(base_prompt)
        )

        intel_data = bot.process(
            prompt=prompt,
            intel_class=SeedingIntel
        )
    else:
        # Process in batches of 25 using futures. Seems like that is the limit for good results
        futures = []
        completed_futures = []
        max_futures = 3
        intel_data = []

        batch_size = 15
        total_batches = (count + batch_size - 1) // batch_size

        for batch_index in range(total_batches):
            batch_count = batch_size if (batch_index < total_batches - 1) else count - batch_size * batch_index

            batch_prompt = (
                Prompt()
                .heading('Seed Count')
                .text(f'Create {batch_count} {model_seeder.model_class.__name__}')
                .prompt(base_prompt)
            )

            future = bot.process_to_future(
                prompt=batch_prompt,
                intel_class=SeedingIntel
            )
            futures.append(future)

            # Only send max_futures calls at a time or when it's the last batch.
            if len(futures) >= max_futures or batch_index == total_batches - 1:
                print(f'-----> Seeding count {batch_count} for batch {batch_index + 1} of {total_batches}')
                for future in futures:
                    intel_data.extend(future.result)
                    completed_futures.append(future)

                futures = []

    return intel_data

DjangoFieldFakerSeeder

Bases: BaseFieldSeeder

Source code in django_spire/contrib/seeding/field/base.py 
17
18
19
20
21
22
23
24
def __init__(
    self,
    fields: dict | None = None,
    default_to: str = 'llm'
) -> None:

    self.fields = self._normalize_fields(fields or {})
    self.default_to = default_to

keyword = FieldSeederTypesEnum.FAKER class-attribute instance-attribute

seed

Source code in django_spire/contrib/seeding/field/django/seeder.py 
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
def seed(self, model_seeder: Any, count: int = 1) -> list[dict]:
    data = []

    for _ in range(count):
        row = {}

        for field_name, faker_config in self.seeder_fields.items():
            faker_method = faker_config[1:] if len(faker_config) > 1 else None

            try:
                row[field_name] = fake_model_field_value(
                    model_class=model_seeder.model_class,
                    field_name=field_name,
                    faker_method=faker_method
                )
            except Exception as e:
                message = f"Error generating faker value for field '{field_name}': {e}"
                raise ValueError(message) from None

        data.append(row)

    return data