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

core/checks.py

@@ -0,0 +1,29 @@
+import hashlib
+from pathlib import Path
+from django.conf import settings
+from django.core import checks
+
+
+def _fixture_hash() -> str:
+    base_dir = Path(settings.BASE_DIR)
+    md5 = hashlib.md5()
+    for path in sorted(base_dir.glob("**/fixtures/*.json")):
+        md5.update(path.read_bytes())
+    return md5.hexdigest()
+
+
+@checks.register(checks.Tags.database)
+def check_unapplied_fixtures(app_configs=None, **kwargs):
+    """Warn if fixture files have changed since last refresh."""
+    hash_file = Path(settings.BASE_DIR) / "fixtures.md5"
+    stored = hash_file.read_text().strip() if hash_file.exists() else ""
+    current = _fixture_hash()
+    if stored != current:
+        return [
+            checks.Warning(
+                "Unapplied fixture changes detected.",
+                hint="Run env-refresh to apply fixtures.",
+                id="core.W001",
+            )
+        ]
+    return []

core/entity.py

@@ -1,4 +1,5 @@
 import copy
+import logging
 import os
 import re
 
@@ -7,6 +8,8 @@ from django.conf import settings
 from django.db import models
 from django.contrib.auth.models import UserManager as DjangoUserManager
 
+logger = logging.getLogger(__name__)
+
 
 class EntityQuerySet(models.QuerySet):
     def delete(self):  # pragma: no cover - delegates to instance delete
@@ -78,14 +81,33 @@ class Entity(models.Model):
             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:
-                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 ""
+                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)
 

core/models.py

@@ -10,12 +10,14 @@ from django.utils.translation import gettext_lazy as _
 from django.core.validators import RegexValidator
 from django.core.exceptions import ValidationError
 from django.apps import apps
-from django.db.models.signals import m2m_changed, post_delete, post_save
+from django.db.models.signals import m2m_changed
 from django.dispatch import receiver
 from datetime import timedelta
 from django.contrib.contenttypes.models import ContentType
 import hashlib
 import os
+import subprocess
+import secrets
 from io import BytesIO
 from django.core.files.base import ContentFile
 import qrcode
@@ -62,6 +64,34 @@ class SigilRoot(Entity):
         verbose_name_plural = "Sigil Roots"
 
 
+class Lead(models.Model):
+    """Common request lead information."""
+
+    user = models.ForeignKey(
+        settings.AUTH_USER_MODEL, null=True, blank=True, on_delete=models.SET_NULL
+    )
+    path = models.TextField(blank=True)
+    referer = models.TextField(blank=True)
+    user_agent = models.TextField(blank=True)
+    ip_address = models.GenericIPAddressField(null=True, blank=True)
+    created_on = models.DateTimeField(auto_now_add=True)
+
+    class Meta:
+        abstract = True
+
+
+class InviteLead(Lead):
+    email = models.EmailField()
+    comment = models.TextField(blank=True)
+
+    class Meta:
+        verbose_name = "Invite Lead"
+        verbose_name_plural = "Invite Leads"
+
+    def __str__(self) -> str:  # pragma: no cover - simple representation
+        return self.email
+
+
 class Address(Entity):
     """Physical location information for a user."""
 
@@ -1075,7 +1105,7 @@ class ReleaseManager(Entity):
         max_length=200,
         blank=True,
         help_text=(
-            "Personal access token used to create GitHub pull requests. "
+            "Personal access token for GitHub operations. "
             "Used before the GITHUB_TOKEN environment variable."
         ),
     )
@@ -1124,14 +1154,30 @@ class Package(Entity):
     release_manager = models.ForeignKey(
         ReleaseManager, on_delete=models.SET_NULL, null=True, blank=True
     )
+    is_active = models.BooleanField(
+        default=False,
+        help_text="Designates the active package for version comparisons",
+    )
 
     class Meta:
         verbose_name = "Package"
         verbose_name_plural = "Packages"
+        constraints = [
+            models.UniqueConstraint(
+                fields=("is_active",),
+                condition=models.Q(is_active=True),
+                name="unique_active_package",
+            )
+        ]
 
     def __str__(self) -> str:  # pragma: no cover - trivial
         return self.name
 
+    def save(self, *args, **kwargs):
+        if self.is_active:
+            type(self).objects.exclude(pk=self.pk).update(is_active=False)
+        super().save(*args, **kwargs)
+
     def to_package(self) -> ReleasePackage:
         """Return a :class:`ReleasePackage` instance from package data."""
         return ReleasePackage(
@@ -1159,7 +1205,6 @@ class PackageRelease(Entity):
         max_length=40, blank=True, default=revision_utils.get_revision, editable=False
     )
     pypi_url = models.URLField("PyPI URL", blank=True, editable=False)
-    pr_url = models.URLField("PR URL", blank=True, editable=False)
 
     class Meta:
         verbose_name = "Package Release"
@@ -1222,11 +1267,13 @@ class PackageRelease(Entity):
 
     @property
     def is_current(self) -> bool:
-        """Return ``True`` if this release matches the current revision."""
-        from utils import revision as revision_utils
-
-        current = revision_utils.get_revision()
-        return bool(current) and current == self.revision
+        """Return ``True`` when this release's version matches the VERSION file
+        and its package is active."""
+        version_path = Path("VERSION")
+        if not version_path.exists():
+            return False
+        current_version = version_path.read_text().strip()
+        return current_version == self.version and self.package.is_active
 
     @classmethod
     def latest(cls):
@@ -1251,17 +1298,29 @@ class PackageRelease(Entity):
         )
         self.revision = revision_utils.get_revision()
         self.save(update_fields=["revision"])
+        PackageRelease.dump_fixture()
+        if kwargs.get("git"):
+            diff = subprocess.run(
+                ["git", "status", "--porcelain", "core/fixtures/releases.json"],
+                capture_output=True,
+                text=True,
+            )
+            if diff.stdout.strip():
+                release_utils._run(["git", "add", "core/fixtures/releases.json"])
+                release_utils._run(
+                    [
+                        "git",
+                        "commit",
+                        "-m",
+                        f"chore: update release fixture for v{self.version}",
+                    ]
+                )
+                release_utils._run(["git", "push"])
 
     @property
     def revision_short(self) -> str:
         return self.revision[-6:] if self.revision else ""
 
-
-@receiver([post_save, post_delete], sender=PackageRelease)
-def _update_release_fixture(sender, instance, **kwargs) -> None:
-    """Keep the release fixture in sync with the database."""
-    PackageRelease.dump_fixture()
-
 # Ensure each RFID can only be linked to one energy account
 @receiver(m2m_changed, sender=EnergyAccount.rfids.through)
 def _rfid_unique_energy_account(sender, instance, action, reverse, model, pk_set, **kwargs):
@@ -1276,3 +1335,54 @@ def _rfid_unique_energy_account(sender, instance, action, reverse, model, pk_set
             ).exclude(energy_accounts=instance)
             if conflict.exists():
                 raise ValidationError("RFID tags may only be assigned to one energy account.")
+
+
+def hash_key(key: str) -> str:
+    """Return a SHA-256 hash for ``key``."""
+
+    return hashlib.sha256(key.encode()).hexdigest()
+
+
+class ChatProfile(models.Model):
+    """Stores a hashed user key used by the assistant for authentication.
+
+    The plain-text ``user_key`` is generated server-side and shown only once.
+    Users must supply this key in the ``Authorization: Bearer <user_key>``
+    header when requesting protected endpoints. Only the hash is stored.
+    """
+
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    user = models.OneToOneField(
+        settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="chat_profile"
+    )
+    user_key_hash = models.CharField(max_length=64, unique=True)
+    scopes = models.JSONField(default=list, blank=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+    last_used_at = models.DateTimeField(null=True, blank=True)
+    is_active = models.BooleanField(default=True)
+
+    class Meta:
+        db_table = "workgroup_chatprofile"
+        verbose_name = "Chat Profile"
+        verbose_name_plural = "Chat Profiles"
+
+    @classmethod
+    def issue_key(cls, user) -> tuple["ChatProfile", str]:
+        """Create or update a profile and return it with a new plain key."""
+
+        key = secrets.token_hex(32)
+        key_hash = hash_key(key)
+        profile, _ = cls.objects.update_or_create(
+            user=user,
+            defaults={"user_key_hash": key_hash, "last_used_at": None, "is_active": True},
+        )
+        return profile, key
+
+    def touch(self) -> None:
+        """Record that the key was used."""
+
+        self.last_used_at = timezone.now()
+        self.save(update_fields=["last_used_at"])
+
+    def __str__(self) -> str:  # pragma: no cover - simple representation
+        return f"ChatProfile for {self.user}"

core/release.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import os
 import subprocess
 import sys
+import shutil
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Optional
@@ -82,20 +83,12 @@ def _git_clean() -> bool:
     return not proc.stdout.strip()
 
 
-def _current_commit() -> str:
-    return subprocess.check_output(["git", "rev-parse", "HEAD"]).decode().strip()
+def _git_has_staged_changes() -> bool:
+    """Return True if there are staged changes ready to commit."""
+    proc = subprocess.run(["git", "diff", "--cached", "--quiet"])
+    return proc.returncode != 0
 
 
-def _current_branch() -> str:
-    return (
-        subprocess.check_output([
-            "git",
-            "rev-parse",
-            "--abbrev-ref",
-            "HEAD",
-        ]).decode().strip()
-    )
-
 
 def _manager_credentials() -> Optional[Credentials]:
     """Return credentials from the Package's release manager if available."""
@@ -174,69 +167,6 @@ def _write_pyproject(package: Package, version: str, requirements: list[str]) ->
     Path("pyproject.toml").write_text(_dump_toml(content), encoding="utf-8")
 
 
-def _ensure_changelog() -> str:
-    header = "Changelog\n=========\n\n"
-    path = Path("CHANGELOG.rst")
-    text = path.read_text(encoding="utf-8") if path.exists() else ""
-    if not text.startswith("Changelog"):
-        text = header + text
-    if "Unreleased" not in text:
-        text = text[: len(header)] + "Unreleased\n----------\n\n" + text[len(header):]
-    return text
-
-
-def _pop_unreleased(text: str) -> tuple[str, str]:
-    lines = text.splitlines()
-    try:
-        idx = lines.index("Unreleased")
-    except ValueError:
-        return "", text
-    body = []
-    i = idx + 2
-    while i < len(lines) and lines[i].startswith("- "):
-        body.append(lines[i])
-        i += 1
-    if i < len(lines) and lines[i] == "":
-        i += 1
-    new_lines = lines[:idx] + lines[i:]
-    return "\n".join(body), "\n".join(new_lines) + ("\n" if text.endswith("\n") else "")
-
-
-def _last_changelog_revision() -> Optional[str]:
-    path = Path("CHANGELOG.rst")
-    if not path.exists():
-        return None
-    for line in path.read_text(encoding="utf-8").splitlines():
-        if "[revision" in line:
-            try:
-                return line.split("[revision", 1)[1].split("]", 1)[0].strip()
-            except Exception:
-                return None
-    return None
-
-
-def update_changelog(version: str, revision: str, prev_revision: Optional[str] = None) -> None:
-    text = _ensure_changelog()
-    body, text = _pop_unreleased(text)
-    if not body:
-        prev_revision = prev_revision or _last_changelog_revision()
-        log_range = f"{prev_revision}..HEAD" if prev_revision else "HEAD"
-        proc = subprocess.run(
-            ["git", "log", "--pretty=%h %s", "--no-merges", log_range],
-            capture_output=True,
-            text=True,
-            check=False,
-        )
-        body = "\n".join(
-            f"- {l.strip()}" for l in proc.stdout.splitlines() if l.strip()
-        )
-    header = f"{version} [revision {revision}]"
-    underline = "-" * len(header)
-    entry = "\n".join([header, underline, "", body, ""]).rstrip() + "\n\n"
-    base_header = "Changelog\n=========\n\n"
-    remaining = text[len(base_header):]
-    new_text = base_header + "Unreleased\n----------\n\n" + entry + remaining
-    Path("CHANGELOG.rst").write_text(new_text, encoding="utf-8")
 
 
 @requires_network
@@ -268,8 +198,8 @@ def build(
                 "Git repository is not clean. Commit, stash, or enable auto stash before building."
             )
 
+    version_path = Path("VERSION")
     if version is None:
-        version_path = Path("VERSION")
         if not version_path.exists():
             raise ReleaseError("VERSION file not found")
         version = version_path.read_text().strip()
@@ -278,6 +208,9 @@ def build(
             patch += 1
             version = f"{major}.{minor}.{patch}"
             version_path.write_text(version + "\n")
+    else:
+        # Ensure the VERSION file reflects the provided release version
+        version_path.write_text(version + "\n")
 
     requirements = [
         line.strip()
@@ -291,16 +224,10 @@ def build(
         if proc.returncode != 0:
             raise TestsFailed(log_path, proc.stdout + proc.stderr)
 
-    commit_hash = _current_commit()
-    prev_revision = _last_changelog_revision()
-    update_changelog(version, commit_hash, prev_revision)
-
     _write_pyproject(package, version, requirements)
     if dist:
         if Path("dist").exists():
-            for p in Path("dist").glob("*"):
-                p.unlink()
-            Path("dist").rmdir()
+            shutil.rmtree("dist")
         try:
             import build  # type: ignore
         except Exception:
@@ -308,10 +235,11 @@ def build(
         _run([sys.executable, "-m", "build"])
 
     if git:
-        files = ["VERSION", "pyproject.toml", "CHANGELOG.rst"]
+        files = ["VERSION", "pyproject.toml"]
         _run(["git", "add"] + files)
         msg = f"PyPI Release v{version}" if twine else f"Release v{version}"
-        _run(["git", "commit", "-m", msg])
+        if _git_has_staged_changes():
+            _run(["git", "commit", "-m", msg])
         _run(["git", "push"])
 
     if tag:
@@ -359,63 +287,23 @@ def promote(
     package: Package = DEFAULT_PACKAGE,
     version: str,
     creds: Optional[Credentials] = None,
-) -> tuple[str, str, str]:
-    """Create a release branch and build the package without tests.
-
-    Returns a tuple of the release commit hash, the new branch name and the
-    original branch name.
-    """
-    current = _current_branch()
-    tmp_branch = f"release/{version}"
-    stashed = False
-    try:
-        try:
-            _run(["git", "checkout", "-b", tmp_branch])
-        except subprocess.CalledProcessError:
-            _run(["git", "checkout", tmp_branch])
-        if not _git_clean():
-            _run(["git", "stash", "--include-untracked"])
-            stashed = True
-        build(
-            package=package,
-            version=version,
-            creds=creds,
-            tests=False,
-            dist=True,
-            git=False,
-            tag=False,
-            stash=True,
-        )
-        try:  # best effort
-            _run(
-                [
-                    sys.executable,
-                    "manage.py",
-                    "squashmigrations",
-                    "core",
-                    "0001",
-                    "--noinput",
-                ],
-                check=False,
-            )
-        except Exception:
-            # The squashmigrations command may not be available or could fail
-            # (e.g. when no migrations exist). Any errors should not interrupt
-            # the release promotion flow.
-            pass
-        _run(["git", "add", "."])  # add all changes
+) -> None:
+    """Build the package and commit the release on the current branch."""
+    if not _git_clean():
+        raise ReleaseError("Git repository is not clean")
+    build(
+        package=package,
+        version=version,
+        creds=creds,
+        tests=False,
+        dist=True,
+        git=False,
+        tag=False,
+        stash=False,
+    )
+    _run(["git", "add", "."])  # add all changes
+    if _git_has_staged_changes():
         _run(["git", "commit", "-m", f"Release v{version}"])
-        commit_hash = _current_commit()
-        release_name = f"{package.name}-{version}-{commit_hash[:7]}"
-        branch = f"release-{release_name}"
-        _run(["git", "branch", "-m", branch])
-    except Exception:
-        _run(["git", "checkout", current])
-        raise
-    finally:
-        if stashed:
-            _run(["git", "stash", "pop"], check=False)
-    return commit_hash, branch, current
 
 
 def publish(

core/system.py

@@ -31,8 +31,8 @@ def _gather_info() -> dict:
     info["mode"] = mode
     info["port"] = 8000 if mode == "public" else 8888
 
-    role_file = lock_dir / "role.lck"
-    info["role"] = role_file.read_text().strip() if role_file.exists() else "unknown"
+    # Use settings.NODE_ROLE as the single source of truth for the node role.
+    info["role"] = getattr(settings, "NODE_ROLE", "Terminal")
 
     info["features"] = {
         "celery": (lock_dir / "celery.lck").exists(),

core/test_system_info.py

@@ -0,0 +1,21 @@
+import os
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
+
+import django
+django.setup()
+
+from django.test import SimpleTestCase, override_settings
+from core.system import _gather_info
+
+
+class SystemInfoRoleTests(SimpleTestCase):
+    @override_settings(NODE_ROLE="Terminal")
+    def test_defaults_to_terminal(self):
+        info = _gather_info()
+        self.assertEqual(info["role"], "Terminal")
+
+    @override_settings(NODE_ROLE="Satellite")
+    def test_uses_settings_role(self):
+        info = _gather_info()
+        self.assertEqual(info["role"], "Satellite")