synodic-client 0.0.1.dev65__tar.gz → 0.0.1.dev67__tar.gz

{synodic_client-0.0.1.dev65 → synodic_client-0.0.1.dev67}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: synodic_client
-Version: 0.0.1.dev65
+Version: 0.0.1.dev67
 Author-Email: Synodic Software <contact@synodic.software>
 License: LGPL-3.0-or-later
 Project-URL: homepage, https://github.com/synodic/synodic-client
@@ -8,7 +8,7 @@ Project-URL: repository, https://github.com/synodic/synodic-client
 Requires-Python: <3.15,>=3.14
 Requires-Dist: pyside6>=6.10.2
 Requires-Dist: packaging>=26.0
-Requires-Dist: porringer>=0.2.1.dev78
+Requires-Dist: porringer>=0.2.1.dev79
 Requires-Dist: qasync>=0.28.0
 Requires-Dist: velopack>=0.0.1444.dev49733
 Requires-Dist: typer>=0.24.1

{synodic_client-0.0.1.dev65 → synodic_client-0.0.1.dev67}/pyproject.toml

@@ -10,12 +10,12 @@ requires-python = ">=3.14, <3.15"
 dependencies = [
     "pyside6>=6.10.2",
     "packaging>=26.0",
-    "porringer>=0.2.1.dev78",
+    "porringer>=0.2.1.dev79",
     "qasync>=0.28.0",
     "velopack>=0.0.1444.dev49733",
     "typer>=0.24.1",
 ]
-version = "0.0.1.dev65"
+version = "0.0.1.dev67"
 
 [project.license]
 text = "LGPL-3.0-or-later"

{synodic_client-0.0.1.dev65 → synodic_client-0.0.1.dev67}/synodic_client/application/screen/__init__.py

@@ -8,7 +8,7 @@ from __future__ import annotations
 
 from datetime import UTC, datetime
 
-from porringer.schema import SetupAction, SkipReason
+from porringer.schema import SetupAction, SetupActionResult, SkipReason
 from porringer.schema.plugin import PluginKind
 
 _SECONDS_PER_MINUTE = 60
@@ -63,18 +63,26 @@ def skip_reason_label(reason: SkipReason | None) -> str:
     return SKIP_REASON_LABELS.get(reason, reason.name.replace('_', ' ').capitalize())
 
 
-def format_cli_command(action: SetupAction, *, suppress_description: bool = False) -> str:
+def format_cli_command(
+    action: SetupAction,
+    *,
+    result: SetupActionResult | None = None,
+    suppress_description: bool = False,
+) -> str:
     """Return a human-readable CLI command string for *action*.
 
-    Prefers ``cli_command``, falls back to ``command``, then synthesises
-    an ``installer install <package>`` string for package actions, and
+    Prefers ``result.cli_command`` (populated after dry-run), falls
+    back to ``action.command``, then synthesises an
+    ``installer install <package>`` string for package actions, and
     finally returns the action description as a last resort.
 
     When *suppress_description* is ``True`` the final description
     fallback returns an empty string instead.
     """
-    if parts := (action.cli_command or action.command):
-        return ' '.join(parts)
+    if result is not None and result.cli_command:
+        return ' '.join(result.cli_command)
+    if action.command:
+        return ' '.join(action.command)
     if action.kind == PluginKind.PACKAGE and action.package:
         return f'{action.installer or "pip"} install {action.package}'
     return '' if suppress_description else action.description

{synodic_client-0.0.1.dev65 → synodic_client-0.0.1.dev67}/synodic_client/application/screen/action_card.py

@@ -73,19 +73,6 @@ _SPINNER_INTERVAL = 50
 _KIND_ORDER: dict[PluginKind | None, int] = {kind: i for i, kind in enumerate(PHASE_ORDER)}
 
 
-def action_key(action: SetupAction) -> tuple[object, ...]:
-    """Return a stable identity key for *action*.
-
-    Uses content-based fields (kind, installer, package name, command)
-    so the same logical action from different ``execute_stream`` runs
-    resolves to the same key.
-    """
-    pkg_name = str(action.package.name) if action.package else None
-    pt_name = str(action.plugin_target.name) if action.plugin_target else None
-    cmd = tuple(action.command) if action.command else None
-    return (action.kind, action.installer, pkg_name, pt_name, cmd)
-
-
 def action_sort_key(action: SetupAction) -> int:
     """Return a sort key that groups cards by execution phase.
 
@@ -396,24 +383,6 @@ class ActionCard(QFrame):
         else:
             self._prerelease_cb.hide()
 
-    def update_command(self, action: SetupAction) -> None:
-        """Update the CLI command label after the resolved preview arrives.
-
-        Called from the two-phase display flow once ``MANIFEST_LOADED``
-        provides actions with their ``cli_command`` populated.
-
-        Args:
-            action: The setup action with resolved CLI command.
-        """
-        if self._is_skeleton:
-            return
-        cmd_text = format_cli_command(action, suppress_description=True)
-        if cmd_text:
-            self._command_label.setText(cmd_text)
-            self._command_row.show()
-        else:
-            self._command_row.hide()
-
     def _populate_status(
         self,
         action: SetupAction,
@@ -494,7 +463,7 @@ class ActionCard(QFrame):
             self._status_label.setText(label)
             self._status_label.setStyleSheet(ACTION_CARD_STATUS_UPDATE)
         elif result.skipped:
-            label = skip_reason_label(result.skip_reason)
+            label = '\u2713 ' + skip_reason_label(result.skip_reason)
             self._status_label.setText(label)
             self._status_label.setStyleSheet(ACTION_CARD_STATUS_SATISFIED)
         elif not result.success:
@@ -517,6 +486,13 @@ class ActionCard(QFrame):
         else:
             self._status_label.setToolTip('')
 
+        # CLI command — update with resolved cli_command from result
+        assert self._action is not None
+        cmd_text = format_cli_command(self._action, result=result, suppress_description=True)
+        if cmd_text:
+            self._command_label.setText(cmd_text)
+            self._command_row.show()
+
         # Version column
         self._check_available_version = result.available_version
         if result.installed_version and result.available_version:
@@ -524,6 +500,9 @@ class ActionCard(QFrame):
             self._version_label.setStyleSheet(ACTION_CARD_VERSION_STYLE + ' color: #d7ba7d;')
         elif result.installed_version:
             self._version_label.setText(result.installed_version)
+        elif result.available_version:
+            self._version_label.setText(f'\u2192 {result.available_version}')
+            self._version_label.setStyleSheet(ACTION_CARD_VERSION_STYLE + ' color: grey;')
 
     def finalize_checking(self) -> None:
         """Resolve a still-pending 'Checking\u2026' status to 'Needed'.
@@ -611,9 +590,8 @@ class ActionCard(QFrame):
 class ActionCardList(QWidget):
     """Container of :class:`ActionCard` widgets.
 
-    Cards are keyed by :func:`action_key` (content-based) so that
-    look-ups work across different ``execute_stream`` runs where the
-    ``SetupAction`` objects are different Python instances.
+    Cards are keyed by ``SetupAction`` directly (frozen dataclass) so
+    that look-ups work across different ``execute_stream`` runs.
     """
 
     prerelease_toggled = Signal(str, bool)
@@ -629,7 +607,7 @@ class ActionCardList(QWidget):
         self._layout.addStretch()
 
         self._cards: list[ActionCard] = []
-        self._action_map: dict[tuple[object, ...], ActionCard] = {}
+        self._action_map: dict[SetupAction, ActionCard] = {}
 
     # ------------------------------------------------------------------
     # Skeleton loading
@@ -679,7 +657,7 @@ class ActionCardList(QWidget):
             card.prerelease_toggled.connect(self.prerelease_toggled.emit)
             self._layout.insertWidget(self._layout.count() - 1, card)
             self._cards.append(card)
-            self._action_map[action_key(act)] = card
+            self._action_map[act] = card
 
     # ------------------------------------------------------------------
     # Card lookup
@@ -696,11 +674,10 @@ class ActionCardList(QWidget):
         return len(self._cards)
 
     def get_card(self, action: SetupAction) -> ActionCard | None:
-        """Look up the card for a given action by stable content key.
+        """Look up the card for a given action.
 
-        Works across different ``execute_stream`` runs — the preview
-        and install phases produce different ``SetupAction`` instances
-        but the same logical action maps to the same card.
+        ``SetupAction`` is a frozen dataclass, so the same logical
+        action from different ``execute_stream`` runs hashes equally.
 
         Args:
             action: The setup action to find.
@@ -708,7 +685,7 @@ class ActionCardList(QWidget):
         Returns:
             The card widget, or ``None`` if not found.
         """
-        return self._action_map.get(action_key(action))
+        return self._action_map.get(action)
 
     # ------------------------------------------------------------------
     # Bulk operations

{synodic_client-0.0.1.dev65 → synodic_client-0.0.1.dev67}/synodic_client/application/screen/install.py

@@ -45,7 +45,7 @@ from PySide6.QtWidgets import (
 
 from synodic_client.application.package_state import PackageStateStore
 from synodic_client.application.screen import skip_reason_label
-from synodic_client.application.screen.action_card import ActionCardList, action_key
+from synodic_client.application.screen.action_card import ActionCardList
 from synodic_client.application.screen.card import CardFrame
 from synodic_client.application.screen.install_workers import run_install, run_preview
 from synodic_client.application.screen.log_panel import ExecutionLogPanel
@@ -595,11 +595,11 @@ class SetupPreviewWidget(QWidget):
         self._install_btn.setEnabled(True)
 
     def _on_preview_resolved(self, preview: SetupResults, manifest_path: str, temp_dir_path: str) -> None:
-        """Handle the fully-resolved preview (CLI commands populated).
+        """Handle the fully-resolved preview.
 
         Called after ``MANIFEST_LOADED`` — cards are already visible
-        from the earlier ``_on_manifest_parsed`` handler.  This only
-        updates CLI command text and the temp-dir reference.
+        from the earlier ``_on_manifest_parsed`` handler.  This updates
+        the temp-dir reference and emits metadata.
         """
         if self._model.preview is None:
             return
@@ -609,19 +609,13 @@ class SetupPreviewWidget(QWidget):
         if preview.metadata:
             self.metadata_ready.emit(preview)
 
-        for action in preview.actions:
-            if action.cli_command:
-                card = self._card_list.get_card(action)
-                if card is not None:
-                    card.update_command(action)
-
     def _on_action_checked(self, row: int, result: SetupActionResult) -> None:
         """Update the model and action card with a dry-run result."""
         m = self._model
         if result.skipped and result.skip_reason == SkipReason.UPDATE_AVAILABLE:
             label = skip_reason_label(result.skip_reason)
             if 0 <= row < len(m.action_states):
-                m.upgradable_keys.add(action_key(m.action_states[row].action))
+                m.upgradable_keys.add(m.action_states[row].action)
         elif result.skipped:
             label = skip_reason_label(result.skip_reason)
         elif not result.success:

{synodic_client-0.0.1.dev65 → synodic_client-0.0.1.dev67}/synodic_client/application/screen/install_workers.py

@@ -159,10 +159,9 @@ def _dispatch_preview_event(
 ) -> None:
     """Route a single preview stream event to the appropriate callback.
 
-    Mutates *state* in-place with updated ``action_index`` / ``got_parsed``.
+    Mutates *state* in-place (``got_parsed`` flag).
     """
     if event.kind == ProgressEventKind.MANIFEST_PARSED and event.manifest:
-        state.action_index = {id(a): i for i, a in enumerate(event.manifest.actions)}
         if cb.on_manifest_parsed is not None:
             cb.on_manifest_parsed(event.manifest, manifest_path, temp_dir_str)
         state.got_parsed = True
@@ -176,16 +175,17 @@ def _dispatch_preview_event(
         return
 
     if event.kind == ProgressEventKind.MANIFEST_LOADED and event.manifest:
-        if not state.got_parsed:
-            state.action_index = {id(a): i for i, a in enumerate(event.manifest.actions)}
         if cb.on_preview_ready is not None:
             cb.on_preview_ready(event.manifest, manifest_path, temp_dir_str)
         return
 
-    if event.kind == ProgressEventKind.ACTION_COMPLETED and event.result and event.action:
-        row = state.action_index.get(id(event.action))
-        if row is not None and cb.on_action_checked is not None:
-            cb.on_action_checked(row, event.result)
+    if (
+        event.kind == ProgressEventKind.ACTION_COMPLETED
+        and event.result
+        and event.action_index is not None
+        and cb.on_action_checked is not None
+    ):
+        cb.on_action_checked(event.action_index, event.result)
 
 
 # ---------------------------------------------------------------------------

{synodic_client-0.0.1.dev65 → synodic_client-0.0.1.dev67}/synodic_client/application/screen/log_panel.py

@@ -26,7 +26,6 @@ from PySide6.QtWidgets import (
 )
 
 from synodic_client.application.screen import ACTION_KIND_LABELS, skip_reason_label
-from synodic_client.application.screen.action_card import action_key
 from synodic_client.application.screen.card import CHEVRON_DOWN, CHEVRON_RIGHT, ClickableHeader
 from synodic_client.application.theme import (
     LOG_CHEVRON_STYLE,
@@ -186,7 +185,7 @@ class ExecutionLogPanel(QWidget):
         self._layout.addStretch()
 
         # Map action content-key → section widget for quick lookup
-        self._sections: dict[tuple[object, ...], ActionLogSection] = {}
+        self._sections: dict[SetupAction, ActionLogSection] = {}
         self._section_count = 0
 
     # --- Public API ---
@@ -204,7 +203,7 @@ class ExecutionLogPanel(QWidget):
         section = ActionLogSection(action, self._section_count, self)
         # Insert before the stretch
         self._layout.insertWidget(self._layout.count() - 1, section)
-        self._sections[action_key(action)] = section
+        self._sections[action] = section
 
         return section
 
@@ -217,7 +216,7 @@ class ExecutionLogPanel(QWidget):
         Returns:
             The section widget, or ``None`` if not found.
         """
-        return self._sections.get(action_key(action))
+        return self._sections.get(action)
 
     def on_sub_progress(self, action: SetupAction, progress: SubActionProgress) -> None:
         """Handle a sub-action progress event.

{synodic_client-0.0.1.dev65 → synodic_client-0.0.1.dev67}/synodic_client/application/screen/schema.py

@@ -11,9 +11,7 @@ from __future__ import annotations
 import enum
 from collections.abc import Callable
 from dataclasses import dataclass, field
-from enum import Enum, auto
 from pathlib import Path
-from typing import Protocol, runtime_checkable
 
 from porringer.schema import (
     PluginInfo,
@@ -25,7 +23,6 @@ from porringer.schema import (
 )
 from porringer.schema.plugin import RuntimePackageResult
 
-from synodic_client.application.screen.action_card import action_key
 from synodic_client.application.uri import normalize_manifest_key
 
 # ---------------------------------------------------------------------------
@@ -239,7 +236,6 @@ class PreviewModel:
 
     def __init__(self) -> None:
         """Initialise a blank preview model."""
-        self._action_key = action_key
         self._normalize = normalize_manifest_key
 
         self.phase: PreviewPhase = PreviewPhase.IDLE
@@ -250,19 +246,19 @@ class PreviewModel:
         self.plugin_installed: dict[str, bool] = {}
         self.prerelease_overrides: set[str] = set()
         self.action_states: list[ActionState] = []
-        self._action_state_map: dict[tuple[object, ...], ActionState] = {}
+        self._action_state_map: dict[SetupAction, ActionState] = {}
         self._action_state_map_len: int = 0
-        self.upgradable_keys: set[tuple[object, ...]] = set()
+        self.upgradable_keys: set[SetupAction] = set()
         self.checked_count: int = 0
         self.completed_count: int = 0
         self.temp_dir: str | None = None
 
     # -- Computed helpers --------------------------------------------------
 
-    def _ensure_action_state_map(self) -> dict[tuple[object, ...], ActionState]:
-        """Return the action-key → state lookup, rebuilding if stale."""
+    def _ensure_action_state_map(self) -> dict[SetupAction, ActionState]:
+        """Return the action → state lookup, rebuilding if stale."""
         if len(self.action_states) != self._action_state_map_len:
-            self._action_state_map = {self._action_key(s.action): s for s in self.action_states}
+            self._action_state_map = {s.action: s for s in self.action_states}
             self._action_state_map_len = len(self.action_states)
         return self._action_state_map
 
@@ -281,8 +277,8 @@ class PreviewModel:
         return self.actionable_count > 0 or any(s.action.kind is None for s in self.action_states)
 
     def action_state_for(self, act: SetupAction) -> ActionState | None:
-        """Look up :class:`ActionState` by content key (O(1) amortized)."""
-        return self._ensure_action_state_map().get(self._action_key(act))
+        """Look up :class:`ActionState` for *act* (O(1) amortized)."""
+        return self._ensure_action_state_map().get(act)
 
     def has_same_manifest(self, key: str) -> bool:
         """Return ``True`` if *key* matches the current manifest key."""
@@ -341,64 +337,4 @@ class PreviewConfig:
 class _DispatchState:
     """Mutable accumulator for :func:`_dispatch_preview_event`."""
 
-    action_index: dict[int, int] = field(default_factory=dict)
     got_parsed: bool = False
-
-
-# ---------------------------------------------------------------------------
-# Update view protocol & banner data models
-# ---------------------------------------------------------------------------
-
-
-@runtime_checkable
-class UpdateView(Protocol):
-    """Minimal display contract for the self-update lifecycle.
-
-    :class:`UpdateBanner` satisfies this protocol implicitly via
-    structural typing.  The controller broadcasts state transitions
-    through a ``list[UpdateView]`` so that every window showing update
-    status stays in sync.
-    """
-
-    def show_downloading(self, version: str) -> None:
-        """Indicate that *version* is being downloaded."""
-        ...
-
-    def show_downloading_progress(self, percentage: int) -> None:
-        """Update the download progress indicator."""
-        ...
-
-    def show_ready(self, version: str) -> None:
-        """Indicate that *version* is downloaded and ready to install."""
-        ...
-
-    def show_error(self, message: str) -> None:
-        """Display an error *message* in the update area."""
-        ...
-
-    def hide_banner(self) -> None:
-        """Hide the update banner."""
-        ...
-
-
-class UpdateBannerState(Enum):
-    """Visual states for the update banner."""
-
-    HIDDEN = auto()
-    DOWNLOADING = auto()
-    READY = auto()
-    ERROR = auto()
-
-
-@dataclass(frozen=True, slots=True)
-class _BannerConfig:
-    """Bundled visual configuration for a banner state transition."""
-
-    state: UpdateBannerState
-    style: str
-    icon: str
-    text: str
-    text_style: str
-    version: str = ''
-    action_label: str = ''
-    show_progress: bool = False

{synodic_client-0.0.1.dev65 → synodic_client-0.0.1.dev67}/synodic_client/application/screen/settings.py

@@ -32,7 +32,8 @@ from synodic_client.application.config_store import ConfigStore
 from synodic_client.application.icon import app_icon
 from synodic_client.application.screen import _format_relative_time
 from synodic_client.application.screen.card import CardFrame
-from synodic_client.application.theme import SETTINGS_WINDOW_MIN_SIZE, UPDATE_STATUS_CHECKING_STYLE
+from synodic_client.application.theme import SETTINGS_WINDOW_MIN_SIZE
+from synodic_client.application.update_model import UpdateModel
 from synodic_client.logging import log_path, set_debug_level
 from synodic_client.schema import GITHUB_REPO_URL
 from synodic_client.startup import is_startup_registered, register_startup, remove_startup
@@ -237,6 +238,32 @@ class SettingsWindow(QMainWindow):
         card.content_layout.addLayout(row)
         return card
 
+    # ------------------------------------------------------------------
+    # Model binding
+    # ------------------------------------------------------------------
+
+    def connect_model(self, model: UpdateModel) -> None:
+        """Connect to an :class:`UpdateModel` for state observation.
+
+        The model's settings-facing signals drive the update status
+        label, check button, restart button, and timestamp label.
+        """
+        model.status_text_changed.connect(self._on_status_changed)
+        model.check_button_enabled_changed.connect(self._check_updates_btn.setEnabled)
+        model.restart_visible_changed.connect(self._restart_btn.setVisible)
+        model.last_checked_changed.connect(self._on_last_checked_changed)
+
+    def _on_status_changed(self, text: str, style: str) -> None:
+        """Apply a status text and style from the model."""
+        self._update_status_label.setText(text)
+        self._update_status_label.setStyleSheet(style)
+
+    def _on_last_checked_changed(self, timestamp: str) -> None:
+        """Apply a *last updated* timestamp from the model."""
+        relative = _format_relative_time(timestamp)
+        self._last_client_update_label.setText(f'Last updated: {relative}')
+        self._last_client_update_label.setToolTip(f'Last updated: {timestamp}')
+
     # ------------------------------------------------------------------
     # Public API
     # ------------------------------------------------------------------
@@ -275,37 +302,6 @@ class SettingsWindow(QMainWindow):
             else:
                 self._last_client_update_label.setText('')
 
-    def set_update_status(self, text: str, style: str = '') -> None:
-        """Set the inline status text next to the *Check for Updates* button.
-
-        Args:
-            text: The status message.
-            style: Optional stylesheet for the label (e.g. color).
-        """
-        self._update_status_label.setText(text)
-        self._update_status_label.setStyleSheet(style)
-
-    def set_checking(self) -> None:
-        """Enter the *checking* state — disable button and show status."""
-        self._check_updates_btn.setEnabled(False)
-        self._restart_btn.hide()
-        self._update_status_label.setText('Checking\u2026')
-        self._update_status_label.setStyleSheet(UPDATE_STATUS_CHECKING_STYLE)
-
-    def reset_check_updates_button(self) -> None:
-        """Re-enable the *Check for Updates* button after a check completes."""
-        self._check_updates_btn.setEnabled(True)
-
-    def set_last_checked(self, timestamp: str) -> None:
-        """Update the *last updated* label from an ISO 8601 timestamp."""
-        relative = _format_relative_time(timestamp)
-        self._last_client_update_label.setText(f'Last updated: {relative}')
-        self._last_client_update_label.setToolTip(f'Last updated: {timestamp}')
-
-    def show_restart_button(self) -> None:
-        """Show the *Restart & Update* button."""
-        self._restart_btn.show()
-
     def show(self) -> None:
         """Sync controls from config, size to content, then show the window."""
         self.sync_from_config()
@@ -360,8 +356,6 @@ class SettingsWindow(QMainWindow):
 
     def _on_check_updates_clicked(self) -> None:
         """Handle the *Check for Updates* button click."""
-        self._check_updates_btn.setEnabled(False)
-        self._update_status_label.setText('Checking\u2026')
         self.check_updates_requested.emit()
 
     def _on_channel_changed(self, index: int) -> None:

{synodic_client-0.0.1.dev65 → synodic_client-0.0.1.dev67}/synodic_client/application/screen/tray.py

@@ -16,6 +16,7 @@ from synodic_client.application.screen.screen import MainWindow
 from synodic_client.application.screen.settings import SettingsWindow
 from synodic_client.application.screen.tool_update_controller import ToolUpdateOrchestrator
 from synodic_client.application.update_controller import UpdateController
+from synodic_client.application.update_model import UpdateModel
 from synodic_client.client import Client
 
 if TYPE_CHECKING:
@@ -66,17 +67,29 @@ class TrayScreen:
         # MainWindow gear button -> open settings
         window.settings_requested.connect(self._show_settings)
 
+        # Update model — centralised observable state for the update lifecycle
+        self._update_model = UpdateModel()
+
         # Update controller - owns the self-update lifecycle & timer
         self._banner = window.update_banner
         self._update_controller = UpdateController(
             app,
             client,
-            [self._banner],
-            settings_window=self._settings_window,
+            self._update_model,
             store=self._store,
         )
         self._update_controller.set_user_active_predicate(self._is_user_active)
 
+        # Connect views to the model
+        self._banner.connect_model(self._update_model)
+        self._settings_window.connect_model(self._update_model)
+
+        # Wire user-action signals back to the controller
+        self._banner.restart_requested.connect(self._update_controller.request_apply)
+        self._banner.retry_requested.connect(self._update_controller.request_retry)
+        self._settings_window.check_updates_requested.connect(self._update_controller.request_check)
+        self._settings_window.restart_requested.connect(self._update_controller.request_apply)
+
         # Tool update orchestrator - owns tool/package update lifecycle
         self._tool_orchestrator = ToolUpdateOrchestrator(
             window,