arthexis 0.1.3__py3-none-any.whl

core/apps.py

@@ -0,0 +1,67 @@
+from django.apps import AppConfig
+from django.utils.translation import gettext_lazy as _
+
+
+class CoreConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "core"
+    verbose_name = _("Business Models")
+
+    def ready(self):  # pragma: no cover - called by Django
+        from django.contrib.auth import get_user_model
+        from django.db.models.signals import post_migrate
+        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
+
+        def create_default_arthexis(**kwargs):
+            User = get_user_model()
+            if not User.all_objects.exists():
+                User.all_objects.create_superuser(
+                    pk=1,
+                    username="arthexis",
+                    email="arthexis@gmail.com",
+                    password="arthexis",
+                )
+
+        post_migrate.connect(create_default_arthexis, sender=self)
+        patch_admin_user_datum()
+        patch_admin_user_data_views()
+        patch_admin_system_view()
+        patch_admin_environment_view()
+
+        from pathlib import Path
+        from django.conf import settings
+
+        lock = Path(settings.BASE_DIR) / "locks" / "celery.lck"
+
+        if lock.exists():
+
+            def ensure_email_collector_task(**kwargs):
+                try:  # pragma: no cover - optional dependency
+                    from django_celery_beat.models import (
+                        IntervalSchedule,
+                        PeriodicTask,
+                    )
+                    from django.db.utils import OperationalError, ProgrammingError
+                except Exception:  # pragma: no cover - tables or module not ready
+                    return
+
+                try:
+                    schedule, _ = IntervalSchedule.objects.get_or_create(
+                        every=1, period=IntervalSchedule.HOURS
+                    )
+                    PeriodicTask.objects.get_or_create(
+                        name="poll_email_collectors",
+                        defaults={
+                            "interval": schedule,
+                            "task": "core.tasks.poll_email_collectors",
+                        },
+                    )
+                except (OperationalError, ProgrammingError):
+                    pass
+
+            post_migrate.connect(ensure_email_collector_task, sender=self)

core/backends.py

@@ -0,0 +1,82 @@
+"""Custom authentication backends for the core app."""
+
+from django.contrib.auth import get_user_model
+from django.contrib.auth.backends import ModelBackend
+import ipaddress
+
+from .models import EnergyAccount
+
+
+class RFIDBackend:
+    """Authenticate using a user's RFID."""
+
+    def authenticate(self, request, rfid=None, **kwargs):
+        if not rfid:
+            return None
+        account = (
+            EnergyAccount.objects.filter(
+                rfids__rfid=rfid.upper(), rfids__allowed=True, user__isnull=False
+            )
+            .select_related("user")
+            .first()
+        )
+        if account:
+            return account.user
+        return None
+
+    def get_user(self, user_id):
+        User = get_user_model()
+        try:
+            return User.objects.get(pk=user_id)
+        except User.DoesNotExist:
+            return None
+
+
+class LocalhostAdminBackend(ModelBackend):
+    """Allow default admin credentials only from local networks."""
+
+    _ALLOWED_NETWORKS = [
+        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"),
+    ]
+
+    def authenticate(self, request, username=None, password=None, **kwargs):
+        if username == "admin" and password == "admin" and request is not None:
+            forwarded = request.META.get("HTTP_X_FORWARDED_FOR")
+            if forwarded:
+                remote = forwarded.split(",")[0].strip()
+            else:
+                remote = request.META.get("REMOTE_ADDR", "")
+            try:
+                ip = ipaddress.ip_address(remote)
+            except ValueError:
+                return None
+            allowed = any(ip in net for net in self._ALLOWED_NETWORKS)
+            if not allowed:
+                return None
+            User = get_user_model()
+            user, created = User.all_objects.get_or_create(
+                username="admin",
+                defaults={
+                    "is_staff": True,
+                    "is_superuser": True,
+                },
+            )
+            if created:
+                user.set_password("admin")
+                user.save()
+            elif not user.check_password("admin"):
+                return None
+            return user
+        return super().authenticate(request, username, password, **kwargs)
+
+    def get_user(self, user_id):
+        User = get_user_model()
+        try:
+            return User.all_objects.get(pk=user_id)
+        except User.DoesNotExist:
+            return None
+

core/entity.py

@@ -0,0 +1,97 @@
+import copy
+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
+
+
+class EntityQuerySet(models.QuerySet):
+    def delete(self):  # pragma: no cover - delegates to instance delete
+        deleted = 0
+        for obj in self:
+            obj.delete()
+            deleted += 1
+        return deleted, {}
+
+
+class EntityManager(models.Manager):
+    def get_queryset(self):
+        return EntityQuerySet(self.model, using=self._db).filter(is_deleted=False)
+
+
+class EntityUserManager(DjangoUserManager):
+    def get_queryset(self):
+        return (
+            EntityQuerySet(self.model, using=self._db)
+            .filter(is_deleted=False)
+            .exclude(username="admin")
+        )
+
+
+class Entity(models.Model):
+    """Base model providing seed data tracking and soft deletion."""
+
+    is_seed_data = models.BooleanField(default=False, editable=False)
+    is_deleted = models.BooleanField(default=False, editable=False)
+
+    objects = EntityManager()
+    all_objects = models.Manager()
+
+    class Meta:
+        abstract = True
+
+    def clone(self):
+        """Return an unsaved copy of this instance."""
+        new = copy.copy(self)
+        new.pk = None
+        return new
+
+    def save(self, *args, **kwargs):
+        if self.pk:
+            try:
+                old = type(self).all_objects.get(pk=self.pk)
+            except type(self).DoesNotExist:
+                pass
+            else:
+                self.is_seed_data = old.is_seed_data
+        super().save(*args, **kwargs)
+
+    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:
+            return ""
+        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")
+
+        def repl(match):
+            root_name, key = match.group(1), match.group(2)
+            try:
+                root = SigilRoot.objects.get(prefix__iexact=root_name)
+            except SigilRoot.DoesNotExist:
+                return ""
+            if root.context_type == SigilRoot.Context.CONFIG:
+                if root.prefix.upper() == "ENV":
+                    return os.environ.get(key, "")
+                if root.prefix.upper() == "SYS":
+                    return str(getattr(settings, key, ""))
+            return ""
+
+        return pattern.sub(repl, text)
+
+    def delete(self, using=None, keep_parents=False):
+        if self.is_seed_data:
+            self.is_deleted = True
+            self.save(update_fields=["is_deleted"])
+        else:
+            super().delete(using=using, keep_parents=keep_parents)

core/environment.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import os
+
+from django.conf import settings
+from django.contrib import admin
+from django.template.response import TemplateResponse
+from django.urls import path
+from django.utils.translation import gettext_lazy as _
+
+
+def _environment_view(request):
+    env_vars = sorted(os.environ.items())
+    django_settings = sorted(
+        [(name, getattr(settings, name)) for name in dir(settings) if name.isupper()]
+    )
+    context = admin.site.each_context(request)
+    context.update(
+        {
+            "title": _("Environment"),
+            "env_vars": env_vars,
+            "django_settings": django_settings,
+        }
+    )
+    return TemplateResponse(request, "admin/environment.html", context)
+
+
+def patch_admin_environment_view() -> None:
+    """Add custom admin view for environment information."""
+    original_get_urls = admin.site.get_urls
+
+    def get_urls():
+        urls = original_get_urls()
+        custom = [
+            path(
+                "environment/",
+                admin.site.admin_view(_environment_view),
+                name="environment",
+            ),
+        ]
+        return custom + urls
+
+    admin.site.get_urls = get_urls

core/fields.py

@@ -0,0 +1,70 @@
+from django.db import models
+from django.db.models.fields import DeferredAttribute
+
+
+class _BaseSigilDescriptor(DeferredAttribute):
+    def __set__(self, instance, value):
+        instance.__dict__[self.field.attname] = value
+
+
+class _CheckSigilDescriptor(_BaseSigilDescriptor):
+    def __get__(self, instance, cls=None):
+        value = super().__get__(instance, cls)
+        if instance is None:
+            return value
+        if getattr(instance, f"{self.field.name}_resolve_sigils", False):
+            return instance.resolve_sigils(self.field.name)
+        return value
+
+
+class _AutoSigilDescriptor(_BaseSigilDescriptor):
+    def __get__(self, instance, cls=None):
+        value = super().__get__(instance, cls)
+        if instance is None:
+            return value
+        return instance.resolve_sigils(self.field.name)
+
+
+class _SigilBaseField:
+    def value_from_object(self, obj):
+        return obj.__dict__.get(self.attname)
+
+
+class SigilCheckFieldMixin(_SigilBaseField):
+    descriptor_class = _CheckSigilDescriptor
+
+    def contribute_to_class(self, cls, name, private_only=False):
+        super().contribute_to_class(cls, name, private_only=private_only)
+        extra_name = f"{name}_resolve_sigils"
+        if not any(f.name == extra_name for f in cls._meta.fields):
+            cls.add_to_class(
+                extra_name,
+                models.BooleanField(
+                    default=False,
+                    verbose_name="Resolve [SIGILS] in templates",
+                ),
+            )
+
+
+class SigilAutoFieldMixin(_SigilBaseField):
+    descriptor_class = _AutoSigilDescriptor
+
+    def contribute_to_class(self, cls, name, private_only=False):
+        super().contribute_to_class(cls, name, private_only=private_only)
+
+
+class SigilShortCheckField(SigilCheckFieldMixin, models.CharField):
+    pass
+
+
+class SigilLongCheckField(SigilCheckFieldMixin, models.TextField):
+    pass
+
+
+class SigilShortAutoField(SigilAutoFieldMixin, models.CharField):
+    pass
+
+
+class SigilLongAutoField(SigilAutoFieldMixin, models.TextField):
+    pass
+

core/lcd_screen.py

@@ -0,0 +1,77 @@
+"""Standalone LCD screen updater.
+
+The script polls ``locks/lcd_screen.lck`` for up to two lines of text and
+writes them to the attached LCD1602 display. If either line exceeds 16
+characters the text scrolls horizontally. A third line in the lock file
+can define the scroll speed in milliseconds per character (default 1000
+ms).
+"""
+from __future__ import annotations
+
+import logging
+import time
+from pathlib import Path
+
+from nodes.lcd import CharLCD1602, LCDUnavailableError
+
+logger = logging.getLogger(__name__)
+
+LOCK_FILE = Path(__file__).resolve().parents[1] / "locks" / "lcd_screen.lck"
+DEFAULT_SCROLL_MS = 1000
+
+
+def _read_lock_file() -> tuple[str, str, int]:
+    try:
+        lines = LOCK_FILE.read_text(encoding="utf-8").splitlines()
+    except FileNotFoundError:
+        return "", "", DEFAULT_SCROLL_MS
+    line1 = lines[0][:64] if len(lines) > 0 else ""
+    line2 = lines[1][:64] if len(lines) > 1 else ""
+    try:
+        speed = int(lines[2]) if len(lines) > 2 else DEFAULT_SCROLL_MS
+    except ValueError:
+        speed = DEFAULT_SCROLL_MS
+    return line1, line2, speed
+
+
+def _display(lcd: CharLCD1602, line1: str, line2: str, scroll_ms: int) -> None:
+    scroll_sec = max(scroll_ms, 0) / 1000.0
+    text1 = line1[:64]
+    text2 = line2[:64]
+    pad1 = text1 + " " * 16 if len(text1) > 16 else text1.ljust(16)
+    pad2 = text2 + " " * 16 if len(text2) > 16 else text2.ljust(16)
+    steps = max(len(pad1) - 15, len(pad2) - 15)
+    for i in range(steps):
+        segment1 = pad1[i : i + 16]
+        segment2 = pad2[i : i + 16]
+        lcd.write(0, 0, segment1.ljust(16))
+        lcd.write(0, 1, segment2.ljust(16))
+        time.sleep(scroll_sec)
+
+
+def main() -> None:  # pragma: no cover - hardware dependent
+    lcd = None
+    last_mtime = 0.0
+    while True:
+        try:
+            if LOCK_FILE.exists():
+                mtime = LOCK_FILE.stat().st_mtime
+                if mtime != last_mtime or lcd is None:
+                    line1, line2, speed = _read_lock_file()
+                    if lcd is None:
+                        lcd = CharLCD1602()
+                        lcd.init_lcd()
+                    lcd.clear()
+                    _display(lcd, line1, line2, speed)
+                    last_mtime = mtime
+        except LCDUnavailableError as exc:
+            logger.warning("LCD unavailable: %s", exc)
+            lcd = None
+        except Exception as exc:
+            logger.warning("LCD update failed: %s", exc)
+            lcd = None
+        time.sleep(0.5)
+
+
+if __name__ == "__main__":  # pragma: no cover - script entry point
+    main()

core/middleware.py

@@ -0,0 +1,34 @@
+from django.contrib.contenttypes.models import ContentType
+from .models import AdminHistory
+
+
+class AdminHistoryMiddleware:
+    """Log recently visited admin changelists for each user."""
+
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        response = self.get_response(request)
+        match = getattr(request, "resolver_match", None)
+        if (
+            request.user.is_authenticated
+            and request.user.is_staff
+            and request.method == "GET"
+            and match
+            and match.url_name
+            and match.url_name.endswith("_changelist")
+            and response.status_code == 200
+        ):
+            parts = request.path.strip("/").split("/")
+            if len(parts) >= 3:
+                app_label, model_name = parts[1], parts[2]
+                content_type = ContentType.objects.get_by_natural_key(
+                    app_label, model_name
+                )
+                AdminHistory.objects.update_or_create(
+                    user=request.user,
+                    url=request.get_full_path(),
+                    defaults={"content_type": content_type},
+                )
+        return response