Merge branch 'develop' into feature/drag_drop

Author: kaotika

examples/ThreadedExample.py

@@ -0,0 +1,77 @@
+import sys
+import time
+from pandasqt.compat import QtCore, QtGui, Qt, Slot, Signal
+import imgs
+
+from pandasqt.views.OverlayProgressView import OverlayProgressWidget
+
+from pandasqt.models.ProgressThread import ProgressWorker, createThread
+
+
+class ExampleWorker(ProgressWorker):
+    def __init__(self, name, ticks):
+        super(ExampleWorker, self).__init__(name)
+        self.ticks = ticks
+
+    def run(self):
+        count = 0
+        while count < 100:
+            time.sleep(1)
+            count += self.ticks
+            if count > 100:
+                count = 100
+                self.progressChanged.emit(count)
+                break
+
+            self.progressChanged.emit(count)
+
+
+class Example(QtGui.QWidget):
+    def __init__(self, parent=None):
+        super(Example, self).__init__(parent)
+
+        self.initUI()
+
+
+    def initUI(self):
+        self.setGeometry(100, 100, 300, 300)
+
+        self.vlayout = QtGui.QVBoxLayout(self)
+
+        self.imgContainer = QtGui.QLabel(self)
+        img = QtGui.QPixmap(':/europe.png')
+        self.imgContainer.setPixmap(img)
+        size = img.size()
+        self.imgContainer.resize(size.width(), self.height())
+
+        self.vlayout.addWidget(self.imgContainer)
+        self.vlayout.addWidget(QtGui.QLabel('FOOO',self))
+
+        threads = []
+
+        worker1 = ExampleWorker('foo', 10)
+        worker2 = ExampleWorker('bar', 13)
+        worker3 = ExampleWorker('spam', 25)
+
+        workers = [worker1, worker2, worker3]
+        for worker in workers:
+            thread = createThread(self, worker)
+            threads.append(thread)
+            worker.finished.connect(self.debugPrint)
+
+        self.pgFrame = OverlayProgressWidget(self.imgContainer, workers=workers)
+
+        for t in threads:
+            t.start()
+
+    @Slot()
+    def debugPrint(self):
+        print 'THREAD %s ended' % (self.sender().name, )
+
+
+if __name__ == '__main__':
+
+    app = QtGui.QApplication(sys.argv)
+    widget = Example()
+    widget.show()
+    app.exec_()

examples/europe.png

@@ -0,0 +1,5 @@
+<RCC>
+  <qresource prefix="/">
+    <file>europe.png</file>
+  </qresource>
+</RCC>

examples/images.qrc

@@ -35,7 +35,7 @@ class DataFrameModel(QtCore.QAbstractTableModel):
         changingDtypeFailed (Signal(columnName, index, dtype)):
             passed from related ColumnDtypeModel.
             emitted after a column has changed it's data type.
-        dataChanged (Signal): 
+        dataChanged (Signal):
             Emitted, if data has changed, e.x. finished loading, new columns added or removed.
             It's not the same as layoutChanged.
             Usefull to reset delegates in the view.
@@ -63,6 +63,7 @@ class DataFrameModel(QtCore.QAbstractTableModel):
     dtypeChanged = Signal(int, object)
     changingDtypeFailed = Signal(object, QtCore.QModelIndex, object)
     dataChanged = Signal()
+    dataFrameChanged = Signal()
 
     def __init__(self, dataFrame=None, copyDataFrame=False):
         """the __init__ method.
@@ -127,6 +128,7 @@ def setDataFrame(self, dataFrame, copyDataFrame=False):
         # )
         self.layoutChanged.emit()
         self.dataChanged.emit()
+        self.dataFrameChanged.emit()
 
     @Slot(int, object)
     def propagateDtypeChanges(self, column, dtype):
@@ -443,13 +445,16 @@ def setFilter(self, search):
 
         self._search.setDataFrame(self._dataFrame)
         searchIndex, valid = self._search.search()
+
         if valid:
             self._dataFrame = self._dataFrame[searchIndex]
             self.layoutChanged.emit()
         else:
             self.clearFilter()
             self.layoutChanged.emit()
 
+        self.dataFrameChanged.emit()
+
     def clearFilter(self):
         """clear all filters.
 

examples/imgs.py

@@ -0,0 +1,53 @@
+from pandasqt.compat import QtCore, QtGui, Qt, Signal, Slot
+
+class ProgressWorker(QtCore.QObject):
+    
+    progressChanged = Signal(int)       # set value of OverlayProgressView
+    finished = Signal()
+
+    def __init__(self, name):
+        """Worker object that will be passed to the thread.
+        
+        Args:
+            name (str): name shown in progress ui.
+
+        """
+        super(ProgressWorker, self).__init__()
+        self.name = name
+
+    @Slot()
+    def doWork(self):
+        """start the thread"""
+        self.run()
+        # emit the result of the operation?
+        self.finished.emit()
+
+    def run(self):
+        """Implement your job here. This is what the thread will do.
+        
+        """
+        raise NotImplemented
+
+
+
+def createThread(parent, worker, deleteWorkerLater=False):
+    """Create a new thread for given worker.
+    
+    Args:
+        parent (QObject): parent of thread and worker.
+        worker (ProgressWorker): worker to use in thread.
+        deleteWorkerLater (bool, optional): delete the worker if thread finishes.
+
+    Returns:
+        QThread
+
+    """
+    thread = QtCore.QThread(parent)
+    thread.started.connect(worker.doWork)
+    worker.finished.connect(thread.quit)
+    if deleteWorkerLater:
+        thread.finished.connect(worker.deleteLater)
+    
+    worker.moveToThread(thread)
+    worker.setParent(parent)
+    return thread

pandasqt/models/DataFrameModel.py

@@ -0,0 +1,121 @@
+from pandasqt.compat import QtCore, QtGui, Qt, Signal, Slot
+
+class OverlayProgressWidget(QtGui.QFrame):
+    def __init__(self, parent, workers=[], debug=True, margin=0):
+        super(OverlayProgressWidget, self).__init__(parent)
+        self._debug = debug
+        self._workers = workers
+        self._detailProgressBars = []
+        self._addedBars = 0
+        self._minHeight = 50
+        self._width = parent.width() * 0.38
+        self._margin = margin
+        self._totalProgress = 0
+
+        self.initUi()
+
+        for worker in workers:
+            self._addProgressBar(worker)
+
+
+    def initUi(self):
+        self.sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.MinimumExpanding, QtGui.QSizePolicy.Expanding)
+
+        self._pbHeight = 30
+
+        self.setMinimumWidth(self._width)
+        #self.setMaximumWidth(self._width)
+        self.setMinimumHeight(self._minHeight)
+
+        self.glayout = QtGui.QGridLayout(self)
+
+        self.totalProgressBar = QtGui.QProgressBar(self)
+        self.totalProgressBar.setMinimumHeight(self._pbHeight)
+        self.totalProgressBar.setMaximumHeight(self._pbHeight)
+
+        self.toggleButton = QtGui.QPushButton('Details', self)
+        self.toggleButton.setCheckable(True)
+        self.toggleButton.toggled.connect(self.showDetails)
+        self.glayout.addWidget(self.totalProgressBar, 0, 0, 1, 1)
+        self.glayout.addWidget(self.toggleButton, 0, 1, 1, 1)
+
+        #styleSheet = """.QProgressBar {
+            #border: none;
+            #border-radius: 3px;
+            #text-align: center;
+            #background-color: rgba(37, 37, 37, 50%);
+            #color: white;
+            #margin: 1px;
+            #border-bottom-left-radius:5px;
+            #border-top-left-radius:5px;
+        #}
+
+        #.QProgressBar::chunk {
+            #background-color: #05B8CC;
+            #border-radius: 3px;
+        #}
+
+        #.OverlayProgressWidget {
+            #background-color: white;
+        #}
+
+        #"""
+        ## set stylesheet for all progressbars in this widget
+        #self.setStyleSheet(styleSheet)
+
+        parent = self.parent()
+        xAnchor = parent.width() - self._width - self._margin
+        yAnchor = self._margin
+        self.setGeometry(xAnchor, yAnchor, self._width, self._minHeight)
+
+    @Slot(bool)
+    def showDetails(self, toggled):
+        for (progressBar, label) in self._detailProgressBars:
+            progressBar.setVisible(toggled)
+            label.setVisible(toggled)
+        self.resizeFrame()
+
+
+    def _addProgressBar(self, worker):
+        progressBar = QtGui.QProgressBar(self)
+        progressBar.setMinimumHeight(self._pbHeight - 5)
+        progressBar.setMaximumHeight(self._pbHeight - 5)
+        label = QtGui.QLabel(worker.name, self)
+        if not self.toggleButton.isChecked():
+            progressBar.hide()
+            label.hide()
+        row = self._addedBars + 1
+        self.glayout.addWidget(progressBar, row, 0, 1, 1)
+        self.glayout.addWidget(label, row, 1, 1, 1)
+        self._addedBars += 1
+        self._detailProgressBars.append((progressBar, label))
+        worker.progressChanged.connect(progressBar.setValue)
+        worker.progressChanged.connect(self.calculateTotalProgress)
+        
+        worker.progressChanged.connect(self.debugProgressChanged)
+        
+    def debugProgressChanged(self, value):
+        print "debugProgressChanged", value
+
+    def addWorker(self, worker):
+        self._workers.append(worker)
+        self._addProgressBar(worker)
+        self.resizeFrame()
+
+    def resizeFrame(self):
+        size = self.glayout.sizeHint()
+        self.resize(size.width(), size.height())
+
+    @Slot()
+    def calculateTotalProgress(self):
+        bars = len(self._detailProgressBars)
+        if bars:
+            progress = 0
+            for (progressBar, label) in self._detailProgressBars:
+                value = progressBar.value()
+                progress += value
+            progress = progress / bars
+        else:
+            progress = 100
+
+        self.totalProgressBar.setValue(progress)

pandasqt/models/ProgressThread.py

@@ -65,7 +65,7 @@ def run_tests(self):
     install_requires=['pandas>=0.15.1', 'pytest', 'pytest-qt==1.2.2', 'pytest-cov', 'python-magic==0.4.6'],
     cmdclass={'test': PyTest},
     author_email='m.Ludwig@datalyze-solutions.com',
-    description='catches exceptions inside qt applications and writes them to a message box and into a log file',
+    description='Utilities to use pandas (the data analysis / manipulation library for Python) with Qt.',
     long_description=long_description,
 
     include_package_data=True,