spiceitup 1.2.2__tar.gz → 1.3.3__tar.gz

{spiceitup-1.2.2 → spiceitup-1.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spiceitup
-Version: 1.2.2
+Version: 1.3.3
 Summary: Quicklook tool for level 2 SPICE imaging
 Home-page: https://git.ias.u-psud.fr/spice/data_quicklook
 Author: David Picard

{spiceitup-1.2.2 → spiceitup-1.3.3}/setup.py

@@ -13,14 +13,14 @@ def load_requirements(filename):
 
 setup(
     name='spiceitup',
-    version='1.2.2',
+    version='1.3.3',
     description='Quicklook tool for level 2 SPICE imaging',
     long_description=open('README.md').read(),
     long_description_content_type='text/markdown',
     author='David Picard',
     author_email='david.picard@universite-paris-saclay.fr',
     url='https://git.ias.u-psud.fr/spice/data_quicklook',
-    packages=['spiceitup'],
+    packages=find_packages(),
     install_requires=[
         "PyQt5",
         "sunraster",

{spiceitup-1.2.2 → spiceitup-1.3.3}/spiceitup/__main__.py

@@ -1,12 +1,11 @@
 import sys
 import warnings
-
-from run import Main
-from settings.const import Const
+import os
+from .settings.const import Const
+from .run import Main
 from PyQt5.QtGui import *
 from PyQt5.QtWidgets import *
 
-
 def main():
     warnings.filterwarnings("ignore")
     # Used to prevent to show All-NaN RuntimeWarning

spiceitup-1.3.3/spiceitup/layout/flow_layout.py

@@ -0,0 +1,91 @@
+from PyQt5.QtCore import QPoint, QRect, QSize, Qt
+from PyQt5.QtWidgets import (QApplication, QLayout, QPushButton, QSizePolicy, QWidget, QGridLayout)
+
+class FlowLayout(QLayout):
+    
+    def __init__(self, parent = None, margin = 0, spacing = -1):
+        super(FlowLayout, self).__init__(parent)
+
+        if parent is not None:
+            self.setContentsMargins(margin, margin, margin, margin)
+
+        self.setSpacing(spacing)
+
+        self.itemList = []
+
+    def __del__(self):
+        item = self.takeAt(0)
+        while item:
+            item = self.takeAt(0)
+
+    def addItem(self, item):
+        self.itemList.append(item)
+
+    def count(self):
+        return len(self.itemList)
+
+    def itemAt(self, index):
+        if index >= 0 and index < len(self.itemList):
+            return self.itemList[index]
+
+        return None
+
+    def takeAt(self, index):
+        if index >= 0 and index < len(self.itemList):
+            return self.itemList.pop(index)
+
+        return None
+
+    def expandingDirections(self):
+        return Qt.Orientations(Qt.Orientation(0))
+
+    def hasHeightForWidth(self):
+        return True
+
+    def heightForWidth(self, width):
+        height = self.doLayout(QRect(0, 0, width, 0), True)
+        return height
+
+    def setGeometry(self, rect):
+        super(FlowLayout, self).setGeometry(rect)
+        self.doLayout(rect, False)
+
+    def sizeHint(self):
+        return self.minimumSize()
+
+    def minimumSize(self):
+        size = QSize()
+
+        for item in self.itemList:
+            size = size.expandedTo(item.minimumSize())
+
+        margin, _, _, _ = self.getContentsMargins()
+
+        size += QSize(2 * margin, 2 * margin)
+        return size
+
+    def doLayout(self, rect, testOnly):
+        x = rect.x()
+        y = rect.y()
+        lineHeight = 0
+
+        for item in self.itemList:
+            wid = item.widget()
+            spaceX = self.spacing() + wid.style().layoutSpacing(QSizePolicy.PushButton,
+                                                                QSizePolicy.PushButton, Qt.Horizontal)
+            spaceY = self.spacing() + wid.style().layoutSpacing(QSizePolicy.PushButton,
+                                                                QSizePolicy.PushButton, Qt.Vertical)
+            nextX = x + item.sizeHint().width() + spaceX
+            if nextX - spaceX > rect.right() and lineHeight > 0:
+                x = rect.x()
+                y = y + lineHeight + spaceY
+                nextX = x + item.sizeHint().width() + spaceX
+                lineHeight = 0
+
+            if not testOnly:
+                item.setGeometry(QRect(QPoint(x, y), item.sizeHint()))
+
+            x = nextX
+            lineHeight = max(lineHeight, item.sizeHint().height())
+
+        return y + lineHeight - rect.y()

spiceitup-1.3.3/spiceitup/layout/flow_layout_edited.py

@@ -0,0 +1,98 @@
+from PyQt5.QtCore import QPoint, QRect, QSize, Qt
+from PyQt5.QtWidgets import (QApplication, QLayout, QPushButton, QSizePolicy, QWidget, QGridLayout)
+
+class FlowLayout(QLayout):
+    q_plot_size = None
+    
+    def __init__(self, parent = None, margin = 0, spacing = -1, q_plot_size = None):
+        # plot_size must be a QSize object
+        super(FlowLayout, self).__init__(parent)
+        
+        if q_plot_size is not None:
+            self.q_plot_size = q_plot_size
+            self.q_plot_size.setHeight(int(self.q_plot_size.width() * 1.3)) # because of win title
+            self.q_plot_size.setWidth(self.q_plot_size.width() * 2) # because 2 plots x,y and lambda,y
+
+        if parent is not None:
+            self.setContentsMargins(margin, margin, margin, margin)
+
+        self.setSpacing(spacing)
+
+        self.itemList = []
+
+    def __del__(self):
+        item = self.takeAt(0)
+        while item:
+            item = self.takeAt(0)
+
+    def addItem(self, item):
+        self.itemList.append(item)
+
+    def count(self):
+        return len(self.itemList)
+
+    def itemAt(self, index):
+        if index >= 0 and index < len(self.itemList):
+            return self.itemList[index]
+
+        return None
+
+    def takeAt(self, index):
+        if index >= 0 and index < len(self.itemList):
+            return self.itemList.pop(index)
+
+        return None
+
+    def expandingDirections(self):
+        return Qt.Orientations(Qt.Orientation(0))
+
+    def hasHeightForWidth(self):
+        return True
+
+    def heightForWidth(self, width):
+        height = self.doLayout(QRect(0, 0, width, 0), True)
+        return height
+
+    def setGeometry(self, rect):
+        super(FlowLayout, self).setGeometry(rect)
+        self.doLayout(rect, False)
+
+    def sizeHint(self):
+        return self.minimumSize()
+
+    def minimumSize(self):
+        size = QSize()
+
+        for item in self.itemList:
+            size = size.expandedTo(item.minimumSize())
+
+        margin, _, _, _ = self.getContentsMargins()
+
+        size += QSize(2 * margin, 2 * margin)
+        return size
+
+    def doLayout(self, rect, testOnly):
+        x = rect.x()
+        y = rect.y()
+        lineHeight = 0
+
+        for item in self.itemList:
+            wid = item.widget()
+            spaceX = self.spacing() + wid.style().layoutSpacing(QSizePolicy.PushButton,
+                                                                QSizePolicy.PushButton, Qt.Horizontal)
+            spaceY = self.spacing() + wid.style().layoutSpacing(QSizePolicy.PushButton,
+                                                                QSizePolicy.PushButton, Qt.Vertical)
+            nextX = x + self.q_plot_size.width() + spaceX #nextX = x + item.sizeHint().width() + spaceX
+            if nextX - spaceX > rect.right() and lineHeight > 0:
+                x = rect.x()
+                y = y + lineHeight + spaceY
+                nextX = x + self.q_plot_size.width() + spaceX #nextX = x + item.sizeHint().width() + spaceX
+                lineHeight = 0
+
+            if not testOnly:
+                item.setGeometry(QRect(QPoint(x, y), self.q_plot_size)) #item.setGeometry(QRect(QPoint(x, y), item.sizeHint()))
+
+            x = nextX
+            lineHeight = max(lineHeight, self.q_plot_size.height()) #lineHeight = max(lineHeight, item.sizeHint().height())
+
+        return y + lineHeight - rect.y()

spiceitup-1.3.3/spiceitup/layout/flow_layout_old.py

@@ -0,0 +1,96 @@
+from PyQt5.QtCore import QPoint, QRect, QSize, Qt
+from PyQt5.QtWidgets import (QApplication, QLayout, QPushButton, QSizePolicy, QWidget, QGridLayout)
+
+class FlowLayout(QLayout):
+    q_plot_size = None
+    
+    def __init__(self, parent = None, margin = 0, spacing = -1, q_plot_size = None):
+        # plot_size must be a QSize object
+        super(FlowLayout, self).__init__(parent)
+        
+        if q_plot_size is not None:
+            self.q_plot_size = q_plot_size
+
+        if parent is not None:
+            self.setContentsMargins(margin, margin, margin, margin)
+
+        self.setSpacing(spacing)
+
+        self.itemList = []
+
+    def __del__(self):
+        item = self.takeAt(0)
+        while item:
+            item = self.takeAt(0)
+
+    def addItem(self, item):
+        self.itemList.append(item)
+
+    def count(self):
+        return len(self.itemList)
+
+    def itemAt(self, index):
+        if index >= 0 and index < len(self.itemList):
+            return self.itemList[index]
+
+        return None
+
+    def takeAt(self, index):
+        if index >= 0 and index < len(self.itemList):
+            return self.itemList.pop(index)
+
+        return None
+
+    def expandingDirections(self):
+        return Qt.Orientations(Qt.Orientation(0))
+
+    def hasHeightForWidth(self):
+        return True
+
+    def heightForWidth(self, width):
+        height = self.doLayout(QRect(0, 0, width, 0), True)
+        return height
+
+    def setGeometry(self, rect):
+        super(FlowLayout, self).setGeometry(rect)
+        self.doLayout(rect, False)
+
+    def sizeHint(self):
+        return self.minimumSize()
+
+    def minimumSize(self):
+        size = QSize()
+
+        for item in self.itemList:
+            size = size.expandedTo(item.minimumSize())
+
+        margin, _, _, _ = self.getContentsMargins()
+
+        size += QSize(2 * margin, 2 * margin)
+        return size
+
+    def doLayout(self, rect, testOnly):
+        x = rect.x()
+        y = rect.y()
+        lineHeight = 0
+
+        for item in self.itemList:
+            wid = item.widget()
+            spaceX = self.spacing() + wid.style().layoutSpacing(QSizePolicy.PushButton,
+                                                                QSizePolicy.PushButton, Qt.Horizontal)
+            spaceY = self.spacing() + wid.style().layoutSpacing(QSizePolicy.PushButton,
+                                                                QSizePolicy.PushButton, Qt.Vertical)
+            nextX = x + item.sizeHint().width() + spaceX
+            if nextX - spaceX > rect.right() and lineHeight > 0:
+                x = rect.x()
+                y = y + lineHeight + spaceY
+                nextX = x + item.sizeHint().width() + spaceX
+                lineHeight = 0
+
+            if not testOnly:
+                item.setGeometry(QRect(QPoint(x, y), item.sizeHint()))
+
+            x = nextX
+            lineHeight = max(lineHeight, item.sizeHint().height())
+
+        return y + lineHeight - rect.y()

spiceitup-1.3.3/spiceitup/logs/log.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python3
+
+from datetime import datetime
+from ..settings.const import Const
+
+from ..utils.internal_utils import get_ms
+
+
+class Log:
+
+    @staticmethod
+    def p(*msgs, msg_type='info'):
+        """Prints in log"""
+        prefix = 'INFO'
+        if msg_type == 'warn':
+            prefix = 'WARNING'
+        elif msg_type == 'error':
+            prefix = 'ERROR'
+        
+        today_dt = datetime.now()
+        today_str = today_dt.strftime(Const.date_format)
+
+        try:
+            with open(Const.log_file, 'a') as f:
+                for msg in msgs:
+                    f.write(today_str + ' ' + prefix + ': ' + str(msg) + '\n')
+        except PermissionError:
+            print('Permission denined when appening in ' + Const.log_file)
+
+
+    @staticmethod
+    def p_ms(msg, first_time_ms=0):
+        """Prints current time in milliseconds in log file.
+        A first_time_ms can be removed in order to investigate more easily the time
+        latency between instructions"""
+        Log.p(str(get_ms() - first_time_ms) + ': ' + msg)
+
+
+    @staticmethod
+    def p_duration(first_time_ms):
+        Log.p('Duration since first time: ' + str(get_ms() - first_time_ms) + ' ms')

spiceitup-1.3.3/spiceitup/main/footer.py

@@ -0,0 +1,229 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+from datetime import datetime
+from functools import partial
+
+from PyQt5.QtCore import Qt
+from PyQt5.QtWidgets import *
+
+from ..logs.log import Log
+from ..processing.threads.run_thread import RunThread
+from ..settings.const import Const
+
+class Footer(QFrame):
+    main = None
+    f_container = None
+    progress_lines = []
+
+    def __init__(self, main):
+        super(Footer, self).__init__()
+        self.main = main
+        self.setFrameShape(QFrame.StyledPanel)
+
+        l_footer = QVBoxLayout(self)
+        self.f_container = QFrame()
+
+        w_scroll = QScrollArea()
+        w_scroll.setWidget(self.f_container)
+        w_scroll.setWidgetResizable(True)
+        l_footer.addWidget(w_scroll)
+
+        self.l_grid = QGridLayout()
+        self.l_grid.setVerticalSpacing(5)
+
+        self.f_container.setLayout(self.l_grid)
+
+    def show_progress_line(self, index):
+        for key, widget in self.progress_lines[index].items():
+            if not isinstance(widget, int) and not isinstance(widget, str):  # exclude index/line and title text
+                widget.show()
+
+    def hide_progress_line(self, index):
+        for key, widget in self.progress_lines[index].items():
+            if not isinstance(widget, int) and not isinstance(widget, str): # exclude index/line and title text
+                widget.hide()
+
+    def get_color(self, val):
+        color = Const.progress_bar_color
+        if val == 100:
+            color = Const.progress_bar_color_done
+        return color
+
+    def get_text_color(self, val):
+        color = Const.progress_bar_color
+        if val == 100:
+            color = Const.green_text
+        return color
+
+    def get_progress_line_index(self, id_):
+        for index, pl in enumerate(self.progress_lines):
+            if pl['id'] == id_:
+                return index
+
+    def update_progress_line_by_id(self, id_, val):
+        index = self.get_progress_line_index(id_)
+        self.update_progress_line(index, val)
+
+    def interrupt_progress_line_by_id(self, id_):
+        index = self.get_progress_line_index(id_)
+        self.interrupt_progress_line(index)
+
+    def interrupt_processes(self):
+        for index, pl in enumerate(self.progress_lines):
+            if pl['val'] < 100:
+                self.interrupt_progress_line(index)
+
+    def interrupt_progress_line(self, index):
+        color = Const.progress_bar_interrupt_color
+        text_color = Const.red_text
+        self.progress_lines[index]['interrupted'] = True
+        self.progress_lines[index]['pb'].setStyleSheet('QProgressBar::chunk { background-color: ' +
+                                                       color + ';}')
+        self.progress_lines[index]['pb2'].setStyleSheet('QProgressBar::chunk { background-color: ' +
+                                                        color + ';}')
+        self.progress_lines[index]['q_title'].setText('<font color="' + text_color + '">' +
+                                                      self.progress_lines[index]['title'] + '</font>')
+        val = self.progress_lines[index]['val']
+        val_str = '-'
+        if val != 1:
+            val_str = str(val) + ' %'
+        self.progress_lines[index]['q_pc'].setText('<font color="' + text_color + '"><b>' +
+                                                   val_str + '</b></font>')
+        self.progress_lines[index]['b_cancel'].setText('Cancelled')
+
+    def update_progress_line(self, index, val, new_line=False):  # Use update_progress_line_by_id from outside instead
+        # because lines are continuously changing here (adding one moves the other ones)
+        if self.progress_lines[index]['interrupted'] and not new_line and val < 100:
+            color = Const.progress_bar_interrupt_color
+            text_color = Const.red_text
+        else:
+            color = self.get_color(val)
+            text_color = self.get_text_color(val)
+        self.progress_lines[index]['pb'].setStyleSheet('QProgressBar::chunk { background-color: ' +
+                                                       color + ';}')
+        self.progress_lines[index]['pb2'].setStyleSheet('QProgressBar::chunk { background-color: ' +
+                                                        color + ';}')
+        if val > 100:
+            Log.p('Warning: value greater than 100% given (' + str(val) + '), set to 100.')
+            val = 100
+
+        # Setting up both sliders
+        val1 = val * 2
+        if val1 > 100:
+            val1 = 100
+        val2 = 2 * (val - 50)
+        if val2 < 0:
+            val2 = 0
+        val_str = '-'
+        if val != 1:
+            val_str = str(val) + ' %'
+        self.progress_lines[index]['pb'].setValue(val1)
+        self.progress_lines[index]['pb2'].setValue(val2)
+        self.progress_lines[index]['q_title'].setText('<font color="' + text_color + '">' +
+                                                      self.progress_lines[index]['title'] + '</font>')
+        self.progress_lines[index]['q_pc'].setText('<font color="' + text_color + '"><b>' +
+                                                   val_str + '</b></font>')
+        self.progress_lines[index]['val'] = val
+
+        if not new_line:
+            pl_from = self.progress_lines[index]
+            pl_from['val'] = val
+            self.update_cancel_button(pl_from, self.progress_lines[index])
+            rt = self.progress_lines[index]['rt']
+            b_cancel = self.progress_lines[index]['b_cancel']
+            try:
+                b_cancel.clicked.disconnect()
+            except TypeError:  # this one was not connected
+                pass
+            b_cancel.clicked.connect(partial(Footer.interrupt,
+                                             b_cancel,
+                                             rt))
+
+    def change_line(self, index, pl):
+        val = self.progress_lines[index]['val']
+        if pl['interrupted']:
+            text_color = Const.red_text
+        else:
+            text_color = self.get_text_color(val)
+        self.progress_lines[index]['title'] = pl['title']
+        self.progress_lines[index]['q_title'].setText('<font color="' + text_color + '">' +
+                                                      pl['title'] + '</font>')
+        self.progress_lines[index]['interrupted'] = pl['interrupted']
+        self.progress_lines[index]['with_cancel'] = pl['with_cancel']
+        self.update_cancel_button(pl, self.progress_lines[index])
+        self.progress_lines[index]['rt'] = pl['rt']
+
+    def update_cancel_button(self, pl_from, pl_to):
+        if pl_to['val'] is not None:
+            is_done = pl_to['val'] >= 100
+            must_be_enabled = pl_from['with_cancel'] and not pl_from['interrupted'] and not is_done
+            pl_to['b_cancel'].setEnabled(must_be_enabled)
+            cancel_text = 'Cancel'
+            if is_done:
+                cancel_text = 'Done'
+            elif pl_from['interrupted']:
+                cancel_text = 'Cancelled'
+            button_css = Const.footer_button + ' '
+            button_css += Const.button_enabled if must_be_enabled else Const.button_disabled
+            pl_to['b_cancel'].setStyleSheet(button_css)
+            pl_to['b_cancel'].setText(cancel_text)
+
+    @staticmethod
+    def interrupt(b_cancel, rt):
+        b_cancel.setText('Cancelled')
+        b_cancel.setEnabled(False)
+        b_cancel.setStyleSheet(Const.footer_button + ' ' + Const.button_disabled)
+        rt.interrupt()
+
+    def create_progress_line(self, rt, title, with_cancel=True):
+        now = datetime.now()
+        title = 'At ' + now.strftime('%H:%M:%S') + ' - ' + title
+        q_title = QLabel()
+        q_pc = QLabel('')
+        q_pc.setAlignment(Qt.AlignCenter)
+        pb = QProgressBar()
+        pb.setFixedHeight(Const.progress_bar_height)
+        pb.setTextVisible(False)
+        pb2 = QProgressBar()
+        pb2.setFixedHeight(Const.progress_bar_height)
+        pb2.setTextVisible(False)
+        b_cancel = QPushButton('Cancel')
+        if with_cancel:
+            b_cancel.setStyleSheet(Const.footer_button + ' ' + Const.button_enabled)
+        else:
+            b_cancel.setStyleSheet(Const.footer_button + ' ' + Const.button_disabled)
+            b_cancel.setEnabled(False)
+
+        new_index = len(self.progress_lines)
+
+        self.l_grid.addWidget(q_title, new_index, 0)
+        self.l_grid.addWidget(pb, new_index, 1)
+        self.l_grid.addWidget(q_pc, new_index, 2)
+        self.l_grid.addWidget(pb2, new_index, 3)
+        self.l_grid.addWidget(b_cancel, new_index, 4)
+
+        # will be erased but create permanent objects (bars, labels, button)
+        self.progress_lines.append({'id': '', 'title': '', 'q_title': q_title, 'with_cancel': None,
+                                    'pb': pb, 'q_pc': q_pc, 'pb2': pb2, 'val': None,
+                                    'interrupted': None, 'b_cancel': b_cancel, 'rt': None})
+
+        if new_index > 0:
+            # Push other lines to free the first line
+            for i in reversed(range(new_index)):
+                # Copying i into (i + 1)
+                self.progress_lines[i + 1]['id'] = self.progress_lines[i]['id']
+                self.change_line(i + 1, self.progress_lines[i])
+                self.update_progress_line(i + 1, self.progress_lines[i]['val'])
+
+        # Now line 0 is available
+        self.update_progress_line(0, 0, True)
+        self.change_line(0, {'title': title, 'interrupted': False, 'with_cancel': with_cancel,
+                                      'b_cancel': b_cancel, 'rt': rt})
+        self.progress_lines[0]['id'] = new_index
+        if with_cancel:
+            self.progress_lines[0]['b_cancel'].clicked.connect(partial(Footer.interrupt,
+                                                                       self.progress_lines[0]['b_cancel'],
+                                                                       rt))
+
+        return new_index  # created id
+