django-model-seeder 2.6.1__tar.gz

django_model_seeder-2.6.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Christian Garcia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

django_model_seeder-2.6.1/MANIFEST.in

@@ -0,0 +1,2 @@
+include README.md
+include LICENSE

django_model_seeder-2.6.1/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: django-model-seeder
+Version: 2.6.1
+Summary: A Django library powered by Data Seed PH for generating realistic, synthetic Philippine-based datasets directly into Django models.
+Author-email: "Christian G. Garcia" <iyaniyan03112003@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/christiangarcia0311/django-model-seeder
+Project-URL: Repository, https://github.com/christiangarcia0311/django-model-seeder.git
+Keywords: synthetic-data,database-seeding,testing
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: django
+Requires-Dist: data-seed-ph
+Requires-Dist: pyyaml
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-django>=4.0; extra == "dev"
+Dynamic: license-file
+
+## Django Model Seeder
+
+[![GitHub stars](https://img.shields.io/github/stars/christiangarcia0311/django-model-seeder?style=social)](https://github.com/christiangarcia0311/django-model-seeder/stargazers)
+[![GitHub issues](https://img.shields.io/github/issues/christiangarcia0311/django-model-seeder?style=flat)](https://github.com/christiangarcia0311/django-model-seeder/issues)
+![Static Badge](https://img.shields.io/badge/License-MIT-orange?style=flat)
+![Static Badge](https://img.shields.io/badge/Github-django_model_seeder-green?style=flat&logo=github)
+![Static Badge](https://img.shields.io/badge/Pypi-django_model_seeder-blue?style=flat&logo=pypi&logoColor=white)
+![Static Badge](https://img.shields.io/badge/Django-5.2+-green?style=flat&logo=django&logoColor=white)
+![Static Badge](https://img.shields.io/badge/Python-3.9+-blue?style=flat&logo=python&logoColor=white)
+[![Last commit](https://img.shields.io/github/last-commit/christiangarcia0311/django-model-seeder?style=flat)](https://github.com/christiangarcia0311/django-model-seeder/commits/main)
+[![Latest release](https://img.shields.io/github/v/release/christiangarcia0311/django-model-seeder?style=flat)](https://github.com/christiangarcia0311/django-model-seeder/releases/latest)
+
+**Command-based synthetic data generation and seeding for Django models using [data-seed-ph](https://github.com/christiangarcia0311/data-seed-ph).**
+
+>[!NOTE]
+> Designed for rapid database population in development environments, API testing, QA automation, and demo applications with seamless integration to Django's management command system.
+
+View full documentation: [Github](https://github.com/christiangarcia0311/django-model-seeder)
+

django_model_seeder-2.6.1/README.md

@@ -0,0 +1,19 @@
+## Django Model Seeder
+
+[![GitHub stars](https://img.shields.io/github/stars/christiangarcia0311/django-model-seeder?style=social)](https://github.com/christiangarcia0311/django-model-seeder/stargazers)
+[![GitHub issues](https://img.shields.io/github/issues/christiangarcia0311/django-model-seeder?style=flat)](https://github.com/christiangarcia0311/django-model-seeder/issues)
+![Static Badge](https://img.shields.io/badge/License-MIT-orange?style=flat)
+![Static Badge](https://img.shields.io/badge/Github-django_model_seeder-green?style=flat&logo=github)
+![Static Badge](https://img.shields.io/badge/Pypi-django_model_seeder-blue?style=flat&logo=pypi&logoColor=white)
+![Static Badge](https://img.shields.io/badge/Django-5.2+-green?style=flat&logo=django&logoColor=white)
+![Static Badge](https://img.shields.io/badge/Python-3.9+-blue?style=flat&logo=python&logoColor=white)
+[![Last commit](https://img.shields.io/github/last-commit/christiangarcia0311/django-model-seeder?style=flat)](https://github.com/christiangarcia0311/django-model-seeder/commits/main)
+[![Latest release](https://img.shields.io/github/v/release/christiangarcia0311/django-model-seeder?style=flat)](https://github.com/christiangarcia0311/django-model-seeder/releases/latest)
+
+**Command-based synthetic data generation and seeding for Django models using [data-seed-ph](https://github.com/christiangarcia0311/data-seed-ph).**
+
+>[!NOTE]
+> Designed for rapid database population in development environments, API testing, QA automation, and demo applications with seamless integration to Django's management command system.
+
+View full documentation: [Github](https://github.com/christiangarcia0311/django-model-seeder)
+

django_model_seeder-2.6.1/django_model_seeder.egg-info/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: django-model-seeder
+Version: 2.6.1
+Summary: A Django library powered by Data Seed PH for generating realistic, synthetic Philippine-based datasets directly into Django models.
+Author-email: "Christian G. Garcia" <iyaniyan03112003@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/christiangarcia0311/django-model-seeder
+Project-URL: Repository, https://github.com/christiangarcia0311/django-model-seeder.git
+Keywords: synthetic-data,database-seeding,testing
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: django
+Requires-Dist: data-seed-ph
+Requires-Dist: pyyaml
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-django>=4.0; extra == "dev"
+Dynamic: license-file
+
+## Django Model Seeder
+
+[![GitHub stars](https://img.shields.io/github/stars/christiangarcia0311/django-model-seeder?style=social)](https://github.com/christiangarcia0311/django-model-seeder/stargazers)
+[![GitHub issues](https://img.shields.io/github/issues/christiangarcia0311/django-model-seeder?style=flat)](https://github.com/christiangarcia0311/django-model-seeder/issues)
+![Static Badge](https://img.shields.io/badge/License-MIT-orange?style=flat)
+![Static Badge](https://img.shields.io/badge/Github-django_model_seeder-green?style=flat&logo=github)
+![Static Badge](https://img.shields.io/badge/Pypi-django_model_seeder-blue?style=flat&logo=pypi&logoColor=white)
+![Static Badge](https://img.shields.io/badge/Django-5.2+-green?style=flat&logo=django&logoColor=white)
+![Static Badge](https://img.shields.io/badge/Python-3.9+-blue?style=flat&logo=python&logoColor=white)
+[![Last commit](https://img.shields.io/github/last-commit/christiangarcia0311/django-model-seeder?style=flat)](https://github.com/christiangarcia0311/django-model-seeder/commits/main)
+[![Latest release](https://img.shields.io/github/v/release/christiangarcia0311/django-model-seeder?style=flat)](https://github.com/christiangarcia0311/django-model-seeder/releases/latest)
+
+**Command-based synthetic data generation and seeding for Django models using [data-seed-ph](https://github.com/christiangarcia0311/data-seed-ph).**
+
+>[!NOTE]
+> Designed for rapid database population in development environments, API testing, QA automation, and demo applications with seamless integration to Django's management command system.
+
+View full documentation: [Github](https://github.com/christiangarcia0311/django-model-seeder)
+

django_model_seeder-2.6.1/django_model_seeder.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+django_model_seeder.egg-info/PKG-INFO
+django_model_seeder.egg-info/SOURCES.txt
+django_model_seeder.egg-info/dependency_links.txt
+django_model_seeder.egg-info/requires.txt
+django_model_seeder.egg-info/top_level.txt
+django_seeder/__init__.py
+django_seeder/config_parser.py
+django_seeder/loaders.py
+django_seeder/seeder.py
+django_seeder/management/__init__.py
+django_seeder/management/commands/__init__.py
+django_seeder/management/commands/clear_seeds.py
+django_seeder/management/commands/list_seeds.py
+django_seeder/management/commands/seed_models.py

django_model_seeder-2.6.1/django_model_seeder.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

django_model_seeder-2.6.1/django_model_seeder.egg-info/requires.txt

@@ -0,0 +1,7 @@
+django
+data-seed-ph
+pyyaml
+
+[dev]
+pytest>=7.0
+pytest-django>=4.0

django_model_seeder-2.6.1/django_model_seeder.egg-info/top_level.txt

@@ -0,0 +1 @@
+django_seeder

django_model_seeder-2.6.1/django_seeder/__init__.py

@@ -0,0 +1,19 @@
+'''
+Django Model Seeder
+-------------------
+
+A Django library powered by Data Seed PH for generating realistic, 
+synthetic Philippine-based datasets directly into Django models
+
+Information
+-----------
+@author: Christian G. Garcia
+@github: github.com/christiangarcia0311/django-model-seeder
+'''
+
+from .seeder import ModelSeeder
+from .loaders import BulkModelLoader
+from .config_parser import ConfigParser
+
+__version__ = '3.1.0'
+__all__ = ['ModelSeeder', 'BulkModelLoader', 'ConfigParser']

django_model_seeder-2.6.1/django_seeder/config_parser.py

@@ -0,0 +1,81 @@
+'''
+Config Parser
+
+This module provides utilities for loading, validating, and merging configuration
+files in JSON and YAML formats. It also includes preprocessing logic to convert
+numeric range lists into tuples for easier downstream data handling.
+
+Information
+-----------
+@author: Christian G. Garcia
+@github: github.com/christiangarcia/django-model-seeder
+'''
+
+
+import json
+import yaml
+from pathlib import Path
+from typing import Dict, Any
+
+
+class ConfigParser:
+    
+    @staticmethod
+    def load_json(filepath: str) -> Dict[str, Any]:
+        with open(filepath, 'r') as f:
+            data = json.load(f)
+        return ConfigParser._convert_to_tuples(data)
+
+    @staticmethod
+    def load_yaml(filepath: str) -> Dict[str, Any]:
+        with open(filepath, 'r') as f:
+            return yaml.safe_load(f)
+
+    @staticmethod
+    def _convert_to_tuples(config: Dict[str, Any]) -> Dict[str, Any]:
+        for model_name, model_config in config.items():
+            if isinstance(model_config, dict) and 'mapping' in model_config:
+                mapping = model_config['mapping']
+                for field_name, value in mapping.items():
+                    if isinstance(value, list) and len(value) >= 2:
+                        if all(isinstance(v, (int, float)) or v == 'float' for v in value):
+                            mapping[field_name] = tuple(value)
+        return config
+
+    @staticmethod
+    def load_config(filepath: str) -> Dict[str, Any]:
+        path = Path(filepath)
+        
+        if path.suffix == '.json':
+            return ConfigParser.load_json(filepath)
+        elif path.suffix in ['.yaml', '.yml']:
+            return ConfigParser.load_yaml(filepath)
+        else:
+            raise ValueError(f"Unsupported config format: {path.suffix}")
+
+    @staticmethod
+    def validate_config(config: Dict[str, Any]) -> bool:
+        if not isinstance(config, dict):
+            return False
+        
+        for model_name, model_config in config.items():
+            if not isinstance(model_config, dict):
+                return False
+            if 'rows' not in model_config or 'mapping' not in model_config:
+                return False
+            if not isinstance(model_config['mapping'], dict):
+                return False
+        
+        return True
+
+    @staticmethod
+    def merge_configs(base_config: Dict[str, Any], override_config: Dict[str, Any]) -> Dict[str, Any]:
+        merged = base_config.copy()
+        
+        for model_name, model_config in override_config.items():
+            if model_name in merged:
+                merged[model_name].update(model_config)
+            else:
+                merged[model_name] = model_config
+        
+        return merged

django_model_seeder-2.6.1/django_seeder/loaders.py

@@ -0,0 +1,84 @@
+'''
+Loaders module
+
+Provides a bulk loader utility for registering Django models and
+executing seed operations using ModelSeeder instances
+
+Information
+-----------
+@author: Christian G. Garcia
+@github: github.com/christiangarcia0311/django-model-seeder
+'''
+
+from django.apps import apps 
+from django.db.models import Model
+from typing import Dict, List, Type, Any, Callable
+from .seeder import ModelSeeder
+
+
+class BulkModelLoader:
+    
+    def __init__(self):
+        self.seeders = {}
+        self.results = {}
+        
+    def register(self, model: Type[Model])-> ModelSeeder:
+        seeder = ModelSeeder(model)
+        self.seeders[model.__name__] = seeder 
+        return seeder 
+    
+    def load_model(self, app_label: str, model_name: str) -> ModelSeeder:
+        model = apps.get_model(app_label, model_name)
+        return self.register(model)
+    
+    def seed_all(
+        self,
+        configurations: Dict[str, Dict[str, Any]],
+        relations_map: Dict[str, Dict[str, Callable]] = None
+    ) -> Dict[str, List[Model]]:
+        
+        relations_map = relations_map or {}
+        results = {}
+        
+        for model_name, config in configurations.items():
+            if model_name in self.seeders:
+                seeder = self.seeders[model_name]
+                rows = config.get('rows', 10)
+                mapping = config.get('mapping', {})
+                relations = relations_map.get(model_name, {})
+                
+                if relations:
+                    results[model_name] = seeder.seed_with_relations(rows, mapping, relations)
+                else:
+                    results[model_name] = seeder.seed(rows, mapping)
+                
+                self.results[model_name] = results[model_name]
+        
+        return results 
+    
+    def seed_model(self, model_name: str, rows: int, mapping: Dict[str, Any]) -> List[Model]:
+        if model_name in self.seeders:
+            result = self.seeders[model_name].seed(rows, mapping, relations_map=None)
+            self.results[model_name] = result
+            return result
+        return []
+    
+    def get_results(self, model_name: str = None) -> Dict[str, List[Model]] | List[Model]:
+        if model_name:
+            return self.results.get(model_name, [])
+        return self.results
+    
+    def clear(self, model_name: str = None):
+        if model_name and model_name in self.seeders:
+            self.seeders[model_name].model.objects.all().delete()
+            
+            if model_name in self.results:
+                del self.results[model_name]
+        else:
+            for seeder in self.seeders.values():
+                seeder.model.objects.all().delete()
+            self.results.clear()
+            
+    def list_models(self) -> List[str]:
+        return list(self.seeders.keys())
+        

django_model_seeder-2.6.1/django_seeder/management/commands/clear_seeds.py

@@ -0,0 +1,76 @@
+'''
+Clear command
+
+This management command provides utilities to delete (clear) seeded or existing
+data from Django models. It supports clearing a specific model or all models
+across all installed apps, with optional confirmation prompts for safety.
+'''
+
+from django.core.management.base import BaseCommand, CommandError
+from django.apps import apps
+
+
+class Command(BaseCommand):
+    help = 'Clear seeded data from Django models'
+
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--model',
+            type=str,
+            help='Specific model to clear (format: ModelName)'
+        )
+        
+        parser.add_argument(
+            '--app',
+            type=str,
+            help='Django app label'
+        )
+        
+        parser.add_argument(
+            '--all',
+            action='store_true',
+            help='Clear all data from all models (dangerous)'
+        )
+        
+        parser.add_argument(
+            '--confirm',
+            action='store_true',
+            help='Skip confirmation prompt'
+        )
+
+    def handle(self, *args, **options):
+        if options['all']:
+            if not options['confirm']:
+                confirm = input('Clear ALL data from ALL models? (yes/no): ')
+                if confirm.lower() != 'yes':
+                    self.stdout.write('Aborted')
+                    return
+            
+            count = 0
+            for app_config in apps.get_app_configs():
+                for model in app_config.get_models():
+                    deleted, _ = model.objects.all().delete()
+                    count += deleted
+                    self.stdout.write(f'Cleared {model.__name__}')
+            
+            self.stdout.write(self.style.SUCCESS(f'Total records deleted: {count}'))
+        
+        elif options['model'] and options['app']:
+            try:
+                model = apps.get_model(options['app'], options['model'])
+                count = model.objects.count()
+                
+                if not options['confirm']:
+                    confirm = input(f'Clear {count} records from {options["model"]}? (yes/no): ')
+                    if confirm.lower() != 'yes':
+                        self.stdout.write('Aborted')
+                        return
+                
+                model.objects.all().delete()
+                self.stdout.write(self.style.SUCCESS(f'Cleared {options["model"]}'))
+            except LookupError:
+                raise CommandError(f'Model not found: {options["app"]}.{options["model"]}')
+        else:
+            self.stdout.write(
+                self.style.ERROR('Either --all or both --model and --app must be provided')
+            )  

django_model_seeder-2.6.1/django_seeder/management/commands/list_seeds.py

@@ -0,0 +1,61 @@
+'''
+List command
+
+
+This management command lists all available Django models that can be used
+for seeding or data operations. It supports filtering by app and optionally
+displaying record counts for each model.
+'''
+
+from django.core.management.base import BaseCommand, CommandError
+from django.apps import apps 
+
+
+class Command(BaseCommand):
+    
+    help = 'List all available Django models for seeding'
+    
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--app',
+            type=str,
+            default=None,
+            help='Filter by specific app label name'
+        )
+        parser.add_argument(
+            '--count',
+            action='store_true',
+            help='Show record count each model'
+        )
+        
+    def handle(self, *args, **options):
+        app_name_filter = options.get('app')
+        show_record_count = options.get('count', False)
+        
+        self.stdout.write(
+            self.style.SUCCESS('Available for seeding:\n')
+        )
+        
+        for app_config in apps.get_app_configs():
+            if app_name_filter and app_config.label != app_name_filter:
+                continue
+            
+            models = app_config.get_models()
+            
+            if models:
+                self.stdout.write(
+                    self.style.WARNING(f'{app_config.label}: ')
+                )
+                
+                for model in models:
+                    model_name = model.__name__ 
+                    count = model.objects.count() if show_record_count else None 
+                    
+                    if show_record_count:
+                        self.stdout.write(
+                            f'{model_name} ({count} records)'
+                        )
+                    else: 
+                        self.stdout.write(f'{model_name}')
+                self.stdout.write('')
+        

django_model_seeder-2.6.1/django_seeder/management/commands/seed_models.py

@@ -0,0 +1,196 @@
+'''
+Seed command
+
+
+This management command seeds Django models with synthetic data using a configurable
+mapping system. It supports JSON/YAML configuration files, direct model targeting,
+data clearing, dry-run previews, and relational data seeding.
+'''
+
+
+
+from django.core.management.base import BaseCommand, CommandError
+from django.apps import apps 
+from django_seeder import BulkModelLoader, ConfigParser
+
+
+class Command(BaseCommand):
+    
+    help = 'Seed Django models with synthetic data'
+    
+    def add_arguments(self, parser):
+        parser.add_argument(
+            '--config',
+            type=str,
+            default=None,
+            help='Path to seed configuration file (JSON or YAML)'
+        )
+        parser.add_argument(
+            '--model',
+            type=str,
+            default=None,
+            help='Seed specific model (format: app_label.ModelName)'
+        )
+        parser.add_argument(
+            '--rows',
+            type=int,
+            default=10,
+            help='Number of rows to seed (default: 10)'
+        )
+        parser.add_argument(
+            '--app',
+            type=str,
+            default=None,
+            help='Django app label name'
+        )
+        parser.add_argument(
+            '--clear',
+            action='store_true',
+            help='Clear existing data in models before seeding'
+        )
+        parser.add_argument(
+            '--dry-run',
+            action='store_true',
+            help='Show what would be seeded without actually seeding'
+        )
+        parser.add_argument(
+            '--verbose',
+            action='store_true',
+            help='Show detailed output'
+        )
+        
+    def handle(self, *args, **options):
+        loader = BulkModelLoader()
+        config = None 
+        
+        if options['config']:
+            try:
+                config = ConfigParser.load_config(options['config'])
+                
+                if not ConfigParser.validate_config(config):
+                    raise CommandError('Invalid file configuration format')
+                
+                for model_name in config.keys():
+                    try:
+                        app_label = config[model_name].get('app_label', 'core')
+                        model = apps.get_model(app_label, model_name)
+                        loader.register(model)
+                    except LookupError:
+                        raise CommandError(f'Model not found: {app_label}.{model_name}')
+                
+                self.stdout.write(
+                    self.style.SUCCESS(f'Loaded config from {options["config"]}')
+                )
+            except FileNotFoundError:
+                raise CommandError(f'Configuration file not found: {options["config"]}')
+            except Exception as e:
+                raise CommandError(f'Error loading config: {str(e)}')
+            
+        elif options['model'] and options['app']:
+            app_label = options['app']
+            model_name = options['model']
+            rows = options['rows']
+            
+            try:
+                model = apps.get_model(app_label, model_name) 
+                loader.register(model)
+                
+                config = {
+                    model_name: {
+                        'rows': rows,
+                        'mapping': self._get_default_mapping(model)
+                    }
+                }
+                
+                self.stdout.write(
+                    self.style.WARNING(
+                        f'No mapping provided. Using auto-detected fields for {model_name}'
+                    )
+                )
+            except LookupError:
+                raise CommandError(f'Model not found: {app_label}.{model_name}')
+            
+        else:
+            raise CommandError('Either --config or both --model and --app must be provided')
+        
+        if not config:
+            raise CommandError('No configuration available')
+        
+        if options['clear']:
+            self.stdout.write(
+                self.style.WARNING('Clearing existing data...')
+            )
+            
+            for model_name in loader.seeders:
+                loader.clear(model_name)
+            
+            self.stdout.write(
+                self.style.SUCCESS('Data successfully cleared')
+            )
+        
+        if options['dry_run']:
+            self.stdout.write(
+                self.style.WARNING('DRY RUN MODE')
+            )
+            
+            for model_name, model_config in config.items():
+                rows = model_config.get('rows', 10)
+                
+                self.stdout.write(
+                    f'  Would seed {rows} rows in {model_name}'
+                )
+            return 
+        
+        try:
+            results = {}
+            
+            for model_name, model_config in config.items():
+                seeder = loader.seeders[model_name]
+                rows = model_config.get('rows', 10)
+                mapping = model_config.get('mapping', {})
+                relations = model_config.get('relations', {})
+                
+                if relations:
+                    relation_resolvers = {}
+                    for rel_field, rel_model_name in relations.items():
+                        if rel_model_name in results:
+                            instances = results[rel_model_name]
+                            relation_resolvers[rel_field] = lambda: instances[__import__('random').randint(0, len(instances) - 1)]
+                    
+                    result = seeder.seed_with_relations(rows, mapping, relation_resolvers)
+                else:
+                    result = seeder.seed(rows, mapping)
+                
+                results[model_name] = result
+            
+            self.stdout.write(
+                self.style.SUCCESS('Seeding successfully completed')
+            )
+            
+            for model_name, instances in results.items():
+                self.stdout.write(
+                    f'{model_name}: {len(instances)} rows seeded'
+                )
+            
+            if options['verbose']:
+                self.stdout.write('\nDetailed Results')
+                
+                for model_name, instances in results.items():
+                    self.stdout.write(f'\n{model_name}')
+                    
+                    for index, instance in enumerate(instances[:3], 1):
+                        self.stdout.write(f' {index}. {instance}')
+                    
+                    if len(instances) > 3:
+                        self.stdout.write(f' ... and {len(instances) - 3} more')
+        
+        except Exception as e:
+            raise CommandError(f'Error during seeding: {str(e)}')
+    
+    def _get_default_mapping(self, model):
+        mapping = {}
+        for field in model._meta.get_fields():
+            if field.many_to_one or field.one_to_one or field.many_to_many:
+                continue
+            mapping[field.name] = field.name
+        return mapping

django_model_seeder-2.6.1/django_seeder/seeder.py

@@ -0,0 +1,113 @@
+'''
+Seeder Module
+
+This module provides the core functionality for generating and inserting
+synthetic data into Django models. It is designed to simplify database
+seeding during development and testing by automatically generating
+structured datasets and converting them into Django ORM model instances.
+
+Information
+-----------
+@author: Christian G. Garcia
+@github: github.com/christiangarcia0311/django-model-seeder
+'''
+
+
+from seed import Dataset
+from django.db.models import Model 
+from typing import Dict, List, Type, Any, Callable
+
+
+class ModelSeeder:
+    
+    def __init__(self, model: Type[Model]):
+        self.model = model
+        self.dataset = Dataset()
+        self.field_mapping = {}
+        
+        self._introspect_fields()
+        
+    def _introspect_fields(self):
+        for field in self.model._meta.get_fields():
+            if field.many_to_one or field.one_to_one:
+                continue
+            
+            self.field_mapping[field.name] = None 
+            
+    def seed(self, rows: int, mapping: Dict[str, Any]) -> List[Model]:
+        data_generator = self.dataset.generate(rows, mapping)
+        
+        instances = []
+        
+        for index, row in data_generator.iterrows():
+            kwargs = {}
+
+            for field_name, value in row.to_dict().items():
+                if field_name in self.field_mapping:
+                    kwargs[field_name] = value
+                    
+            instance = self.model(**kwargs)
+            instances.append(instance)
+            
+        self.model.objects.bulk_create(instances)
+        return instances
+    
+    def seed_with_relations(
+        self,
+        rows: int,
+        mapping: Dict[str, Any],
+        relations: Dict[str, Callable] = None 
+    ) -> List[Model]:
+        data_generator = self.dataset.generate(rows, mapping)
+        
+        instances = []
+        
+        for index, row in data_generator.iterrows():
+            kwargs = {}
+            
+            for field_name, value in row.to_dict().items():
+                if field_name in self.field_mapping:
+                    kwargs[field_name] = value
+                
+            if relations:
+                for relation_field, resolver_func in relations.items():
+                    try:
+                        kwargs[relation_field] = resolver_func()
+                    except Exception as e:
+                        print(f'Warning: Could not resolve relation {relation_field}: {e}')
+                        continue 
+                    
+            instance = self.model(**kwargs)
+            instances.append(instance)
+        
+        self.model.objects.bulk_create(instances)
+        return instances 
+    
+    def seed_with_validation(
+        self,
+        rows: int,
+        mapping: Dict[str, Any],
+        validator: Callable = None 
+    ) -> List[Model]:
+        data_generator = self.dataset.generate(rows, mapping)
+        
+        instances = []
+        
+        for index, row in data_generator.iterrows():
+            kwargs = {}
+            
+            for field_name, value in row.to_dict().items():
+                if field_name in self.field_mapping:
+                    kwargs[field_name] = value
+                    
+            if validator and not validator(kwargs):
+                continue 
+            
+            instance = self.model(**kwargs)
+            instances.append(instance)
+        
+        self.model.objects.bulk_create(instances)
+        return instances 
+    
+
+

django_model_seeder-2.6.1/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "django-model-seeder"
+version = "2.6.1"
+description = "A Django library powered by Data Seed PH for generating realistic, synthetic Philippine-based datasets directly into Django models."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+authors = [{name = "Christian G. Garcia", email = "iyaniyan03112003@gmail.com"}]
+dependencies = [
+    "django",
+    "data-seed-ph",
+    "pyyaml",
+]
+keywords = ["synthetic-data", "database-seeding", "testing"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-django>=4.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/christiangarcia0311/django-model-seeder"
+Repository = "https://github.com/christiangarcia0311/django-model-seeder.git"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["django_seeder*"]
+exclude = ["fixtures*", "tests*"]

django_model_seeder-2.6.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+