synodic-client 0.0.1.dev40__tar.gz → 0.0.1.dev42__tar.gz

{synodic_client-0.0.1.dev40 → synodic_client-0.0.1.dev42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: synodic_client
-Version: 0.0.1.dev40
+Version: 0.0.1.dev42
 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.dev40 → synodic_client-0.0.1.dev42}/pyproject.toml

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

synodic_client-0.0.1.dev42/synodic_client/_version.py

@@ -0,0 +1 @@
+__version__ = '0.0.1.dev42'

{synodic_client-0.0.1.dev40 → synodic_client-0.0.1.dev42}/synodic_client/application/screen/screen.py

@@ -8,6 +8,7 @@ from pathlib import Path
 
 from porringer.api import API
 from porringer.backend.builder import Builder
+from porringer.backend.command.core.discovery import DiscoveredPlugins
 from porringer.core.plugin_schema.plugin_manager import PluginManager
 from porringer.core.plugin_schema.project_environment import ProjectEnvironment
 from porringer.schema import (
@@ -1158,26 +1159,29 @@ class ToolsView(QWidget):
             return None
         return {name for name, chip in self._filter_chips.items() if chip.isChecked()}
 
-    def _apply_filter(self, _text: str | None = None) -> None:
-        """Show/hide section widgets based on search text and active chips.
+    @staticmethod
+    def _is_plugin_active(plugin_name: str, active: set[str] | None) -> bool:
+        """Return whether *plugin_name* passes the chip filter."""
+        return active is None or plugin_name in active
 
-        A single pass walks ``_section_widgets`` tracking the current
-        plugin and kind.  Visibility rules:
+    @staticmethod
+    def _finalise_provider(
+        provider: PluginProviderHeader | None,
+        has_visible: bool,
+    ) -> bool:
+        """Set provider visibility and return whether it had visible children."""
+        if provider is not None:
+            provider.setVisible(has_visible)
+        return has_visible
 
-        * **PluginProviderHeader** — visible when its plugin is in the
-          active chip set **and** at least one child row matches the
-          search text.
-        * **PluginRow** — visible when its plugin is active **and** its
-          package name or plugin name contains the search text.
-        * **ProjectChildRow** — follows its parent :class:`PluginRow`.
-        * **PluginKindHeader** — visible when at least one child
-          provider in its kind group is visible.
+    def _apply_filter(self, _text: str | None = None) -> None:
+        """Show/hide section widgets based on search text and active chips.
 
-        After the pass, kind headers with no visible children are hidden.
+        Delegates to :meth:`_is_plugin_active` for chip matching and
+        :meth:`_finalise_provider` for provider visibility bookkeeping.
         """
         query = self._search_input.text().strip().lower()
         active = self._active_chip_plugins()
-        all_active = active is None  # None → no chips yet, show all
 
         current_kind_header: PluginKindHeader | None = None
         kind_has_visible = False
@@ -1187,13 +1191,8 @@ class ToolsView(QWidget):
 
         for widget in self._section_widgets:
             if isinstance(widget, PluginKindHeader):
-                # Finalise previous kind
+                kind_has_visible |= self._finalise_provider(current_provider, provider_has_visible_child)
                 if current_kind_header is not None:
-                    # Finalise last provider of previous kind
-                    if current_provider is not None:
-                        current_provider.setVisible(provider_has_visible_child)
-                        if provider_has_visible_child:
-                            kind_has_visible = True
                     current_kind_header.setVisible(kind_has_visible)
 
                 current_kind_header = widget
@@ -1202,31 +1201,20 @@ class ToolsView(QWidget):
                 provider_has_visible_child = False
 
             elif isinstance(widget, PluginProviderHeader):
-                # Finalise previous provider
-                if current_provider is not None:
-                    current_provider.setVisible(provider_has_visible_child)
-                    if provider_has_visible_child:
-                        kind_has_visible = True
+                kind_has_visible |= self._finalise_provider(current_provider, provider_has_visible_child)
 
                 current_provider = widget
                 provider_has_visible_child = False
-                plugin_name = widget._plugin_name
-                plugin_active = all_active or (active is not None and plugin_name in active)
-
-                if not plugin_active:
-                    # Entire provider hidden
+                if not self._is_plugin_active(widget._plugin_name, active):
                     widget.setVisible(False)
-                    provider_has_visible_child = False
 
             elif isinstance(widget, PluginRow):
-                plugin_name = widget._plugin_name
-                plugin_active = all_active or (active is not None and plugin_name in active)
-                if not plugin_active:
+                if not self._is_plugin_active(widget._plugin_name, active):
                     widget.setVisible(False)
                     parent_row_visible = False
                     continue
 
-                name_match = not query or query in widget._package_name.lower() or query in plugin_name.lower()
+                name_match = not query or query in widget._package_name.lower() or query in widget._plugin_name.lower()
                 widget.setVisible(name_match)
                 parent_row_visible = name_match
                 if name_match:
@@ -1236,10 +1224,7 @@ class ToolsView(QWidget):
                 widget.setVisible(parent_row_visible)
 
         # Finalise last provider and kind
-        if current_provider is not None:
-            current_provider.setVisible(provider_has_visible_child)
-            if provider_has_visible_child:
-                kind_has_visible = True
+        kind_has_visible |= self._finalise_provider(current_provider, provider_has_visible_child)
         if current_kind_header is not None:
             current_kind_header.setVisible(kind_has_visible)
 
@@ -1834,6 +1819,7 @@ class ProjectsView(QWidget):
             if self._coordinator is not None:
                 snapshot = await self._coordinator.refresh()
                 results = snapshot.validated_directories
+                discovered = snapshot.discovered
             else:
                 loop = asyncio.get_running_loop()
                 results = await loop.run_in_executor(
@@ -1843,6 +1829,7 @@ class ProjectsView(QWidget):
                         check_manifest=True,
                     ),
                 )
+                discovered = None
 
             directories: list[tuple[Path, str, bool]] = []
             current_paths: set[Path] = set()
@@ -1854,32 +1841,12 @@ class ProjectsView(QWidget):
                 current_paths.add(path)
 
             # Remove widgets for directories no longer in cache
-            for path in list(self._widgets):
-                if path not in current_paths:
-                    widget = self._widgets.pop(path)
-                    self._stack.removeWidget(widget)
-                    widget.reset()
-                    widget.deleteLater()
+            self._remove_stale_widgets(current_paths)
 
             # Grab pre-discovered plugins so each widget can skip redundant discovery
-            discovered = snapshot.discovered if self._coordinator is not None else None
 
             # Create new widgets for new directories
-            for path, _name, valid in directories:
-                if path not in self._widgets and valid:
-                    widget = SetupPreviewWidget(
-                        self._porringer,
-                        self,
-                        show_close=False,
-                        config=self._config,
-                    )
-                    widget._discovered_plugins = discovered
-                    widget.install_finished.connect(self._on_install_finished)
-                    widget.phase_changed.connect(
-                        lambda phase, p=path: self._on_widget_phase_changed(p, phase),
-                    )
-                    self._widgets[path] = widget
-                    self._stack.addWidget(widget)
+            self._create_directory_widgets(directories, discovered)
 
             # Rebuild sidebar
             self._sidebar.set_directories(directories)
@@ -1909,6 +1876,37 @@ class ProjectsView(QWidget):
 
     # --- Event handlers ---
 
+    def _remove_stale_widgets(self, current_paths: set[Path]) -> None:
+        """Remove stacked widgets for directories no longer in the cache."""
+        for path in list(self._widgets):
+            if path not in current_paths:
+                widget = self._widgets.pop(path)
+                self._stack.removeWidget(widget)
+                widget.reset()
+                widget.deleteLater()
+
+    def _create_directory_widgets(
+        self,
+        directories: list[tuple[Path, str, bool]],
+        discovered: DiscoveredPlugins | None,
+    ) -> None:
+        """Create :class:`SetupPreviewWidget` instances for new valid directories."""
+        for path, _name, valid in directories:
+            if path not in self._widgets and valid:
+                widget = SetupPreviewWidget(
+                    self._porringer,
+                    self,
+                    show_close=False,
+                    config=self._config,
+                )
+                widget._discovered_plugins = discovered
+                widget.install_finished.connect(self._on_install_finished)
+                widget.phase_changed.connect(
+                    lambda phase, p=path: self._on_widget_phase_changed(p, phase),
+                )
+                self._widgets[path] = widget
+                self._stack.addWidget(widget)
+
     def _on_selection_changed(self, path: Path) -> None:
         """Handle sidebar selection — switch the stacked widget."""
         widget = self._widgets.get(path)

{synodic_client-0.0.1.dev40 → synodic_client-0.0.1.dev42}/synodic_client/application/screen/settings.py

@@ -29,7 +29,7 @@ from PySide6.QtWidgets import (
 
 from synodic_client.application.icon import app_icon
 from synodic_client.application.screen.card import CardFrame
-from synodic_client.application.theme import SETTINGS_WINDOW_MIN_SIZE
+from synodic_client.application.theme import SETTINGS_WINDOW_MIN_SIZE, UPDATE_STATUS_CHECKING_STYLE
 from synodic_client.logging import log_path
 from synodic_client.resolution import ResolvedConfig, update_user_config
 from synodic_client.startup import is_startup_registered, register_startup, remove_startup
@@ -163,6 +163,11 @@ class SettingsWindow(QMainWindow):
         self._detect_updates_check.toggled.connect(self._on_detect_updates_changed)
         content.addWidget(self._detect_updates_check)
 
+        # Automatically apply updates
+        self._auto_apply_check = QCheckBox('Automatically apply updates')
+        self._auto_apply_check.toggled.connect(self._on_auto_apply_changed)
+        content.addWidget(self._auto_apply_check)
+
         # Check for Updates
         row = QHBoxLayout()
         self._check_updates_btn = QPushButton('Check for Updates\u2026')
@@ -218,16 +223,24 @@ class SettingsWindow(QMainWindow):
 
             # Checkboxes
             self._detect_updates_check.setChecked(config.detect_updates)
+            self._auto_apply_check.setChecked(config.auto_apply)
             self._auto_start_check.setChecked(is_startup_registered())
 
-    def set_update_status(self, text: str) -> None:
-        """Set the inline status text next to the *Check for Updates* button."""
+    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._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."""
@@ -262,6 +275,7 @@ class SettingsWindow(QMainWindow):
             self._auto_update_spin,
             self._tool_update_spin,
             self._detect_updates_check,
+            self._auto_apply_check,
             self._auto_start_check,
             self._check_updates_btn,
         )
@@ -301,6 +315,9 @@ class SettingsWindow(QMainWindow):
     def _on_detect_updates_changed(self, checked: bool) -> None:
         self._persist(detect_updates=checked)
 
+    def _on_auto_apply_changed(self, checked: bool) -> None:
+        self._persist(auto_apply=checked)
+
     def _on_auto_start_changed(self, checked: bool) -> None:
         self._config = update_user_config(auto_start=checked)
         if checked:

{synodic_client-0.0.1.dev40 → synodic_client-0.0.1.dev42}/synodic_client/application/screen/tray.py

@@ -17,10 +17,9 @@ from PySide6.QtWidgets import (
 from synodic_client.application.icon import app_icon
 from synodic_client.application.screen.screen import MainWindow, ToolsView
 from synodic_client.application.screen.settings import SettingsWindow
+from synodic_client.application.update_controller import UpdateController
 from synodic_client.application.workers import (
     ToolUpdateResult,
-    check_for_update,
-    download_update,
     run_package_remove,
     run_tool_updates,
 )
@@ -31,7 +30,6 @@ from synodic_client.resolution import (
     resolve_config,
     resolve_update_config,
 )
-from synodic_client.updater import UpdateInfo
 
 logger = logging.getLogger(__name__)
 
@@ -59,7 +57,6 @@ class TrayScreen:
         self._client = client
         self._window = window
         self._config = config
-        self._update_task: asyncio.Task[None] | None = None
         self._tool_task: asyncio.Task[None] | None = None
 
         self.tray_icon = app_icon()
@@ -74,14 +71,19 @@ class TrayScreen:
         # Settings window (created once, shown/hidden on demand)
         self._settings_window = SettingsWindow(self._resolve_config())
         self._settings_window.settings_changed.connect(self._on_settings_changed)
-        self._settings_window.check_updates_requested.connect(self._on_check_updates)
 
         # MainWindow gear button → open settings
         window.settings_requested.connect(self._show_settings)
 
-        # Periodic auto-update checking
-        self._auto_update_timer: QTimer | None = None
-        self._restart_auto_update_timer()
+        # Update controller — owns the self-update lifecycle & timer
+        self._banner = window.update_banner
+        self._update_controller = UpdateController(
+            app,
+            client,
+            self._banner,
+            self._settings_window,
+            config,
+        )
 
         # Periodic tool update checking
         self._tool_update_timer: QTimer | None = None
@@ -90,11 +92,6 @@ class TrayScreen:
         # Connect ToolsView signals — deferred because ToolsView is created lazily
         window.tools_view_created.connect(self._connect_tools_view)
 
-        # Connect update banner signals
-        self._banner = window.update_banner
-        self._banner.restart_requested.connect(self._apply_update)
-        self._banner.retry_requested.connect(lambda: self._do_check_updates(silent=True))
-
     def _build_menu(self, app: QApplication, window: MainWindow) -> None:
         """Build the tray context menu."""
         self.menu = QMenu()
@@ -105,12 +102,6 @@ class TrayScreen:
 
         self.menu.addSeparator()
 
-        self.update_action = QAction('Check for Updates...', self.menu)
-        self.update_action.triggered.connect(self._on_check_updates)
-        self.menu.addAction(self.update_action)
-
-        self.menu.addSeparator()
-
         self.settings_action = QAction('Settings\u2026', self.menu)
         self.settings_action.triggered.connect(self._show_settings)
         self.menu.addAction(self.settings_action)
@@ -172,16 +163,6 @@ class TrayScreen:
         logger.info('%s enabled (every %d minute(s))', label, interval_minutes)
         return timer
 
-    def _restart_auto_update_timer(self) -> None:
-        """Start (or restart) the periodic auto-update timer from config."""
-        config = resolve_update_config(self._resolve_config())
-        self._auto_update_timer = self._restart_timer(
-            self._auto_update_timer,
-            config.auto_update_interval_minutes,
-            self._on_auto_check_updates,
-            'Automatic update checking',
-        )
-
     def _restart_tool_update_timer(self) -> None:
         """Start (or restart) the periodic tool update timer from config."""
         config = resolve_update_config(self._resolve_config())
@@ -206,116 +187,10 @@ class TrayScreen:
     def _on_settings_changed(self, config: ResolvedConfig) -> None:
         """React to a change made in the settings window."""
         self._config = config
-        self._reinitialize_updater(config)
-
-    def _reinitialize_updater(self, config: ResolvedConfig) -> None:
-        """Re-derive update settings and restart the updater and timers.
-
-        The new ``Updater`` starts with the ``importlib.metadata``
-        version which may be stale after a Velopack update.  The
-        authoritative Velopack version is recovered automatically on
-        the first ``_get_velopack_manager()`` call (i.e. the next
-        update check), so no special handling is required here.
-        """
-        update_cfg = resolve_update_config(config)
-        self._client.initialize_updater(update_cfg)
-        self._restart_auto_update_timer()
+        # Delegate updater reinit + immediate check to the controller
+        self._update_controller.on_settings_changed(config)
+        # Restart tool-update timer with new config
         self._restart_tool_update_timer()
-        logger.info('Updater re-initialized (channel: %s, source: %s)', update_cfg.channel.name, update_cfg.repo_url)
-
-    def _reset_update_action(self) -> None:
-        """Restore the 'Check for Updates' action to its idle state."""
-        self.update_action.setEnabled(True)
-        self.update_action.setText('Check for Updates...')
-
-    def _on_check_updates(self) -> None:
-        """Handle manual check for updates action."""
-        self._do_check_updates(silent=False)
-
-    def _on_auto_check_updates(self) -> None:
-        """Handle automatic (periodic) check for updates.
-
-        Failures and no-update results are logged silently without
-        showing the in-app error banner.
-        """
-        self._do_check_updates(silent=True)
-
-    def _do_check_updates(self, *, silent: bool) -> None:
-        """Run an update check.
-
-        Args:
-            silent: When ``True``, suppress the in-app error banner
-                for failures and no-update results.  The banner is
-                always shown when an update *is* available.
-        """
-        if self._client.updater is None:
-            if not silent:
-                self._banner.show_error('Updater is not initialized.')
-            return
-
-        # Disable both the tray action and the settings button while checking
-        self.update_action.setEnabled(False)
-        self.update_action.setText('Checking for Updates...')
-        self._settings_window.set_checking()
-
-        self._update_task = asyncio.create_task(self._async_check_updates(silent=silent))
-
-    async def _async_check_updates(self, *, silent: bool) -> None:
-        """Run the update check coroutine and route results."""
-        try:
-            result = await check_for_update(self._client)
-            self._on_update_check_finished(result, silent=silent)
-        except Exception as exc:
-            logger.exception('Update check failed')
-            self._on_update_check_error(str(exc), silent=silent)
-
-    def _on_update_check_finished(self, result: UpdateInfo | None, *, silent: bool = False) -> None:
-        """Handle update check completion."""
-        self._reset_update_action()
-        self._settings_window.reset_check_updates_button()
-
-        if result is None:
-            self._settings_window.set_update_status('Check failed')
-            if not silent:
-                self._banner.show_error('Failed to check for updates.')
-            else:
-                logger.warning('Automatic update check failed (no result)')
-            return
-
-        if result.error:
-            self._settings_window.set_update_status(result.error)
-            if not silent:
-                self._banner.show_error(result.error)
-            else:
-                logger.warning('Automatic update check failed: %s', result.error)
-            return
-
-        if not result.available:
-            self._settings_window.set_update_status(
-                f'Up to date ({result.current_version})',
-            )
-            if not silent:
-                logger.info('No updates available (current: %s)', result.current_version)
-            else:
-                logger.debug('Automatic update check: no update available')
-            return
-
-        # Update available — show banner and start download automatically
-        version = str(result.latest_version)
-        self._settings_window.set_update_status(f'Update available: {version}')
-        self._banner.show_downloading(version)
-        self._start_download(version)
-
-    def _on_update_check_error(self, error: str, *, silent: bool = False) -> None:
-        """Handle update check error."""
-        self._reset_update_action()
-        self._settings_window.reset_check_updates_button()
-        self._settings_window.set_update_status(f'Error: {error}')
-
-        if not silent:
-            self._banner.show_error(f'Update check error: {error}')
-        else:
-            logger.warning('Automatic update check error: %s', error)
 
     # -- Tool update helpers --
 
@@ -571,51 +446,3 @@ class TrayScreen:
             tools_view.refresh()
 
         self._window.show()
-
-    # -- Self-update download & apply --
-
-    def _start_download(self, version: str) -> None:
-        """Start downloading the update in the background.
-
-        Args:
-            version: The version string being downloaded (for banner display).
-        """
-        self._update_task = asyncio.create_task(self._async_download(version))
-
-    async def _async_download(self, version: str) -> None:
-        """Run the download coroutine and route results."""
-        try:
-            success = await download_update(
-                self._client,
-                on_progress=self._banner.show_downloading_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_finished(self, success: bool, version: str) -> None:
-        """Handle download completion — transition banner to ready state."""
-        if not success:
-            self._banner.show_error('Download failed. Please try again later.')
-            return
-
-        self._banner.show_ready(version)
-        self._settings_window.set_update_status(f'Ready to install: {version}')
-
-    def _on_download_error(self, error: str) -> None:
-        """Handle download error — show error banner."""
-        self._banner.show_error(f'Download error: {error}')
-
-    def _apply_update(self) -> None:
-        """Apply the downloaded update and restart."""
-        if self._client.updater is None:
-            return
-
-        try:
-            self._client.apply_update_on_exit(restart=True)
-            logger.info('Update scheduled — restarting application')
-            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}')

{synodic_client-0.0.1.dev40 → synodic_client-0.0.1.dev42}/synodic_client/application/theme.py

@@ -436,6 +436,21 @@ SETTINGS_GEAR_STYLE = (
 )
 """Gear button style for the MainWindow tab corner widget."""
 
+# ---------------------------------------------------------------------------
+# Settings inline update-status colours
+# ---------------------------------------------------------------------------
+UPDATE_STATUS_UP_TO_DATE_STYLE = 'color: #89d185; font-size: 12px;'
+"""Green text for 'Up to date' / 'Ready' status."""
+
+UPDATE_STATUS_AVAILABLE_STYLE = 'color: #cca700; font-size: 12px;'
+"""Orange text for 'Update available' status."""
+
+UPDATE_STATUS_ERROR_STYLE = 'color: #f48771; font-size: 12px;'
+"""Red text for error / check-failed status."""
+
+UPDATE_STATUS_CHECKING_STYLE = 'color: #808080; font-size: 12px; font-style: italic;'
+"""Grey italic text for 'Checking…' status."""
+
 # ---------------------------------------------------------------------------
 # Update banner (in-app self-update notification)
 # ---------------------------------------------------------------------------