arthexis 0.1.13__py3-none-any.whl → 0.1.15__py3-none-any.whl

core/rfid_import_export.py

@@ -0,0 +1,113 @@
+"""Shared helpers for RFID import and export workflows."""
+
+from __future__ import annotations
+
+from collections import OrderedDict
+from collections.abc import Iterable, Mapping
+
+from core.models import EnergyAccount, RFID
+
+
+def account_column_for_field(account_field: str) -> str:
+    """Return the column name that should be used for the account field.
+
+    Args:
+        account_field: Either ``"id"`` or ``"name"`` depending on how energy
+            accounts should be represented.
+
+    Returns:
+        The CSV column header to use for the selected account field.
+    """
+
+    return "energy_account_names" if account_field == "name" else "energy_accounts"
+
+
+def serialize_accounts(tag: RFID, account_field: str) -> str:
+    """Convert the RFID's accounts to a serialized string."""
+
+    accounts = tag.energy_accounts.all()
+    if account_field == "name":
+        return ",".join(account.name for account in accounts if account.name)
+    return ",".join(str(account.id) for account in accounts)
+
+
+def _normalized_unique_names(values: Iterable[str]) -> list[str]:
+    """Return a list of unique, normalized account names preserving order."""
+
+    seen: OrderedDict[str, None] = OrderedDict()
+    for value in values:
+        normalized = value.strip().upper()
+        if not normalized:
+            continue
+        if normalized not in seen:
+            seen[normalized] = None
+    return list(seen.keys())
+
+
+def _accounts_from_ids(values: Iterable[str]) -> list[EnergyAccount]:
+    """Resolve a list of account ids into EnergyAccount instances."""
+
+    identifiers: list[int] = []
+    for value in values:
+        value = value.strip()
+        if not value:
+            continue
+        try:
+            identifiers.append(int(value))
+        except (TypeError, ValueError):
+            continue
+    if not identifiers:
+        return []
+    existing = EnergyAccount.objects.in_bulk(identifiers)
+    return [existing[idx] for idx in identifiers if idx in existing]
+
+
+def parse_accounts(row: Mapping[str, object], account_field: str) -> list[EnergyAccount]:
+    """Resolve energy accounts for an RFID import row.
+
+    Args:
+        row: Mapping of column names to raw values for the import row.
+        account_field: Preferred field (``"id"`` or ``"name"``) describing how
+            accounts are encoded.
+
+    Returns:
+        A list of :class:`EnergyAccount` instances. The list will be empty when
+        no accounts should be linked.
+    """
+
+    preferred_column = account_column_for_field(account_field)
+    fallback_column = (
+        "energy_accounts"
+        if preferred_column == "energy_account_names"
+        else "energy_account_names"
+    )
+
+    def _value_for(column: str) -> str:
+        raw = row.get(column, "")
+        if raw is None:
+            return ""
+        return str(raw).strip()
+
+    raw_value = _value_for(preferred_column)
+    effective_field = account_field
+
+    if not raw_value:
+        raw_value = _value_for(fallback_column)
+        if raw_value:
+            effective_field = (
+                "name" if fallback_column == "energy_account_names" else "id"
+            )
+
+    if not raw_value:
+        return []
+
+    parts = raw_value.split(",")
+    if effective_field == "name":
+        accounts: list[EnergyAccount] = []
+        for normalized_name in _normalized_unique_names(parts):
+            account, _ = EnergyAccount.objects.get_or_create(name=normalized_name)
+            accounts.append(account)
+        return accounts
+
+    return _accounts_from_ids(parts)
+

core/sigil_builder.py

@@ -1,149 +1,149 @@
-from __future__ import annotations
-
-
-from django.apps import apps
-from django.contrib import admin
-from django.template.response import TemplateResponse
-from django.urls import path, reverse
-from django.utils.translation import gettext_lazy as _
-
-from .fields import SigilAutoFieldMixin
-from .sigil_resolver import (
-    resolve_sigils as resolve_sigils_in_text,
-    resolve_sigil as _resolve_sigil,
-)
-
-
-def generate_model_sigils(**kwargs) -> None:
-    """Ensure built-in configuration SigilRoot entries exist."""
-    SigilRoot = apps.get_model("core", "SigilRoot")
-    for prefix in ["ENV", "CONF", "SYS"]:
-        # Ensure built-in configuration roots exist without violating the
-        # unique ``prefix`` constraint, even if older databases already have
-        # entries with a different ``context_type``.
-        root = SigilRoot.objects.filter(prefix__iexact=prefix).first()
-        if root:
-            root.prefix = prefix
-            root.context_type = SigilRoot.Context.CONFIG
-            root.save(update_fields=["prefix", "context_type"])
-        else:
-            SigilRoot.objects.create(
-                prefix=prefix,
-                context_type=SigilRoot.Context.CONFIG,
-            )
-
-
-def _sigil_builder_view(request):
-    SigilRoot = apps.get_model("core", "SigilRoot")
-    grouped: dict[str, dict[str, object]] = {}
-    builtin_roots = [
-        {
-            "prefix": "ENV",
-            "url": reverse("admin:environment"),
-            "label": _("Environ"),
-        },
-        {
-            "prefix": "CONF",
-            "url": reverse("admin:config"),
-            "label": _("Config"),
-        },
-        {
-            "prefix": "SYS",
-            "url": reverse("admin:system"),
-            "label": _("System"),
-        },
-    ]
-    for root in SigilRoot.objects.filter(
-        context_type=SigilRoot.Context.ENTITY
-    ).select_related("content_type"):
-        if not root.content_type:
-            continue
-        model = root.content_type.model_class()
-        model_name = model._meta.object_name
-        entry = grouped.setdefault(
-            model_name,
-            {
-                "model": model_name,
-                "fields": [f.name.upper() for f in model._meta.fields],
-                "prefixes": [],
-            },
-        )
-        entry["prefixes"].append(root.prefix.upper())
-    roots = sorted(grouped.values(), key=lambda r: r["model"])
-    for entry in roots:
-        entry["prefixes"].sort()
-
-    auto_fields = []
-    seen = set()
-    for model in apps.get_models():
-        model_name = model._meta.object_name
-        if model_name in seen:
-            continue
-        seen.add(model_name)
-        prefixes = grouped.get(model_name, {}).get("prefixes", [])
-        for field in model._meta.fields:
-            if isinstance(field, SigilAutoFieldMixin):
-                auto_fields.append(
-                    {
-                        "model": model_name,
-                        "roots": prefixes,
-                        "field": field.name.upper(),
-                    }
-                )
-
-    sigils_text = ""
-    resolved_text = ""
-    show_sigils_input = True
-    show_result = False
-    if request.method == "POST":
-        sigils_text = request.POST.get("sigils_text", "")
-        source_text = sigils_text
-        upload = request.FILES.get("sigils_file")
-        if upload:
-            source_text = upload.read().decode("utf-8", errors="ignore")
-            show_sigils_input = False
-        else:
-            single = request.POST.get("sigil", "")
-            if single:
-                source_text = (
-                    f"[{single}]" if not single.startswith("[") else single
-                )
-                sigils_text = source_text
-        if source_text:
-            resolved_text = resolve_sigils_in_text(source_text)
-            show_result = True
-        if upload:
-            sigils_text = ""
-
-    context = admin.site.each_context(request)
-    context.update(
-        {
-            "title": _("Sigil Builder"),
-            "sigil_roots": roots,
-            "builtin_roots": builtin_roots,
-            "auto_fields": auto_fields,
-            "sigils_text": sigils_text,
-            "resolved_text": resolved_text,
-            "show_sigils_input": show_sigils_input,
-            "show_result": show_result,
-        }
-    )
-    return TemplateResponse(request, "admin/sigil_builder.html", context)
-
-
-def patch_admin_sigil_builder_view() -> None:
-    """Add custom admin view for listing SigilRoots."""
-    original_get_urls = admin.site.get_urls
-
-    def get_urls():
-        urls = original_get_urls()
-        custom = [
-            path(
-                "sigil-builder/",
-                admin.site.admin_view(_sigil_builder_view),
-                name="sigil_builder",
-            ),
-        ]
-        return custom + urls
-
-    admin.site.get_urls = get_urls
+from __future__ import annotations
+
+
+from django.apps import apps
+from django.contrib import admin
+from django.template.response import TemplateResponse
+from django.urls import path, reverse
+from django.utils.translation import gettext_lazy as _
+
+from .fields import SigilAutoFieldMixin
+from .sigil_resolver import (
+    resolve_sigils as resolve_sigils_in_text,
+    resolve_sigil as _resolve_sigil,
+)
+
+
+def generate_model_sigils(**kwargs) -> None:
+    """Ensure built-in configuration SigilRoot entries exist."""
+    SigilRoot = apps.get_model("core", "SigilRoot")
+    for prefix in ["ENV", "CONF", "SYS"]:
+        # Ensure built-in configuration roots exist without violating the
+        # unique ``prefix`` constraint, even if older databases already have
+        # entries with a different ``context_type``.
+        root = SigilRoot.objects.filter(prefix__iexact=prefix).first()
+        if root:
+            root.prefix = prefix
+            root.context_type = SigilRoot.Context.CONFIG
+            root.save(update_fields=["prefix", "context_type"])
+        else:
+            SigilRoot.objects.create(
+                prefix=prefix,
+                context_type=SigilRoot.Context.CONFIG,
+            )
+
+
+def _sigil_builder_view(request):
+    SigilRoot = apps.get_model("core", "SigilRoot")
+    grouped: dict[str, dict[str, object]] = {}
+    builtin_roots = [
+        {
+            "prefix": "ENV",
+            "url": reverse("admin:environment"),
+            "label": _("Environ"),
+        },
+        {
+            "prefix": "CONF",
+            "url": reverse("admin:config"),
+            "label": _("Config"),
+        },
+        {
+            "prefix": "SYS",
+            "url": reverse("admin:system"),
+            "label": _("System"),
+        },
+    ]
+    for root in SigilRoot.objects.filter(
+        context_type=SigilRoot.Context.ENTITY
+    ).select_related("content_type"):
+        if not root.content_type:
+            continue
+        model = root.content_type.model_class()
+        model_name = model._meta.object_name
+        entry = grouped.setdefault(
+            model_name,
+            {
+                "model": model_name,
+                "fields": [f.name.upper() for f in model._meta.fields],
+                "prefixes": [],
+            },
+        )
+        entry["prefixes"].append(root.prefix.upper())
+    roots = sorted(grouped.values(), key=lambda r: r["model"])
+    for entry in roots:
+        entry["prefixes"].sort()
+
+    auto_fields = []
+    seen = set()
+    for model in apps.get_models():
+        model_name = model._meta.object_name
+        if model_name in seen:
+            continue
+        seen.add(model_name)
+        prefixes = grouped.get(model_name, {}).get("prefixes", [])
+        for field in model._meta.fields:
+            if isinstance(field, SigilAutoFieldMixin):
+                auto_fields.append(
+                    {
+                        "model": model_name,
+                        "roots": prefixes,
+                        "field": field.name.upper(),
+                    }
+                )
+
+    sigils_text = ""
+    resolved_text = ""
+    show_sigils_input = True
+    show_result = False
+    if request.method == "POST":
+        sigils_text = request.POST.get("sigils_text", "")
+        source_text = sigils_text
+        upload = request.FILES.get("sigils_file")
+        if upload:
+            source_text = upload.read().decode("utf-8", errors="ignore")
+            show_sigils_input = False
+        else:
+            single = request.POST.get("sigil", "")
+            if single:
+                source_text = (
+                    f"[{single}]" if not single.startswith("[") else single
+                )
+                sigils_text = source_text
+        if source_text:
+            resolved_text = resolve_sigils_in_text(source_text)
+            show_result = True
+        if upload:
+            sigils_text = ""
+
+    context = admin.site.each_context(request)
+    context.update(
+        {
+            "title": _("Sigil Builder"),
+            "sigil_roots": roots,
+            "builtin_roots": builtin_roots,
+            "auto_fields": auto_fields,
+            "sigils_text": sigils_text,
+            "resolved_text": resolved_text,
+            "show_sigils_input": show_sigils_input,
+            "show_result": show_result,
+        }
+    )
+    return TemplateResponse(request, "admin/sigil_builder.html", context)
+
+
+def patch_admin_sigil_builder_view() -> None:
+    """Add custom admin view for listing SigilRoots."""
+    original_get_urls = admin.site.get_urls
+
+    def get_urls():
+        urls = original_get_urls()
+        custom = [
+            path(
+                "sigil-builder/",
+                admin.site.admin_view(_sigil_builder_view),
+                name="sigil_builder",
+            ),
+        ]
+        return custom + urls
+
+    admin.site.get_urls = get_urls

core/sigil_context.py

@@ -1,20 +1,20 @@
-from __future__ import annotations
-
-from threading import local
-from typing import Dict, Type
-from django.db import models
-
-_thread = local()
-
-
-def set_context(context: Dict[Type[models.Model], str]) -> None:
-    _thread.context = context
-
-
-def get_context() -> Dict[Type[models.Model], str]:
-    return getattr(_thread, "context", {})
-
-
-def clear_context() -> None:
-    if hasattr(_thread, "context"):
-        delattr(_thread, "context")
+from __future__ import annotations
+
+from threading import local
+from typing import Dict, Type
+from django.db import models
+
+_thread = local()
+
+
+def set_context(context: Dict[Type[models.Model], str]) -> None:
+    _thread.context = context
+
+
+def get_context() -> Dict[Type[models.Model], str]:
+    return getattr(_thread, "context", {})
+
+
+def clear_context() -> None:
+    if hasattr(_thread, "context"):
+        delattr(_thread, "context")