django-authnest 0.1.0__tar.gz

django_authnest-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mithalesh Pal
+
+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_authnest-0.1.0/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: django-authnest
+Version: 0.1.0
+Summary: Reusable Django REST auth: email/phone/username login, JWT, email verification, password flows, profile, soft delete.
+Author-email: Mithalesh Pal <mithleshpallearning@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/mith1995/custom-auth
+Project-URL: Issues, https://github.com/mith1995/custom-auth/issues
+Keywords: django,drf,authentication,jwt,auth
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 5.1
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: django>=5.1
+Requires-Dist: djangorestframework
+Requires-Dist: djangorestframework-simplejwt
+Requires-Dist: pillow
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-django; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Dynamic: license-file

django_authnest-0.1.0/authnest/admin.py

@@ -0,0 +1,143 @@
+from django.contrib import admin, messages
+from django.contrib.auth.admin import UserAdmin as DjangoUserAdmin
+
+from django import forms
+from django.contrib.auth.forms import BaseUserCreationForm
+
+from .conf import authnest_settings
+
+from .models import User
+from .utils import normalize_email, normalize_phone
+
+
+class DeletedFilter(admin.SimpleListFilter):
+    title = "account status"
+    parameter_name = "account"
+
+    def lookups(self, request, model_admin):
+        return [("alive", "Alive"), ("deleted", "Soft deleted")]
+
+    def queryset(self, request, queryset):
+        if self.value() == "alive":
+            return queryset.alive()
+        if self.value() == "deleted":
+            return queryset.deleted()
+        return queryset
+
+class AdminUserCreationForm(BaseUserCreationForm):
+    class Meta(BaseUserCreationForm.Meta):
+        model = User
+        fields = ("username", "email", "phone")
+
+    def clean_email(self):
+        email = normalize_email(self.cleaned_data.get("email"))
+        # all_objects: soft-deleted user ki email bhi reserved hai
+        if email and User.all_objects.filter(email__iexact=email).exists():
+            raise forms.ValidationError("Is email se account pehle se maujood hai.")
+        return email
+
+    def clean_phone(self):
+        phone = normalize_phone(self.cleaned_data.get("phone"))
+        if phone and User.all_objects.filter(phone=phone).exists():
+            raise forms.ValidationError("Is phone number se account pehle se maujood hai.")
+        return phone
+
+    def clean(self):
+        cleaned = super().clean()
+        if not cleaned.get("email") and not cleaned.get("phone"):
+            raise forms.ValidationError(
+                "Email ya phone mein se kam se kam ek dena zaroori hai."
+            )
+        return cleaned
+
+@admin.register(User)
+class UserAdmin(DjangoUserAdmin):
+    list_display = (
+        "identifier", "email", "phone", "is_staff", "is_active",
+        "is_email_verified", "status", "date_joined",
+    )
+    list_filter = (DeletedFilter, "is_staff", "is_active", "is_email_verified")
+    search_fields = ("email", "phone", "username", "first_name", "last_name")
+    ordering = ("-date_joined",)
+    readonly_fields = ("last_login", "date_joined", "deleted_at")
+    filter_horizontal = ("groups", "user_permissions")
+    actions = ["restore_users"]
+
+    fieldsets = (
+        (None, {"fields": ("username", "password")}),
+        ("Identity", {"fields": ("email", "phone", "is_email_verified", "is_phone_verified")}),
+        ("Profile", {"fields": ("first_name", "last_name", "dob", "profile_picture")}),
+        ("Permissions", {"fields": ("is_active", "is_staff", "is_superuser", "groups", "user_permissions")}),
+        ("Dates", {"fields": ("last_login", "date_joined", "deleted_at")}),
+    )
+
+    def get_queryset(self, request):
+        # Soft delete on ho to all_objects (deleted bhi dikhein), off ho to sirf alive
+        manager = (
+            self.model.all_objects
+            if authnest_settings.SOFT_DELETE
+            else self.model.objects
+        )
+        queryset = manager.all()
+        ordering = self.get_ordering(request)
+        return queryset.order_by(*ordering) if ordering else queryset
+
+    def get_list_display(self, request):
+        if authnest_settings.SOFT_DELETE:
+            return self.list_display
+        return [column for column in self.list_display if column != "status"]
+
+    def get_list_filter(self, request):
+        if authnest_settings.SOFT_DELETE:
+            return self.list_filter
+        return [item for item in self.list_filter if item is not DeletedFilter]
+
+    def get_actions(self, request):
+        actions = super().get_actions(request)
+        if not authnest_settings.SOFT_DELETE:
+            actions.pop("restore_users", None)
+            actions.pop("hard_delete_users", None)
+        return actions
+
+    def get_fieldsets(self, request, obj=None):
+        fieldsets = super().get_fieldsets(request, obj)
+        if obj is None or authnest_settings.SOFT_DELETE:
+            return fieldsets
+        return [
+            (
+                name,
+                {
+                    **options,
+                    "fields": tuple(f for f in options["fields"] if f != "deleted_at"),
+                },
+            )
+            for name, options in fieldsets
+        ]
+
+    def has_add_permission(self, request):
+        # Users registration ya createsuperuser se bante hain, admin me nahi
+        return False
+
+    add_form = AdminUserCreationForm
+    add_fieldsets = (
+        (
+            None,
+            {
+                "classes": ("wide",),
+                "fields": ("username", "email", "phone", "password1", "password2"),
+            },
+        ),
+    )
+
+    @admin.display(description="User")
+    def identifier(self, obj):
+        return str(obj)
+
+    @admin.display(description="Status")
+    def status(self, obj):
+        return "Deleted" if obj.is_deleted else "Alive"
+
+    @admin.action(description="Restore selected users")
+    def restore_users(self, request, queryset):
+        count = queryset.deleted().restore()
+        self.message_user(request, f"{count} user restore ho gaye.", messages.SUCCESS)

django_authnest-0.1.0/authnest/apps.py

@@ -0,0 +1,10 @@
+from django.apps import AppConfig
+
+class AuthnestConfig(AppConfig):
+    name = "authnest"
+    default_auto_field = "django.db.models.BigAutoField"
+    verbose_name = "Authnest"
+
+    def ready(self):
+        from .conf import authnest_settings
+        authnest_settings.validate()

django_authnest-0.1.0/authnest/backends.py

@@ -0,0 +1,46 @@
+from django.contrib.auth import get_user_model
+from django.contrib.auth.backends import ModelBackend
+
+from .conf import authnest_settings
+from .utils import normalize_phone, normalize_email
+
+class AuthnestBackend(ModelBackend):
+    """Email / phone / username se login. Allowed methods settings se aate hain."""
+
+    def authenticate(self, request, username = None, password = None, scope="admin", **kwargs):
+        
+        if scope not in ("user", "admin") or not username or password is None:
+            return None
+        
+        UserModel = get_user_model()
+        user = self._find_user(UserModel, username.strip(), scope)
+        
+        if user is None:
+            # User na mile tab bhi hash chalao, taaki response time se pata na chale
+            UserModel().set_password(password)
+            return None
+
+        if user.check_password(password) and self.user_can_authenticate(user):
+            return user
+
+        return None
+
+    def _find_user(self, UserModel, identifier, scope):
+        if scope == "user":
+            allowed = authnest_settings.USER_LOGIN_METHODS
+        else:
+            allowed = authnest_settings.ADMIN_LOGIN_METHODS
+
+        lookups = []
+        if "email" in allowed and "@" in identifier:
+            lookups.append({"email__iexact": normalize_email(identifier)})
+        if "phone" in allowed and "@" not in identifier:
+            lookups.append({"phone": normalize_phone(identifier)})
+        if "username" in allowed:
+            lookups.append({"username": identifier})
+
+        for lookup in lookups:
+            user = UserModel._default_manager.filter(**lookup).first()
+            if user is not None and user.is_staff == (scope == "admin"):
+                return user
+        return None

django_authnest-0.1.0/authnest/conf.py

@@ -0,0 +1,97 @@
+from django.conf import settings
+from django.core.exceptions import ImproperlyConfigured
+
+DEFAULTS = {
+    "SOFT_DELETE": True,
+    "USER_LOGIN_METHODS": ["email"],
+    "ADMIN_LOGIN_METHODS": ["username"],
+    "REQUIRE_EMAIL_VERIFICATION": True,
+    "ENABLE_2FA": False,
+    "SEND_EMAILS_ASYNC": False,
+    "FRONTEND_URL": "http://localhost:5173",
+    "VERIFY_EMAIL_PATH": "/verify-email", # frontend ka route jahan verify link khulega (jaise /verify-email)
+    "RESET_PASSWORD_PATH": "/reset-password", # reset password page ka route (jaise /reset-password)
+    "EMAIL_VERIFICATION_TIMEOUT": 24 * 3600, # verify link kitne seconds me expire ho (jaise 1 din)
+    "PASSWORD_RESET_TIMEOUT": 3600, # reset link ki expiry (jaise 1 ghanta)
+    "ACCESS_TOKEN_LIFETIME": 15 * 60,           # seconds (15 minute)
+    "REFRESH_TOKEN_LIFETIME": 7 * 24 * 3600,    # seconds (7 din)
+    "REFRESH_TOKEN_IN_COOKIE": True,            # True: httpOnly cookie, False: response body
+    "REFRESH_TOKEN_ROTATION": True,             # har refresh par naya token, purana blacklist
+    "REFRESH_COOKIE_NAME": "authnest_refresh",
+    "REFRESH_COOKIE_PATH": "/",
+    "REFRESH_COOKIE_SECURE": None,              # None = auto (DEBUG band ho to Secure)
+    "REFRESH_COOKIE_SAMESITE": "Lax",
+    "PROFILE_PICTURE_MAX_SIZE": 2 * 1024 * 1024, # 2MB
+    "CONFIRM_EMAIL_CHANGE_PATH": "/confirm-email-change",
+}  
+
+ALLOWED_USER_LOGIN_METHODS = {"email", "phone"}
+ALLOWED_ADMIN_LOGIN_METHODS = {"email", "username"}
+
+class AuthnestSettings:
+    def __getattr__(self, name):
+        # settings.py me Authnest na ho to khali dict (lazy: access ke time padha)
+        user_settings = getattr(settings, "AUTHNEST", {})
+
+        if name in user_settings:
+            return user_settings[name]
+        if name in DEFAULTS:
+            return DEFAULTS[name]
+        raise AttributeError(f"Invalid Authnest setting: '{name}'")
+
+    def validate(self):
+        self.validate_methods("USER_LOGIN_METHODS", ALLOWED_USER_LOGIN_METHODS)
+        self.validate_methods("ADMIN_LOGIN_METHODS", ALLOWED_ADMIN_LOGIN_METHODS)
+
+        if not isinstance(self.SOFT_DELETE, bool):
+            raise ImproperlyConfigured(
+                "AUTHNEST['SOFT_DELETE'] must be True or False."
+            )
+
+        for name in ("ACCESS_TOKEN_LIFETIME", "REFRESH_TOKEN_LIFETIME"):
+            value = getattr(self, name)
+            if isinstance(value, bool) or not isinstance(value, int) or value <= 0:
+                raise ImproperlyConfigured(
+                    f"AUTHNEST['{name}'] must be a positive integer (seconds)."
+                )
+
+        for name in ("REFRESH_TOKEN_IN_COOKIE", "REFRESH_TOKEN_ROTATION"):
+            if not isinstance(getattr(self, name), bool):
+                raise ImproperlyConfigured(
+                    f"AUTHNEST['{name}'] must be True or False."
+                )
+
+        if self.REFRESH_COOKIE_SAMESITE not in ("Lax", "Strict", "None"):
+            raise ImproperlyConfigured(
+                "AUTHNEST['REFRESH_COOKIE_SAMESITE'] must be 'Lax', 'Strict', or 'None'."
+            )
+
+        if "rest_framework_simplejwt.token_blacklist" not in settings.INSTALLED_APPS:
+            raise ImproperlyConfigured(
+                "Add 'rest_framework_simplejwt.token_blacklist' to INSTALLED_APPS "
+                "(Authnest needs it for logout and refresh token rotation)."
+            )
+
+        size = self.PROFILE_PICTURE_MAX_SIZE
+        if isinstance(size, bool) or not (isinstance(size, int)) or size <= 0:
+            raise ImproperlyConfigured(
+                f"AUTHNEST['PROFILE_PICTURE_MAX_SIZE'] must be a positive integer (bytes)."
+            )
+        
+    def validate_methods(self, setting_name, allowed):
+        methods = getattr(self, setting_name)
+
+        if not isinstance(methods, (list, tuple, set)) or not methods:
+            raise ImproperlyConfigured(
+                f"AUTHNEST['{setting_name}'] must be a non-empty list. "
+                f"Allowed values: {sorted(allowed)}"
+            )
+
+        invalid = set(methods) - allowed
+        if invalid:
+            raise ImproperlyConfigured(
+                f"AUTHNEST['{setting_name}'] has invalid values {sorted(invalid)}. "
+                f"Allowed values: {sorted(allowed)}"
+            )
+
+authnest_settings = AuthnestSettings()

django_authnest-0.1.0/authnest/exceptions.py

@@ -0,0 +1,16 @@
+from rest_framework import status
+from rest_framework.exceptions import APIException
+
+class InvalidCredentials(APIException):
+    status_code = status.HTTP_401_UNAUTHORIZED
+    default_detail = {
+        "detail": "Login details galat hain",
+        "code": "invalid_credentials",
+    }
+
+class EmailNotVerified(APIException):
+    status_code = status.HTTP_403_FORBIDDEN
+    default_detail = {
+        "detail": "Pehle apna email verify karein.",
+        "code": "email_not_verified",
+    }

django_authnest-0.1.0/authnest/managers.py

@@ -0,0 +1,100 @@
+import uuid
+
+from django.contrib.auth.models import BaseUserManager
+from django.db import models
+from django.utils import timezone
+from .utils import normalize_email, normalize_phone
+from .conf import authnest_settings
+
+class UserQuerySet(models.QuerySet):
+    def alive(self):
+        return self.filter(deleted_at__isnull=True)
+
+    def deleted(self):
+        return self.filter(deleted_at__isnull=False)
+
+    def delete(self):
+        if not authnest_settings.SOFT_DELETE:
+            return self.hard_delete()
+
+        # Jo rows pehle se soft-deleted hain unke pk abhi nikalo (update se pehle)
+        already_deleted_pks = list(self.deleted().values_list("pk", flat=True))
+
+        # Alive rows soft delete
+        soft_count = self.alive().update(deleted_at=timezone.now(), is_active=False)
+
+        # Pehle se soft-deleted rows asli me delete
+        total, per_model = 0, {}
+        if already_deleted_pks:
+            total, per_model = self.model.all_objects.filter(
+                pk__in=already_deleted_pks
+            ).hard_delete()
+
+        per_model = dict(per_model)
+        if soft_count:
+            label = self.model._meta.label
+            per_model[label] = per_model.get(label, 0) + soft_count
+        return total + soft_count, per_model
+    delete.alters_data = True
+    delete.queryset_only = True
+
+    def hard_delete(self):
+        return super().delete()
+    hard_delete.alters_data = True
+    hard_delete.queryset_only = True
+
+    def restore(self):
+        return self.update(deleted_at=None, is_active=True)
+    restore.queryset_only = True
+    restore.alters_data = True
+
+class UserManager(BaseUserManager.from_queryset(UserQuerySet)):
+    """objects: sirf alive users. Normal app code isi se kaam karega."""
+
+    use_in_migrations = True
+
+    def get_queryset(self):
+        return super().get_queryset().alive()
+
+    # ---------- helpers ----------
+    def _generate_username(self):
+        while True:
+            username = f"user_{uuid.uuid4().hex[:12]}"
+            if not self.model._base_manager.filter(username=username).exists():
+                return username
+
+    # ---------- creation ----------
+    def create_user(self, email=None, phone=None, password=None, username=None, **extra_fields):
+        email = normalize_email(email)
+        phone = normalize_phone(phone)
+        if not email and not phone:
+            raise ValueError("Email ya phone mein se kam se kam ek zaroori hai")
+
+        extra_fields.setdefault("is_staff", False)
+        extra_fields.setdefault("is_superuser", False)
+
+        user = self.model(
+            email=email,
+            phone=phone,
+            username=username or self._generate_username(),
+            **extra_fields,
+        )
+
+        user.set_password(password)
+        user.save(using=self._db)
+        return user
+
+    def create_superuser(self, username, email=None, password=None, **extra_fields):
+        extra_fields.setdefault("is_staff", True)
+        extra_fields.setdefault("is_superuser", True)
+        extra_fields.setdefault("is_email_verified", True)
+
+        if extra_fields["is_staff"] is not True:
+            raise ValueError("Superuser ke liye is_staff=True zaroori hai.")
+        if extra_fields["is_superuser"] is not True:
+            raise ValueError("Superuser ke liye is_superuser=True zaroori hai.")
+
+        return self.create_user(email=email, password=password, username=username, **extra_fields)
+
+class AllUsersManager(models.Manager.from_queryset(UserQuerySet)):
+    """all_objects: deleted users bhi. Registration check, restore aur admin ke liye."""

django_authnest-0.1.0/authnest/migrations/0001_initial.py

@@ -0,0 +1,50 @@
+# Generated by Django 6.1.2 on 2026-10-31 06:34
+
+import authnest.managers
+import django.core.validators
+import django.utils.timezone
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ('auth', '0012_alter_user_first_name_max_length'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='User',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('password', models.CharField(max_length=128, verbose_name='password')),
+                ('last_login', models.DateTimeField(blank=True, null=True, verbose_name='last login')),
+                ('is_superuser', models.BooleanField(default=False, help_text='Designates that this user has all permissions without explicitly assigning them.', verbose_name='superuser status')),
+                ('email', models.EmailField(blank=True, max_length=255, null=True, unique=True)),
+                ('phone', models.CharField(blank=True, max_length=16, null=True, unique=True, validators=[django.core.validators.RegexValidator(message='Phone number must be international format, like +919876543210', regex='^\\+[1-9]\\d{7,14}$')])),
+                ('username', models.CharField(blank=True, max_length=150, null=True, unique=True)),
+                ('first_name', models.CharField(blank=True, max_length=150)),
+                ('last_name', models.CharField(blank=True, max_length=150)),
+                ('dob', models.DateField(blank=True, null=True)),
+                ('profile_picture', models.ImageField(blank=True, null=True, upload_to='authnest/profiles/')),
+                ('is_active', models.BooleanField(default=True)),
+                ('is_staff', models.BooleanField(default=False)),
+                ('is_email_verified', models.BooleanField(default=False)),
+                ('is_phone_verified', models.BooleanField(default=False)),
+                ('date_joined', models.DateTimeField(default=django.utils.timezone.now)),
+                ('deleted_at', models.DateTimeField(blank=True, null=True)),
+                ('groups', models.ManyToManyField(blank=True, help_text='The groups this user belongs to. A user will get all permissions granted to each of their groups.', related_name='user_set', related_query_name='user', to='auth.group', verbose_name='groups')),
+                ('user_permissions', models.ManyToManyField(blank=True, help_text='Specific permissions for this user.', related_name='user_set', related_query_name='user', to='auth.permission', verbose_name='user permissions')),
+            ],
+            options={
+                'verbose_name': 'user',
+                'verbose_name_plural': 'users',
+                'constraints': [models.CheckConstraint(condition=models.Q(('email__isnull', False), ('phone__isnull', False), _connector='OR'), name='authnest_user_email_or_phone_required')],
+            },
+            managers=[
+                ('objects', authnest.managers.UserManager()),
+            ],
+        ),
+    ]

django_authnest-0.1.0/authnest/models.py

@@ -0,0 +1,100 @@
+from django.db import models
+from django.contrib.auth.models import AbstractBaseUser, PermissionsMixin
+from django.core.validators import RegexValidator
+from django.db.models import Q
+from django.utils import timezone
+from .conf import authnest_settings
+from .managers import AllUsersManager, UserManager
+
+phone_validator = RegexValidator(
+    regex=r"^\+[1-9]\d{7,14}$",
+    message="Phone number must be international format, like +919876543210"
+)
+
+class User(AbstractBaseUser, PermissionsMixin):
+    # --- Identity (login ke liye) ---
+    email = models.EmailField(
+        max_length=255,
+        unique=True,
+        null=True,
+        blank=True
+    )
+    phone = models.CharField(
+        max_length=16,
+        unique=True,
+        null=True,
+        blank=True,
+        validators=[phone_validator]
+    )
+    username = models.CharField(
+        max_length=150,
+        unique=True,
+        null=True,
+        blank=True
+    )
+
+    # --- Profile ---
+    first_name = models.CharField(max_length=150, blank=True)
+    last_name = models.CharField(max_length=150, blank=True)
+    dob = models.DateField(null=True, blank=True)
+    profile_picture = models.ImageField(
+        upload_to="authnest/profiles/",
+        null=True,
+        blank=True
+    )
+    
+    # --- Status ---
+    is_active = models.BooleanField(default=True)
+    is_staff = models.BooleanField(default=False)
+    is_email_verified = models.BooleanField(default=False)
+    is_phone_verified = models.BooleanField(default=False)
+    date_joined = models.DateTimeField(default=timezone.now)
+
+    # --- Soft delete ---
+    deleted_at = models.DateTimeField(null=True, blank=True)
+
+    objects = UserManager()
+    all_objects = AllUsersManager()
+
+    USERNAME_FIELD = "username"
+    EMAIL_FIELD = "email"
+    REQUIRED_FIELDS = ["email"]
+
+    class Meta:
+        verbose_name = "user"
+        verbose_name_plural = "users"
+        constraints = [
+            models.CheckConstraint(
+                condition=Q(email__isnull=False) | Q(phone__isnull=False),
+                name="authnest_user_email_or_phone_required"
+            )
+        ]
+
+    def __str__(self):
+        return self.email or self.phone or self.username or f"User {self.pk}"
+
+    @property
+    def is_deleted(self):
+        return self.deleted_at is not None
+
+    @property
+    def full_name(self):
+        return f"{self.first_name} {self.last_name}".strip()
+
+    def delete(self, using=None, keep_parents=False):
+        if not authnest_settings.SOFT_DELETE or self.is_deleted:
+            return self.hard_delete(using=using, keep_parents=keep_parents)
+
+
+        self.deleted_at = timezone.now()
+        self.is_active = False
+        self.save(update_fields=["deleted_at", "is_active"])
+
+    def restore(self):
+        self.deleted_at = None
+        self.is_active = True
+        self.save(update_fields=["deleted_at", "is_active"])
+
+    def hard_delete(self, using=None, keep_parents=False):
+        # Asli delete, jo Django ka original delete() chalata hai
+        return super().delete(using=using, keep_parents=keep_parents)