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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: synodic_client
-Version: 0.0.1.dev38
+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.dev54
+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.dev38 → 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.dev54",
+    "porringer>=0.2.1.dev71",
     "qasync>=0.28.0",
     "velopack>=0.0.1444.dev49733",
     "typer>=0.24.1",
 ]
-version = "0.0.1.dev38"
+version = "0.0.1.dev40"
 
 [project.license]
 text = "LGPL-3.0-or-later"
@@ -35,8 +35,8 @@ build = [
     "pyinstaller>=6.19.0",
 ]
 lint = [
-    "ruff>=0.15.3",
-    "pyrefly>=0.54.0",
+    "ruff>=0.15.4",
+    "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.dev38 → 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',