CondaInterface/CondaPackagesWidget.py

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

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

"""
Module implementing the conda packages management widget.
"""

from __future__ import unicode_literals

from PyQt5.QtCore import pyqtSlot, Qt
from PyQt5.QtGui import QCursor
from PyQt5.QtWidgets import QWidget, QToolButton, QMenu, QTreeWidgetItem, \
    QApplication

from .Ui_CondaPackagesWidget import Ui_CondaPackagesWidget

import UI.PixmapCache


class CondaPackagesWidget(QWidget, Ui_CondaPackagesWidget):
    """
    Class implementing the conda packages management widget.
    """
    PackageVersionRole = Qt.UserRole + 1
    PackageBuildRole = Qt.UserRole + 2
    
    def __init__(self, conda, parent=None):
        """
        Constructor
        
        @param conda reference to the conda interface
        @type Conda
        @param parent reference to the parent widget
        @type QWidget
        """
        super(CondaPackagesWidget, self).__init__(parent)
        self.setupUi(self)
        
        self.__conda = conda
        
        self.condaMenuButton.setObjectName(
            "navigation_supermenu_button")
        self.condaMenuButton.setIcon(UI.PixmapCache.getIcon("superMenu.png"))
        self.condaMenuButton.setToolTip(self.tr("Conda Menu"))
        self.condaMenuButton.setPopupMode(QToolButton.InstantPopup)
        self.condaMenuButton.setToolButtonStyle(Qt.ToolButtonIconOnly)
        self.condaMenuButton.setFocusPolicy(Qt.NoFocus)
        self.condaMenuButton.setAutoRaise(True)
        self.condaMenuButton.setShowMenuInside(True)
        
        self.__initCondaMenu()
        self.__populateEnvironments()
        self.__updateActionButtons()
        
        self.__conda.condaEnvironmentCreated.connect(
            self.on_refreshButton_clicked)
        self.__conda.condaEnvironmentRemoved.connect(
            self.on_refreshButton_clicked)
    
    def __populateEnvironments(self):
        """
        Private method to get a list of environments and populate the selector.
        """
        environments = [("", "")] + sorted(
            self.__conda.getCondaEnvironmentsList())
        for environment in environments:
            self.environmentsComboBox.addItem(environment[0], environment[1])
    
    def __initCondaMenu(self):
        """
        Private method to create the super menu and attach it to the super
        menu button.
        """
        self.__condaMenu = QMenu(self)
        # TODO: implement Conda menu
        self.__condaMenu.addAction(self.tr("Test Entry"),
                                   self.on_refreshButton_clicked)
        
        self.condaMenuButton.setMenu(self.__condaMenu)
    
    def __selectedUpdateableItems(self):
        """
        Private method to get a list of selected items that can be updated.
        
        @return list of selected items that can be updated
        @rtype list of QTreeWidgetItem
        """
        return [
            itm for itm in self.packagesList.selectedItems()
            if bool(itm.text(2))
        ]
    
    def __allUpdateableItems(self):
        """
        Private method to get a list of all items that can be updated.
        
        @return list of all items that can be updated
        @rtype list of QTreeWidgetItem
        """
        updateableItems = []
        for index in range(self.packagesList.topLevelItemCount()):
            itm = self.packagesList.topLevelItem(index)
            if itm.text(2):
                updateableItems.append(itm)
        
        return updateableItems
    
    def __updateActionButtons(self):
        """
        Private method to set the state of the action buttons.
        """
        self.upgradeButton.setEnabled(
            bool(self.__selectedUpdateableItems()))
        self.uninstallButton.setEnabled(
            bool(self.packagesList.selectedItems()))
        self.upgradeAllButton.setEnabled(
            bool(self.__allUpdateableItems()))
    
    @pyqtSlot(int)
    def on_environmentsComboBox_currentIndexChanged(self, index):
        """
        Private slot handling the selection of a conda environment.
        
        @param index index of the selected conda environment
        @type int
        """
        self.packagesList.clear()
        prefix = self.environmentsComboBox.itemData(index)
        if prefix:
            QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
            QApplication.processEvents()
            
            self.packagesList.setUpdatesEnabled(False)
            # 1. populate with installed packages
            installedPackages = \
                self.__conda.getInstalledPackages(prefix=prefix)
            for package, version, build in installedPackages:
                itm = QTreeWidgetItem(self.packagesList, [package, version])
                itm.setData(1, self.PackageVersionRole, version)
                itm.setData(1, self.PackageBuildRole, build)
            
            # 2. update with update information
            updateablePackages = \
                self.__conda.getUpdateablePackages(prefix=prefix)
            for package, version, build in updateablePackages:
                items = self.packagesList.findItems(
                    package, Qt.MatchExactly | Qt.MatchCaseSensitive)
                if items:
                    itm = items[0]
                    itm.setText(2, version)
                    itm.setData(2, self.PackageVersionRole, version)
                    itm.setData(2, self.PackageBuildRole, build)
                    if itm.data(1, self.PackageVersionRole) == version:
                        # build must be different, show in version display
                        itm.setText(1, self.tr("{0} (Build: {1})").format(
                            itm.data(1, self.PackageVersionRole),
                            itm.data(1, self.PackageBuildRole),
                        ))
                        itm.setText(2, self.tr("{0} (Build: {1})").format(
                            itm.data(2, self.PackageVersionRole),
                            itm.data(2, self.PackageBuildRole),
                        ))
            
            self.packagesList.sortItems(0, Qt.AscendingOrder)
            self.packagesList.setUpdatesEnabled(True)
            QApplication.restoreOverrideCursor()
        
        self.__updateActionButtons()
    
    @pyqtSlot()
    def on_packagesList_itemSelectionChanged(self):
        """
        Private slot to handle the selection of some items..
        """
        self.__updateActionButtons()
    
    @pyqtSlot()
    def on_refreshButton_clicked(self):
        """
        Private slot to refresh the display.
        """
        currentEnvironment = self.environmentsComboBox.currentText()
        self.environmentsComboBox.clear()
        self.packagesList.clear()
        
        QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
        QApplication.processEvents()
        
        self.__populateEnvironments()
        
        index = self.environmentsComboBox.findText(
            currentEnvironment, Qt.MatchExactly | Qt.MatchCaseSensitive)
        if index != -1:
            self.environmentsComboBox.setCurrentIndex(index)
        
        QApplication.restoreOverrideCursor()
        self.__updateActionButtons()
    
    @pyqtSlot()
    def on_upgradeButton_clicked(self):
        """
        Private slot to upgrade selected packages of the selected environment.
        """
        packages = [itm.text(0) for itm in self.__selectedUpdateableItems()]
        if packages:
            prefix = self.environmentsComboBox.itemData(
                self.environmentsComboBox.currentIndex())
            ok = self.__conda.updatePackages(packages, prefix=prefix)
            if ok:
                self.on_refreshButton_clicked()
    
    @pyqtSlot()
    def on_upgradeAllButton_clicked(self):
        """
        Private slot to upgrade all packages of the selected environment.
        """
        prefix = self.environmentsComboBox.itemData(
            self.environmentsComboBox.currentIndex())
        ok = self.__conda.updateAllPackages(prefix=prefix)
        if ok:
            self.on_refreshButton_clicked()
    
    @pyqtSlot()
    def on_uninstallButton_clicked(self):
        """
        Private slot to remove selected packages of the selected environment.
        """
        packages = [itm.text(0) for itm in self.packagesList.selectedItems()]
        if packages:
            prefix = self.environmentsComboBox.itemData(
                self.environmentsComboBox.currentIndex())
            ok = self.__conda.uninstallPackages(packages, prefix=prefix)
            if ok:
                self.on_refreshButton_clicked()