djresttoolkit 0.5.0__tar.gz → 0.6.0__tar.gz

{djresttoolkit-0.5.0 → djresttoolkit-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: djresttoolkit
-Version: 0.5.0
+Version: 0.6.0
 Summary: A collection of Django and DRF utilities to simplify API development.
 Project-URL: Homepage, https://github.com/shaileshpandit141/djresttoolkit
 Project-URL: Documentation, https://shaileshpandit141.github.io/djresttoolkit
@@ -46,6 +46,7 @@ Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Python: >=3.13
+Requires-Dist: faker>=37.5.3
 Requires-Dist: pydantic>=2.11.7
 Provides-Extra: dev
 Requires-Dist: mypy; extra == 'dev'

{djresttoolkit-0.5.0 → djresttoolkit-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@
 
 [project]
 name = "djresttoolkit"
-version = "0.5.0"
+version = "0.6.0"
 description = "A collection of Django and DRF utilities to simplify API development."
 readme = { file = "README.md", content-type = "text/markdown" }
 license = { file = "LICENSE" }
@@ -46,6 +46,7 @@ keywords = [
 ]
 requires-python = ">=3.13"
 dependencies = [
+    "faker>=37.5.3",
     "pydantic>=2.11.7",
 ]
 

djresttoolkit-0.6.0/src/djresttoolkit/dbseed/models/__init__.py

@@ -0,0 +1,4 @@
+from ._base_seed_model import BaseSeedModel
+from ._gen import Field, Gen
+
+__all__ = ["BaseSeedModel", "Gen", "Field"]

djresttoolkit-0.6.0/src/djresttoolkit/dbseed/models/_base_seed_model.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from typing import Any
+
+from django.db.models import ForeignKey, ManyToManyField, Model, OneToOneField
+from pydantic import BaseModel
+
+
+class BaseSeedModel(BaseModel):
+    """
+    Base class for all fake data models.
+    Each subclass must define a `model` attribute.
+    """
+
+    class Meta:
+        model: type[Model]
+
+    def __init_subclass__(cls, **kwargs: Any) -> None:
+        super().__init_subclass__(**kwargs)
+        if not hasattr(cls, "Meta") or not hasattr(cls.Meta, "model"):
+            raise TypeError(
+                f"{cls.__name__} must define a Meta class with a Django model"
+            )
+
+    @classmethod
+    def get_meta(cls) -> type[Meta]:
+        """Class-level access."""
+        return cls.Meta
+
+    @classmethod
+    def create_instance(cls) -> tuple[dict[str, Any], list[ManyToManyField[Any, Any]]]:
+        """Handle ForeignKey, OneToOneField and ManyToMany relationship."""
+
+        # dump pydantic model to python dict
+        data = cls().model_dump()
+
+        # Handle ForeignKey and OneToOneField
+        for field in cls.get_meta().model._meta.get_fields():
+            if isinstance(field, (ForeignKey, OneToOneField)):
+                rel_model = field.remote_field.model
+                if rel_model.objects.exists():
+                    # For OneToOne, must ensure unique (pick unused relation)
+                    if isinstance(field, OneToOneField):
+                        used_ids = cls.get_meta().model.objects.values_list(
+                            field.name, flat=True
+                        )
+                        available = rel_model.objects.exclude(pk__in=used_ids)
+                        if available.exists():
+                            data[field.name] = available.order_by("?").first()
+                    else:  # Normal ForeignKey
+                        data[field.name] = rel_model.objects.order_by("?").first()
+
+        # Collect ManyToMany fields
+        m2m_fields: list[ManyToManyField[Any, Any]] = [
+            field
+            for field in cls.get_meta().model._meta.get_fields()
+            if isinstance(field, ManyToManyField)
+        ]
+        return data, m2m_fields

djresttoolkit-0.6.0/src/djresttoolkit/dbseed/models/_gen.py

@@ -0,0 +1,11 @@
+from faker import Faker
+from pydantic import Field as PydField
+
+
+class Generator:
+    @classmethod
+    def create_faker(cls) -> Faker:
+        return Faker()
+
+Gen = Generator.create_faker()
+Field = PydField

djresttoolkit-0.6.0/src/djresttoolkit/management/commands/dbseed.py

@@ -0,0 +1,115 @@
+import pkgutil
+from importlib import import_module
+from types import ModuleType
+from typing import Any
+
+from django.apps import apps
+from django.core.management.base import BaseCommand, CommandParser
+from django.db import transaction
+from django.db.models import Model, QuerySet
+
+from djresttoolkit.dbseed.models import BaseSeedModel
+
+
+class Command(BaseCommand):
+    help = "Seed the database with fake data for any Django model"
+
+    def add_arguments(self, parser: CommandParser) -> None:
+        """Add command arguments."""
+        parser.add_argument(
+            "--count",
+            type=int,
+            default=5,
+            help="Number of records per model",
+        )
+        parser.add_argument(
+            "--model",
+            type=str,
+            default=None,
+            help="Specific model name to seed (e.g., User, Product)",
+        )
+        parser.add_argument(
+            "--seed",
+            type=int,
+            default=None,
+            help="Optional Faker seed for reproducible data",
+        )
+
+    def handle(self, *args: Any, **options: Any) -> None:
+        """Handle ForeignKey, OneToOneField and ManyToMany relationship."""
+
+        count = options["count"]
+        model_name = options["model"]
+        seed = options["seed"]
+
+        if seed is not None:
+            from faker import Faker
+
+            faker = Faker()
+            faker.seed_instance(seed)
+
+        seed_model_classes: list[type[BaseSeedModel]] = []
+
+        # Discover all dbseed dirs in installed apps
+        for app_config in apps.get_app_configs():
+            try:
+                module: ModuleType = import_module(f"{app_config.name}.dbseed")
+            except ModuleNotFoundError:
+                continue  # app has no dbseed dir
+
+            # Iterate over modules in the dbseed package
+            for _, name, ispkg in pkgutil.iter_modules(module.__path__):
+                if ispkg:
+                    continue
+
+                submodule = import_module(f"{app_config.name}.dbseed.{name}")
+                for attr_name in dir(submodule):
+                    attr = getattr(submodule, attr_name)
+                    if (
+                        isinstance(attr, type)
+                        and issubclass(attr, BaseSeedModel)
+                        and attr is not BaseSeedModel
+                    ):
+                        # Filter by model name if provided
+                        if (
+                            not model_name
+                            or model_name.lower()
+                            == attr.__name__.replace("DBSeedModel", "").lower()
+                        ):
+                            seed_model_classes.append(attr)
+
+        if not seed_model_classes:
+            self.stdout.write(self.style.WARNING("No matching dbseed models found."))
+            return None
+
+        # Generate fake data for each discovered dbseed model
+        for dbseed_cls in seed_model_classes:
+            django_model = dbseed_cls.get_meta().model
+            created_count: int = 0
+
+            for _ in range(count):
+                try:
+                    with transaction.atomic():
+                        data, m2m_fields = dbseed_cls.create_instance()
+                        obj = django_model.objects.create(**data)
+                        created_count += 1
+
+                        # Assign ManyToMany fields
+                        for m2m_field in m2m_fields:
+                            rel_model = m2m_field.remote_field.model
+                            related_instances: QuerySet[Model] | list[Any] = (
+                                rel_model.objects.order_by("?")[:2]
+                                if rel_model.objects.exists()
+                                else []
+                            )
+                            getattr(obj, m2m_field.name).set(related_instances)
+                except Exception as error:
+                    self.stderr.write(
+                        f"Error creating {django_model.__name__} instance: {error}"
+                    )
+                    continue
+            self.stdout.write(
+                self.style.SUCCESS(
+                    f"{created_count} records inserted for {django_model.__name__}"
+                )
+            )