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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: synodic_client
-Version: 0.0.1.dev63
+Version: 0.0.1.dev65
 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.dev77
+Requires-Dist: porringer>=0.2.1.dev78
 Requires-Dist: qasync>=0.28.0
 Requires-Dist: velopack>=0.0.1444.dev49733
 Requires-Dist: typer>=0.24.1

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

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

{synodic_client-0.0.1.dev63 → synodic_client-0.0.1.dev65}/synodic_client/application/bootstrap.py

@@ -17,8 +17,8 @@ import sys
 
 from synodic_client.config import set_dev_mode
 from synodic_client.logging import configure_logging
-from synodic_client.subprocess_patch import apply as _apply_subprocess_patch
 from synodic_client.protocol import extract_uri_from_args
+from synodic_client.subprocess_patch import apply as _apply_subprocess_patch
 from synodic_client.updater import initialize_velopack
 
 # Parse flags early so logging uses the right filename and level.

synodic_client-0.0.1.dev65/synodic_client/application/config_store.py

@@ -0,0 +1,65 @@
+"""Centralized configuration store.
+
+Provides a single source of truth for :class:`ResolvedConfig` so that
+every consumer (ToolsView, SettingsWindow, UpdateController,
+ToolUpdateOrchestrator) always reads the same snapshot and receives
+change notifications through a Qt signal.
+"""
+
+from __future__ import annotations
+
+from PySide6.QtCore import QObject, Signal
+
+from synodic_client.resolution import ResolvedConfig, resolve_config, update_user_config
+
+
+class ConfigStore(QObject):
+    """Observable wrapper around :class:`ResolvedConfig`.
+
+    All config mutations go through :meth:`update` (which persists to
+    disk) or :meth:`set` (which replaces without persisting).  Both
+    emit :attr:`changed` so every connected consumer stays in sync.
+
+    Typical usage::
+
+        store = ConfigStore(initial_config)
+        store.changed.connect(some_consumer.on_config_changed)
+        store.update(auto_apply=False)  # persists + emits
+    """
+
+    changed = Signal(object)
+    """Emitted with the new ``ResolvedConfig`` after every mutation."""
+
+    def __init__(self, config: ResolvedConfig | None = None, parent: QObject | None = None) -> None:
+        """Create a new store, optionally seeded with *config*."""
+        super().__init__(parent)
+        self._config = config if config is not None else resolve_config()
+
+    @property
+    def config(self) -> ResolvedConfig:
+        """The current configuration snapshot."""
+        return self._config
+
+    def update(self, **changes: object) -> ResolvedConfig:
+        """Persist *changes* to disk and broadcast the new config.
+
+        Wraps :func:`~synodic_client.resolution.update_user_config`.
+
+        Args:
+            **changes: Field-name / value pairs forwarded to
+                :func:`update_user_config`.
+
+        Returns:
+            The fresh :class:`ResolvedConfig`.
+        """
+        self._config = update_user_config(**changes)
+        self.changed.emit(self._config)
+        return self._config
+
+    def set(self, config: ResolvedConfig) -> None:
+        """Replace the config without persisting and notify listeners.
+
+        Use for externally resolved configs (e.g. passed at startup).
+        """
+        self._config = config
+        self.changed.emit(self._config)

synodic_client-0.0.1.dev65/synodic_client/application/package_state.py

@@ -0,0 +1,125 @@
+"""Shared package update state registry.
+
+Provides :class:`PackageStateStore`, a centralised record of
+per-package update status used by both ToolsView and ProjectsView
+so that version/update information discovered in one view is
+immediately available to the other.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from PySide6.QtCore import QObject, Signal
+
+
+@dataclass(slots=True)
+class PackageState:
+    """Canonical update state for a single package.
+
+    Keyed by ``(signal_key, name)`` inside :class:`PackageStateStore`.
+    """
+
+    name: str
+    """Package name (e.g. ``"ruff"``)."""
+
+    installed_version: str = ''
+    """Currently installed version, or empty if unknown."""
+
+    available_version: str = ''
+    """Latest available version, or empty if unknown."""
+
+    has_update: bool = False
+    """Whether the package has a newer version available."""
+
+
+class PackageStateStore(QObject):
+    """Shared registry of package update states across views.
+
+    Both ToolsView and ProjectsView write discovered update information
+    into the store; each view can then read the canonical state
+    regardless of which view made the discovery.
+
+    :attr:`state_changed` is emitted whenever new data arrives so
+    listeners can refresh their badges/labels without polling.
+    """
+
+    state_changed = Signal()
+    """Emitted whenever any package state is created or modified."""
+
+    def __init__(self, parent: QObject | None = None) -> None:
+        """Initialise with an empty registry."""
+        super().__init__(parent)
+        self._data: dict[str, dict[str, PackageState]] = {}
+
+    # -- Bulk write (ToolsView check_updates) ----------------------------
+
+    def set_check_results(self, available: dict[str, dict[str, str]]) -> None:
+        """Populate from ``check_updates`` results.
+
+        *available* maps ``{signal_key: {package_name: latest_version}}``
+        — the same shape previously stored in
+        ``ToolsView._updates_available``.
+        """
+        self._data.clear()
+        for key, packages in available.items():
+            for pkg_name, latest in packages.items():
+                self._data.setdefault(key, {})[pkg_name] = PackageState(
+                    name=pkg_name,
+                    available_version=latest,
+                    has_update=True,
+                )
+        self.state_changed.emit()
+
+    # -- Single-action write (ProjectsView dry-run) ----------------------
+
+    def record_action_result(
+        self,
+        signal_key: str,
+        pkg_name: str,
+        *,
+        installed_version: str = '',
+        available_version: str = '',
+        has_update: bool = False,
+    ) -> None:
+        """Record a single dry-run result.
+
+        Merges with any existing state so that data discovered by
+        different views accumulates rather than overwrites.
+        """
+        existing = self._data.get(signal_key, {}).get(pkg_name)
+        state = PackageState(
+            name=pkg_name,
+            installed_version=installed_version or (existing.installed_version if existing else ''),
+            available_version=available_version or (existing.available_version if existing else ''),
+            has_update=has_update or (existing.has_update if existing else False),
+        )
+        self._data.setdefault(signal_key, {})[pkg_name] = state
+        self.state_changed.emit()
+
+    # -- Read API --------------------------------------------------------
+
+    def get_updates(self, signal_key: str) -> dict[str, str]:
+        """Return ``{package_name: latest_version}`` for packages with updates.
+
+        Drop-in replacement for ``_updates_available.get(key, {})``.
+        """
+        bucket = self._data.get(signal_key, {})
+        return {name: s.available_version for name, s in bucket.items() if s.has_update}
+
+    def has_updates_for(self, signal_key: str) -> bool:
+        """Return whether any package under *signal_key* has an update."""
+        return any(s.has_update for s in self._data.get(signal_key, {}).values())
+
+    def get(self, signal_key: str, pkg_name: str) -> PackageState | None:
+        """Return the state for a specific package, or ``None``."""
+        return self._data.get(signal_key, {}).get(pkg_name)
+
+    @property
+    def has_data(self) -> bool:
+        """Return whether any update data has been recorded."""
+        return bool(self._data)
+
+    def clear(self) -> None:
+        """Remove all recorded state."""
+        self._data.clear()

{synodic_client-0.0.1.dev63 → synodic_client-0.0.1.dev65}/synodic_client/application/qt.py

@@ -15,6 +15,7 @@ from porringer.schema import LocalConfiguration
 from PySide6.QtCore import QEvent, QObject, Qt, QTimer
 from PySide6.QtWidgets import QApplication, QWidget
 
+from synodic_client.application.config_store import ConfigStore
 from synodic_client.application.icon import app_icon
 from synodic_client.application.init import run_startup_preamble
 from synodic_client.application.instance import SingleInstance
@@ -216,8 +217,9 @@ def application(*, uri: str | None = None, dev_mode: bool = False, debug: bool =
         sys.exit(0)
     instance.start_server()
 
-    _screen = Screen(porringer, config)
-    _tray = TrayScreen(app, client, _screen.window, config=config)
+    _store = ConfigStore(config)
+    _screen = Screen(porringer, _store)
+    _tray = TrayScreen(app, client, _screen.window, store=_store)
 
     # Keep install preview windows alive until the app exits
     _install_windows: list[InstallPreviewWindow] = []
@@ -227,7 +229,7 @@ def application(*, uri: str | None = None, dev_mode: bool = False, debug: bool =
         window = InstallPreviewWindow(
             porringer,
             manifest_url,
-            config=config,
+            config=_store.config,
         )
         _install_windows.append(window)
         window.show()

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

@@ -51,3 +51,24 @@ class ToolUpdateResult:
     failed: int = 0
     updated_packages: set[str] = field(default_factory=set)
     """Package names that were successfully upgraded."""
+
+
+@dataclass(frozen=True, slots=True)
+class UpdateTarget:
+    """Identifies the scope of a manual tool update.
+
+    Passed to the shared completion handler so it can clear the correct
+    updating state and derive timestamp keys.  ``None`` (the default in
+    the handler) means the update was periodic / automatic.
+
+    When *package* is empty the update targeted an entire plugin;
+    otherwise it targeted one specific package within the plugin.
+    *plugin* always carries the signal key (possibly composite
+    ``"plugin:tag"``).
+    """
+
+    plugin: str
+    """Signal key for the plugin (may be composite ``"name:tag"``)."""
+
+    package: str = ''
+    """Package name, or empty when the whole plugin was updated."""

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

@@ -43,6 +43,7 @@ from PySide6.QtWidgets import (
     QWidget,
 )
 
+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.card import CardFrame
@@ -113,6 +114,7 @@ class SetupPreviewWidget(QWidget):
         *,
         show_close: bool = True,
         config: ResolvedConfig | None = None,
+        package_store: PackageStateStore | None = None,
     ) -> None:
         """Initialize the preview widget.
 
@@ -122,11 +124,13 @@ class SetupPreviewWidget(QWidget):
             show_close: Whether to show the Close button.  Set ``False``
                 when embedding inside a persistent view (e.g. a tab).
             config: Global configuration for per-manifest pre-release state.
+            package_store: Shared package update state registry.
         """
         super().__init__(parent)
         self._porringer = porringer
         self._show_close = show_close
         self._config = config
+        self._package_store = package_store
         self._discovered_plugins: DiscoveredPlugins | None = None
 
         self._model = PreviewModel()
@@ -293,7 +297,6 @@ class SetupPreviewWidget(QWidget):
         path_or_url: str,
         *,
         project_directory: Path | None = None,
-        detect_updates: bool = True,
     ) -> None:
         """Load a manifest preview, or skip if the same manifest is already showing results.
 
@@ -305,7 +308,6 @@ class SetupPreviewWidget(QWidget):
         Args:
             path_or_url: Manifest path or URL.
             project_directory: Working directory for project sync actions.
-            detect_updates: Query package indices for newer versions.
         """
         key = normalize_manifest_key(path_or_url)
 
@@ -345,7 +347,6 @@ class SetupPreviewWidget(QWidget):
             self._run_preview_task(
                 path_or_url,
                 project_directory=self._model.project_directory,
-                detect_updates=detect_updates,
                 prerelease_packages=overrides,
             ),
         )
@@ -474,7 +475,6 @@ class SetupPreviewWidget(QWidget):
         path_or_url: str,
         *,
         project_directory: Path | None = None,
-        detect_updates: bool = True,
         prerelease_packages: set[str] | None = None,
     ) -> None:
         """Run the preview coroutine and route completion/errors."""
@@ -484,7 +484,6 @@ class SetupPreviewWidget(QWidget):
                 path_or_url,
                 config=PreviewConfig(
                     project_directory=project_directory,
-                    detect_updates=detect_updates,
                     prerelease_packages=prerelease_packages,
                 ),
                 callbacks=PreviewCallbacks(
@@ -640,6 +639,16 @@ class SetupPreviewWidget(QWidget):
             if card is not None:
                 card.set_check_result(result)
 
+            # Record in shared store so ToolsView can reflect the update
+            if self._package_store is not None and action.installer and action.package:
+                self._package_store.record_action_result(
+                    action.installer,
+                    str(action.package.name),
+                    installed_version=result.installed_version or '',
+                    available_version=result.available_version or '',
+                    has_update=result.skip_reason == SkipReason.UPDATE_AVAILABLE,
+                )
+
         # Update phase text
         m.checked_count += 1
         total = len(m.action_states)
@@ -987,11 +996,9 @@ class InstallPreviewWindow(QMainWindow):
         logger.info('Starting install preview for: %s', self._manifest_url)
         self._url_label.setText(f'<b>Manifest:</b> {self._manifest_url}')
 
-        detect = self._config.detect_updates if self._config else True
         self._preview_widget.load(
             self._manifest_url,
             project_directory=self._project_directory,
-            detect_updates=detect,
         )
 
     # --- Callbacks ---

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

@@ -232,7 +232,6 @@ async def run_preview(
             paths=[manifest_path],
             dry_run=True,
             project_directory=cfg.project_directory,
-            detect_updates=cfg.detect_updates,
             prerelease_packages=cfg.prerelease_packages,
         )
         state = _DispatchState()

{synodic_client-0.0.1.dev63 → synodic_client-0.0.1.dev65}/synodic_client/application/screen/projects.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import asyncio
 import logging
 from pathlib import Path
+from typing import TYPE_CHECKING
 
 from porringer.api import API
 from porringer.backend.command.core.discovery import DiscoveredPlugins
@@ -19,12 +20,15 @@ from PySide6.QtWidgets import (
 )
 
 from synodic_client.application.data import DataCoordinator
+from synodic_client.application.package_state import PackageStateStore
 from synodic_client.application.screen.install import SetupPreviewWidget
 from synodic_client.application.screen.schema import PreviewPhase
 from synodic_client.application.screen.sidebar import ManifestSidebar
 from synodic_client.application.screen.spinner import LoadingIndicator
 from synodic_client.application.theme import COMPACT_MARGINS
-from synodic_client.resolution import ResolvedConfig
+
+if TYPE_CHECKING:
+    from synodic_client.application.config_store import ConfigStore
 
 logger = logging.getLogger(__name__)
 
@@ -41,24 +45,27 @@ class ProjectsView(QWidget):
     def __init__(
         self,
         porringer: API,
-        config: ResolvedConfig,
+        store: ConfigStore,
         parent: QWidget | None = None,
         *,
         coordinator: DataCoordinator | None = None,
+        package_store: PackageStateStore | None = None,
     ) -> None:
         """Initialize the projects view.
 
         Args:
             porringer: The porringer API instance.
-            config: Resolved configuration.
+            store: The centralised :class:`ConfigStore`.
             parent: Optional parent widget.
             coordinator: Shared data coordinator for validated directory
                 data.
+            package_store: Shared package update state registry.
         """
         super().__init__(parent)
         self._porringer = porringer
-        self._config = config
+        self._store = store
         self._coordinator = coordinator
+        self._package_store = package_store
         self._refresh_in_progress = False
         self._pending_select: Path | None = None
         self._widgets: dict[Path, SetupPreviewWidget] = {}
@@ -163,7 +170,6 @@ class ProjectsView(QWidget):
                     widget.load(
                         str(path),
                         project_directory=path if path.is_dir() else path.parent,
-                        detect_updates=self._config.detect_updates,
                     )
 
         except Exception:
@@ -196,7 +202,8 @@ class ProjectsView(QWidget):
                     self._porringer,
                     self,
                     show_close=False,
-                    config=self._config,
+                    config=self._store.config,
+                    package_store=self._package_store,
                 )
                 widget._discovered_plugins = discovered
                 widget.install_finished.connect(self._on_install_finished)

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

@@ -334,7 +334,6 @@ class PreviewConfig:
     """Optional execution parameters for :func:`run_preview`."""
 
     project_directory: Path | None = None
-    detect_updates: bool = True
     prerelease_packages: set[str] | None = None