arthexis 0.1.20__py3-none-any.whl → 0.1.22__py3-none-any.whl

core/admin.py

@@ -83,6 +83,7 @@ from .models import (
     OdooProfile,
     OpenPayProfile,
     EmailInbox,
+    GoogleCalendarProfile,
     SocialProfile,
     EmailCollector,
     Package,
@@ -91,9 +92,7 @@ from .models import (
     SecurityGroup,
     InviteLead,
     PublicWifiAccess,
-    AssistantProfile,
     Todo,
-    hash_key,
 )
 from .user_data import (
     EntityModelAdmin,
@@ -110,8 +109,6 @@ from .rfid_import_export import (
     parse_accounts,
     serialize_accounts,
 )
-from .mcp import process as mcp_process
-from .mcp.server import resolve_base_urls
 from . import release as release_utils
 
 logger = logging.getLogger(__name__)
@@ -1009,6 +1006,41 @@ class OpenPayProfileAdminForm(forms.ModelForm):
         )
 
 
+class GoogleCalendarProfileAdminForm(forms.ModelForm):
+    """Admin form for :class:`core.models.GoogleCalendarProfile`."""
+
+    api_key = forms.CharField(
+        widget=forms.PasswordInput(render_value=True),
+        required=False,
+        help_text="Leave blank to keep the current key.",
+    )
+
+    class Meta:
+        model = GoogleCalendarProfile
+        fields = "__all__"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if self.instance.pk:
+            self.fields["api_key"].initial = ""
+            self.initial["api_key"] = ""
+        else:
+            self.fields["api_key"].required = True
+
+    def clean_api_key(self):
+        key = self.cleaned_data.get("api_key")
+        if not key and self.instance.pk:
+            return keep_existing("api_key")
+        return key
+
+    def _post_clean(self):
+        super()._post_clean()
+        _restore_sigil_values(
+            self,
+            ["calendar_id", "api_key", "display_name", "timezone"],
+        )
+
+
 class MaskedPasswordFormMixin:
     """Mixin that hides stored passwords while allowing updates."""
 
@@ -1226,6 +1258,15 @@ class OpenPayProfileInlineForm(ProfileFormMixin, OpenPayProfileAdminForm):
         return cleaned
 
 
+class GoogleCalendarProfileInlineForm(
+    ProfileFormMixin, GoogleCalendarProfileAdminForm
+):
+    profile_fields = GoogleCalendarProfile.profile_fields
+
+    class Meta(GoogleCalendarProfileAdminForm.Meta):
+        exclude = ("user", "group")
+
+
 class EmailInboxInlineForm(ProfileFormMixin, EmailInboxAdminForm):
     profile_fields = EmailInbox.profile_fields
 
@@ -1304,46 +1345,6 @@ class ReleaseManagerInlineForm(ProfileFormMixin, forms.ModelForm):
         }
 
 
-class AssistantProfileInlineForm(ProfileFormMixin, forms.ModelForm):
-    user_key = forms.CharField(
-        required=False,
-        widget=forms.PasswordInput(render_value=True),
-        help_text="Provide a plain key to create or rotate credentials.",
-    )
-    profile_fields = ("assistant_name", "user_key", "scopes", "is_active")
-
-    class Meta:
-        model = AssistantProfile
-        fields = ("assistant_name", "scopes", "is_active")
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        if not self.instance.pk and "is_active" in self.fields:
-            self.fields["is_active"].initial = False
-
-    def clean(self):
-        cleaned = super().clean()
-        if cleaned.get("DELETE"):
-            return cleaned
-        if not self.instance.pk and not cleaned.get("user_key"):
-            if cleaned.get("scopes") or cleaned.get("is_active"):
-                raise forms.ValidationError(
-                    "Provide a user key to create an assistant profile."
-                )
-        return cleaned
-
-    def save(self, commit=True):
-        instance = super().save(commit=False)
-        user_key = self.cleaned_data.get("user_key")
-        if user_key:
-            instance.user_key_hash = hash_key(user_key)
-            instance.last_used_at = None
-        if commit:
-            instance.save()
-            self.save_m2m()
-        return instance
-
-
 PROFILE_INLINE_CONFIG = {
     OdooProfile: {
         "form": OdooProfileInlineForm,
@@ -1390,6 +1391,16 @@ PROFILE_INLINE_CONFIG = {
         ),
         "readonly_fields": ("verified_on", "verification_reference"),
     },
+    GoogleCalendarProfile: {
+        "form": GoogleCalendarProfileInlineForm,
+        "fields": (
+            "display_name",
+            "calendar_id",
+            "api_key",
+            "max_events",
+            "timezone",
+        ),
+    },
     EmailInbox: {
         "form": EmailInboxInlineForm,
         "fields": (
@@ -1474,12 +1485,6 @@ PROFILE_INLINE_CONFIG = {
             "secondary_pypi_url",
         ),
     },
-    AssistantProfile: {
-        "form": AssistantProfileInlineForm,
-        "fields": ("assistant_name", "user_key", "scopes", "is_active"),
-        "readonly_fields": ("user_key_hash", "created_at", "last_used_at"),
-        "template": "admin/edit_inline/profile_stacked.html",
-    },
 }
 
 
@@ -1526,7 +1531,6 @@ PROFILE_MODELS = (
     EmailOutbox,
     SocialProfile,
     ReleaseManager,
-    AssistantProfile,
 )
 USER_PROFILE_INLINES = [
     _build_profile_inline(model, "user") for model in PROFILE_MODELS
@@ -1868,6 +1872,44 @@ class OpenPayProfileAdmin(ProfileAdminMixin, SaveBeforeChangeAction, EntityModel
     verify_credentials_action.short_description = _("Test credentials")
 
 
+class GoogleCalendarProfileAdmin(
+    ProfileAdminMixin, SaveBeforeChangeAction, EntityModelAdmin
+):
+    form = GoogleCalendarProfileAdminForm
+    list_display = ("owner", "calendar_identifier", "max_events")
+    search_fields = (
+        "display_name",
+        "calendar_id",
+        "user__username",
+        "group__name",
+    )
+    changelist_actions = ["my_profile"]
+    change_actions = ["my_profile_action"]
+    fieldsets = (
+        (_("Owner"), {"fields": ("user", "group")}),
+        (
+            _("Calendar"),
+            {
+                "fields": (
+                    "display_name",
+                    "calendar_id",
+                    "api_key",
+                    "max_events",
+                    "timezone",
+                )
+            },
+        ),
+    )
+
+    @admin.display(description=_("Owner"))
+    def owner(self, obj):
+        return obj.owner_display()
+
+    @admin.display(description=_("Calendar"))
+    def calendar_identifier(self, obj):
+        display = obj.get_display_name()
+        return display or obj.resolved_calendar_id()
+
 class EmailSearchForm(forms.Form):
     subject = forms.CharField(
         required=False, widget=forms.TextInput(attrs={"style": "width: 40em;"})
@@ -2013,188 +2055,6 @@ class EmailInboxAdmin(ProfileAdminMixin, SaveBeforeChangeAction, EntityModelAdmi
         return TemplateResponse(request, "admin/core/emailinbox/search.html", context)
 
 
-@admin.register(AssistantProfile)
-class AssistantProfileAdmin(
-    ProfileAdminMixin, SaveBeforeChangeAction, EntityModelAdmin
-):
-    list_display = ("assistant_name", "owner", "created_at", "last_used_at", "is_active")
-    readonly_fields = ("user_key_hash", "created_at", "last_used_at")
-
-    change_form_template = "admin/workgroupassistantprofile_change_form.html"
-    change_list_template = "admin/assistantprofile_change_list.html"
-    change_actions = ["my_profile_action"]
-    changelist_actions = ["my_profile"]
-    fieldsets = (
-        ("Owner", {"fields": ("user", "group")}),
-        ("Credentials", {"fields": ("user_key_hash",)}),
-        (
-            "Configuration",
-            {
-                "fields": (
-                    "assistant_name",
-                    "scopes",
-                    "is_active",
-                    "created_at",
-                    "last_used_at",
-                )
-            },
-        ),
-    )
-
-    def owner(self, obj):
-        return obj.owner_display()
-
-    owner.short_description = "Owner"
-
-    def get_urls(self):
-        urls = super().get_urls()
-        opts = self.model._meta
-        app_label = opts.app_label
-        model_name = opts.model_name
-        custom = [
-            path(
-                "<path:object_id>/generate-key/",
-                self.admin_site.admin_view(self.generate_key),
-                name=f"{app_label}_{model_name}_generate_key",
-            ),
-            path(
-                "server/start/",
-                self.admin_site.admin_view(self.start_server),
-                name=f"{app_label}_{model_name}_start_server",
-            ),
-            path(
-                "server/stop/",
-                self.admin_site.admin_view(self.stop_server),
-                name=f"{app_label}_{model_name}_stop_server",
-            ),
-            path(
-                "server/status/",
-                self.admin_site.admin_view(self.server_status),
-                name=f"{app_label}_{model_name}_status",
-            ),
-        ]
-        return custom + urls
-
-    def changelist_view(self, request, extra_context=None):
-        extra_context = extra_context or {}
-        status = mcp_process.get_status()
-        opts = self.model._meta
-        app_label = opts.app_label
-        model_name = opts.model_name
-        extra_context.update(
-            {
-                "mcp_status": status,
-                "mcp_server_actions": {
-                    "start": reverse(f"admin:{app_label}_{model_name}_start_server"),
-                    "stop": reverse(f"admin:{app_label}_{model_name}_stop_server"),
-                    "status": reverse(f"admin:{app_label}_{model_name}_status"),
-                },
-            }
-        )
-        return super().changelist_view(request, extra_context=extra_context)
-
-    def _redirect_to_changelist(self):
-        opts = self.model._meta
-        return HttpResponseRedirect(
-            reverse(f"admin:{opts.app_label}_{opts.model_name}_changelist")
-        )
-
-    def generate_key(self, request, object_id, *args, **kwargs):
-        profile = self.get_object(request, object_id)
-        if profile is None:
-            return HttpResponseRedirect("../")
-        if profile.user is None:
-            self.message_user(
-                request,
-                "Assign a user before generating a key.",
-                level=messages.ERROR,
-            )
-            return HttpResponseRedirect("../")
-        profile, key = AssistantProfile.issue_key(profile.user)
-        context = {
-            **self.admin_site.each_context(request),
-            "opts": self.model._meta,
-            "original": profile,
-            "user_key": key,
-        }
-        return TemplateResponse(request, "admin/assistantprofile_key.html", context)
-
-    def render_change_form(
-        self, request, context, add=False, change=False, form_url="", obj=None
-    ):
-        response = super().render_change_form(
-            request, context, add=add, change=change, form_url=form_url, obj=obj
-        )
-        config = dict(getattr(settings, "MCP_SIGIL_SERVER", {}))
-        host = config.get("host") or "127.0.0.1"
-        port = config.get("port", 8800)
-        base_url, issuer_url = resolve_base_urls(config)
-        mount_path = config.get("mount_path") or "/"
-        display_base_url = base_url or f"http://{host}:{port}"
-        display_issuer_url = issuer_url or display_base_url
-        chat_endpoint = f"{display_base_url.rstrip('/')}/api/chat/"
-        if isinstance(response, dict):
-            response.setdefault("mcp_server_host", host)
-            response.setdefault("mcp_server_port", port)
-            response.setdefault("mcp_server_base_url", display_base_url)
-            response.setdefault("mcp_server_issuer_url", display_issuer_url)
-            response.setdefault("mcp_server_mount_path", mount_path)
-            response.setdefault("mcp_server_chat_endpoint", chat_endpoint)
-        else:
-            context_data = getattr(response, "context_data", None)
-            if context_data is not None:
-                context_data.setdefault("mcp_server_host", host)
-                context_data.setdefault("mcp_server_port", port)
-                context_data.setdefault("mcp_server_base_url", display_base_url)
-                context_data.setdefault("mcp_server_issuer_url", display_issuer_url)
-                context_data.setdefault("mcp_server_mount_path", mount_path)
-                context_data.setdefault("mcp_server_chat_endpoint", chat_endpoint)
-        return response
-
-    def start_server(self, request):
-        try:
-            pid = mcp_process.start_server()
-        except mcp_process.ServerAlreadyRunningError as exc:
-            self.message_user(request, str(exc), level=messages.WARNING)
-        except mcp_process.ServerStartError as exc:
-            self.message_user(request, str(exc), level=messages.ERROR)
-        else:
-            self.message_user(
-                request,
-                f"Started MCP server (PID {pid}).",
-                level=messages.SUCCESS,
-            )
-        return self._redirect_to_changelist()
-
-    def stop_server(self, request):
-        try:
-            pid = mcp_process.stop_server()
-        except mcp_process.ServerNotRunningError as exc:
-            self.message_user(request, str(exc), level=messages.WARNING)
-        except mcp_process.ServerStopError as exc:
-            self.message_user(request, str(exc), level=messages.ERROR)
-        else:
-            self.message_user(
-                request,
-                f"Stopped MCP server (PID {pid}).",
-                level=messages.SUCCESS,
-            )
-        return self._redirect_to_changelist()
-
-    def server_status(self, request):
-        status = mcp_process.get_status()
-        if status["running"]:
-            msg = f"MCP server is running (PID {status['pid']})."
-            level = messages.INFO
-        else:
-            msg = "MCP server is not running."
-            level = messages.WARNING
-        if status.get("last_error"):
-            msg = f"{msg} {status['last_error']}"
-        self.message_user(request, msg, level=level)
-        return self._redirect_to_changelist()
-
-
 class EnergyCreditInline(admin.TabularInline):
     model = EnergyCredit
     fields = ("amount_kw", "created_by", "created_on")
@@ -2649,8 +2509,30 @@ class ProductAdmin(EntityModelAdmin):
                 ],
                 limit=0,
             )
-        except Exception:
+        except Exception as exc:
+            logger.exception(
+                "Failed to fetch Odoo products for user %s (profile_id=%s, host=%s, database=%s)",
+                getattr(getattr(request, "user", None), "pk", None),
+                getattr(profile, "pk", None),
+                getattr(profile, "host", None),
+                getattr(profile, "database", None),
+            )
             context["error"] = _("Unable to fetch products from Odoo.")
+            if getattr(request.user, "is_superuser", False):
+                fault = getattr(exc, "faultString", "")
+                message = str(exc)
+                details = [
+                    f"Host: {getattr(profile, 'host', '')}",
+                    f"Database: {getattr(profile, 'database', '')}",
+                    f"User ID: {getattr(profile, 'odoo_uid', '')}",
+                ]
+                if fault and fault != message:
+                    details.append(f"Fault: {fault}")
+                if message:
+                    details.append(f"Exception: {type(exc).__name__}: {message}")
+                else:
+                    details.append(f"Exception type: {type(exc).__name__}")
+                context["debug_error"] = "\n".join(details)
             return context, []
 
         context["has_credentials"] = True
@@ -2930,7 +2812,7 @@ class RFIDAdmin(EntityModelAdmin, ImportExportModelAdmin):
         "user_data_flag",
         "color",
         "kind",
-        "endianness",
+        "endianness_short",
         "released",
         "allowed",
         "last_seen_on",
@@ -2995,6 +2877,14 @@ class RFIDAdmin(EntityModelAdmin, ImportExportModelAdmin):
     def user_data_flag(self, obj):
         return getattr(obj, "is_user_data", False)
 
+    @admin.display(description=_("End"), ordering="endianness")
+    def endianness_short(self, obj):
+        labels = {
+            RFID.BIG_ENDIAN: _("Big"),
+            RFID.LITTLE_ENDIAN: _("Little"),
+        }
+        return labels.get(obj.endianness, obj.get_endianness_display())
+
     def scan_rfids(self, request, queryset):
         return redirect("admin:core_rfid_scan")
 
@@ -3690,6 +3580,7 @@ class RFIDAdmin(EntityModelAdmin, ImportExportModelAdmin):
                 "toggle_url": toggle_url,
                 "toggle_label": toggle_label,
                 "public_view_url": public_view_url,
+                "deep_read_url": reverse("rfid-scan-deep"),
             }
         )
         context["title"] = _("Scan RFIDs")
@@ -3947,9 +3838,9 @@ class PackageReleaseAdmin(SaveBeforeChangeAction, EntityModelAdmin):
             self.message_user(request, str(exc), messages.ERROR)
             return
         releases = resp.json().get("releases", {})
-        created = 0
         updated = 0
         restored = 0
+        missing: list[str] = []
 
         for version, files in releases.items():
             release_on = self._release_on_from_files(files)
@@ -3974,23 +3865,11 @@ class PackageReleaseAdmin(SaveBeforeChangeAction, EntityModelAdmin):
                 if update_fields:
                     release.save(update_fields=update_fields)
                 continue
-            PackageRelease.objects.create(
-                package=package,
-                release_manager=package.release_manager,
-                version=version,
-                revision="",
-                pypi_url=f"https://pypi.org/project/{package.name}/{version}/",
-                release_on=release_on,
-            )
-            created += 1
+            missing.append(version)
 
-        if created or updated or restored:
+        if updated or restored:
             PackageRelease.dump_fixture()
             message_parts = []
-            if created:
-                message_parts.append(
-                    f"Created {created} release{'s' if created != 1 else ''} from PyPI"
-                )
             if updated:
                 message_parts.append(
                     f"Updated release date for {updated} release"
@@ -4001,8 +3880,17 @@ class PackageReleaseAdmin(SaveBeforeChangeAction, EntityModelAdmin):
                     f"Restored {restored} release{'s' if restored != 1 else ''}"
                 )
             self.message_user(request, "; ".join(message_parts), messages.SUCCESS)
-        else:
-            self.message_user(request, "No new releases found", messages.INFO)
+        elif not missing:
+            self.message_user(request, "No matching releases found", messages.INFO)
+
+        if missing:
+            versions = ", ".join(sorted(missing))
+            count = len(missing)
+            message = (
+                "Manual creation required for "
+                f"{count} release{'s' if count != 1 else ''}: {versions}"
+            )
+            self.message_user(request, message, messages.WARNING)
 
     refresh_from_pypi.label = "Refresh from PyPI"
     refresh_from_pypi.short_description = "Refresh from PyPI"

core/apps.py

@@ -348,9 +348,3 @@ class CoreConfig(AppConfig):
             weak=False,
         )
 
-        try:
-            from .mcp.auto_start import schedule_auto_start
-
-            schedule_auto_start(check_profiles_immediately=False)
-        except Exception:  # pragma: no cover - defensive
-            logger.exception("Failed to schedule MCP auto-start")