PipxInterface/PipxWidget.py

# -*- coding: utf-8 -*-

# Copyright (c) 2024 Detlev Offenbach <detlev@die-offenbachs.de>
#

"""
Module implementing the pipx management widget.
"""

import os

from PyQt6.QtCore import Qt, pyqtSlot
from PyQt6.QtWidgets import QDialog, QMenu, QTreeWidgetItem, QWidget

from eric7.EricGui import EricPixmapCache
from eric7.EricGui.EricOverrideCursor import EricOverrideCursor
from eric7.EricWidgets import EricFileDialog, EricMessageBox

from .Pipx import Pipx
from .PipxAppStartDialog import PipxAppStartDialog
from .Ui_PipxWidget import Ui_PipxWidget


class PipxWidget(QWidget, Ui_PipxWidget):
    """
    Class documentation goes here.
    """

    PackageColumn = 0
    VersionColumn = 1
    PythonVersionColumn = 2

    AppPathRole = Qt.ItemDataRole.UserRole
    VersionRole = Qt.ItemDataRole.UserRole + 1
    LatestVersionRole = Qt.ItemDataRole.UserRole + 2

    def __init__(self, plugin, fromEric=True, parent=None):
        """
        Constructor

        @param plugin reference to the plug-in object
        @type MqttMonitorPlugin
        @param fromEric flag indicating the eric-ide mode (defaults to True)
            (True = eric-ide mode, False = application mode)
        @type bool (optional)
        @param parent reference to the parent widget (defaults to None)
        @type QWidget (optional)
        """
        super().__init__(parent)
        self.setupUi(self)

        self.__plugin = plugin
        self.__pipx = Pipx(self)

        if fromEric:
            self.layout().setContentsMargins(0, 3, 0, 0)
        else:
            self.layout().setContentsMargins(0, 0, 0, 0)

        # TODO: set the various icons
        self.pipxMenuButton.setIcon(EricPixmapCache.getIcon("superMenu"))
        self.refreshButton.setIcon(EricPixmapCache.getIcon("reload"))
        self.installButton.setIcon(EricPixmapCache.getIcon("plus"))
        self.outdatedButton.setIcon(EricPixmapCache.getIcon("question"))
        self.upgradeButton.setIcon(EricPixmapCache.getIcon("upgrade"))
        self.uninstallButton.setIcon(EricPixmapCache.getIcon("minus"))

        self.installButton.clicked.connect(self.__installPackages)
        self.outdatedButton.clicked.connect(self.__checkOutdatedPackages)
        self.upgradeButton.clicked.connect(self.__upgradePackage)
        self.uninstallButton.clicked.connect(self.__uninstallPackage)

        self.pipxMenuButton.setAutoRaise(True)
        self.pipxMenuButton.setShowMenuInside(True)

        self.packagesList.header().setSortIndicator(
            PipxWidget.PackageColumn, Qt.SortOrder.AscendingOrder
        )

        self.__initPipxMenu()
        self.__showPipxVersion()

        pipxPaths = self.__pipx.getPipxStrPaths()
        self.venvsPathEdit.setText(pipxPaths["venvsPath"])
        self.applicationsPathEdit.setText(pipxPaths["appsPath"])
        self.manPagesPathEdit.setText(pipxPaths["manPath"])
        self.interpretersPathEdit.setText(pipxPaths["pythonPath"])

        self.__populatePackages()
        self.on_packagesList_itemSelectionChanged()

    #######################################################################
    ## Menu related methods below
    #######################################################################

    def __initPipxMenu(self):
        """
        Private method to create the super menu and attach it to the super
        menu button.
        """
        ###################################################################
        ## Menu with install related actions
        ###################################################################

        self.__installSubmenu = QMenu(self.tr("Install"))
        self.__installPackagesAct = self.__installSubmenu.addAction(
            self.tr("Install Packages"), self.__installPackages
        )
        self.__installAllPackagesAct = self.__installSubmenu.addAction(
            self.tr("Install All Packages"), self.__installAllPackages
        )
        self.__installSubmenu.addSeparator()
        self.__reinstallPackagesAct = self.__installSubmenu.addAction(
            self.tr("Re-Install Selected Package"), self.__reinstallPackage
        )
        self.__reinstallAllPackagesAct = self.__installSubmenu.addAction(
            self.tr("Re-Install All Packages"), self.__reinstallAllPackages
        )
        self.__installSubmenu.addSeparator()
        self.__createSpecMetadataAct = self.__installSubmenu.addAction(
            self.tr("Create Spec Metadata File"), self.__createSpecMetadataFile
        )

        ###################################################################
        ## Menu with upgrade related actions
        ###################################################################

        self.__upgradeSubmenu = QMenu(self.tr("Upgrade"))
        self.__checkOutdatedPackagesAct = self.__upgradeSubmenu.addAction(
            self.tr("Check Outdated Packages"), self.__checkOutdatedPackages
        )
        self.__upgradeSubmenu.addSeparator()
        self.__upgradePackagesAct = self.__upgradeSubmenu.addAction(
            self.tr("Upgrade Selected Package"), self.__upgradePackage
        )
        self.__upgradeAllPackagesAct = self.__upgradeSubmenu.addAction(
            self.tr("Upgrade All Packages"), self.__upgradeAllPackages
        )
        self.__upgradeSubmenu.addSeparator()
        self.__upgradeSharedLibsAct = self.__upgradeSubmenu.addAction(
            self.tr("Upgrade Shared Libraries"), self.__upgradeSharedLibs
        )

        ###################################################################
        ## Menu with upgrade related actions
        ###################################################################

        self.__uninstallSubmenu = QMenu(self.tr("Uninstall"))
        self.__uninstallPackagesAct = self.__uninstallSubmenu.addAction(
            self.tr("Uninstall Selected Package"), self.__uninstallPackage
        )
        self.__uninstallAllPackagesAct = self.__uninstallSubmenu.addAction(
            self.tr("Uninstall All Packages"), self.__uninstallAllPackages
        )

        ###################################################################
        ## Main menu
        ###################################################################

        self.__pipxMenu = QMenu()
        self.__installSubmenuAct = self.__pipxMenu.addMenu(self.__installSubmenu)
        self.__pipxMenu.addSeparator()
        self.__upgradeSubmenuAct = self.__pipxMenu.addMenu(self.__upgradeSubmenu)
        self.__pipxMenu.addSeparator()
        self.__uninstallSubmenuAct = self.__pipxMenu.addMenu(self.__uninstallSubmenu)
        self.__pipxMenu.addSeparator()
        self.__pipxMenu.addAction(
            self.tr("Standalone Interpreters"), self.__showInterpreters
        )

        self.__pipxMenu.aboutToShow.connect(self.__aboutToShowPipxMenu)

        self.pipxMenuButton.setMenu(self.__pipxMenu)

    @pyqtSlot()
    def __aboutToShowPipxMenu(self):
        """
        Private slot to set the action enabled status.
        """
        selectedPackages = self.__selectedPackages()

        self.__reinstallPackagesAct.setEnabled(len(selectedPackages) == 1)
        self.__upgradePackagesAct.setEnabled(bool(selectedPackages))
        self.__uninstallPackagesAct.setEnabled(len(selectedPackages) == 1)

    @pyqtSlot()
    def __installPackages(self):
        """
        Private slot to install packages to be given by the user.
        """
        from .PipxPackagesInputDialog import PipxPackagesInputDialog

        dlg = PipxPackagesInputDialog(self.tr("Install Packages"))
        if dlg.exec() == QDialog.DialogCode.Accepted:
            packages, pyVersion, fetchMissing, force, systemSitePackages = dlg.getData()
            self.__pipx.installPackages(
                packages,
                interpreterVersion=pyVersion,
                fetchMissingInterpreter=fetchMissing,
                forceVenvModification=force,
                systemSitePackages=systemSitePackages,
            )
            self.on_refreshButton_clicked()

    @pyqtSlot()
    def __installAllPackages(self):
        """
        Private slot to install all packages listed in a specification file.
        """
        from .PipxSpecInputDialog import PipxSpecInputDialog

        dlg = PipxSpecInputDialog(self.tr("Install All Packages"))
        if dlg.exec() == QDialog.DialogCode.Accepted:
            specFile, pyVersion, fetchMissing, force, systemSitePackages = dlg.getData()
            self.__pipx.installAllPackages(
                specFile,
                interpreterVersion=pyVersion,
                fetchMissingInterpreter=fetchMissing,
                forceVenvModification=force,
                systemSitePackages=systemSitePackages,
            )
            self.on_refreshButton_clicked()

    @pyqtSlot()
    def __createSpecMetadataFile(self):
        """
        Private slot to create a spec metadata file needed by 'pipx install-all'.
        """
        specFile, selectedFilter = EricFileDialog.getSaveFileNameAndFilter(
            self,
            self.tr("Create Spec Metadata File"),
            "",
            self.tr("JSON Files (*.json);;All Files (*)"),
            self.tr("JSON Files (*.json)"),
            EricFileDialog.DontConfirmOverwrite,
        )
        if specFile:
            ext = os.path.splitext(specFile)[1]
            if not ext:
                ex = selectedFilter.split("(*")[1].split(")")[0]
                if ex:
                    specFile += ex

            if os.path.exists(specFile):
                ok = EricMessageBox.yesNo(
                    self,
                    self.tr("Create Spec Metadata File"),
                    self.tr(
                        "<p>The file <b>{0}</b> exists already. Overwrite it?</p>"
                    ).format(specFile),
                )
                if not ok:
                    return

            ok, message = self.__pipx.createSpecMetadataFile(specFile=specFile)
            if ok:
                EricMessageBox.information(
                    self,
                    self.tr("Create Spec Metadata File"),
                    self.tr(
                        "<p>The spec metadata file <b>{0}</b> was created"
                        " successfully.</p>"
                    ).format(specFile),
                )
            else:
                EricMessageBox.critical(
                    self,
                    self.tr("Create Spec Metadata File"),
                    self.tr(
                        "<p>The spec metadata file <b>{0}</b> could not be created.</p>"
                        "<p>Reason: {1}</p>"
                    ).format(specFile, message),
                )

    @pyqtSlot()
    def __reinstallPackage(self):
        """
        Private slot to force a re-installation of the selected package.
        """
        from .PipxReinstallDialog import PipxReinstallDialog

        package = self.__selectedPackages()[0]
        yes = EricMessageBox.yesNo(
            self,
            self.tr("Re-Install Package"),
            self.tr(
                "<p>Shall the package <b>{0}</b> really be reinstalled?</p>"
            ).format(package),
        )
        if yes:
            dlg = PipxReinstallDialog(reinstallAll=False, parent=self)
            if dlg.exec() == QDialog.DialogCode.Accepted:
                pyVersion, fetchMissing, _ = dlg.getData()
                self.__pipx.reinstallPackage(
                    package,
                    interpreterVersion=pyVersion,
                    fetchMissingInterpreter=fetchMissing,
                )
            self.on_refreshButton_clicked()

    @pyqtSlot()
    def __reinstallAllPackages(self):
        """
        Private slot to force a re-installation of all packages.
        """
        from .PipxReinstallDialog import PipxReinstallDialog

        yes = EricMessageBox.yesNo(
            self,
            self.tr("Re-Install All Packages"),
            self.tr("""Do you really want to reinstall all packages?"""),
        )
        if yes:
            dlg = PipxReinstallDialog(reinstallAll=True, parent=self)
            if dlg.exec() == QDialog.DialogCode.Accepted:
                pyVersion, fetchMissing, skipList = dlg.getData()
                self.__pipx.reinstallAllPackages(
                    interpreterVersion=pyVersion,
                    fetchMissingInterpreter=fetchMissing,
                    skipPackages=skipList,
                )
            self.on_refreshButton_clicked()

    @pyqtSlot()
    def __checkOutdatedPackages(self):
        """
        Private slot to check, if there are any outdated packages.
        """
        with EricOverrideCursor():
            for row in range(self.packagesList.topLevelItemCount()):
                itm = self.packagesList.topLevelItem(row)
                package = itm.text(PipxWidget.PackageColumn)
                latestVersion = self.__pipx.checkPackageOutdated(package)
                if latestVersion is not None:
                    self.__markPackageOutdated(itm, latestVersion)
        self.__resizePackagesColumns()

    @pyqtSlot()
    def __upgradePackage(self):
        """
        Private slot to upgrade the selected package.
        """
        package = self.__selectedPackages()[0]
        self.__pipx.upgradePackage(package)
        self.on_refreshButton_clicked()

    @pyqtSlot()
    def __upgradeAllPackages(self):
        """
        Private slot to upgrade all packages.
        """
        self.__pipx.upgradeAllPackages()
        self.on_refreshButton_clicked()

    @pyqtSlot()
    def __upgradeSharedLibs(self):
        """
        Private slot to upgrade the shared libraries.
        """
        self.__pipx.upgradeSharedLibraries()

    @pyqtSlot()
    def __uninstallPackage(self):
        """
        Private slot to uninstall the selected package.
        """
        package = self.__selectedPackages()[0]
        yes = EricMessageBox.yesNo(
            self,
            self.tr("Uninstall Package"),
            self.tr(
                "<p>Shall the package <b>{0}</b> really be uninstalled?</p>"
            ).format(package),
        )
        if yes:
            self.__pipx.uninstallPackage(package)
            self.on_refreshButton_clicked()

    @pyqtSlot()
    def __uninstallAllPackages(self):
        """
        Private slot to uninstall all packages.
        """
        yes = EricMessageBox.yesNo(
            self,
            self.tr("Uninstall All Packages"),
            self.tr("<p>Do you really want to uninstall <b>ALL</b> packages?</p>"),
        )
        if yes:
            self.__pipx.uninstallAllPackages()
            self.on_refreshButton_clicked()

    @pyqtSlot()
    def __showInterpreters(self):
        """
        Private slot to show a list of standalone Python interpreters.
        """
        from .PipxInterpretersDialog import PipxInterpretersDialog

        dlg = PipxInterpretersDialog(self.__pipx, self)
        dlg.exec()

    #######################################################################
    ## Main widget related methods below
    #######################################################################

    def __showPipxVersion(self):
        """
        Private method to show the pipx version in the widget header.
        """
        self.pipxVersionLabel.setText(
            self.tr("<b>pipx Version {0}</b>").format(self.__pipx.getPipxVersion())
        )

    def __resizePackagesColumns(self):
        """
        Private method to resize the columns of the packages list.
        """
        self.packagesList.header().setStretchLastSection(True)
        self.packagesList.resizeColumnToContents(PipxWidget.PackageColumn)
        self.packagesList.resizeColumnToContents(PipxWidget.VersionColumn)
        self.packagesList.resizeColumnToContents(PipxWidget.PythonVersionColumn)

    def __markPackageOutdated(self, item, latestVersion):
        """
        Private method to mark the given package item as outdated.

        @param item reference to the outdated package item
        @type QTreeWidgetItem
        @param latestVersion latest version of the package
        @type str
        """
        version = item.data(0, PipxWidget.VersionRole)
        item.setData(0, PipxWidget.LatestVersionRole, latestVersion)
        item.setText(
            PipxWidget.VersionColumn,
            self.tr("{0} ({1})", "current version, latest version").format(
                version, latestVersion
            ),
        )

    def __populatePackages(self):
        """
        Private method to populate the packages list.
        """
        self.packagesList.clear()

        packages = self.__pipx.getInstalledPackages()
        for package in packages:
            topItem = QTreeWidgetItem(
                self.packagesList,
                [
                    package["name"],
                    package["version"],
                    self.tr("{0}{1}", "Python version, standalone indicator").format(
                        package["python"],
                        self.tr(" (standalone)") if package["is_standalone"] else "",
                    ),
                ],
            )
            topItem.setData(0, PipxWidget.VersionRole, package["version"])
            for app, appPath in package["apps"]:
                itm = QTreeWidgetItem(topItem, [app])
                itm.setData(0, PipxWidget.AppPathRole, appPath)
        self.__resizePackagesColumns()

    @pyqtSlot()
    def on_refreshButton_clicked(self):
        """
        Private slot to refresh the packages list.
        """
        self.__showPipxVersion()

        expandedPackages = []
        outdatedPackages = {}
        for row in range(self.packagesList.topLevelItemCount()):
            itm = self.packagesList.topLevelItem(row)
            if itm.isExpanded():
                expandedPackages.append(itm.text(PipxWidget.PackageColumn))
            latestVersion = itm.data(0, PipxWidget.LatestVersionRole)
            if latestVersion is not None:
                outdatedPackages[itm.text(PipxWidget.PackageColumn)] = latestVersion

        self.__populatePackages()

        for row in range(self.packagesList.topLevelItemCount()):
            itm = self.packagesList.topLevelItem(row)
            package = itm.text(PipxWidget.PackageColumn)
            if package in expandedPackages:
                itm.setExpanded(True)

            if (
                package in outdatedPackages
                and itm.data(0, PipxWidget.VersionRole) != outdatedPackages[package]
            ):
                self.__markPackageOutdated(itm, outdatedPackages[package])

        self.__resizePackagesColumns()

    @pyqtSlot(QTreeWidgetItem, int)
    def on_packagesList_itemActivated(self, item, column):
        """
        Private slot to start the activated item, if it is not a top level one.

        @param item reference to the activated item
        @type QTreeWidgetItem
        @param column column number of the activation
        @type int
        """
        if item.parent() is not None:
            app = item.data(0, PipxWidget.AppPathRole)
            dlg = PipxAppStartDialog(app, self.__plugin, self)
            dlg.show()

    @pyqtSlot()
    def on_packagesList_itemSelectionChanged(self):
        """
        Private slot to handle a change of selected packages and apps.
        """
        selectedPackages = self.__selectedPackages()

        self.upgradeButton.setEnabled(bool(selectedPackages))
        self.uninstallButton.setEnabled(len(selectedPackages) == 1)

    def __selectedPackages(self):
        """
        Private method to determine the list of selected packages.

        @return list of selected packages
        @rtype list of QTreeWidgetItem
        """
        packages = []

        for row in range(self.packagesList.topLevelItemCount()):
            itm = self.packagesList.topLevelItem(row)
            if itm.isSelected():
                packages.append(itm.text(PipxWidget.PackageColumn))

        return packages