nilva-django-admin 0.2.0__py3-none-any.whl

nilva_django_admin/__init__.py

@@ -0,0 +1,15 @@
+"""Nilva Django Admin — the Nilva house Django-admin toolkit.
+
+The ``BaseModelAdmin`` / ``BaseInlineAdmin`` composition every Nilva backend
+re-declares (django-object-actions + django-autoutils avatar/filter/JSON
+helpers + editor auditing + Jalali datepickers), the django-autoutils
+Django-6 compatibility patch, an in-house Keycloak SSO admin login (no
+django-admin-keycloak), the Cheshmeh-style captcha on the login form and on
+selected models' change forms, and ``NilvaAdminSite`` with settings-driven
+dynamic model visibility. Theming comes from ``django-admin-interface``.
+
+Import the pieces explicitly — ``base``/``sites``/``captcha``/``sso`` need
+Django; importing this package itself pulls nothing heavy.
+"""
+
+__version__ = "0.2.0"

nilva_django_admin/admin_apps.py

@@ -0,0 +1,19 @@
+"""AdminConfig swap-in — lives in its own module so Django's default-AppConfig
+detection for ``nilva_django_admin`` stays unambiguous.
+"""
+
+from django.contrib.admin.apps import AdminConfig
+
+
+class NilvaAdminConfig(AdminConfig):
+    """Use in INSTALLED_APPS *instead of* ``django.contrib.admin`` so
+    ``admin.site`` becomes a :class:`nilva_django_admin.sites.NilvaAdminSite`::
+
+        INSTALLED_APPS = [
+            ...
+            "nilva_django_admin",
+            "nilva_django_admin.admin_apps.NilvaAdminConfig",  # not django.contrib.admin
+        ]
+    """
+
+    default_site = "nilva_django_admin.sites.NilvaAdminSite"

nilva_django_admin/apps.py

@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+
+class NilvaDjangoAdminConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "nilva_django_admin"
+    verbose_name = "Nilva Admin"

nilva_django_admin/base.py

@@ -0,0 +1,175 @@
+"""House ``BaseModelAdmin`` / ``BaseInlineAdmin`` — the Shahab composition,
+decoupled from project models via duck-typing.
+
+Every admin class inherits from these instead of ``admin.ModelAdmin`` /
+``admin.TabularInline`` directly. They compose django-object-actions,
+django-autoutils (advanced filters, avatars, edit links, limited FKs, pretty
+JSON, related inlines) and editor auditing, and honour the model protocols
+the fleet already uses:
+
+* ``get_obj()`` — permission-object indirection (``BASE_PERMISSION_OBJECT``)
+* ``get_prefetch_related_fields()`` — class-level ``PREFETCH_RELATED`` lists
+* ``avatar_img_tag(size=…)`` — avatar-model rendering
+* ``editor`` — audit field shown via :meth:`AbstractEditorAdmin.editor_icon`
+"""
+
+import logging
+from urllib import parse
+
+# Importing django_jalali.admin patches Django's admin FORMFIELD_FOR_DBFIELD_DEFAULTS
+# so jDateField/jDateTimeField render with the Persian datepicker widget. This
+# must happen before any ModelAdmin class is defined, so it lives here in the
+# base admin module that every app imports. Optional: skipped when
+# django-jalali isn't installed.
+try:
+    import django_jalali.admin  # noqa: F401
+except ImportError:
+    pass
+
+from django.contrib import admin
+from django.db.models import QuerySet
+from django.utils.translation import gettext_lazy as _
+from django_autoutils.admin_utils import (
+    AdvanceListFilter,
+    AvatarAdmin,
+    EditLinkAdmin,
+    InlineRelatedAdmin,
+    LimitForeignKeyAdmin,
+    PrettyJsonAdmin,
+    admin_display,
+)
+from django_autoutils.html_tag import get_edit_icon
+from django_object_actions import DjangoObjectActions
+
+from .captcha import captcha_protected, model_requires_captcha
+from .compat import patch_autoutils_html_tag
+from .settings import admin_settings
+
+patch_autoutils_html_tag()
+
+logger = logging.getLogger("nilva_django_admin")
+
+
+def _prefetch_for(model, queryset: QuerySet) -> QuerySet:
+    if hasattr(model, "get_prefetch_related_fields"):
+        return queryset.prefetch_related(*model.get_prefetch_related_fields())
+    return queryset
+
+
+class AbstractEditorAdmin:
+    """Mixin for models carrying an ``editor`` audit field."""
+
+    def _handle_instance(self, obj):
+        """For change extra field from inline object call this function."""
+
+    @admin_display(description=_("editor"))
+    def editor_icon(self, obj):
+        """Editor icon with editor name in admin panel object page."""
+        if not obj:
+            return None
+        if not hasattr(obj, "editor"):
+            return None
+        return get_edit_icon(obj.editor)
+
+
+class BaseModelAdmin(
+    DjangoObjectActions,
+    AdvanceListFilter,
+    AvatarAdmin,
+    AbstractEditorAdmin,
+    LimitForeignKeyAdmin,
+    PrettyJsonAdmin,
+    InlineRelatedAdmin,
+    admin.ModelAdmin,
+):
+    """Base admin for all models."""
+
+    search_fields = ("=id",)
+    show_full_result_count = False
+
+    def __init__(self, model, admin_site):
+        self.list_per_page = admin_settings.LIST_PER_PAGE
+        if not getattr(self, "avatar_icon_field", None):
+            self.avatar_icon_field = admin_settings.AVATAR_ICON_FIELD
+        super().__init__(model, admin_site)
+
+    def filter_queryset_by_url(self, request, queryset):
+        """Re-apply the changelist filters/search carried in
+        ``_changelist_filters`` (object-action round-trips)."""
+        changelist_filters = request.GET.get("_changelist_filters", "")
+        filters = dict(parse.parse_qsl(changelist_filters))
+        filter_fields_data = {}
+        for k, v in filters.items():
+            if k == "q" and v:
+                queryset = self.get_search_results(request, queryset, v)[0]
+            elif self.lookup_allowed(k, v, request):
+                filter_fields_data[k] = v
+        return queryset.filter(**filter_fields_data)
+
+    def _get_avatar_obj(self, obj):
+        return self.get_obj(obj)
+
+    @staticmethod
+    def get_obj(obj):
+        """Follow the ``get_obj()`` permission-object protocol when present."""
+        if hasattr(obj, "get_obj"):
+            return obj.get_obj()
+        return obj
+
+    @admin_display(description=_("icon"))
+    def avatar_icon(self, obj=None):
+        """Render the avatar via the model's ``avatar_img_tag`` when it has
+        one, else fall back to django-autoutils' implementation."""
+        target = self._get_avatar_obj(obj) if obj is not None else None
+        if hasattr(target, "avatar_img_tag"):
+            return target.avatar_img_tag(size=30)
+        return super().avatar_icon(obj=obj)
+
+    def get_queryset(self, request):
+        return _prefetch_for(self.model, super().get_queryset(request))
+
+    def get_form(self, request, obj=None, **kwargs):
+        if model_requires_captcha(self.model):
+            # inject BEFORE the factory runs so the declared captcha fields
+            # legitimise their names in the derived Meta.fields list
+            kwargs["form"] = captcha_protected(kwargs.get("form", self.form))
+        return super().get_form(request, obj, **kwargs)
+
+    def get_fieldsets(self, request, obj=None):
+        fieldsets = super().get_fieldsets(request, obj)
+        if model_requires_captcha(self.model):
+            from django.contrib.admin.utils import flatten_fieldsets
+
+            if "captcha_code" not in flatten_fieldsets(fieldsets):
+                fieldsets = [*fieldsets, (_("CAPTCHA"), {"fields": ("captcha_id", "captcha_code")})]
+        return fieldsets
+
+    @staticmethod
+    def get_back_url_for_changelist(request):
+        return "/".join(request.get_full_path().split("/")[:-3])
+
+    @staticmethod
+    def get_back_url(request):
+        full_path = request.get_full_path()
+        if "actions" not in full_path:
+            return full_path
+        return "/".join(full_path.split("/")[:-3])
+
+
+class BaseInlineAdmin(AvatarAdmin, EditLinkAdmin, LimitForeignKeyAdmin, AbstractEditorAdmin, admin.TabularInline):
+    """Base admin for all inlines."""
+
+    extra = 0
+
+    def __init__(self, parent_model, admin_site):
+        if not getattr(self, "avatar_icon_field", None):
+            self.avatar_icon_field = admin_settings.AVATAR_ICON_FIELD
+        super().__init__(parent_model, admin_site)
+
+    def get_queryset(self, request):
+        return _prefetch_for(self.model, super().get_queryset(request))
+
+    def _get_avatar_obj(self, obj):
+        if hasattr(obj, "get_obj"):
+            return obj.get_obj()
+        return obj

nilva_django_admin/captcha.py

@@ -0,0 +1,159 @@
+"""Captcha for the admin — port of Cheshmeh's ``CaptchaService``.
+
+Talks to the MCI/EBCOM-style captcha HTTP service: ``GET
+{BASE_URL}?width=…&height=…&type=…`` returns ``{"id": …, "image": …}`` and
+``GET {BASE_URL}/{id}/verify/{code}`` answers 200 for a correct code.
+
+Two admin surfaces use it:
+
+* the login form (``NILVA_ADMIN["LOGIN_CAPTCHA"] = True``), and
+* the add/change forms of every model listed in
+  ``NILVA_ADMIN["CAPTCHA_MODELS"]`` (injected by ``BaseModelAdmin``).
+
+The captcha id travels in a hidden form field (stateless — no session), and a
+failed submit automatically swaps in a fresh captcha for the redisplay.
+"""
+
+import logging
+
+import requests
+from django import forms
+from django.core.exceptions import ValidationError
+from django.utils.html import format_html
+from django.utils.translation import gettext_lazy as _
+
+from .settings import admin_settings
+
+logger = logging.getLogger("nilva_django_admin")
+
+#: Persian / Arabic-Indic digits -> ASCII for typed captcha codes.
+_DIGIT_MAP = str.maketrans("۰۱۲۳۴۵۶۷۸۹٠١٢٣٤٥٦٧٨٩", "01234567890123456789")
+
+
+class CaptchaError(Exception):
+    """The captcha service could not be reached or answered garbage."""
+
+
+class CaptchaService:
+    """Client for the captcha HTTP service (config: ``NILVA_ADMIN["CAPTCHA"]``)."""
+
+    def __init__(self, config: dict | None = None):
+        self.config = dict(config) if config is not None else dict(admin_settings.CAPTCHA)
+
+    @property
+    def base_url(self) -> str:
+        base_url = self.config.get("BASE_URL")
+        if not base_url:
+            raise CaptchaError("NILVA_ADMIN['CAPTCHA']['BASE_URL'] is required for captcha support")
+        return str(base_url).rstrip("/")
+
+    @property
+    def _proxies(self) -> dict | None:
+        proxy = self.config.get("PROXY")
+        return {"http": proxy, "https": proxy} if proxy else None
+
+    def _get(self, url: str) -> requests.Response:
+        try:
+            return requests.get(url, proxies=self._proxies, timeout=self.config.get("TIMEOUT", 5.0))
+        except requests.RequestException as exc:
+            logger.error("captcha service unreachable", extra={"url": url, "error_info": str(exc)})
+            raise CaptchaError(f"captcha service unreachable: {exc}") from exc
+
+    def get_captcha(self) -> dict:
+        """A fresh challenge: ``{"id": …, "image": …}`` (image is URL/data-URI)."""
+        url = (
+            f"{self.base_url}?width={self.config.get('WIDTH')}"
+            f"&height={self.config.get('HEIGHT')}&type={self.config.get('TYPE')}"
+        )
+        response = self._get(url)
+        if response.status_code != 200:
+            raise CaptchaError(f"captcha service returned {response.status_code}")
+        try:
+            return response.json()["result"]["data"]
+        except (ValueError, KeyError) as exc:
+            raise CaptchaError("captcha service returned an unexpected payload") from exc
+
+    def validate(self, captcha_id, code) -> bool:
+        """True when ``code`` solves challenge ``captcha_id``.
+
+        The staging escape hatch (``VALIDATION_IGNORE``) is honoured only
+        when ``DEBUG=True`` so it is impossible to enable in production.
+        """
+        if self.config.get("VALIDATION_IGNORE"):
+            from django.conf import settings as django_settings
+
+            if getattr(django_settings, "DEBUG", False):
+                return True
+        code = str(code or "").strip().translate(_DIGIT_MAP)
+        if not captcha_id or not code:
+            return False
+        response = self._get(f"{self.base_url}/{captcha_id}/verify/{code}")
+        return response.status_code == 200
+
+
+class CaptchaFormMixin(forms.Form):
+    """Adds a stateless captcha challenge to any form (model or auth).
+
+    The challenge image is exposed as ``form.captcha_image`` and also embedded
+    in the ``captcha_code`` field's help text, so it renders with default
+    admin templates without any template override.
+    """
+
+    captcha_id = forms.CharField(widget=forms.HiddenInput, required=True, label="")
+    captcha_code = forms.CharField(label=_("CAPTCHA"), required=True)
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.captcha_image = None
+        if not self.is_bound:
+            self.refresh_captcha()
+
+    def refresh_captcha(self):
+        """Fetch a fresh challenge and wire it into the (possibly bound) form."""
+        try:
+            data = CaptchaService().get_captcha()
+        except CaptchaError:
+            data = {}
+        captcha_id = data.get("id", "")
+        self.captcha_image = data.get("image")
+        self.initial["captcha_id"] = captcha_id
+        if self.captcha_image:
+            self.fields["captcha_code"].help_text = format_html(
+                '<img src="{}" alt="CAPTCHA" class="nilva-captcha-image"/>', self.captcha_image
+            )
+        if self.is_bound:
+            mutable = self.data.copy()
+            mutable[self.add_prefix("captcha_id")] = str(captcha_id)
+            mutable[self.add_prefix("captcha_code")] = ""
+            self.data = mutable
+
+    def clean(self):
+        cleaned_data = super().clean()
+        captcha_id = cleaned_data.get("captcha_id")
+        code = cleaned_data.get("captcha_code")
+        try:
+            valid = CaptchaService().validate(captcha_id, code)
+        except CaptchaError:
+            self.refresh_captcha()
+            raise ValidationError(
+                _("The CAPTCHA service is unavailable. Please try again."), code="captcha_unavailable"
+            ) from None
+        if not valid:
+            self.refresh_captcha()
+            raise ValidationError(_("Invalid CAPTCHA. Please try again"), code="invalid_captcha")
+        return cleaned_data
+
+
+def captcha_protected(form_class: type[forms.BaseForm]) -> type[forms.BaseForm]:
+    """``form_class`` with the captcha mixin prepended (idempotent)."""
+    if issubclass(form_class, CaptchaFormMixin):
+        return form_class
+    return type(f"Captcha{form_class.__name__}", (CaptchaFormMixin, form_class), {})
+
+
+def model_requires_captcha(model) -> bool:
+    """True when ``model`` matches a ``NILVA_ADMIN["CAPTCHA_MODELS"]`` pattern."""
+    from fnmatch import fnmatch
+
+    label = f"{model._meta.app_label}.{model._meta.object_name}".lower()
+    return any(fnmatch(label, str(pattern).lower()) for pattern in admin_settings.CAPTCHA_MODELS)

nilva_django_admin/compat.py

@@ -0,0 +1,47 @@
+"""django-autoutils Django-6 compatibility patch.
+
+django-autoutils 2.1.1 builds image HTML with ``format_html(f"...")`` passing
+NO format args. Django 6's ``format_html`` raises "args or kwargs must be
+provided." for that, which 500s every admin page rendering an avatar (e.g.
+the user change view). These replacements use real placeholders — which also
+restores auto-escaping and fixes the invalid ``<image>`` tag — and are
+patched onto the library module so its ``get_avatar_image`` /
+``get_edit_icon`` pick them up.
+
+Applied automatically when :mod:`nilva_django_admin.base` is imported;
+idempotent.
+"""
+
+from django.utils.html import format_html
+
+
+def _safe_get_image_link(image, width, height, border_radius, title="image", link=""):
+    return format_html(
+        '<a href="{}"><img src="{}" width="{}" height="{}" title="{}" style="border-radius: {}%"/></a>',
+        link,
+        image,
+        width,
+        height,
+        title,
+        border_radius,
+    )
+
+
+def _safe_get_image_text(image, width, height, border_radius, text):
+    return format_html(
+        '<div><img src="{}" width="{}" height="{}" title="{}" style="border-radius: {}%"/>{}</div>',
+        image,
+        width,
+        height,
+        text,
+        border_radius,
+        text,
+    )
+
+
+def patch_autoutils_html_tag():
+    """Install the safe builders onto ``django_autoutils.html_tag``."""
+    import django_autoutils.html_tag as html_tag
+
+    html_tag.get_image_link = _safe_get_image_link
+    html_tag.get_image_text = _safe_get_image_text

nilva_django_admin/settings.py

@@ -0,0 +1,135 @@
+"""Library settings — overridable via the ``NILVA_ADMIN`` dict in Django settings.
+
+Follows the ``nilva-django-logger`` settings-object pattern::
+
+    # settings.py
+    NILVA_ADMIN = {
+        "APP_NAME": "shahab",
+        "SITE_TITLE": "Shahab administration",
+        "LOGIN_CAPTCHA": True,
+        "CAPTCHA_MODELS": ("user.User",),
+        "HIDDEN_MODELS": ("auth.Group",),
+        "KEYCLOAK": {
+            "SERVER_URL": "https://sso.nilva.ai",
+            "REALM_NAME": "nilva",
+            "CLIENT_ID": "...",
+            "CLIENT_SECRET": "...",
+        },
+        "CAPTCHA": {"BASE_URL": "https://.../services/captcha/v1.0"},
+    }
+
+    # anywhere
+    from nilva_django_admin.settings import admin_settings
+    admin_settings.LIST_PER_PAGE
+
+Dict-valued blocks (``KEYCLOAK``, ``CAPTCHA``) merge key-by-key over their
+defaults. Django is optional at import time; before ``django.conf`` is
+configured the defaults apply.
+"""
+
+from __future__ import annotations
+
+DEFAULTS = {
+    # Used to derive default Keycloak role names ("{APP_NAME}_staff", …).
+    "APP_NAME": None,
+    # BaseModelAdmin defaults.
+    "LIST_PER_PAGE": 20,
+    "AVATAR_ICON_FIELD": "avatar_32",
+    # NilvaAdminSite: header/title override and dynamic model visibility.
+    # VISIBLE_MODELS None → every registered model; else fnmatch patterns like
+    # "worklog.*" or "user.User". HIDDEN_MODELS always removes.
+    "SITE_TITLE": None,
+    "VISIBLE_MODELS": None,
+    "HIDDEN_MODELS": (),
+    # Admin login.
+    "LOGIN_CAPTCHA": False,
+    "SSO_BUTTON_TEXT": "Login with SSO",
+    # Change-form captcha: "app_label.Model" patterns whose admin add/change
+    # forms require a captcha.
+    "CAPTCHA_MODELS": (),
+    # The MCI/EBCOM-style captcha HTTP service (Cheshmeh's CaptchaService).
+    "CAPTCHA": {
+        "BASE_URL": None,  # e.g. https://host/services/captcha/v1.0
+        "WIDTH": 200,
+        "HEIGHT": 100,
+        "TYPE": "DIGITS",
+        "PROXY": None,
+        "TIMEOUT": 5.0,
+        "VALIDATION_IGNORE": False,  # honoured only when DEBUG=True
+    },
+    # In-house Keycloak SSO login for the admin (no django-admin-keycloak).
+    "KEYCLOAK": {
+        "SERVER_URL": None,
+        "REALM_NAME": None,
+        "CLIENT_ID": None,
+        "CLIENT_SECRET": None,
+        "REDIRECT_URI": "/admin/",  # post-login destination
+        "SCOPE": "openid",
+        "ROLE_STAFF_USER": None,  # None → "{APP_NAME}_staff"
+        "ROLE_SUPER_USER": None,  # None → "{APP_NAME}_super_user"
+        "SYNC_GROUPS": True,  # mirror Keycloak groups/roles onto django Groups
+        "VERIFY_SSL": False,
+        "TIMEOUT": 5.0,
+    },
+}
+
+
+def _django_user_settings() -> dict:
+    try:
+        from django.conf import settings as django_settings
+    except ImportError:
+        return {}
+    if not django_settings.configured:
+        return {}
+    return getattr(django_settings, "NILVA_ADMIN", {}) or {}
+
+
+class AdminSettings:
+    """Attribute access over ``DEFAULTS`` overridden by ``NILVA_ADMIN``."""
+
+    def __init__(self, defaults: dict | None = None):
+        self.defaults = defaults or DEFAULTS
+        self._cached_attrs = set()
+
+    @property
+    def user_settings(self) -> dict:
+        if not hasattr(self, "_user_settings"):
+            self._user_settings = _django_user_settings()
+        return self._user_settings
+
+    def __getattr__(self, attr):
+        if attr not in self.defaults:
+            raise AttributeError(f"Invalid NILVA_ADMIN setting: {attr!r}")
+        default = self.defaults[attr]
+        try:
+            value = self.user_settings[attr]
+            if isinstance(default, dict) and isinstance(value, dict):
+                value = {**default, **value}
+        except KeyError:
+            value = default
+        self._cached_attrs.add(attr)
+        setattr(self, attr, value)
+        return value
+
+    def reload(self):
+        for attr in self._cached_attrs:
+            delattr(self, attr)
+        self._cached_attrs.clear()
+        if hasattr(self, "_user_settings"):
+            del self._user_settings
+
+
+admin_settings = AdminSettings()
+
+
+def _reload_admin_settings(*args, **kwargs):
+    if kwargs.get("setting") == "NILVA_ADMIN":
+        admin_settings.reload()
+
+
+try:  # keep @override_settings(NILVA_ADMIN=...) working in tests
+    from django.test.signals import setting_changed
+
+    setting_changed.connect(_reload_admin_settings)
+except ImportError:  # pragma: no cover - plain-Python usage
+    pass

nilva_django_admin/sites.py

@@ -0,0 +1,95 @@
+"""``NilvaAdminSite`` — dynamic model visibility, SSO login button,
+optional login captcha and settings-driven titles.
+
+Swap it in by replacing ``django.contrib.admin`` in ``INSTALLED_APPS`` with
+``"nilva_django_admin.apps.NilvaAdminConfig"`` (plus ``"nilva_django_admin"``
+itself for the login template).
+
+Model visibility is dynamic: ``NILVA_ADMIN["VISIBLE_MODELS"]`` /
+``["HIDDEN_MODELS"]`` take ``fnmatch`` patterns ("user.User", "worklog.*")
+evaluated per request, so which models show up in the admin follows settings
+without code changes. ``auto_register()`` registers every still-unregistered
+concrete model with :class:`~nilva_django_admin.base.BaseModelAdmin`.
+"""
+
+from fnmatch import fnmatch
+
+from django.apps import apps as django_apps
+from django.contrib import admin
+from django.contrib.admin.exceptions import AlreadyRegistered
+from django.contrib.admin.forms import AdminAuthenticationForm
+from django.urls import NoReverseMatch, reverse
+
+from .captcha import captcha_protected
+from .settings import admin_settings
+from .sso import KeycloakSSO
+
+CaptchaAdminAuthenticationForm = captcha_protected(AdminAuthenticationForm)
+
+
+def _matches(model_label: str, patterns) -> bool:
+    return any(fnmatch(model_label, str(pattern).lower()) for pattern in patterns)
+
+
+def model_is_visible(model) -> bool:
+    """Apply the VISIBLE_MODELS whitelist (None → all) then HIDDEN_MODELS."""
+    label = f"{model._meta.app_label}.{model._meta.object_name}".lower()
+    visible = admin_settings.VISIBLE_MODELS
+    if visible is not None and not _matches(label, visible):
+        return False
+    return not _matches(label, admin_settings.HIDDEN_MODELS)
+
+
+class NilvaAdminSite(admin.AdminSite):
+    login_template = "nilva_django_admin/login.html"
+
+    @property
+    def login_form(self):
+        if admin_settings.LOGIN_CAPTCHA:
+            return CaptchaAdminAuthenticationForm
+        return AdminAuthenticationForm
+
+    def each_context(self, request):
+        context = super().each_context(request)
+        title = admin_settings.SITE_TITLE
+        if title:
+            context["site_header"] = title
+            context["site_title"] = title
+        context["sso_button_text"] = admin_settings.SSO_BUTTON_TEXT
+        context["sso_login_url"] = None
+        if KeycloakSSO.is_configured():
+            try:
+                context["sso_login_url"] = reverse("nilva-sso-login")
+            except NoReverseMatch:  # urls not mounted — hide the button
+                pass
+        return context
+
+    def get_app_list(self, request, app_label=None):
+        app_list = super().get_app_list(request, app_label)
+        filtered = []
+        for app in app_list:
+            models = [entry for entry in app["models"] if model_is_visible(entry["model"])]
+            if models:
+                filtered.append({**app, "models": models})
+        return filtered
+
+    def auto_register(self, admin_class=None, exclude=()):
+        """Register every unregistered concrete model with ``BaseModelAdmin``
+        (or ``admin_class``). ``exclude`` takes the same fnmatch patterns."""
+        if admin_class is None:
+            from .base import BaseModelAdmin
+
+            admin_class = BaseModelAdmin
+        registered = []
+        for model in django_apps.get_models():
+            label = f"{model._meta.app_label}.{model._meta.object_name}".lower()
+            if model._meta.auto_created or model._meta.abstract or model._meta.swapped:
+                continue
+            if model in self._registry or _matches(label, exclude):
+                continue
+            try:
+                self.register(model, admin_class)
+                registered.append(model)
+            except AlreadyRegistered:  # pragma: no cover - raced by app admin.py
+                pass
+        return registered

nilva_django_admin/sso.py

@@ -0,0 +1,186 @@
+"""In-house Keycloak SSO for the Django admin — replaces django-admin-keycloak.
+
+Plain OIDC authorization-code flow over ``requests``: redirect to the realm's
+``/auth`` endpoint, exchange the code at ``/token``, read the profile from
+``/userinfo`` and the realm roles from the (server-to-server obtained) access
+token payload. Role mapping follows the house convention:
+``{APP_NAME}_staff`` → ``is_staff``, ``{APP_NAME}_super_user`` →
+``is_superuser``; users without the staff role are rejected. Keycloak
+groups/roles are optionally mirrored onto existing Django ``Group`` rows.
+
+Config: ``NILVA_ADMIN["KEYCLOAK"]`` (see :mod:`nilva_django_admin.settings`).
+"""
+
+import base64
+import binascii
+import json
+import logging
+from urllib.parse import urlencode
+
+import requests
+from django.contrib.auth import get_user_model, login
+from django.contrib.auth.models import Group
+from django.core.exceptions import ImproperlyConfigured, PermissionDenied
+
+from .settings import admin_settings
+
+logger = logging.getLogger("nilva_django_admin")
+
+STATE_SESSION_KEY = "nilva_sso_state"
+NEXT_SESSION_KEY = "nilva_sso_next"
+ID_TOKEN_SESSION_KEY = "nilva_sso_id_token"
+
+
+class SSOError(Exception):
+    """Token exchange / userinfo failure."""
+
+
+def _decode_jwt_payload(token: str) -> dict:
+    """Payload of a JWT *without* signature verification — only ever used on
+    tokens received directly from the token endpoint over TLS."""
+    try:
+        payload = token.split(".")[1]
+        padded = payload + "=" * (-len(payload) % 4)
+        return json.loads(base64.urlsafe_b64decode(padded))
+    except IndexError, ValueError, binascii.Error:
+        return {}
+
+
+class KeycloakSSO:
+    """OIDC client over the ``NILVA_ADMIN["KEYCLOAK"]`` block."""
+
+    def __init__(self, config: dict | None = None):
+        self.config = dict(config) if config is not None else dict(admin_settings.KEYCLOAK)
+        missing = [key for key in ("SERVER_URL", "REALM_NAME", "CLIENT_ID") if not self.config.get(key)]
+        if missing:
+            raise ImproperlyConfigured(f"NILVA_ADMIN['KEYCLOAK'] is missing: {', '.join(missing)}")
+
+    @classmethod
+    def is_configured(cls) -> bool:
+        conf = admin_settings.KEYCLOAK
+        return bool(conf.get("SERVER_URL") and conf.get("REALM_NAME") and conf.get("CLIENT_ID"))
+
+    @property
+    def _realm_url(self) -> str:
+        server = str(self.config["SERVER_URL"]).rstrip("/")
+        return f"{server}/realms/{self.config['REALM_NAME']}/protocol/openid-connect"
+
+    def authorize_url(self, redirect_uri: str, state: str) -> str:
+        params = urlencode(
+            {
+                "client_id": self.config["CLIENT_ID"],
+                "response_type": "code",
+                "scope": self.config.get("SCOPE") or "openid",
+                "redirect_uri": redirect_uri,
+                "state": state,
+            }
+        )
+        return f"{self._realm_url}/auth?{params}"
+
+    def _request(self, method: str, url: str, **kwargs) -> dict:
+        try:
+            response = requests.request(
+                method,
+                url,
+                timeout=self.config.get("TIMEOUT", 5.0),
+                verify=self.config.get("VERIFY_SSL", False),
+                **kwargs,
+            )
+        except requests.RequestException as exc:
+            raise SSOError(f"keycloak unreachable: {exc}") from exc
+        if response.status_code != 200:
+            raise SSOError(f"keycloak returned {response.status_code}: {response.text}")
+        try:
+            return response.json()
+        except ValueError as exc:
+            raise SSOError("keycloak returned a non-JSON response") from exc
+
+    def exchange_code(self, code: str, redirect_uri: str) -> dict:
+        return self._request(
+            "post",
+            f"{self._realm_url}/token",
+            data={
+                "grant_type": "authorization_code",
+                "code": code,
+                "redirect_uri": redirect_uri,
+                "client_id": self.config["CLIENT_ID"],
+                "client_secret": self.config.get("CLIENT_SECRET") or "",
+            },
+        )
+
+    def userinfo(self, access_token: str) -> dict:
+        return self._request("get", f"{self._realm_url}/userinfo", headers={"Authorization": f"Bearer {access_token}"})
+
+    def logout_url(self, post_logout_redirect_uri: str, id_token: str | None = None) -> str:
+        params = {"client_id": self.config["CLIENT_ID"], "post_logout_redirect_uri": post_logout_redirect_uri}
+        if id_token:
+            params["id_token_hint"] = id_token
+        return f"{self._realm_url}/logout?{urlencode(params)}"
+
+    # ── role / user mapping ─────────────────────────────────────────────────
+
+    def _role_names(self) -> tuple[str, str]:
+        app_name = admin_settings.APP_NAME
+        staff = self.config.get("ROLE_STAFF_USER") or (app_name and f"{app_name}_staff")
+        superuser = self.config.get("ROLE_SUPER_USER") or (app_name and f"{app_name}_super_user")
+        if not staff or not superuser:
+            raise ImproperlyConfigured(
+                "Set NILVA_ADMIN['KEYCLOAK']['ROLE_STAFF_USER'/'ROLE_SUPER_USER'] or NILVA_ADMIN['APP_NAME']"
+            )
+        return staff, superuser
+
+    @staticmethod
+    def extract_roles(token_response: dict, userinfo: dict) -> set[str]:
+        """Realm roles from the access-token payload plus any ``groups``
+        claim from userinfo (group names without their leading slash)."""
+        payload = _decode_jwt_payload(token_response.get("access_token", ""))
+        roles = set(payload.get("realm_access", {}).get("roles", []))
+        for client_access in payload.get("resource_access", {}).values():
+            roles.update(client_access.get("roles", []))
+        roles.update(str(group).lstrip("/") for group in userinfo.get("groups") or [])
+        return roles
+
+    def authenticate(self, request, code: str, redirect_uri: str):
+        """Complete the flow: exchange, map, upsert the user and log in.
+
+        Raises ``PermissionDenied`` when the user lacks the staff role and
+        ``SSOError`` on gateway trouble.
+        """
+        token_response = self.exchange_code(code, redirect_uri)
+        userinfo = self.userinfo(token_response["access_token"])
+        roles = self.extract_roles(token_response, userinfo)
+        role_staff, role_super = self._role_names()
+
+        is_superuser = role_super in roles
+        is_staff = role_staff in roles or is_superuser
+        if not is_staff:
+            logger.warning("sso login rejected: missing staff role", extra={"roles": sorted(roles)})
+            raise PermissionDenied("SSO account has no admin access role.")
+
+        user = self._upsert_user(userinfo, is_staff=is_staff, is_superuser=is_superuser)
+        if self.config.get("SYNC_GROUPS"):
+            user.groups.set(Group.objects.filter(name__in=roles))
+
+        login(request, user)
+        request.session[ID_TOKEN_SESSION_KEY] = token_response.get("id_token", "")
+        logger.info("sso login success", extra={"username": user.get_username()})
+        return user
+
+    @staticmethod
+    def _upsert_user(userinfo: dict, *, is_staff: bool, is_superuser: bool):
+        user_model = get_user_model()
+        username = userinfo.get("preferred_username") or userinfo.get("email")
+        if not username:
+            raise SSOError("userinfo carries neither preferred_username nor email")
+        try:
+            user = user_model._default_manager.get_by_natural_key(username)
+        except user_model.DoesNotExist:
+            user = user_model.objects.create_user(username=username)
+            user.set_unusable_password()
+        user.email = userinfo.get("email") or user.email
+        user.first_name = userinfo.get("given_name") or user.first_name
+        user.last_name = userinfo.get("family_name") or user.last_name
+        user.is_staff = is_staff
+        user.is_superuser = is_superuser
+        user.save()
+        return user

nilva_django_admin/templates/nilva_django_admin/login.html

@@ -0,0 +1,67 @@
+{% extends "admin/login.html" %}
+{% load i18n %}
+
+{% block content %}
+{% if form.errors and not form.non_field_errors %}
+<p class="errornote">
+{% blocktranslate count counter=form.errors.items|length %}Please correct the error below.{% plural %}Please correct the errors below.{% endblocktranslate %}
+</p>
+{% endif %}
+
+{% if form.non_field_errors %}
+{% for error in form.non_field_errors %}
+<p class="errornote">
+    {{ error }}
+</p>
+{% endfor %}
+{% endif %}
+
+<div id="content-main">
+
+{% if user.is_authenticated %}
+<p class="errornote">
+{% blocktranslate trimmed %}
+    You are authenticated as {{ username }}, but are not authorized to
+    access this page. Would you like to login to a different account?
+{% endblocktranslate %}
+</p>
+{% endif %}
+
+<form action="{{ app_path }}" method="post" id="login-form">{% csrf_token %}
+  <div class="form-row">
+    {{ form.username.errors }}
+    {{ form.username.label_tag }} {{ form.username }}
+  </div>
+  <div class="form-row">
+    {{ form.password.errors }}
+    {{ form.password.label_tag }} {{ form.password }}
+    <input type="hidden" name="next" value="{{ next }}">
+  </div>
+  {% if form.captcha_code %}
+  <div class="form-row nilva-captcha-row">
+    {{ form.captcha_code.errors }}
+    {% if form.captcha_image %}<img src="{{ form.captcha_image }}" alt="CAPTCHA" class="nilva-captcha-image">{% endif %}
+    {{ form.captcha_code.label_tag }} {{ form.captcha_code }}
+    {{ form.captcha_id }}
+    <a href="{{ app_path }}" class="nilva-captcha-refresh">{% translate 'Refresh CAPTCHA' %}</a>
+  </div>
+  {% endif %}
+  {% url 'admin_password_reset' as password_reset_url %}
+  {% if password_reset_url %}
+  <div class="password-reset-link">
+    <a href="{{ password_reset_url }}">{% translate 'Forgotten your login credentials?' %}</a>
+  </div>
+  {% endif %}
+  <div class="submit-row">
+    <input type="submit" value="{% translate 'Log in' %}">
+  </div>
+</form>
+
+{% if sso_login_url %}
+<div class="submit-row nilva-sso-row">
+  <a class="button" href="{{ sso_login_url }}{% if next %}?next={{ next|urlencode }}{% endif %}">{{ sso_button_text }}</a>
+</div>
+{% endif %}
+
+</div>
+{% endblock %}

nilva_django_admin/urls.py

@@ -0,0 +1,15 @@
+"""SSO URLs — mount under any prefix::
+
+# urls.py
+path("api/sso/", include("nilva_django_admin.urls")),
+"""
+
+from django.urls import path
+
+from .views import SsoCallbackView, SsoLoginView, SsoLogoutView
+
+urlpatterns = [
+    path("login/", SsoLoginView.as_view(), name="nilva-sso-login"),
+    path("callback/", SsoCallbackView.as_view(), name="nilva-sso-callback"),
+    path("logout/", SsoLogoutView.as_view(), name="nilva-sso-logout"),
+]

nilva_django_admin/views.py

@@ -0,0 +1,76 @@
+"""SSO login / callback / logout views (wired via ``nilva_django_admin.urls``)."""
+
+import logging
+
+from django.contrib import messages
+from django.contrib.auth import logout
+from django.core.exceptions import PermissionDenied
+from django.http import HttpResponseBadRequest, HttpResponseRedirect
+from django.urls import reverse
+from django.utils.crypto import get_random_string
+from django.utils.http import url_has_allowed_host_and_scheme
+from django.utils.translation import gettext_lazy as _
+from django.views import View
+
+from .settings import admin_settings
+from .sso import ID_TOKEN_SESSION_KEY, NEXT_SESSION_KEY, STATE_SESSION_KEY, KeycloakSSO, SSOError
+
+logger = logging.getLogger("nilva_django_admin")
+
+
+def _callback_uri(request) -> str:
+    return request.build_absolute_uri(reverse("nilva-sso-callback"))
+
+
+def _safe_next(request, candidate: str | None) -> str:
+    default = admin_settings.KEYCLOAK["REDIRECT_URI"]
+    if candidate and url_has_allowed_host_and_scheme(candidate, allowed_hosts={request.get_host()}):
+        return candidate
+    return default
+
+
+class SsoLoginView(View):
+    """Kick off the authorization-code flow."""
+
+    def get(self, request):
+        sso = KeycloakSSO()
+        state = get_random_string(32)
+        request.session[STATE_SESSION_KEY] = state
+        request.session[NEXT_SESSION_KEY] = _safe_next(request, request.GET.get("next"))
+        return HttpResponseRedirect(sso.authorize_url(_callback_uri(request), state))
+
+
+class SsoCallbackView(View):
+    """Finish the flow: verify state, exchange the code, log the user in."""
+
+    def get(self, request):
+        state = request.GET.get("state")
+        code = request.GET.get("code")
+        if not code or not state or state != request.session.get(STATE_SESSION_KEY):
+            return HttpResponseBadRequest("Invalid SSO state.")
+        request.session.pop(STATE_SESSION_KEY, None)
+        next_url = request.session.pop(NEXT_SESSION_KEY, admin_settings.KEYCLOAK["REDIRECT_URI"])
+
+        try:
+            KeycloakSSO().authenticate(request, code, _callback_uri(request))
+        except PermissionDenied:
+            messages.error(request, _("Your SSO account has no admin access role."))
+            return HttpResponseRedirect(admin_settings.KEYCLOAK["REDIRECT_URI"])
+        except SSOError as exc:
+            logger.error("sso login failed", extra={"error_info": str(exc)})
+            messages.error(request, _("SSO login failed. Please try again."))
+            return HttpResponseRedirect(admin_settings.KEYCLOAK["REDIRECT_URI"])
+
+        return HttpResponseRedirect(next_url)
+
+
+class SsoLogoutView(View):
+    """Log out of Django, then out of the Keycloak session."""
+
+    def get(self, request):
+        id_token = request.session.get(ID_TOKEN_SESSION_KEY)
+        logout(request)
+        redirect_uri = request.build_absolute_uri(admin_settings.KEYCLOAK["REDIRECT_URI"])
+        if KeycloakSSO.is_configured():
+            return HttpResponseRedirect(KeycloakSSO().logout_url(redirect_uri, id_token))
+        return HttpResponseRedirect(redirect_uri)

nilva_django_admin-0.2.0.dist-info/METADATA

@@ -0,0 +1,175 @@
+Metadata-Version: 2.4
+Name: nilva-django-admin
+Version: 0.2.0
+Summary: Nilva house Django-admin toolkit — BaseModelAdmin/BaseInlineAdmin composition, in-house Keycloak SSO admin login, captcha on login + selected models, dynamic model visibility, django-admin-interface theming
+Author-email: Nilva <dev@nilva.ai>
+License-Expression: MIT
+Project-URL: homepage, https://gitlab.nilva.ai/nilva/dev-assets/django/nilva-django-admin
+Project-URL: repository, https://gitlab.nilva.ai/nilva/dev-assets/django/nilva-django-admin
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: OS Independent
+Classifier: Framework :: Django
+Classifier: Framework :: Django :: 6.0
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: django>=6.0
+Requires-Dist: django-autoutils>=2.1.1
+Requires-Dist: django-object-actions>=5.0.0
+Requires-Dist: requests>=2.32
+Requires-Dist: django-admin-interface>=0.30.1
+Provides-Extra: jalali
+Requires-Dist: django-jalali>=7.4.0; extra == "jalali"
+Dynamic: license-file
+
+# nilva-django-admin
+
+Nilva's house Django-admin toolkit: the `BaseModelAdmin` / `BaseInlineAdmin`
+composition every backend re-declares, an **in-house Keycloak SSO admin
+login** (no `django-admin-keycloak`), the **Cheshmeh-style captcha** on the
+login form and on selected models' change forms, **dynamic model
+visibility** driven by settings, the django-autoutils Django-6 compatibility
+patch, and [django-admin-interface](https://pypi.org/project/django-admin-interface/)
+theming as a dependency.
+
+## Install
+
+```bash
+uv add nilva-django-admin                  # everything below
+uv add "nilva-django-admin[jalali]"        # + Persian datepickers for jDateField models
+```
+
+## Wiring
+
+```python
+# settings.py
+INSTALLED_APPS = [
+    "admin_interface",          # theming (ships with this package)
+    "colorfield",
+    ...
+    "nilva_django_admin",                              # templates + app
+    "nilva_django_admin.admin_apps.NilvaAdminConfig",  # INSTEAD of django.contrib.admin
+    ...
+]
+
+NILVA_ADMIN = {
+    "APP_NAME": "shahab",
+    "SITE_TITLE": "Shahab administration",
+    "LOGIN_CAPTCHA": True,
+    "CAPTCHA_MODELS": ("user.User", "salary.*"),
+    "HIDDEN_MODELS": ("auth.Group",),
+    "KEYCLOAK": {
+        "SERVER_URL": "https://sso.nilva.ai",
+        "REALM_NAME": "nilva",
+        "CLIENT_ID": "...",
+        "CLIENT_SECRET": "...",
+    },
+    "CAPTCHA": {"BASE_URL": "https://host/services/captcha/v1.0"},
+}
+
+# urls.py
+path("api/sso/", include("nilva_django_admin.urls")),
+```
+
+## Base admin classes
+
+```python
+from nilva_django_admin.base import BaseInlineAdmin, BaseModelAdmin
+
+@admin.register(Delivery)
+class DeliveryAdmin(BaseModelAdmin):
+    list_display = ("id", "avatar_icon", "name", "editor_icon")
+```
+
+django-object-actions buttons, django-autoutils filters/avatars/edit-links/
+pretty-JSON, `editor_icon` auditing, the duck-typed house protocols
+(`get_obj()`, `get_prefetch_related_fields()`, `avatar_img_tag()`), Jalali
+datepickers when `django-jalali` is installed, and the Django-6
+`format_html` compat patch for django-autoutils 2.1.1. Defaults
+(`LIST_PER_PAGE`, `AVATAR_ICON_FIELD`) come from `NILVA_ADMIN`.
+
+## SSO admin login (in-house, no django-admin-keycloak)
+
+Plain OIDC authorization-code flow implemented in
+`nilva_django_admin.sso` / `.views`:
+
+* `GET <mount>/login/` redirects to the realm's `/auth` endpoint (CSRF
+  `state` kept in the session, `?next=` honoured when it is same-host).
+* `GET <mount>/callback/` exchanges the code, reads roles from the access
+  token (`realm_access` + `resource_access` + userinfo `groups`), maps
+  `{APP_NAME}_staff` → `is_staff` and `{APP_NAME}_super_user` →
+  `is_superuser` (overridable via `ROLE_STAFF_USER` / `ROLE_SUPER_USER`),
+  creates/updates the Django user and logs it in. Accounts without the
+  staff role are rejected. With `SYNC_GROUPS` (default) matching Django
+  `Group` rows are assigned.
+* `GET <mount>/logout/` logs out of Django and the Keycloak session.
+
+The admin login page (rendered by `NilvaAdminSite`) shows a **Login with
+SSO** button automatically whenever `KEYCLOAK` is configured and the URLs
+are mounted.
+
+## Captcha (Cheshmeh's service)
+
+`nilva_django_admin.captcha.CaptchaService` talks to the MCI/EBCOM-style
+captcha HTTP service (`GET ?width=…` → `{id, image}`; `GET
+/{id}/verify/{code}`). Typed codes are Persian/Arabic-digit normalized; the
+`VALIDATION_IGNORE` staging bypass only works when `DEBUG=True`.
+
+* **Login captcha** — `NILVA_ADMIN["LOGIN_CAPTCHA"] = True` puts the captcha
+  on the admin login form.
+* **Model captcha** — every model matching a `CAPTCHA_MODELS` pattern gets a
+  captcha on its admin add/change form. `BaseModelAdmin` injects the field
+  and appends a CAPTCHA fieldset when the admin declares explicit
+  `fieldsets`. A failed code re-renders with a fresh challenge; the
+  challenge id travels in a hidden field, so no session state is involved.
+
+## Dynamic model visibility
+
+Which models the admin shows follows settings, per request — no code
+changes or restarts of registration logic:
+
+```python
+NILVA_ADMIN = {
+    "VISIBLE_MODELS": ("worklog.*", "user.User"),  # None → all registered
+    "HIDDEN_MODELS": ("auth.Permission",),          # always wins
+}
+```
+
+`NilvaAdminSite.get_app_list` applies the `fnmatch` patterns, so the index
+and sidebar only show matching models. And for the inverse — surfacing
+models nobody wrote an admin for:
+
+```python
+# urls.py, after admin.autodiscover
+admin.site.auto_register()          # every unregistered model → BaseModelAdmin
+admin.site.auto_register(exclude=("django_celery_beat.*",))
+```
+
+## Theming
+
+`django-admin-interface` is a dependency: add `admin_interface` and
+`colorfield` to `INSTALLED_APPS` (before the admin), run `migrate`, and
+manage themes from the admin itself.
+
+## Settings reference — `NILVA_ADMIN`
+
+| key | default | notes |
+|-----|---------|-------|
+| `APP_NAME` | `None` | role-name defaults |
+| `LIST_PER_PAGE` / `AVATAR_ICON_FIELD` | `20` / `"avatar_32"` | `BaseModelAdmin` |
+| `SITE_TITLE` | `None` | site header/title |
+| `VISIBLE_MODELS` / `HIDDEN_MODELS` | `None` / `()` | fnmatch patterns |
+| `LOGIN_CAPTCHA` | `False` | captcha on the login form |
+| `CAPTCHA_MODELS` | `()` | captcha on these models' change forms |
+| `CAPTCHA.BASE_URL` … | — | captcha service (`WIDTH`/`HEIGHT`/`TYPE`/`PROXY`/`TIMEOUT`/`VALIDATION_IGNORE`) |
+| `KEYCLOAK.SERVER_URL` … | — | SSO (`REALM_NAME`/`CLIENT_ID`/`CLIENT_SECRET`/`SCOPE`/`REDIRECT_URI`/`ROLE_*`/`SYNC_GROUPS`/`VERIFY_SSL`/`TIMEOUT`) |
+| `SSO_BUTTON_TEXT` | `"Login with SSO"` | login page button |
+
+## Development
+
+```bash
+uv sync --group dev
+./run_tests.sh          # ./run_tests.sh -c for coverage
+uv run ruff check .
+```

nilva_django_admin-0.2.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+nilva_django_admin/__init__.py,sha256=Sme_VIYUzy1CTtWRQbKVFtvjDD1FDbQO8YFNrhMdcsg,744
+nilva_django_admin/admin_apps.py,sha256=mLJYTrDK4nuZFTsH7jc7_3LITu26LpnkNwXv2NYxZOQ,629
+nilva_django_admin/apps.py,sha256=6fuw0FiqAhfpJ2Bf5KGzSVHKZvvpTmoiX614-UsLhI8,199
+nilva_django_admin/base.py,sha256=73ecYxrSKK7_5gE-wkSkfhXfV7rclhzJuc9kjAm0ILM,6395
+nilva_django_admin/captcha.py,sha256=iG0yo9_SfImRwByps2XOi7KiW4ifbzMl6OnkEDExLCg,6397
+nilva_django_admin/compat.py,sha256=qFcNUKYuZV3en7QgNE8fwrtulcFkKclFm8uHM3SVx1k,1534
+nilva_django_admin/settings.py,sha256=Fm4eWYvE-813VotOVDSSrCh0UVJ7Z5Bj40vg2KeASPw,4431
+nilva_django_admin/sites.py,sha256=zryogF6-_rmiQnsnbvV8mqOgC37BQAB3VJ5VKHdp5XQ,3797
+nilva_django_admin/sso.py,sha256=k7lGlgpZeiwRxCv_1MRnMrbypAKRSpJH33HwoRi2UtI,8031
+nilva_django_admin/urls.py,sha256=UE9QlUx4f6IcDV9GLTPl2FzUOPElRZtxqsvQ1paY1qI,440
+nilva_django_admin/views.py,sha256=4DST0u14DNWaLqaHLp7hWKBeprri-5mTNY1M1-WMVEo,3070
+nilva_django_admin/templates/nilva_django_admin/login.html,sha256=ZuZyQ24IGX7A-x9pc6f_dRGOjZwxdbxhF4crg-JM7j8,2130
+nilva_django_admin-0.2.0.dist-info/licenses/LICENSE,sha256=GaZw6y1gmDVsgrV6Kbba2e0GWozUuG_DP41_BT7fHUg,1061
+nilva_django_admin-0.2.0.dist-info/METADATA,sha256=QJ8xHl3pHcQckaFlbxvE0BsRI_dLi7uWanLivqUhrKM,6826
+nilva_django_admin-0.2.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+nilva_django_admin-0.2.0.dist-info/top_level.txt,sha256=B3VWRdw-c_cT9hxYXijNqdShn0O44n3HXL4ATrL8B7c,19
+nilva_django_admin-0.2.0.dist-info/RECORD,,

nilva_django_admin-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

nilva_django_admin-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Nilva
+
+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.

nilva_django_admin-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+nilva_django_admin