eric: comparison src/eric7/WebBrowser/Download/DownloadItem.py

-:e9e7eca7efee
+:bf71ee032bb4
 import enum
 import os
 import pathlib
-from PyQt6.QtCore import (
+from PyQt6.QtCore import pyqtSlot, pyqtSignal, QTime, QUrl, QStandardPaths, QDateTime
-pyqtSlot, pyqtSignal, QTime, QUrl, QStandardPaths, QDateTime
-)
 from PyQt6.QtGui import QDesktopServices
 from PyQt6.QtWidgets import QWidget, QStyle, QDialog
 from PyQt6.QtWebEngineCore import QWebEngineDownloadRequest
 from EricWidgets import EricFileDialog
 class DownloadState(enum.Enum):
 """
 Class implementing the various download states.
 """
 Downloading = 0
 Successful = 1
 Cancelled = 2
 class DownloadItem(QWidget, Ui_DownloadItem):
 """
 Class implementing a widget controlling a download.
 @signal statusChanged() emitted upon a status change of a download
 @signal downloadFinished(success) emitted when a download finished
 @signal progress(int, int) emitted to signal the download progress
 """
 statusChanged = pyqtSignal()
 downloadFinished = pyqtSignal(bool)
 progress = pyqtSignal(int, int)
 def __init__(self, downloadRequest=None, pageUrl=None, parent=None):
 """
 Constructor
 @param downloadRequest reference to the download object containing the
 download data.
 @type QWebEngineDownloadRequest
 @param pageUrl URL of the calling page
 @type QUrl
 @param parent reference to the parent widget
 @type QWidget
 """
 super().__init__(parent)
 self.setupUi(self)
 self.fileIcon.setStyleSheet("background-color: transparent")
 self.datetimeLabel.setStyleSheet("background-color: transparent")
 self.filenameLabel.setStyleSheet("background-color: transparent")
 if ericApp().usesDarkPalette():
 self.infoLabel.setStyleSheet(
 "color: #c0c0c0; background-color: transparent"
-)      # light gray
+)  # light gray
 else:
 self.infoLabel.setStyleSheet(
 "color: #808080; background-color: transparent"
-)      # dark gray
+)  # dark gray
 self.progressBar.setMaximum(0)
 self.pauseButton.setIcon(UI.PixmapCache.getIcon("pause"))
 self.stopButton.setIcon(UI.PixmapCache.getIcon("stopLoading"))
 self.openButton.setIcon(UI.PixmapCache.getIcon("open"))
 self.openButton.setEnabled(False)
 self.openButton.setVisible(False)
 self.__state = DownloadState.Downloading
 icon = self.style().standardIcon(QStyle.StandardPixmap.SP_FileIcon)
 self.fileIcon.setPixmap(icon.pixmap(48, 48))
 self.__downloadRequest = downloadRequest
 if pageUrl is None:
 self.__pageUrl = QUrl()
 else:
 self.__pageUrl = pageUrl
 self.__finishedDownloading = False
 self.__gettingFileName = False
 self.__canceledFileSelect = False
 self.__autoOpen = False
 self.__downloadedDateTime = QDateTime()
 self.__initialize()
 def __initialize(self):
 """
 Private method to initialize the widget.
 """
 if self.__downloadRequest is None:
 return
 self.__finishedDownloading = False
 self.__bytesReceived = 0
 self.__bytesTotal = -1
 # start timer for the download estimation
 self.__downloadTime = QTime.currentTime()
 # attach to the download item object
 self.__url = self.__downloadRequest.url()
-self.__downloadRequest.receivedBytesChanged.connect(
+self.__downloadRequest.receivedBytesChanged.connect(self.__downloadProgress)
-self.__downloadProgress)
 self.__downloadRequest.isFinishedChanged.connect(self.__finished)
 # reset info
 self.datetimeLabel.clear()
 self.datetimeLabel.hide()
 self.infoLabel.clear()
 self.progressBar.setValue(0)
 if (
-self.__downloadRequest.state() ==
+self.__downloadRequest.state()
-QWebEngineDownloadRequest.DownloadState.DownloadRequested
+== QWebEngineDownloadRequest.DownloadState.DownloadRequested
 ):
 self.__getFileName()
 if not self.__fileName:
 self.__downloadRequest.cancel()
 else:
 self.__downloadRequest.setDownloadFileName(self.__fileName)
 self.__downloadRequest.accept()
 else:
 fileName = self.__downloadRequest.downloadFileName()
 self.__setFileName(fileName)
 def __getFileName(self):
 """
 Private method to get the file name to save to from the user.
 """
 if self.__gettingFileName:
 return
 savePage = self.__downloadRequest.isSavePageDownload()
 documentLocation = QStandardPaths.writableLocation(
-QStandardPaths.StandardLocation.DocumentsLocation)
+QStandardPaths.StandardLocation.DocumentsLocation
-downloadDirectory = (
-WebBrowserWindow.downloadManager().downloadDirectory()
 )
+downloadDirectory = WebBrowserWindow.downloadManager().downloadDirectory()
 if self.__fileName:
 fileName = self.__fileName
 originalFileName = self.__originalFileName
 self.__toDownload = True
 ask = False
 else:
 defaultFileName, originalFileName = self.__saveFileName(
-documentLocation if savePage else downloadDirectory)
+documentLocation if savePage else downloadDirectory
+)
 fileName = defaultFileName
 self.__originalFileName = originalFileName
 ask = True
 self.__autoOpen = False
 if not savePage:
 from .DownloadAskActionDialog import DownloadAskActionDialog
 url = self.__downloadRequest.url()
 mimetype = Utilities.MimeTypes.mimeType(originalFileName)
 dlg = DownloadAskActionDialog(
 pathlib.Path(originalFileName).name,
 mimetype,
 "{0}://{1}".format(url.scheme(), url.authority()),
-self)
+self,
+)
-if (
-dlg.exec() == QDialog.DialogCode.Rejected or
+if dlg.exec() == QDialog.DialogCode.Rejected or dlg.getAction() == "cancel":
-dlg.getAction() == "cancel"
-):
 self.progressBar.setVisible(False)
 self.on_stopButton_clicked()
 self.filenameLabel.setText(
 self.tr("Download canceled: {0}").format(
-pathlib.Path(defaultFileName).name))
+pathlib.Path(defaultFileName).name
+)
+)
 self.__canceledFileSelect = True
 self.__setDateTime()
 return
 if dlg.getAction() == "scan":
 self.__mainWindow.requestVirusTotalScan(url)
 self.progressBar.setVisible(False)
 self.on_stopButton_clicked()
 self.filenameLabel.setText(
 self.tr("VirusTotal scan scheduled: {0}").format(
-pathlib.Path(defaultFileName).name))
+pathlib.Path(defaultFileName).name
+)
+)
 self.__canceledFileSelect = True
 return
 self.__autoOpen = dlg.getAction() == "open"
 tempLocation = QStandardPaths.writableLocation(
-QStandardPaths.StandardLocation.TempLocation)
+QStandardPaths.StandardLocation.TempLocation
-fileName = (
-tempLocation + '/' +
-pathlib.Path(fileName).stem
 )
+fileName = tempLocation + "/" + pathlib.Path(fileName).stem
 if ask and not self.__autoOpen:
 self.__gettingFileName = True
 fileName = EricFileDialog.getSaveFileName(
-None,
+None, self.tr("Save File"), defaultFileName, ""
-self.tr("Save File"),
+)
-defaultFileName,
-"")
 self.__gettingFileName = False
 if not fileName:
 self.progressBar.setVisible(False)
 self.on_stopButton_clicked()
 self.filenameLabel.setText(
-self.tr("Download canceled: {0}")
+self.tr("Download canceled: {0}").format(
-.format(pathlib.Path(defaultFileName).name))
+pathlib.Path(defaultFileName).name
+)
+)
 self.__canceledFileSelect = True
 self.__setDateTime()
 return
 self.__setFileName(fileName)
 def __setFileName(self, fileName):
 """
 Private method to set the file name to save the download into.
 @param fileName name of the file to save into
 @type str
 """
 fpath = pathlib.Path(fileName)
-WebBrowserWindow.downloadManager().setDownloadDirectory(
+WebBrowserWindow.downloadManager().setDownloadDirectory(fpath.parent.resolve())
-fpath.parent.resolve())
 self.filenameLabel.setText(fpath.name)
 self.__fileName = str(fpath)
 # check file path for saving
 saveDirPath = pathlib.Path(self.__fileName).parent()
 if not saveDirPath.exists():
 saveDirPath.mkdir(parents=True)
 def __saveFileName(self, directory):
 """
 Private method to calculate a name for the file to download.
 @param directory name of the directory to store the file into (string)
 @return proposed filename and original filename (string, string)
 """
 fpath = pathlib.Path(self.__downloadRequest.downloadFileName())
 origName = fpath.name
 name = os.path.join(directory, origName)
 return name, origName
 @pyqtSlot(bool)
 def on_pauseButton_clicked(self, checked):
 """
 Private slot to pause the download.
 @param checked flag indicating the state of the button
 @type bool
 """
 if checked:
 self.__downloadRequest.pause()
 else:
 self.__downloadRequest.resume()
 @pyqtSlot()
 def on_stopButton_clicked(self):
 """
 Private slot to stop the download.
 """
 self.cancelDownload()
 def cancelDownload(self):
 """
 Public slot to stop the download.
 """
 self.setUpdatesEnabled(False)
 self.setUpdatesEnabled(True)
 self.__state = DownloadState.Cancelled
 self.__downloadRequest.cancel()
 self.__setDateTime()
 self.downloadFinished.emit(False)
 @pyqtSlot()
 def on_openButton_clicked(self):
 """
 Private slot to open the downloaded file.
 """
 self.openFile()
 def openFile(self):
 """
 Public slot to open the downloaded file.
 """
 url = QUrl.fromLocalFile(pathlib.Path(self.__fileName).resolve())
 QDesktopServices.openUrl(url)
 def openFolder(self):
 """
 Public slot to open the folder containing the downloaded file.
 """
 url = QUrl.fromLocalFile(pathlib.Path(self.__fileName).resolve())
 QDesktopServices.openUrl(url)
 @pyqtSlot()
 def __downloadProgress(self):
 """
 Private slot to show the download progress.
 """
 if self.__bytesTotal > 0:
 currentValue = self.__bytesReceived * 100 // self.__bytesTotal
 totalValue = 100
 self.progressBar.setValue(currentValue)
 self.progressBar.setMaximum(totalValue)
 self.progress.emit(currentValue, totalValue)
 self.__updateInfoLabel()
 def downloadProgress(self):
 """
 Public method to get the download progress.
 @return current download progress
 @rtype int
 """
 return self.progressBar.value()
 def bytesTotal(self):
 """
 Public method to get the total number of bytes of the download.
 @return total number of bytes (integer)
 """
 if self.__bytesTotal == -1:
 self.__bytesTotal = self.__downloadRequest.totalBytes()
 return self.__bytesTotal
 def bytesReceived(self):
 """
 Public method to get the number of bytes received.
 @return number of bytes received (integer)
 """
 return self.__bytesReceived
 def remainingTime(self):
 """
 Public method to get an estimation for the remaining time.
 @return estimation for the remaining time (float)
 """
 if not self.downloading():
 return -1.0
 if self.bytesTotal() == -1:
 return -1.0
 cSpeed = self.currentSpeed()
 timeRemaining = (
-(self.bytesTotal() - self.bytesReceived()) / cSpeed
+(self.bytesTotal() - self.bytesReceived()) / cSpeed if cSpeed != 0 else 1
-if cSpeed != 0 else
-1
 )
 # ETA should never be 0
 if timeRemaining == 0:
 timeRemaining = 1
 return timeRemaining
 def currentSpeed(self):
 """
 Public method to get an estimation for the download speed.
 @return estimation for the download speed (float)
 """
 if not self.downloading():
 return -1.0
 return (
-self.__bytesReceived * 1000.0 /
+self.__bytesReceived
-self.__downloadTime.msecsTo(QTime.currentTime())
+* 1000.0
+/ self.__downloadTime.msecsTo(QTime.currentTime())
 )
 def __updateInfoLabel(self):
 """
 Private method to update the info label.
 """
 bytesTotal = self.bytesTotal()
 running = not self.downloadedSuccessfully()
 speed = self.currentSpeed()
 timeRemaining = self.remainingTime()
 info = ""
 if running:
 remaining = ""
 if bytesTotal > 0:
 remaining = timeString(timeRemaining)
-info = self.tr(
+info = self.tr("{0} of {1} ({2}/sec) {3}").format(
-"{0} of {1} ({2}/sec) {3}"
-).format(
 dataString(self.__bytesReceived),
-bytesTotal == -1 and self.tr("?") or
+bytesTotal == -1 and self.tr("?") or dataString(bytesTotal),
-dataString(bytesTotal),
 speedString(speed),
-remaining
+remaining,
 )
 else:
 if bytesTotal in (self.__bytesReceived, -1):
-info = self.tr(
+info = self.tr("{0} downloaded").format(
-"{0} downloaded"
+dataString(self.__bytesReceived)
-).format(dataString(self.__bytesReceived))
+)
 else:
-info = self.tr(
+info = self.tr("{0} of {1} - Stopped").format(
-"{0} of {1} - Stopped"
+dataString(self.__bytesReceived), dataString(bytesTotal)
-).format(dataString(self.__bytesReceived),
+)
-dataString(bytesTotal))
 self.infoLabel.setText(info)
 def downloading(self):
 """
 Public method to determine, if a download is in progress.
 @return flag indicating a download is in progress (boolean)
 """
 return self.__state == DownloadState.Downloading
 def downloadedSuccessfully(self):
 """
 Public method to check for a successful download.
 @return flag indicating a successful download (boolean)
 """
 return self.__state == DownloadState.Successful
 def downloadCanceled(self):
 """
 Public method to check, if the download was cancelled.
 @return flag indicating a canceled download (boolean)
 """
 return self.__state == DownloadState.Cancelled
 def __finished(self):
 """
 Private slot to handle the download finished.
 """
 self.__finishedDownloading = True
-noError = (self.__downloadRequest.state() ==
+noError = (
-QWebEngineDownloadRequest.DownloadState.DownloadCompleted)
+self.__downloadRequest.state()
+== QWebEngineDownloadRequest.DownloadState.DownloadCompleted
+)
 self.progressBar.setVisible(False)
 self.pauseButton.setEnabled(False)
 self.pauseButton.setVisible(False)
 self.stopButton.setEnabled(False)
 self.stopButton.setVisible(False)
 self.openButton.setEnabled(noError)
 self.openButton.setVisible(noError)
 self.__state = DownloadState.Successful
 self.__updateInfoLabel()
 self.__setDateTime()
 self.__adjustSize()
 self.statusChanged.emit()
 self.downloadFinished.emit(True)
 if self.__autoOpen:
 self.openFile()
 def canceledFileSelect(self):
 """
 Public method to check, if the user canceled the file selection.
 @return flag indicating cancellation (boolean)
 """
 return self.__canceledFileSelect
 def setIcon(self, icon):
 """
 Public method to set the download icon.
 @param icon reference to the icon to be set (QIcon)
 """
 self.fileIcon.setPixmap(icon.pixmap(48, 48))
 def fileName(self):
 """
 Public method to get the name of the output file.
 @return name of the output file (string)
 """
 return self.__fileName
 def absoluteFilePath(self):
 """
 Public method to get the absolute path of the output file.
 @return absolute path of the output file (string)
 """
 return pathlib.Path(self.__fileName).resolve()
 def getData(self):
 """
 Public method to get the relevant download data.
 @return dictionary containing the URL, save location, done flag,
 the URL of the related web page and the date and time of the
 download
 @rtype dict of {"URL": QUrl, "Location": str, "Done": bool,
 "PageURL": QUrl, "Downloaded": QDateTime}
 return {
 "URL": self.__url,
 "Location": self.__fileName,
 "Done": self.downloadedSuccessfully(),
 "PageURL": self.__pageUrl,
-"Downloaded": self.__downloadedDateTime
+"Downloaded": self.__downloadedDateTime,
 }
 def setData(self, data):
 """
 Public method to set the relevant download data.
 @param data dictionary containing the URL, save location, done flag,
 the URL of the related web page and the date and time of the
 download
 @type dict of {"URL": QUrl, "Location": str, "Done": bool,
 "PageURL": QUrl, "Downloaded": QDateTime}
 """
 self.__url = data["URL"]
 self.__fileName = data["Location"]
 self.__pageUrl = data["PageURL"]
 self.filenameLabel.setText(pathlib.Path(self.__fileName).name)
 self.infoLabel.setText(self.__fileName)
 try:
 self.__setDateTime(data["Downloaded"])
 except KeyError:
 self.__setDateTime(QDateTime())
 self.pauseButton.setEnabled(False)
 self.pauseButton.setVisible(False)
 self.stopButton.setEnabled(False)
 self.stopButton.setVisible(False)
 self.openButton.setEnabled(data["Done"])
 if data["Done"]:
 self.__state = DownloadState.Successful
 else:
 self.__state = DownloadState.Cancelled
 self.progressBar.setVisible(False)
 self.__adjustSize()
 def getInfoData(self):
 """
 Public method to get the text of the info label.
 @return text of the info label (string)
 """
 return self.infoLabel.text()
 def getPageUrl(self):
 """
 Public method to get the URL of the download page.
 @return URL of the download page (QUrl)
 """
 return self.__pageUrl
 def __adjustSize(self):
 """
 Private method to adjust the size of the download item.
 """
 self.ensurePolished()
 msh = self.minimumSizeHint()
 self.resize(max(self.width(), msh.width()), msh.height())
 def __setDateTime(self, dateTime=None):
 """
 Private method to set the download date and time.
 @param dateTime date and time to be set
 @type QDateTime
 """
 if dateTime is None:
 self.__downloadedDateTime = QDateTime.currentDateTime()

Mercurial Repositories > eric / file comparison

comparison: src/eric7/WebBrowser/Download/DownloadItem.py

src/eric7/WebBrowser/Download/DownloadItem.py