arthexis 0.1.8__py3-none-any.whl → 0.1.9__py3-none-any.whl

core/admin_history.py

@@ -0,0 +1,50 @@
+import json
+from django.contrib.admin.options import ModelAdmin
+from django.contrib.admin.models import LogEntry
+from django.utils.encoding import smart_str
+
+
+def patch_admin_history():
+    if getattr(ModelAdmin, "_history_patched", False):
+        return
+
+    def construct_change_message(self, request, form, formsets, add=False):
+        fields = []
+        if add:
+            for name, value in form.cleaned_data.items():
+                fields.append({"field": name, "old": None, "new": smart_str(value)})
+            if not fields:
+                return ""
+            return json.dumps({"added": fields})
+        for name in form.changed_data:
+            fields.append(
+                {
+                    "field": name,
+                    "old": smart_str(form.initial.get(name)),
+                    "new": smart_str(form.cleaned_data.get(name)),
+                }
+            )
+        if not fields:
+            return ""
+        return json.dumps({"changed": fields})
+
+    def get_change_message(self):
+        try:
+            data = json.loads(self.change_message)
+        except Exception:
+            return self.change_message
+        if isinstance(data, dict):
+            if "added" in data:
+                parts = [f"{d['field']}='{d['new']}'" for d in data["added"]]
+                return "Added " + ", ".join(parts)
+            if "changed" in data:
+                parts = [
+                    f"{d['field']}: '{d['old']}' -> '{d['new']}'"
+                    for d in data["changed"]
+                ]
+                return "Changed " + ", ".join(parts)
+        return self.change_message
+
+    ModelAdmin.construct_change_message = construct_change_message
+    LogEntry.get_change_message = get_change_message
+    ModelAdmin._history_patched = True

core/admindocs.py

@@ -1,6 +1,15 @@
 import argparse
+import inspect
+from types import SimpleNamespace
+
+from django.apps import apps
+from django.contrib import admin
 from django.core.management import get_commands, load_command_class
-from django.contrib.admindocs.views import BaseAdminDocsView
+from django.contrib.admindocs.views import (
+    BaseAdminDocsView,
+    user_has_model_view_permission,
+)
+from django.urls import NoReverseMatch, reverse
 
 
 class CommandsView(BaseAdminDocsView):
@@ -42,3 +51,101 @@ class CommandsView(BaseAdminDocsView):
                 }
             )
         return super().get_context_data(**{**kwargs, "commands": commands})
+
+
+class OrderedModelIndexView(BaseAdminDocsView):
+    template_name = "admin_doc/model_index.html"
+
+    GROUP_OVERRIDES = {
+        "ocpp.location": "core",
+        "core.rfid": "ocpp",
+        "core.package": "teams",
+        "core.packagerelease": "teams",
+    }
+
+    def _get_docs_app_config(self, meta):
+        override_label = self.GROUP_OVERRIDES.get(meta.label_lower)
+        if override_label:
+            return apps.get_app_config(override_label)
+        return meta.app_config
+
+    def get_context_data(self, **kwargs):
+        models = []
+        for m in apps.get_models():
+            if user_has_model_view_permission(self.request.user, m._meta):
+                meta = m._meta
+                meta.docstring = inspect.getdoc(m) or ""
+                app_config = self._get_docs_app_config(meta)
+                models.append(
+                    SimpleNamespace(
+                        app_label=meta.app_label,
+                        model_name=meta.model_name,
+                        object_name=meta.object_name,
+                        docstring=meta.docstring,
+                        app_config=app_config,
+                    )
+                )
+        models.sort(key=lambda m: str(m.app_config.verbose_name))
+        return super().get_context_data(**{**kwargs, "models": models})
+
+
+class ModelGraphIndexView(BaseAdminDocsView):
+    template_name = "admin_doc/model_graphs.html"
+
+    def get_context_data(self, **kwargs):
+        sections = {}
+        user = self.request.user
+
+        for model in admin.site._registry:
+            meta = model._meta
+            if not user_has_model_view_permission(user, meta):
+                continue
+
+            app_config = apps.get_app_config(meta.app_label)
+            section = sections.setdefault(
+                app_config.label,
+                {
+                    "app_label": app_config.label,
+                    "verbose_name": str(app_config.verbose_name),
+                    "models": [],
+                },
+            )
+
+            section["models"].append(
+                {
+                    "object_name": meta.object_name,
+                    "verbose_name": str(meta.verbose_name),
+                    "doc_url": reverse(
+                        "django-admindocs-models-detail",
+                        kwargs={
+                            "app_label": meta.app_label,
+                            "model_name": meta.model_name,
+                        },
+                    ),
+                }
+            )
+
+        graph_sections = []
+        for section in sections.values():
+            section_models = section["models"]
+            section_models.sort(key=lambda model: model["verbose_name"])
+
+            try:
+                app_list_url = reverse("admin:app_list", args=[section["app_label"]])
+            except NoReverseMatch:
+                app_list_url = ""
+
+            graph_sections.append(
+                {
+                    **section,
+                    "graph_url": reverse(
+                        "admin-model-graph", args=[section["app_label"]]
+                    ),
+                    "app_list_url": app_list_url,
+                    "model_count": len(section_models),
+                }
+            )
+
+        graph_sections.sort(key=lambda section: section["verbose_name"])
+
+        return super().get_context_data(**{**kwargs, "sections": graph_sections})

core/apps.py

@@ -1,22 +1,43 @@
+import logging
+
 from django.apps import AppConfig
 from django.utils.translation import gettext_lazy as _
 
 
+logger = logging.getLogger(__name__)
+
+
 class CoreConfig(AppConfig):
     default_auto_field = "django.db.models.BigAutoField"
     name = "core"
     verbose_name = _("2. Business")
 
     def ready(self):  # pragma: no cover - called by Django
+        from contextlib import suppress
+        from functools import wraps
+        import hashlib
+        import time
+        import traceback
+        from pathlib import Path
+
+        from django.conf import settings
         from django.contrib.auth import get_user_model
         from django.db.models.signals import post_migrate
+        from django.core.signals import got_request_exception
+
+        from core.github_helper import report_exception_to_github
+        from .entity import Entity
         from .user_data import (
             patch_admin_user_datum,
             patch_admin_user_data_views,
         )
         from .system import patch_admin_system_view
         from .environment import patch_admin_environment_view
-        from . import checks  # noqa: F401
+        from .sigil_builder import (
+            patch_admin_sigil_builder_view,
+            generate_model_sigils,
+        )
+        from .admin_history import patch_admin_history
 
         def create_default_arthexis(**kwargs):
             User = get_user_model()
@@ -29,13 +50,57 @@ class CoreConfig(AppConfig):
                 )
 
         post_migrate.connect(create_default_arthexis, sender=self)
+        post_migrate.connect(generate_model_sigils, sender=self)
         patch_admin_user_datum()
         patch_admin_user_data_views()
         patch_admin_system_view()
         patch_admin_environment_view()
+        patch_admin_sigil_builder_view()
+        patch_admin_history()
 
-        from pathlib import Path
-        from django.conf import settings
+        from django.core.serializers import base as serializer_base
+
+        if not hasattr(
+            serializer_base.DeserializedObject.save, "_entity_fixture_patch"
+        ):
+            original_save = serializer_base.DeserializedObject.save
+
+            @wraps(original_save)
+            def patched_save(self, save_m2m=True, using=None, **kwargs):
+                obj = self.object
+                if isinstance(obj, Entity):
+                    manager = getattr(
+                        type(obj), "all_objects", type(obj)._default_manager
+                    )
+                    if using:
+                        manager = manager.db_manager(using)
+                    for fields in obj._unique_field_groups():
+                        lookup = {}
+                        for field in fields:
+                            value = getattr(obj, field.attname)
+                            if value is None:
+                                lookup = {}
+                                break
+                            lookup[field.attname] = value
+                        if not lookup:
+                            continue
+                        existing = (
+                            manager.filter(**lookup)
+                            .only("pk", "is_seed_data", "is_user_data")
+                            .first()
+                        )
+                        if existing is not None:
+                            obj.pk = existing.pk
+                            obj.is_seed_data = existing.is_seed_data
+                            obj.is_user_data = existing.is_user_data
+                            obj._state.adding = False
+                            if using:
+                                obj._state.db = using
+                            break
+                return original_save(self, save_m2m=save_m2m, using=using, **kwargs)
+
+            patched_save._entity_fixture_patch = True
+            serializer_base.DeserializedObject.save = patched_save
 
         lock = Path(settings.BASE_DIR) / "locks" / "celery.lck"
 
@@ -66,3 +131,93 @@ class CoreConfig(AppConfig):
                     pass
 
             post_migrate.connect(ensure_email_collector_task, sender=self)
+
+        from django.db.backends.signals import connection_created
+
+        def enable_sqlite_wal(**kwargs):
+            connection = kwargs.get("connection")
+            if connection.vendor == "sqlite":
+                cursor = connection.cursor()
+                cursor.execute("PRAGMA journal_mode=WAL;")
+                cursor.execute("PRAGMA busy_timeout=60000;")
+                cursor.close()
+
+        connection_created.connect(enable_sqlite_wal)
+
+        def queue_github_issue(sender, request=None, **kwargs):
+            if not getattr(settings, "GITHUB_ISSUE_REPORTING_ENABLED", True):
+                return
+            if request is None:
+                return
+
+            exception = kwargs.get("exception")
+            if exception is None:
+                return
+
+            try:
+                tb_exc = traceback.TracebackException.from_exception(exception)
+                stack = tb_exc.stack
+                top_frame = stack[-1] if stack else None
+                fingerprint_parts = [
+                    exception.__class__.__module__,
+                    exception.__class__.__name__,
+                ]
+                if top_frame:
+                    fingerprint_parts.extend(
+                        [
+                            top_frame.filename,
+                            str(top_frame.lineno),
+                            top_frame.name,
+                        ]
+                    )
+                fingerprint = hashlib.sha256(
+                    "|".join(fingerprint_parts).encode("utf-8")
+                ).hexdigest()
+
+                cooldown = getattr(settings, "GITHUB_ISSUE_REPORTING_COOLDOWN", 3600)
+                lock_dir = Path(settings.BASE_DIR) / "locks" / "github-issues"
+                fingerprint_path = None
+                now = time.time()
+
+                with suppress(OSError):
+                    lock_dir.mkdir(parents=True, exist_ok=True)
+                    fingerprint_path = lock_dir / fingerprint
+                    if fingerprint_path.exists():
+                        age = now - fingerprint_path.stat().st_mtime
+                        if age < cooldown:
+                            return
+
+                if fingerprint_path is not None:
+                    with suppress(OSError):
+                        fingerprint_path.write_text(str(now))
+
+                user_repr = None
+                user = getattr(request, "user", None)
+                if user is not None:
+                    try:
+                        if getattr(user, "is_authenticated", False):
+                            user_repr = user.get_username()
+                        else:
+                            user_repr = "anonymous"
+                    except Exception:  # pragma: no cover - defensive
+                        user_repr = str(user)
+
+                payload = {
+                    "path": getattr(request, "path", None),
+                    "method": getattr(request, "method", None),
+                    "user": user_repr,
+                    "active_app": getattr(request, "active_app", None),
+                    "fingerprint": fingerprint,
+                    "exception_class": f"{exception.__class__.__module__}.{exception.__class__.__name__}",
+                    "traceback": "".join(tb_exc.format()),
+                }
+
+                report_exception_to_github.delay(payload)
+            except Exception:  # pragma: no cover - defensive
+                logger.exception("Failed to queue GitHub issue from request exception")
+
+        got_request_exception.connect(
+            queue_github_issue,
+            dispatch_uid="core.github_issue_reporter",
+            weak=False,
+        )

core/backends.py

@@ -1,8 +1,11 @@
 """Custom authentication backends for the core app."""
 
+import contextlib
+import ipaddress
+import socket
+
 from django.contrib.auth import get_user_model
 from django.contrib.auth.backends import ModelBackend
-import ipaddress
 
 from .models import EnergyAccount
 
@@ -32,6 +35,37 @@ class RFIDBackend:
             return None
 
 
+def _collect_local_ip_addresses():
+    """Return IP addresses assigned to the current machine."""
+
+    hosts = {socket.gethostname().strip()}
+    with contextlib.suppress(Exception):
+        hosts.add(socket.getfqdn().strip())
+
+    addresses = set()
+    for host in filter(None, hosts):
+        with contextlib.suppress(OSError):
+            _, _, ip_list = socket.gethostbyname_ex(host)
+            for candidate in ip_list:
+                with contextlib.suppress(ValueError):
+                    addresses.add(ipaddress.ip_address(candidate))
+        with contextlib.suppress(OSError):
+            for info in socket.getaddrinfo(host, None, family=socket.AF_UNSPEC):
+                sockaddr = info[-1]
+                if not sockaddr:
+                    continue
+                raw_address = sockaddr[0]
+                if isinstance(raw_address, bytes):
+                    with contextlib.suppress(UnicodeDecodeError):
+                        raw_address = raw_address.decode()
+                if isinstance(raw_address, str):
+                    if "%" in raw_address:
+                        raw_address = raw_address.split("%", 1)[0]
+                    with contextlib.suppress(ValueError):
+                        addresses.add(ipaddress.ip_address(raw_address))
+    return tuple(sorted(addresses, key=str))
+
+
 class LocalhostAdminBackend(ModelBackend):
     """Allow default admin credentials only from local networks."""
 
@@ -39,9 +73,8 @@ class LocalhostAdminBackend(ModelBackend):
         ipaddress.ip_network("::1/128"),
         ipaddress.ip_network("127.0.0.0/8"),
         ipaddress.ip_network("192.168.0.0/16"),
-        ipaddress.ip_network("172.16.0.0/12"),
-        ipaddress.ip_network("10.42.0.0/16"),
     ]
+    _LOCAL_IPS = _collect_local_ip_addresses()
 
     def authenticate(self, request, username=None, password=None, **kwargs):
         if username == "admin" and password == "admin" and request is not None:
@@ -55,6 +88,8 @@ class LocalhostAdminBackend(ModelBackend):
             except ValueError:
                 return None
             allowed = any(ip in net for net in self._ALLOWED_NETWORKS)
+            if not allowed and ip in self._LOCAL_IPS:
+                allowed = True
             if not allowed:
                 return None
             User = get_user_model()
@@ -65,11 +100,19 @@ class LocalhostAdminBackend(ModelBackend):
                     "is_superuser": True,
                 },
             )
+            arthexis_user = (
+                User.all_objects.filter(username="arthexis").exclude(pk=user.pk).first()
+            )
             if created:
+                if arthexis_user and user.operate_as_id is None:
+                    user.operate_as = arthexis_user
                 user.set_password("admin")
                 user.save()
             elif not user.check_password("admin"):
                 return None
+            elif arthexis_user and user.operate_as_id is None:
+                user.operate_as = arthexis_user
+                user.save(update_fields=["operate_as"])
             return user
         return super().authenticate(request, username, password, **kwargs)
 
@@ -79,4 +122,3 @@ class LocalhostAdminBackend(ModelBackend):
             return User.all_objects.get(pk=user_id)
         except User.DoesNotExist:
             return None
-

core/entity.py

@@ -1,12 +1,9 @@
 import copy
 import logging
-import os
-import re
 
-from django.apps import apps
-from django.conf import settings
-from django.db import models
 from django.contrib.auth.models import UserManager as DjangoUserManager
+from django.core.exceptions import FieldDoesNotExist
+from django.db import models
 
 logger = logging.getLogger(__name__)
 
@@ -27,17 +24,14 @@ class EntityManager(models.Manager):
 
 class EntityUserManager(DjangoUserManager):
     def get_queryset(self):
-        return (
-            EntityQuerySet(self.model, using=self._db)
-            .filter(is_deleted=False)
-            .exclude(username="admin")
-        )
+        return EntityQuerySet(self.model, using=self._db).filter(is_deleted=False)
 
 
 class Entity(models.Model):
     """Base model providing seed data tracking and soft deletion."""
 
     is_seed_data = models.BooleanField(default=False, editable=False)
+    is_user_data = models.BooleanField(default=False, editable=False)
     is_deleted = models.BooleanField(default=False, editable=False)
 
     objects = EntityManager()
@@ -60,11 +54,66 @@ class Entity(models.Model):
                 pass
             else:
                 self.is_seed_data = old.is_seed_data
+                self.is_user_data = old.is_user_data
         super().save(*args, **kwargs)
 
+    @classmethod
+    def _unique_field_groups(cls):
+        """Return concrete field tuples enforcing uniqueness for this model."""
+
+        opts = cls._meta
+        groups: list[tuple[models.Field, ...]] = []
+
+        for field in opts.concrete_fields:
+            if field.unique and not field.primary_key:
+                groups.append((field,))
+
+        for unique in opts.unique_together:
+            fields: list[models.Field] = []
+            for name in unique:
+                try:
+                    field = opts.get_field(name)
+                except FieldDoesNotExist:
+                    fields = []
+                    break
+                if not getattr(field, "concrete", False) or field.primary_key:
+                    fields = []
+                    break
+                fields.append(field)
+            if fields:
+                groups.append(tuple(fields))
+
+        for constraint in opts.constraints:
+            if not isinstance(constraint, models.UniqueConstraint):
+                continue
+            if not constraint.fields or constraint.condition is not None:
+                continue
+            fields = []
+            for name in constraint.fields:
+                try:
+                    field = opts.get_field(name)
+                except FieldDoesNotExist:
+                    fields = []
+                    break
+                if not getattr(field, "concrete", False) or field.primary_key:
+                    fields = []
+                    break
+                fields.append(field)
+            if fields:
+                groups.append(tuple(fields))
+
+        unique_groups: list[tuple[models.Field, ...]] = []
+        seen: set[tuple[str, ...]] = set()
+        for fields in groups:
+            key = tuple(field.attname for field in fields)
+            if key in seen:
+                continue
+            seen.add(key)
+            unique_groups.append(fields)
+        return unique_groups
+
     def resolve_sigils(self, field: str) -> str:
         """Return ``field`` value with [ROOT.KEY] tokens resolved."""
-        # Find field ignoring case
         name = field.lower()
         fobj = next((f for f in self._meta.fields if f.name.lower() == name), None)
         if not fobj:
@@ -72,44 +121,9 @@ class Entity(models.Model):
         value = self.__dict__.get(fobj.attname, "")
         if value is None:
             return ""
-        text = str(value)
-
-        pattern = re.compile(r"\[([A-Za-z0-9_]+)\.([A-Za-z0-9_]+)\]")
-        SigilRoot = apps.get_model("core", "SigilRoot")
+        from .sigil_resolver import resolve_sigils as _resolve
 
-        def repl(match):
-            root_name, key = match.group(1), match.group(2)
-            try:
-                root = SigilRoot.objects.get(prefix__iexact=root_name)
-                if root.context_type == SigilRoot.Context.CONFIG:
-                    if root.prefix.upper() == "ENV":
-                        if key in os.environ:
-                            return os.environ[key]
-                        logger.warning(
-                            "Missing environment variable for sigil [%s.%s]",
-                            root_name,
-                            key,
-                        )
-                        return match.group(0)
-                    if root.prefix.upper() == "SYS":
-                        if hasattr(settings, key):
-                            return str(getattr(settings, key))
-                        logger.warning(
-                            "Missing settings attribute for sigil [%s.%s]",
-                            root_name,
-                            key,
-                        )
-                        return match.group(0)
-                logger.warning(
-                    "Unresolvable sigil [%s.%s]: unsupported context", root_name, key
-                )
-            except SigilRoot.DoesNotExist:
-                logger.warning("Unknown sigil root [%s]", root_name)
-            except Exception:
-                logger.exception("Error resolving sigil [%s.%s]", root_name, key)
-            return match.group(0)
-
-        return pattern.sub(repl, text)
+        return _resolve(str(value), current=self)
 
     def delete(self, using=None, keep_parents=False):
         if self.is_seed_data:

core/fields.py

@@ -29,6 +29,12 @@ class _SigilBaseField:
     def value_from_object(self, obj):
         return obj.__dict__.get(self.attname)
 
+    def pre_save(self, model_instance, add):
+        # ``models.Field.pre_save`` uses ``getattr`` which would resolve the
+        # sigil descriptor. Persist the raw database value instead so env-based
+        # placeholders remain intact when editing through admin forms.
+        return self.value_from_object(model_instance)
+
 
 class SigilCheckFieldMixin(_SigilBaseField):
     descriptor_class = _CheckSigilDescriptor
@@ -67,4 +73,3 @@ class SigilShortAutoField(SigilAutoFieldMixin, models.CharField):
 
 class SigilLongAutoField(SigilAutoFieldMixin, models.TextField):
     pass
-

core/github_helper.py

@@ -0,0 +1,25 @@
+"""Helpers for reporting exceptions to GitHub."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from celery import shared_task
+
+
+logger = logging.getLogger(__name__)
+
+
+@shared_task
+def report_exception_to_github(payload: dict[str, Any]) -> None:
+    """Send exception context to the GitHub issue helper.
+
+    The task is intentionally light-weight in this repository. Deployments can
+    replace it with an implementation that forwards ``payload`` to the
+    automation responsible for creating GitHub issues.
+    """
+
+    logger.info(
+        "Queued GitHub issue report for %s", payload.get("fingerprint", "<unknown>")
+    )