synodic-client 0.0.1.dev54__tar.gz → 0.0.1.dev56__tar.gz

{synodic_client-0.0.1.dev54 → synodic_client-0.0.1.dev56}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: synodic_client
-Version: 0.0.1.dev54
+Version: 0.0.1.dev56
 Author-Email: Synodic Software <contact@synodic.software>
 License: LGPL-3.0-or-later
 Project-URL: homepage, https://github.com/synodic/synodic-client

{synodic_client-0.0.1.dev54 → synodic_client-0.0.1.dev56}/pyproject.toml

@@ -15,7 +15,7 @@ dependencies = [
     "velopack>=0.0.1444.dev49733",
     "typer>=0.24.1",
 ]
-version = "0.0.1.dev54"
+version = "0.0.1.dev56"
 
 [project.license]
 text = "LGPL-3.0-or-later"

{synodic_client-0.0.1.dev54 → synodic_client-0.0.1.dev56}/synodic_client/application/screen/schema.py

@@ -13,6 +13,7 @@ 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,
@@ -336,10 +337,41 @@ class _DispatchState:
 
 
 # ---------------------------------------------------------------------------
-# Update banner data models (from update_banner.py)
+# 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."""
 

{synodic_client-0.0.1.dev54 → synodic_client-0.0.1.dev56}/synodic_client/application/screen/settings.py

@@ -301,6 +301,12 @@ class SettingsWindow(QMainWindow):
         """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()

{synodic_client-0.0.1.dev54 → synodic_client-0.0.1.dev56}/synodic_client/application/screen/tray.py

@@ -72,7 +72,7 @@ class TrayScreen:
         self._update_controller = UpdateController(
             app,
             client,
-            self._banner,
+            [self._banner],
             settings_window=self._settings_window,
             config=config,
         )

{synodic_client-0.0.1.dev54 → synodic_client-0.0.1.dev56}/synodic_client/application/update_controller.py

@@ -17,6 +17,7 @@ from typing import TYPE_CHECKING
 from PySide6.QtCore import QTimer
 from PySide6.QtWidgets import QApplication
 
+from synodic_client.application.screen.schema import UpdateView
 from synodic_client.application.screen.update_banner import UpdateBanner
 from synodic_client.application.theme import (
     UPDATE_STATUS_AVAILABLE_STYLE,
@@ -48,22 +49,20 @@ class UpdateController:
         The running ``QApplication`` (needed for ``quit()`` on auto-apply).
     client:
         The Synodic Client service facade.
-    banner:
-        The in-app ``UpdateBanner`` widget.
+    views:
+        One or more :class:`UpdateView` implementations to broadcast
+        state transitions to (typically ``UpdateBanner`` instances).
     settings_window:
-        The ``SettingsWindow`` (receives status text + colour).
+        The ``SettingsWindow`` (check button + last-updated label).
     config:
         Optional pre-resolved configuration.  ``None`` resolves from disk.
-    is_user_active:
-        Predicate returning ``True`` when the user has a visible window.
-        Auto-apply is deferred while active; checks still run normally.
     """
 
     def __init__(
         self,
         app: QApplication,
         client: Client,
-        banner: UpdateBanner,
+        views: list[UpdateView],
         *,
         settings_window: SettingsWindow,
         config: ResolvedConfig | None = None,
@@ -73,13 +72,13 @@ class UpdateController:
         Args:
             app: The running ``QApplication``.
             client: The Synodic Client service facade.
-            banner: The in-app ``UpdateBanner`` widget.
-            settings_window: The settings window for status feedback.
+            views: One or more :class:`UpdateView` implementations.
+            settings_window: The settings window (check button + timestamp).
             config: Optional pre-resolved configuration.
         """
         self._app = app
         self._client = client
-        self._banner = banner
+        self._views = views
         self._settings_window = settings_window
         self._config = config
         self._is_user_active: Callable[[], bool] = lambda: False
@@ -94,11 +93,13 @@ class UpdateController:
         self._auto_update_timer: QTimer | None = None
         self._restart_auto_update_timer()
 
-        # Wire banner signals
-        self._banner.restart_requested.connect(self._apply_update)
-        self._banner.retry_requested.connect(lambda: self.check_now(silent=True))
+        # Wire banner signals (UpdateBanner-specific, outside the protocol)
+        for view in self._views:
+            if isinstance(view, UpdateBanner):
+                view.restart_requested.connect(self._apply_update)
+                view.retry_requested.connect(lambda: self.check_now(silent=True))
 
-        # Wire settings check-updates button
+        # Wire settings check-updates and restart buttons
         self._settings_window.check_updates_requested.connect(self._on_manual_check)
         self._settings_window.restart_requested.connect(self._apply_update)
 
@@ -128,6 +129,25 @@ class UpdateController:
         """
         return self._auto_apply and not self._is_user_active()
 
+    def _persist_check_timestamp(self) -> None:
+        """Persist the current time as *last_client_update* and refresh the label."""
+        ts = datetime.now(UTC).isoformat()
+        update_user_config(last_client_update=ts)
+        self._settings_window.set_last_checked(ts)
+
+    def _report_error(self, message: str, *, silent: bool) -> None:
+        """Show an error to the user or log it, depending on *silent*.
+
+        Always updates the settings status line.  When not *silent*,
+        also broadcasts the error to all update-banner views.
+        """
+        self._settings_window.set_update_status('Check failed', UPDATE_STATUS_ERROR_STYLE)
+        if silent:
+            logger.warning('%s', message)
+        else:
+            for view in self._views:
+                view.show_error(message)
+
     # ------------------------------------------------------------------
     # Timer management
     # ------------------------------------------------------------------
@@ -212,10 +232,11 @@ class UpdateController:
         """Run an update check."""
         if self._client.updater is None:
             if not silent:
-                self._banner.show_error('Updater is not initialized.')
+                for view in self._views:
+                    view.show_error('Updater is not initialized.')
             return
 
-        # Preserve the restart button when an update is already pending
+        # Preserve the banner state when an update is already pending
         if self._pending_version is None:
             self._settings_window.set_checking()
 
@@ -237,21 +258,16 @@ class UpdateController:
         self._settings_window.reset_check_updates_button()
 
         if result is None:
-            self._settings_window.set_update_status('Check failed', UPDATE_STATUS_ERROR_STYLE)
-            if not silent:
-                self._banner.show_error('Failed to check for updates.')
-            else:
-                logger.warning('Automatic update check failed (no result)')
+            self._report_error('Failed to check for updates.', silent=silent)
             return
 
         if result.error:
-            self._settings_window.set_update_status('Check failed', UPDATE_STATUS_ERROR_STYLE)
-            if not silent:
-                self._banner.show_error(result.error)
-            else:
-                logger.warning('Automatic update check failed: %s', result.error)
+            self._report_error(result.error, silent=silent)
             return
 
+        # Successful check — refresh the "last updated" timestamp
+        self._persist_check_timestamp()
+
         if not result.available:
             self._settings_window.set_update_status('Up to date', UPDATE_STATUS_UP_TO_DATE_STYLE)
             if not silent:
@@ -268,22 +284,15 @@ class UpdateController:
             return
 
         # New update available — download it
-        self._settings_window.set_update_status(
-            f'v{version} available',
-            UPDATE_STATUS_AVAILABLE_STYLE,
-        )
-        self._banner.show_downloading(version)
+        self._settings_window.set_update_status(f'v{version} available', UPDATE_STATUS_AVAILABLE_STYLE)
+        for view in self._views:
+            view.show_downloading(version)
         self._start_download(version)
 
     def _on_check_error(self, error: str, *, silent: bool = False) -> None:
         """Handle unexpected exception during update check."""
         self._settings_window.reset_check_updates_button()
-        self._settings_window.set_update_status('Check failed', UPDATE_STATUS_ERROR_STYLE)
-
-        if not silent:
-            self._banner.show_error(f'Update check error: {error}')
-        else:
-            logger.warning('Automatic update check error: %s', error)
+        self._report_error(f'Update check error: {error}', silent=silent)
 
     # ------------------------------------------------------------------
     # Download flow
@@ -298,50 +307,51 @@ class UpdateController:
         try:
             success = await download_update(
                 self._client,
-                on_progress=self._banner.show_downloading_progress,
+                on_progress=self._on_download_progress,
             )
             self._on_download_finished(success, version)
         except Exception as exc:
             logger.exception('Update download failed')
             self._on_download_error(str(exc))
 
+    def _on_download_progress(self, percentage: int) -> None:
+        """Broadcast download progress to all views."""
+        for view in self._views:
+            view.show_downloading_progress(percentage)
+
     def _on_download_finished(self, success: bool, version: str) -> None:
         """Handle download completion."""
         if not success:
-            self._banner.show_error('Download failed. Please try again later.')
             self._settings_window.set_update_status('Download failed', UPDATE_STATUS_ERROR_STYLE)
+            for view in self._views:
+                view.show_error('Download failed. Please try again later.')
             return
 
-        # Persist the client update timestamp
-        update_user_config(last_client_update=datetime.now(UTC).isoformat())
+        # Persist the client-update timestamp (actual update downloaded)
+        ts = datetime.now(UTC).isoformat()
+        update_user_config(last_client_update=ts)
 
         self._pending_version = version
 
         if self._can_auto_apply():
             # Silently apply and restart — no banner, no user interaction
             logger.info('Auto-applying update v%s', version)
-            self._settings_window.set_update_status(
-                f'v{version} installing\u2026',
-                UPDATE_STATUS_AVAILABLE_STYLE,
-            )
             self._apply_update(silent=True)
             return
 
         self._show_ready(version)
 
     def _show_ready(self, version: str) -> None:
-        """Present the *ready to restart* state in both UIs."""
-        self._banner.show_ready(version)
-        self._settings_window.set_update_status(
-            f'v{version} ready',
-            UPDATE_STATUS_UP_TO_DATE_STYLE,
-        )
+        """Present the *ready to restart* state across all views."""
+        self._settings_window.set_update_status(f'v{version} ready', UPDATE_STATUS_UP_TO_DATE_STYLE)
         self._settings_window.show_restart_button()
+        for view in self._views:
+            view.show_ready(version)
 
     def _on_download_error(self, error: str) -> None:
-        """Handle download error — show error banner."""
-        self._banner.show_error(f'Download error: {error}')
-        self._settings_window.set_update_status('Download failed', UPDATE_STATUS_ERROR_STYLE)
+        """Handle download error — show error across all views."""
+        for view in self._views:
+            view.show_error(f'Download error: {error}')
 
     # ------------------------------------------------------------------
     # Apply
@@ -364,4 +374,5 @@ class UpdateController:
             self._app.quit()
         except Exception as e:
             logger.error('Failed to apply update: %s', e)
-            self._banner.show_error(f'Failed to apply update: {e}')
+            for view in self._views:
+                view.show_error(f'Failed to apply update: {e}')

{synodic_client-0.0.1.dev54 → synodic_client-0.0.1.dev56}/tests/unit/qt/test_update_controller.py

@@ -74,7 +74,7 @@ def _make_controller(
         controller = UpdateController(
             app,
             client,
-            banner,
+            [banner],
             settings_window=settings,
             config=config,
         )
@@ -228,81 +228,6 @@ class TestDownloadFinished:
         assert banner.state.name == 'ERROR'
         settings.set_update_status.assert_called_with('Download failed', UPDATE_STATUS_ERROR_STYLE)
 
-    @staticmethod
-    def test_download_sets_pending_version() -> None:
-        """A successful download should set _pending_version."""
-        ctrl, app, client, banner, settings = _make_controller(auto_apply=False)
-        ctrl._on_download_finished(True, '2.0.0')
-
-        assert ctrl._pending_version == '2.0.0'
-
-
-# ---------------------------------------------------------------------------
-# Pending version — skip redundant downloads
-# ---------------------------------------------------------------------------
-
-
-class TestPendingVersion:
-    """Verify behaviour when an update is already downloaded and pending."""
-
-    @staticmethod
-    def test_check_skips_download_when_version_already_pending() -> None:
-        """Re-checking the same version should restore ready state, not re-download."""
-        ctrl, _app, _client, banner, settings = _make_controller(auto_apply=False)
-        ctrl._pending_version = '2.0.0'
-
-        result = UpdateInfo(available=True, current_version=Version('1.0.0'), latest_version=Version('2.0.0'))
-
-        with patch.object(ctrl, '_start_download') as mock_dl:
-            ctrl._on_check_finished(result, silent=True)
-
-        mock_dl.assert_not_called()
-        assert banner.state.name == 'READY'
-        settings.show_restart_button.assert_called_once()
-
-    @staticmethod
-    def test_check_downloads_when_newer_version() -> None:
-        """A different version should trigger a fresh download."""
-        ctrl, _app, _client, banner, settings = _make_controller(auto_apply=False)
-        ctrl._pending_version = '1.5.0'
-
-        result = UpdateInfo(available=True, current_version=Version('1.0.0'), latest_version=Version('2.0.0'))
-
-        with patch.object(ctrl, '_start_download') as mock_dl:
-            ctrl._on_check_finished(result, silent=True)
-
-        mock_dl.assert_called_once_with('2.0.0')
-
-    @staticmethod
-    def test_do_check_preserves_settings_ui_when_pending() -> None:
-        """set_checking should NOT be called when an update is already pending."""
-        ctrl, _app, _client, banner, settings = _make_controller()
-        ctrl._pending_version = '2.0.0'
-
-        with patch('asyncio.create_task'):
-            ctrl._do_check(silent=True)
-
-        settings.set_checking.assert_not_called()
-
-    @staticmethod
-    def test_do_check_shows_checking_when_no_pending() -> None:
-        """set_checking should be called when there is no pending update."""
-        ctrl, _app, _client, banner, settings = _make_controller()
-
-        with patch('asyncio.create_task'):
-            ctrl._do_check(silent=True)
-
-        settings.set_checking.assert_called_once()
-
-    @staticmethod
-    def test_apply_clears_pending_version() -> None:
-        """_apply_update should clear _pending_version."""
-        ctrl, app, client, banner, settings = _make_controller()
-        ctrl._pending_version = '2.0.0'
-        ctrl._apply_update()
-
-        assert ctrl._pending_version is None
-
 
 # ---------------------------------------------------------------------------
 # User-active gating