synodic-client 0.0.1.dev32__tar.gz → 0.0.1.dev34__tar.gz

{synodic_client-0.0.1.dev32 → synodic_client-0.0.1.dev34}/PKG-INFO

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

@@ -15,7 +15,7 @@ dependencies = [
     "velopack>=0.0.1442.dev64255",
     "typer>=0.24.1",
 ]
-version = "0.0.1.dev32"
+version = "0.0.1.dev34"
 
 [project.license]
 text = "LGPL-3.0-or-later"

synodic_client-0.0.1.dev34/synodic_client/_version.py

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

{synodic_client-0.0.1.dev32 → synodic_client-0.0.1.dev34}/synodic_client/application/bootstrap.py

@@ -18,7 +18,7 @@ import sys
 from synodic_client.config import set_dev_mode
 from synodic_client.logging import configure_logging
 from synodic_client.protocol import register_protocol
-from synodic_client.resolution import resolve_auto_start, resolve_config
+from synodic_client.resolution import resolve_config, seed_user_config_from_build
 from synodic_client.startup import register_startup, remove_startup
 from synodic_client.updater import initialize_velopack
 
@@ -32,10 +32,13 @@ configure_logging()
 initialize_velopack()
 
 if not _dev_mode:
+    # Seed user config from the build config (one-time propagation).
+    seed_user_config_from_build()
+
     register_protocol(sys.executable)
 
     _config = resolve_config()
-    if resolve_auto_start(_config):
+    if _config.auto_start:
         register_startup(sys.executable)
     else:
         remove_startup()

{synodic_client-0.0.1.dev32 → synodic_client-0.0.1.dev34}/synodic_client/application/qt.py

@@ -21,15 +21,21 @@ from synodic_client.application.screen.screen import Screen
 from synodic_client.application.screen.tray import TrayScreen
 from synodic_client.application.uri import parse_uri
 from synodic_client.client import Client
-from synodic_client.config import GlobalConfiguration, set_dev_mode
+from synodic_client.config import set_dev_mode
 from synodic_client.logging import configure_logging
 from synodic_client.protocol import register_protocol
-from synodic_client.resolution import resolve_auto_start, resolve_config, resolve_update_config
+from synodic_client.resolution import (
+    ResolvedConfig,
+    resolve_config,
+    resolve_update_config,
+    resolve_version,
+    seed_user_config_from_build,
+)
 from synodic_client.startup import register_startup, remove_startup
 from synodic_client.updater import initialize_velopack
 
 
-def _init_services(logger: logging.Logger) -> tuple[Client, API, GlobalConfiguration]:
+def _init_services(logger: logging.Logger) -> tuple[Client, API, ResolvedConfig]:
     """Create and configure core services.
 
     Returns:
@@ -47,11 +53,10 @@ def _init_services(logger: logging.Logger) -> tuple[Client, API, GlobalConfigura
     cached_dirs = porringer.cache.list_directories()
 
     logger.info(
-        'Synodic Client v%s started (channel: %s, source: %s, config_fields_set: %s, cached_projects: %d)',
-        client.version,
+        'Synodic Client v%s started (channel: %s, source: %s, cached_projects: %d)',
+        resolve_version(client),
         update_config.channel.name,
         update_config.repo_url,
-        sorted(config.model_fields_set),
         len(cached_dirs),
     )
 
@@ -140,8 +145,11 @@ def application(*, uri: str | None = None, dev_mode: bool = False) -> None:
         initialize_velopack()
         register_protocol(sys.executable)
 
+        # Seed user config from build config (one-time propagation).
+        seed_user_config_from_build()
+
         startup_config = resolve_config()
-        if resolve_auto_start(startup_config):
+        if startup_config.auto_start:
             register_startup(sys.executable)
         else:
             remove_startup()

{synodic_client-0.0.1.dev32 → synodic_client-0.0.1.dev34}/synodic_client/application/screen/install.py

@@ -72,7 +72,7 @@ from synodic_client.application.theme import (
     MUTED_STYLE,
     NO_MARGINS,
 )
-from synodic_client.config import GlobalConfiguration, save_config
+from synodic_client.resolution import ResolvedConfig, update_user_config
 
 logger = logging.getLogger(__name__)
 
@@ -332,7 +332,7 @@ class SetupPreviewWidget(QWidget):
         parent: QWidget | None = None,
         *,
         show_close: bool = True,
-        config: GlobalConfiguration | None = None,
+        config: ResolvedConfig | None = None,
     ) -> None:
         """Initialize the preview widget.
 
@@ -579,14 +579,14 @@ class SetupPreviewWidget(QWidget):
         if self._config is None or self._manifest_key is None:
             return
 
-        pkgs = self._config.prerelease_packages or {}
+        pkgs = dict(self._config.prerelease_packages or {})
         if self._prerelease_overrides:
             pkgs[self._manifest_key] = sorted(self._prerelease_overrides)
         else:
             pkgs.pop(self._manifest_key, None)
 
-        self._config.prerelease_packages = pkgs if pkgs else None
-        save_config(self._config)
+        new_value = pkgs if pkgs else None
+        self._config = update_user_config(prerelease_packages=new_value)
         logger.info('Pre-release overrides for %s: %s', self._manifest_key, self._prerelease_overrides)
 
         if not self._installing:
@@ -918,7 +918,7 @@ class InstallPreviewWindow(QMainWindow):
         manifest_url: str,
         parent: QWidget | None = None,
         *,
-        config: GlobalConfiguration | None = None,
+        config: ResolvedConfig | None = None,
     ) -> None:
         """Initialize the install preview window.
 
@@ -926,13 +926,13 @@ class InstallPreviewWindow(QMainWindow):
             porringer: The porringer API instance.
             manifest_url: The URL of the manifest to install.
             parent: Optional parent widget.
-            config: Resolved global configuration for per-manifest pre-release
+            config: Resolved configuration for per-manifest pre-release
                 state and update detection flags.
         """
         super().__init__(parent)
         self._porringer = porringer
         self._manifest_url = manifest_url
-        self._config = config or GlobalConfiguration()
+        self._config = config
         self._temp_dir_path: str | None = None
         self._runner: QThread | None = None
 
@@ -1038,13 +1038,16 @@ class InstallPreviewWindow(QMainWindow):
         self._preview_widget.set_manifest_key(self._manifest_url)
 
         manifest_key = normalize_manifest_key(self._manifest_url)
-        overrides = set((self._config.prerelease_packages or {}).get(manifest_key, []))
+        config = self._config
+        if config is None:
+            return
+        overrides = set((config.prerelease_packages or {}).get(manifest_key, []))
 
         preview_worker = PreviewWorker(
             self._porringer,
             self._manifest_url,
             project_directory=self._project_directory,
-            detect_updates=self._config.detect_updates,
+            detect_updates=config.detect_updates,
             prerelease_packages=overrides or None,
         )
 

{synodic_client-0.0.1.dev32 → synodic_client-0.0.1.dev34}/synodic_client/application/screen/screen.py

@@ -53,7 +53,7 @@ from synodic_client.application.theme import (
     PLUGIN_UPDATE_STYLE,
     SETTINGS_GEAR_STYLE,
 )
-from synodic_client.config import GlobalConfiguration, save_config
+from synodic_client.resolution import ResolvedConfig, update_user_config
 
 logger = logging.getLogger(__name__)
 
@@ -306,14 +306,14 @@ class PluginsView(QWidget):
     def __init__(
         self,
         porringer: API,
-        config: GlobalConfiguration,
+        config: ResolvedConfig,
         parent: QWidget | None = None,
     ) -> None:
         """Initialize the plugins view.
 
         Args:
             porringer: The porringer API instance.
-            config: Resolved global configuration (for auto-update toggles).
+            config: Resolved configuration (for auto-update toggles).
             parent: Optional parent widget.
         """
         super().__init__(parent)
@@ -484,10 +484,7 @@ class PluginsView(QWidget):
 
     def _on_auto_update_toggled(self, plugin_name: str, enabled: bool) -> None:
         """Persist the auto-update toggle change to config."""
-        mapping = self._config.plugin_auto_update
-        if mapping is None:
-            mapping = {}
-            self._config.plugin_auto_update = mapping
+        mapping = dict(self._config.plugin_auto_update or {})
 
         if enabled:
             mapping.pop(plugin_name, None)
@@ -495,10 +492,8 @@ class PluginsView(QWidget):
             mapping[plugin_name] = False
 
         # Clean up the dict if all plugins are enabled
-        if not mapping:
-            self._config.plugin_auto_update = None
-
-        save_config(self._config)
+        new_value = mapping if mapping else None
+        self._config = update_user_config(plugin_auto_update=new_value)
         logger.info('Auto-update for %s set to %s', plugin_name, enabled)
 
 
@@ -510,12 +505,12 @@ class ProjectsView(QWidget):
     install execution.
     """
 
-    def __init__(self, porringer: API, config: GlobalConfiguration, parent: QWidget | None = None) -> None:
+    def __init__(self, porringer: API, config: ResolvedConfig, parent: QWidget | None = None) -> None:
         """Initialize the projects view.
 
         Args:
             porringer: The porringer API instance.
-            config: Resolved global configuration.
+            config: Resolved configuration.
             parent: Optional parent widget.
         """
         super().__init__(parent)
@@ -805,17 +800,17 @@ class MainWindow(QMainWindow):
     def __init__(
         self,
         porringer: API | None = None,
-        config: GlobalConfiguration | None = None,
+        config: ResolvedConfig | None = None,
     ) -> None:
         """Initialize the main window.
 
         Args:
             porringer: Optional porringer API instance for manifest display.
-            config: Resolved global configuration for plugin auto-update state.
+            config: Resolved configuration for plugin auto-update state.
         """
         super().__init__()
         self._porringer = porringer
-        self._config = config or GlobalConfiguration()
+        self._config = config
         self.setWindowTitle('Synodic Client')
         self.setMinimumSize(*MAIN_WINDOW_MIN_SIZE)
         self.setWindowIcon(app_icon())
@@ -832,7 +827,7 @@ class MainWindow(QMainWindow):
 
     def show(self) -> None:
         """Show the window, initializing UI lazily on first show."""
-        if self._tabs is None and self._porringer is not None:
+        if self._tabs is None and self._porringer is not None and self._config is not None:
             self._tabs = QTabWidget(self)
 
             self._projects_view = ProjectsView(self._porringer, self._config, self)
@@ -867,13 +862,13 @@ class Screen:
     def __init__(
         self,
         porringer: API | None = None,
-        config: GlobalConfiguration | None = None,
+        config: ResolvedConfig | None = None,
     ) -> None:
         """Initialize the screen.
 
         Args:
             porringer: Optional porringer API instance.
-            config: Resolved global configuration.
+            config: Resolved configuration.
         """
         self._porringer = porringer
         self._config = config

{synodic_client-0.0.1.dev32 → synodic_client-0.0.1.dev34}/synodic_client/application/screen/settings.py

@@ -1,8 +1,8 @@
 """Settings window for the Synodic Client application.
 
 Provides a single-page window with grouped sections for all application
-settings.  Quick-access items (Channel, Check for Updates) remain in the
-tray menu; the full set is available here.
+settings including update-channel selection and a manual *Check for
+Updates* button with inline status feedback.
 """
 
 import logging
@@ -10,7 +10,7 @@ import sys
 from collections.abc import Iterator
 from contextlib import contextmanager
 
-from PySide6.QtCore import QUrl, Signal
+from PySide6.QtCore import Qt, QUrl, Signal
 from PySide6.QtGui import QDesktopServices
 from PySide6.QtWidgets import (
     QCheckBox,
@@ -30,12 +30,10 @@ 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.config import GlobalConfiguration, save_config
 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
 from synodic_client.updater import (
-    DEFAULT_AUTO_UPDATE_INTERVAL_MINUTES,
-    DEFAULT_TOOL_UPDATE_INTERVAL_MINUTES,
     GITHUB_REPO_URL,
 )
 
@@ -45,22 +43,26 @@ logger = logging.getLogger(__name__)
 class SettingsWindow(QMainWindow):
     """Application settings window with grouped card sections.
 
-    All controls persist changes immediately via :func:`save_config` and
-    emit :attr:`settings_changed` so that the tray and updater can react.
+    All controls persist changes immediately via :func:`update_user_config`
+    and emit :attr:`settings_changed` so that the tray and updater can
+    react.  The signal carries the new :class:`ResolvedConfig`.
     """
 
-    settings_changed = Signal()
-    """Emitted whenever a setting is changed and persisted."""
+    settings_changed = Signal(object)
+    """Emitted with the new ``ResolvedConfig`` whenever a setting is changed and persisted."""
+
+    check_updates_requested = Signal()
+    """Emitted when the user clicks the *Check for Updates* button."""
 
     def __init__(
         self,
-        config: GlobalConfiguration,
+        config: ResolvedConfig,
         parent: QWidget | None = None,
     ) -> None:
         """Initialise the settings window.
 
         Args:
-            config: The shared global configuration object.
+            config: The current resolved configuration snapshot.
             parent: Optional parent widget.
         """
         super().__init__(parent)
@@ -124,6 +126,12 @@ class SettingsWindow(QMainWindow):
         row.addWidget(browse_btn)
         content.addLayout(row)
 
+        self._add_update_controls(content)
+
+        return card
+
+    def _add_update_controls(self, content: QVBoxLayout) -> None:
+        """Add interval spinners, detect-updates checkbox, and update button."""
         # Auto-update interval
         row = QHBoxLayout()
         label = QLabel('App update interval (min)')
@@ -155,7 +163,16 @@ class SettingsWindow(QMainWindow):
         self._detect_updates_check.toggled.connect(self._on_detect_updates_changed)
         content.addWidget(self._detect_updates_check)
 
-        return card
+        # Check for Updates
+        row = QHBoxLayout()
+        self._check_updates_btn = QPushButton('Check for Updates\u2026')
+        self._check_updates_btn.clicked.connect(self._on_check_updates_clicked)
+        row.addWidget(self._check_updates_btn)
+        self._update_status_label = QLabel('')
+        self._update_status_label.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse)
+        row.addWidget(self._update_status_label)
+        row.addStretch()
+        content.addLayout(row)
 
     def _build_startup_section(self) -> CardFrame:
         """Construct the *Startup* settings card."""
@@ -195,20 +212,22 @@ class SettingsWindow(QMainWindow):
             # Update source
             self._source_edit.setText(config.update_source or '')
 
-            # Intervals
-            auto_interval = config.auto_update_interval_minutes
-            self._auto_update_spin.setValue(
-                auto_interval if auto_interval is not None else DEFAULT_AUTO_UPDATE_INTERVAL_MINUTES,
-            )
-            tool_interval = config.tool_update_interval_minutes
-            self._tool_update_spin.setValue(
-                tool_interval if tool_interval is not None else DEFAULT_TOOL_UPDATE_INTERVAL_MINUTES,
-            )
+            # Intervals (already resolved to concrete ints)
+            self._auto_update_spin.setValue(config.auto_update_interval_minutes)
+            self._tool_update_spin.setValue(config.tool_update_interval_minutes)
 
             # Checkboxes
             self._detect_updates_check.setChecked(config.detect_updates)
             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."""
+        self._update_status_label.setText(text)
+
+    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 show(self) -> None:
         """Sync controls from config, then show the window."""
         self.sync_from_config()
@@ -220,10 +239,14 @@ class SettingsWindow(QMainWindow):
     # Callbacks
     # ------------------------------------------------------------------
 
-    def _persist(self) -> None:
-        """Save config and notify listeners."""
-        save_config(self._config)
-        self.settings_changed.emit()
+    def _persist(self, **changes: object) -> None:
+        """Save config changes and notify listeners.
+
+        Args:
+            **changes: Field-name / value pairs to persist.
+        """
+        self._config = update_user_config(**changes)
+        self.settings_changed.emit(self._config)
 
     @contextmanager
     def _block_signals(self) -> Iterator[None]:
@@ -235,6 +258,7 @@ class SettingsWindow(QMainWindow):
             self._tool_update_spin,
             self._detect_updates_check,
             self._auto_start_check,
+            self._check_updates_btn,
         )
         for w in widgets:
             w.blockSignals(True)
@@ -244,14 +268,18 @@ class SettingsWindow(QMainWindow):
             for w in widgets:
                 w.blockSignals(False)
 
+    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:
-        self._config.update_channel = 'dev' if index == 1 else 'stable'
-        self._persist()
+        self._persist(update_channel='dev' if index == 1 else 'stable')
 
     def _on_source_changed(self) -> None:
         text = self._source_edit.text().strip()
-        self._config.update_source = text or None
-        self._persist()
+        self._persist(update_source=text or None)
 
     def _on_browse_source(self) -> None:
         path = QFileDialog.getExistingDirectory(self, 'Select Releases Directory')
@@ -260,25 +288,21 @@ class SettingsWindow(QMainWindow):
             self._on_source_changed()
 
     def _on_auto_update_interval_changed(self, value: int) -> None:
-        self._config.auto_update_interval_minutes = value
-        self._persist()
+        self._persist(auto_update_interval_minutes=value)
 
     def _on_tool_update_interval_changed(self, value: int) -> None:
-        self._config.tool_update_interval_minutes = value
-        self._persist()
+        self._persist(tool_update_interval_minutes=value)
 
     def _on_detect_updates_changed(self, checked: bool) -> None:
-        self._config.detect_updates = checked
-        self._persist()
+        self._persist(detect_updates=checked)
 
     def _on_auto_start_changed(self, checked: bool) -> None:
-        self._config.auto_start = checked
-        save_config(self._config)
+        self._config = update_user_config(auto_start=checked)
         if checked:
             register_startup(sys.executable)
         else:
             remove_startup()
-        self.settings_changed.emit()
+        self.settings_changed.emit(self._config)
 
     @staticmethod
     def _open_log() -> None: