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

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

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

{synodic_client-0.0.1.dev39 → synodic_client-0.0.1.dev40}/pyproject.toml

@@ -10,12 +10,12 @@ requires-python = ">=3.14, <3.15"
 dependencies = [
     "pyside6>=6.10.2",
     "packaging>=26.0",
-    "porringer>=0.2.1.dev56",
+    "porringer>=0.2.1.dev71",
     "qasync>=0.28.0",
     "velopack>=0.0.1444.dev49733",
     "typer>=0.24.1",
 ]
-version = "0.0.1.dev39"
+version = "0.0.1.dev40"
 
 [project.license]
 text = "LGPL-3.0-or-later"
@@ -36,7 +36,7 @@ build = [
 ]
 lint = [
     "ruff>=0.15.4",
-    "pyrefly>=0.54.0",
+    "pyrefly>=0.55.0",
 ]
 test = [
     "pytest>=9.0.2",
@@ -109,7 +109,7 @@ write_template = "__version__ = '{}'\n"
 allow-prereleases = true
 
 [tool.pdm.scripts]
-analyze = "ruff check synodic_client tests"
+analyze = "ruff check"
 format = "ruff format"
 test = "pytest --cov=synodic_client --verbose tests"
 type-check = "pyrefly check"

synodic_client-0.0.1.dev40/synodic_client/_version.py

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

synodic_client-0.0.1.dev40/synodic_client/application/data.py

@@ -0,0 +1,192 @@
+"""Shared data coordinator for the Synodic Client application.
+
+Centralises porringer API calls so that plugin discovery, directory
+listing, and runtime context resolution happen once per refresh cycle
+and the results are reused by every consumer (ToolsView, ProjectsView,
+TrayScreen, install workers).
+
+The coordinator follows an *invalidate-on-mutation* strategy: callers
+that modify state (install, uninstall, add/remove directory) call
+:meth:`invalidate` to force the next :meth:`refresh` to re-fetch.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from dataclasses import dataclass, field
+
+from porringer.api import API
+from porringer.backend.command.core.discovery import DiscoveredPlugins
+from porringer.core.plugin_schema.plugin_manager import PluginManager
+from porringer.schema import (
+    CheckParameters,
+    CheckResult,
+    DirectoryValidationResult,
+    ManifestDirectory,
+    PluginInfo,
+)
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(slots=True)
+class Snapshot:
+    """Immutable bundle of data produced by a single refresh cycle.
+
+    All fields are populated by :meth:`DataCoordinator.refresh` and
+    remain stable until the next refresh.
+    """
+
+    plugins: list[PluginInfo] = field(default_factory=list)
+    """All discovered plugins with install status and version info."""
+
+    directories: list[ManifestDirectory] = field(default_factory=list)
+    """Cached project directories (un-validated)."""
+
+    validated_directories: list[DirectoryValidationResult] = field(default_factory=list)
+    """Cached directories with ``exists`` / ``has_manifest`` validation."""
+
+    discovered: DiscoveredPlugins | None = None
+    """Full plugin discovery result including runtime context."""
+
+    plugin_managers: dict[str, PluginManager] = field(default_factory=dict)
+    """Project-environment plugins implementing the ``PluginManager`` protocol."""
+
+
+class DataCoordinator:
+    """Single source of truth for porringer data across the application.
+
+    Usage::
+
+        coordinator = DataCoordinator(porringer)
+        snapshot = await coordinator.refresh()  # first load
+        # … later, after an install …
+        coordinator.invalidate()
+        snapshot = await coordinator.refresh()  # re-fetches everything
+
+    The coordinator caches the most recent :class:`Snapshot` so that
+    synchronous property access (``coordinator.snapshot``) is available
+    between refresh cycles.
+    """
+
+    def __init__(self, porringer: API) -> None:
+        """Initialize the coordinator with a porringer API instance."""
+        self._porringer = porringer
+        self._snapshot: Snapshot = Snapshot()
+        self._stale = True
+        self._refresh_lock = asyncio.Lock()
+
+    # -- Public API --------------------------------------------------------
+
+    @property
+    def snapshot(self) -> Snapshot:
+        """Return the most recent snapshot (may be empty before first refresh)."""
+        return self._snapshot
+
+    @property
+    def discovered_plugins(self) -> DiscoveredPlugins | None:
+        """Shortcut to the current ``DiscoveredPlugins`` instance."""
+        return self._snapshot.discovered
+
+    def invalidate(self) -> None:
+        """Mark the cached data as stale.
+
+        The next call to :meth:`refresh` will re-fetch everything from
+        porringer.  This is a lightweight O(1) flag-flip.
+        """
+        self._stale = True
+
+    async def refresh(self, *, force: bool = False) -> Snapshot:
+        """Fetch fresh data from porringer if stale (or *force* is set).
+
+        Multiple concurrent callers are coalesced via an ``asyncio.Lock``
+        so that only one discovery + listing round-trip runs at a time.
+
+        Returns:
+            The populated :class:`Snapshot`.
+        """
+        if not self._stale and not force:
+            return self._snapshot
+
+        async with self._refresh_lock:
+            # Double-check after acquiring the lock — another coroutine
+            # may have already refreshed while we were waiting.
+            if not self._stale and not force:
+                return self._snapshot
+
+            self._snapshot = await self._fetch()
+            self._stale = False
+            return self._snapshot
+
+    async def check_updates(
+        self,
+        plugins: list[str] | None = None,
+    ) -> list[CheckResult]:
+        """Run update detection using the cached ``DiscoveredPlugins``.
+
+        Args:
+            plugins: Optional include-set of plugin names.  ``None``
+                means all plugins.
+
+        Returns:
+            A list of :class:`CheckResult` per plugin.
+        """
+        params = CheckParameters(plugins=plugins)
+        return await self._porringer.sync.check_updates(
+            params,
+            plugins=self._snapshot.discovered,
+        )
+
+    # -- Internals ---------------------------------------------------------
+
+    async def _fetch(self) -> Snapshot:
+        """Run the full discovery + listing pipeline.
+
+        1. ``API.discover_plugins()`` — plugin entry-points + runtime
+           context in one shot.
+        2. ``PluginCommands.list()`` — installed status + versions,
+           passing the already-discovered ``DiscoveredPlugins``.
+        3. ``cache.list_directories(validate=True, check_manifest=True)``
+           — directory listing with validation baked in.
+        4. Filter ``project_environments`` for ``PluginManager`` instances.
+
+        All blocking calls are dispatched via ``asyncio.to_thread``.
+        """
+        loop = asyncio.get_running_loop()
+
+        # Step 1: discover all plugins + resolve runtime context
+        discovered = await API.discover_plugins()
+
+        # Step 2 + 3 in parallel: plugin list + validated directories
+        plugins_task = asyncio.create_task(
+            self._porringer.plugin.list(plugins=discovered),
+        )
+        dirs_future = loop.run_in_executor(
+            None,
+            lambda: self._porringer.cache.list_directories(
+                validate=True,
+                check_manifest=True,
+            ),
+        )
+
+        plugins = await plugins_task
+        validated = await dirs_future
+
+        # Step 4: extract PluginManager instances from project_environments
+        managers: dict[str, PluginManager] = {}
+        for _name, env in discovered.project_environments.items():
+            if isinstance(env, PluginManager) and env.is_available():
+                managers[env.tool_name()] = env
+
+        # Derive the un-validated directory list for callers that only
+        # need path + name (e.g. _gather_packages).
+        directories = [r.directory for r in validated]
+
+        return Snapshot(
+            plugins=plugins,
+            directories=directories,
+            validated_directories=validated,
+            discovered=discovered,
+            plugin_managers=managers,
+        )

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

@@ -43,6 +43,7 @@ def plugin_kind_group_label(kind: PluginKind) -> str:
 
 SKIP_REASON_LABELS: dict[SkipReason, str] = {
     SkipReason.ALREADY_INSTALLED: 'Already installed',
+    SkipReason.NOT_INSTALLED: 'Not installed',
     SkipReason.ALREADY_LATEST: 'Already latest',
     SkipReason.NO_PROJECT_DIRECTORY: 'No project directory',
     SkipReason.UPDATE_AVAILABLE: 'Update available',

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

@@ -24,6 +24,7 @@ from urllib.parse import urlparse
 from urllib.request import url2pathname
 
 from porringer.api import API
+from porringer.backend.command.core.discovery import DiscoveredPlugins
 from porringer.schema import (
     DownloadParameters,
     ProgressEvent,
@@ -230,6 +231,8 @@ async def run_install(
     manifest_path: Path,
     config: InstallConfig | None = None,
     callbacks: InstallCallbacks | None = None,
+    *,
+    plugins: DiscoveredPlugins | None = None,
 ) -> SetupResults:
     """Execute setup actions via porringer and stream progress.
 
@@ -243,6 +246,8 @@ async def run_install(
         config: Optional execution parameters (directory, strategy,
             prerelease overrides).
         callbacks: Optional progress callbacks.
+        plugins: Pre-discovered plugins to pass through to porringer,
+            avoiding redundant discovery.
 
     Returns:
         Aggregated :class:`SetupResults`.
@@ -259,7 +264,7 @@ async def run_install(
     collected: list[SetupActionResult] = []
     manifest_result: SetupResults | None = None
 
-    async for event in porringer.sync.execute_stream(params):
+    async for event in porringer.sync.execute_stream(params, plugins=plugins):
         if event.kind == ProgressEventKind.MANIFEST_LOADED and event.manifest:
             manifest_result = event.manifest
             actions = list(event.manifest.actions)
@@ -275,7 +280,7 @@ async def run_install(
         ):
             cb.on_sub_progress(event.action, event.sub_action)
 
-        if event.kind == ProgressEventKind.ACTION_COMPLETED and event.result:
+        if event.kind == ProgressEventKind.ACTION_COMPLETED and event.result and event.action:
             collected.append(event.result)
             if cb.on_progress is not None:
                 cb.on_progress(event.action, event.result)
@@ -340,6 +345,7 @@ class SetupPreviewWidget(QWidget):
         self._porringer = porringer
         self._show_close = show_close
         self._config = config
+        self._discovered_plugins: DiscoveredPlugins | None = None
 
         self._model = PreviewModel()
         self._task: asyncio.Task[None] | None = None
@@ -705,6 +711,7 @@ class SetupPreviewWidget(QWidget):
                     on_preview_ready=self._on_preview_resolved,
                     on_action_checked=self._on_action_checked,
                 ),
+                plugins=self._discovered_plugins,
             )
             self._on_preview_finished()
         except asyncio.CancelledError:
@@ -729,6 +736,7 @@ class SetupPreviewWidget(QWidget):
                     on_sub_progress=self._on_sub_progress,
                     on_progress=self._on_action_progress,
                 ),
+                plugins=self._discovered_plugins,
             )
             self._on_install_finished(results)
         except asyncio.CancelledError:
@@ -1259,8 +1267,7 @@ async def _resolve_manifest_path(url: str) -> tuple[Path, str | None]:
     dest = Path(temp_dir) / 'porringer.json'
 
     params = DownloadParameters(url=url, destination=dest, timeout=3)
-    loop = asyncio.get_running_loop()
-    result = await loop.run_in_executor(None, API.download, params)
+    result = await API.download(params)
 
     if not result.success:
         _safe_rmtree(temp_dir)
@@ -1314,6 +1321,7 @@ async def run_preview(
     *,
     config: PreviewConfig | None = None,
     callbacks: PreviewCallbacks | None = None,
+    plugins: DiscoveredPlugins | None = None,
 ) -> None:
     """Download a manifest and perform a dry-run preview.
 
@@ -1331,6 +1339,8 @@ async def run_preview(
         url: Manifest URL or local path.
         config: Optional preview configuration.
         callbacks: Optional preview callbacks.
+        plugins: Pre-discovered plugins to pass through to porringer,
+            avoiding redundant discovery.
     """
     logger.info('run_preview starting for: %s', url)
     temp_dir: str | None = None
@@ -1351,7 +1361,7 @@ async def run_preview(
         temp_dir_str = temp_dir or ''
         manifest_path_str = str(manifest_path)
 
-        async for event in porringer.sync.execute_stream(setup_params):
+        async for event in porringer.sync.execute_stream(setup_params, plugins=plugins):
             _dispatch_preview_event(
                 event,
                 manifest_path_str,