napari-plugin-manager 0.1.0a1__py3-none-any.whl → 0.1.1__py3-none-any.whl

napari_plugin_manager/qt_package_installer.py

@@ -8,6 +8,7 @@ executable path, arguments and environment modifications.
 Available actions for each tool are `install`, `uninstall`
 and `cancel`.
 """
+
 import atexit
 import contextlib
 import os
@@ -19,8 +20,8 @@ from functools import lru_cache
 from logging import getLogger
 from pathlib import Path
 from subprocess import call
-from tempfile import gettempdir, mkstemp
-from typing import Deque, Optional, Sequence, Tuple
+from tempfile import NamedTemporaryFile, gettempdir
+from typing import Deque, Optional, Sequence, Tuple, TypedDict
 
 from napari._version import version as _napari_version
 from napari._version import version_tuple as _napari_version_tuple
@@ -41,9 +42,17 @@ class InstallerActions(StringEnum):
     INSTALL = auto()
     UNINSTALL = auto()
     CANCEL = auto()
+    CANCEL_ALL = auto()
     UPGRADE = auto()
 
 
+class ProcessFinishedData(TypedDict):
+    exit_code: int
+    exit_status: int
+    action: InstallerActions
+    pkgs: Tuple[str, ...]
+
+
 class InstallerTools(StringEnum):
     "Available tools for InstallerQueue jobs"
     CONDA = auto()
@@ -56,10 +65,13 @@ class AbstractInstallerTool:
     pkgs: Tuple[str, ...]
     origins: Tuple[str, ...] = ()
     prefix: Optional[str] = None
+    process: QProcess = None
 
     @property
     def ident(self):
-        return hash((self.action, *self.pkgs, *self.origins, self.prefix))
+        return hash(
+            (self.action, *self.pkgs, *self.origins, self.prefix, self.process)
+        )
 
     # abstract method
     @classmethod
@@ -84,7 +96,7 @@ class AbstractInstallerTool:
         """
         Version constraints to limit unwanted changes in installation.
         """
-        return [f"napari=={_napari_version}", "pydantic<2"]
+        return [f"napari=={_napari_version}", "numpy<2"]
 
     @classmethod
     def available(cls) -> bool:
@@ -139,11 +151,12 @@ class PipInstallerTool(AbstractInstallerTool):
     @classmethod
     @lru_cache(maxsize=0)
     def _constraints_file(cls) -> str:
-        _, path = mkstemp("-napari-constraints.txt", text=True)
-        with open(path, "w") as f:
+        with NamedTemporaryFile(
+            "w", suffix="-napari-constraints.txt", delete=False
+        ) as f:
             f.write("\n".join(cls.constraints()))
-        atexit.register(os.unlink, path)
-        return path
+        atexit.register(os.unlink, f.name)
+        return f.name
 
 
 class CondaInstallerTool(AbstractInstallerTool):
@@ -214,7 +227,7 @@ class CondaInstallerTool(AbstractInstallerTool):
         pin_level = 2 if is_dev else 3
         version = ".".join([str(x) for x in _napari_version_tuple[:pin_level]])
 
-        return [f"napari={version}", "pydantic<2.0a0"]
+        return [f"napari={version}", "numpy<2.0a0"]
 
     def _add_constraints_to_env(
         self, env: QProcessEnvironment
@@ -235,24 +248,30 @@ class CondaInstallerTool(AbstractInstallerTool):
         raise ValueError("Prefix has not been specified!")
 
 
-class InstallerQueue(QProcess):
+class InstallerQueue(QObject):
     """Queue for installation and uninstallation tasks in the plugin manager."""
 
-    # emitted when all jobs are finished
-    # not to be confused with finished, which is emitted when each job is finished
-    allFinished = Signal()
+    # emitted when all jobs are finished. Not to be confused with finished,
+    # which is emitted when each individual job is finished.
+    # Tuple of exit codes for each individual job
+    allFinished = Signal(tuple)
+
+    # emitted when each job finishes
+    # dict: ProcessFinishedData
+    processFinished = Signal(dict)
 
-    def __init__(self, parent: Optional[QObject] = None) -> None:
+    # emitted when each job starts
+    started = Signal()
+
+    def __init__(
+        self, parent: Optional[QObject] = None, prefix: Optional[str] = None
+    ) -> None:
         super().__init__(parent)
         self._queue: Deque[AbstractInstallerTool] = deque()
+        self._current_process: QProcess = None
+        self._prefix = prefix
         self._output_widget = None
-
-        self.setProcessChannelMode(QProcess.MergedChannels)
-        self.readyReadStandardOutput.connect(self._on_stdout_ready)
-        self.readyReadStandardError.connect(self._on_stderr_ready)
-
-        self.finished.connect(self._on_process_finished)
-        self.errorOccurred.connect(self._on_error_occurred)
+        self._exit_codes = []
 
     # -------------------------- Public API ------------------------------
     def install(
@@ -289,6 +308,7 @@ class InstallerQueue(QProcess):
             pkgs=pkgs,
             prefix=prefix,
             origins=origins,
+            process=self._create_process(),
             **kwargs,
         )
         return self._queue_item(item)
@@ -327,6 +347,7 @@ class InstallerQueue(QProcess):
             pkgs=pkgs,
             prefix=prefix,
             origins=origins,
+            process=self._create_process(),
             **kwargs,
         )
         return self._queue_item(item)
@@ -360,31 +381,50 @@ class InstallerQueue(QProcess):
             action=InstallerActions.UNINSTALL,
             pkgs=pkgs,
             prefix=prefix,
+            process=self._create_process(),
             **kwargs,
         )
         return self._queue_item(item)
 
-    def cancel(self, job_id: Optional[JobId] = None):
-        """Cancel `job_id` if it is running.
+    def cancel(self, job_id: JobId):
+        """Cancel `job_id` if it is running. If `job_id` does not exist int the queue,
+        a ValueError is raised.
 
         Parameters
         ----------
-        job_id : Optional[JobId], optional
-            Job ID to cancel.  If not provided, cancel all jobs.
+        job_id : JobId
+            Job ID to cancel.
         """
-        if job_id is None:
-            # cancel all jobs
-            self._queue.clear()
-            self._end_process()
-            return
-
-        for i, item in enumerate(self._queue):
+        for i, item in enumerate(deque(self._queue)):
             if item.ident == job_id:
-                if i == 0:  # first in queue, currently running
-                    self._end_process()
-                else:  # still pending, just remove from queue
+                if i == 0:
+                    # first in queue, currently running
+                    self._queue.remove(item)
+
+                    with contextlib.suppress(RuntimeError):
+                        item.process.finished.disconnect(
+                            self._on_process_finished
+                        )
+                        item.process.errorOccurred.disconnect(
+                            self._on_error_occurred
+                        )
+
+                    self._end_process(item.process)
+                else:
+                    # still pending, just remove from queue
                     self._queue.remove(item)
+
+                self.processFinished.emit(
+                    {
+                        'exit_code': 1,
+                        'exit_status': 0,
+                        'action': InstallerActions.CANCEL,
+                        'pkgs': item.pkgs,
+                    }
+                )
+                self._process_queue()
                 return
+
         msg = f"No job with id {job_id}. Current queue:\n - "
         msg += "\n - ".join(
             [
@@ -394,6 +434,32 @@ class InstallerQueue(QProcess):
         )
         raise ValueError(msg)
 
+    def cancel_all(self):
+        """Terminate all process in the queue and emit the `processFinished` signal."""
+        all_pkgs = []
+        for item in deque(self._queue):
+            all_pkgs.extend(item.pkgs)
+            process = item.process
+
+            with contextlib.suppress(RuntimeError):
+                process.finished.disconnect(self._on_process_finished)
+                process.errorOccurred.disconnect(self._on_error_occurred)
+
+            self._end_process(process)
+
+        self._queue.clear()
+        self._current_process = None
+        self.processFinished.emit(
+            {
+                'exit_code': 1,
+                'exit_status': 0,
+                'action': InstallerActions.CANCEL_ALL,
+                'pkgs': all_pkgs,
+            }
+        )
+        self._process_queue()
+        return
+
     def waitForFinished(self, msecs: int = 10000) -> bool:
         """Block and wait for all jobs to finish.
 
@@ -403,18 +469,32 @@ class InstallerQueue(QProcess):
             Time to wait, by default 10000
         """
         while self.hasJobs():
-            super().waitForFinished(msecs)
+            if self._current_process is not None:
+                self._current_process.waitForFinished(msecs)
         return True
 
     def hasJobs(self) -> bool:
         """True if there are jobs remaining in the queue."""
         return bool(self._queue)
 
+    def currentJobs(self) -> int:
+        """Return the number of running jobs in the queue."""
+        return len(self._queue)
+
     def set_output_widget(self, output_widget: QTextEdit):
         if output_widget:
             self._output_widget = output_widget
 
     # -------------------------- Private methods ------------------------------
+    def _create_process(self) -> QProcess:
+        process = QProcess(self)
+        process.setProcessChannelMode(QProcess.MergedChannels)
+        process.readyReadStandardOutput.connect(self._on_stdout_ready)
+        process.readyReadStandardError.connect(self._on_stderr_ready)
+        process.finished.connect(self._on_process_finished)
+        process.errorOccurred.connect(self._on_error_occurred)
+        return process
+
     def _log(self, msg: str):
         log.debug(msg)
         if self._output_widget:
@@ -440,7 +520,7 @@ class InstallerQueue(QProcess):
             pkgs=pkgs,
             action=action,
             origins=origins,
-            prefix=prefix,
+            prefix=prefix or self._prefix,
             **kwargs,
         )
 
@@ -451,30 +531,38 @@ class InstallerQueue(QProcess):
 
     def _process_queue(self):
         if not self._queue:
-            self.allFinished.emit()
+            self.allFinished.emit(tuple(self._exit_codes))
+            self._exit_codes = []
             return
+
         tool = self._queue[0]
-        self.setProgram(str(tool.executable()))
-        self.setProcessEnvironment(tool.environment())
-        self.setArguments([str(arg) for arg in tool.arguments()])
-        # this might throw a warning because the same process
-        # was already running but it's ok
-        self._log(
-            trans._(
-                "Starting '{program}' with args {args}",
-                program=self.program(),
-                args=self.arguments(),
+        process = tool.process
+
+        if process.state() != QProcess.Running:
+            process.setProgram(str(tool.executable()))
+            process.setProcessEnvironment(tool.environment())
+            process.setArguments([str(arg) for arg in tool.arguments()])
+            process.started.connect(self.started)
+
+            self._log(
+                trans._(
+                    "Starting '{program}' with args {args}",
+                    program=process.program(),
+                    args=process.arguments(),
+                )
             )
-        )
-        self.start()
 
-    def _end_process(self):
+            process.start()
+            self._current_process = process
+
+    def _end_process(self, process: QProcess):
         if os.name == 'nt':
             # TODO: this might be too agressive and won't allow rollbacks!
             # investigate whether we can also do .terminate()
-            self.kill()
+            process.kill()
         else:
-            self.terminate()
+            process.terminate()
+
         if self._output_widget:
             self._output_widget.append(
                 trans._("\nTask was cancelled by the user.")
@@ -515,8 +603,10 @@ class InstallerQueue(QProcess):
         exit_status: Optional[QProcess.ExitStatus] = None,
         error: Optional[QProcess.ProcessError] = None,
     ):
+        item = None
         with contextlib.suppress(IndexError):
-            self._queue.popleft()
+            item = self._queue.popleft()
+
         if error:
             msg = trans._(
                 "Task finished with errors! Error: {error}.", error=error
@@ -527,18 +617,34 @@ class InstallerQueue(QProcess):
                 exit_code=exit_code,
                 exit_status=exit_status,
             )
+
+        if item is not None:
+            self.processFinished.emit(
+                {
+                    'exit_code': exit_code,
+                    'exit_status': exit_status,
+                    'action': item.action,
+                    'pkgs': item.pkgs,
+                }
+            )
+            self._exit_codes.append(exit_code)
+
         self._log(msg)
         self._process_queue()
 
     def _on_stdout_ready(self):
-        text = self.readAllStandardOutput().data().decode()
-        if text:
-            self._log(text)
+        if self._current_process is not None:
+            text = (
+                self._current_process.readAllStandardOutput().data().decode()
+            )
+            if text:
+                self._log(text)
 
     def _on_stderr_ready(self):
-        text = self.readAllStandardError().data().decode()
-        if text:
-            self._log(text)
+        if self._current_process is not None:
+            text = self._current_process.readAllStandardError().data().decode()
+            if text:
+                self._log(text)
 
 
 def _get_python_exe():