Changeset 158a0c7 in sasview for src

Timestamp:

Jul 13, 2018 4:24:30 AM (6 years ago)

Author:

Torin Cooper-Bennun <torin.cooper-bennun@…>

Children:

41d6187

Parents:

5dba493 (diff), ecbfddd (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

merge useful commits from ESS_GUI

• commit 'ecbfddd': add VS files, stackdumps to gitignore check whether .py files are outdated before generating them from .ui or .qrc files (huge startup speed-up) Update version number to 5.0 - SASVIEW-949 CR: Deleting a single dataitem child will close the corresponding plot (SASVIEW-958) corrections to GUITests doc add documentation to GUITests

Location:

src/sas

Files:

• qtgui/GUITests.py (modified) (1 diff)
• qtgui/MainWindow/DataExplorer.py (modified) (1 diff)
• qtgui/Utilities/GuiUtils.py (modified) (3 diffs)
• qtgui/convertUI.py (modified) (4 diffs)
• sasview/__init__.py (modified) (1 diff)
• logger_config.py (modified) (4 diffs)
• logging.ini (modified) (1 diff)
• qtgui/MainWindow/MainWindow.py (modified) (1 diff)
• qtgui/Perspectives/Fitting/FittingWidget.py (modified) (1 diff)
• qtgui/Utilities/LocalConfig.py (modified) (1 diff)
• qtgui/Utilities/SasviewLogger.py (modified) (6 diffs)

src/sas/qtgui/GUITests.py

@@ -3 +3 @@
 from PyQt5 import QtGui
 from PyQt5 import QtWidgets
+
+"""
+Unit tests for the QT GUI
+=========================
+
+In order to run the tests, first install SasView and sasmodels to site-packages
+by running ``python setup.py install`` in both repositories.
+
+The tests can be run with ``python GUITests.py``, or to get more verbose
+console output (recommended), use ``python GUITests.py -v``.
+"""
 
 # Prepare the general QApplication instance

src/sas/qtgui/MainWindow/DataExplorer.py

@@ -496 +496 @@
         # Now query the model item for available plots
         plots = GuiUtils.plotsFromFilename(filename, model)
-        item = GuiUtils.itemFromFilename(filename, model)
 
         new_plots = []
-        for plot in plots:
+        for item, plot in plots.items():
             plot_id = plot.id
             if plot_id in list(self.active_plots.keys()):

src/sas/qtgui/Utilities/GuiUtils.py

@@ -415 +415 @@
     assert isinstance(filename, str)
 
-    plot_data = []
+    plot_data = {}
     # Iterate over model looking for named items
     for index in range(model_item.rowCount()):
@@ -421 +421 @@
         if str(item.text()) == filename:
             # TODO: assure item type is correct (either data1/2D or Plotter)
-            plot_data.append(item.child(0).data())
+            plot_data[item] = item.child(0).data()
             # Going 1 level deeper only
             for index_2 in range(item.rowCount()):
@@ -427 +427 @@
                 if item_2 and item_2.isCheckable():
                     # TODO: assure item type is correct (either data1/2D or Plotter)
-                    plot_data.append(item_2.child(0).data())
+                    plot_data[item_2] = item_2.child(0).data()
 
     return plot_data

src/sas/qtgui/convertUI.py

@@ -13 +13 @@
     os.system(execute)
 
+def file_in_newer(file_in, file_out):
+    """
+    Check whether file_in is newer than file_out, if file_out exists.
+
+    Returns True if file_in is newer, or if file_out doesn't exist; False
+    otherwise.
+    """
+    try:
+        out_stat = os.stat(file_out)
+    except OSError:
+        # file_out does not exist
+        return True
+
+    in_stat = os.stat(file_in)
+
+    # simple comparison of modification time
+    return in_stat.st_mtime >= out_stat.st_mtime
+
 # look for .ui files
 for root, dirs, files in os.walk("."):
@@ -19 +37 @@
             file_in = os.path.join(root, file)
             file_out = os.path.splitext(file_in)[0]+'.py'
-            pyuic(file_in, file_out)
+            if file_in_newer(file_in, file_out):
+                print("Generating " + file_out + " ...")
+                pyuic(file_in, file_out)
 
 # RC file in UI directory
@@ -27 +47 @@
 out_file = 'main_resources_rc.py'
 
-pyrrc(os.path.join(ui_root, rc_file), os.path.join(ui_root, out_file))
+in_file = os.path.join(ui_root, rc_file)
+out_file = os.path.join(ui_root, out_file)
+
+if file_in_newer(in_file, out_file):
+    print("Generating " + out_file + " ...")
+    pyrrc(in_file, out_file)
 
 # Images
@@ -34 +59 @@
 rc_file = 'images.qrc'
 out_file = 'images_rc.py'
-pyrrc(os.path.join(images_root, rc_file), os.path.join(out_root, out_file))
+
+in_file = os.path.join(images_root, rc_file)
+out_file = os.path.join(ui_root, out_file)
+
+if file_in_newer(in_file, out_file):
+    print("Generating " + out_file + " ...")
+    pyrrc(in_file, out_file)
+

src/sas/sasview/__init__.py

@@ -1 @@
-__version__ = "4.1"
+__version__ = "5.0"
 __build__ = "GIT_COMMIT"

src/sas/logger_config.py

@@ -8 +8 @@
 import pkg_resources
 
+import sas.qtgui.Utilities.LocalConfig as LocalConfig
 
 '''
@@ -29 +30 @@
             logging.captureWarnings(True)
             logger = logging.getLogger(self.name)
+
+        # use this as a final override if the need arises
+        logging.disable(LocalConfig.DISABLE_LOGGING)
+
         return logger
 
@@ -38 +43 @@
         self._update_all_logs_to_debug(logger)
         logging.captureWarnings(True)
+
+        # use this as a final override if the need arises
+        logging.disable(LocalConfig.DISABLE_LOGGING)
+
         return logger
 
@@ -49 +58 @@
         '''
         for handler in logger.handlers or logger.parent.handlers:
-            #handler.setLevel(logging.DEBUG)
-            handler.setLevel(logging.WARNING)
+            handler.setLevel(logging.DEBUG)
         for name, _ in logging.Logger.manager.loggerDict.items():
-            #logging.getLogger(name).setLevel(logging.DEBUG)
-            logging.getLogger(name).setLevel(logging.WARNING)
+            logging.getLogger(name).setLevel(logging.DEBUG)
 
     def _find_config_file(self, filename="logging.ini"):

src/sas/logging.ini

@@ -12 +12 @@
 #format=%(asctime)s - %(name)s - %(levelname)s - %(message)s
 #format=%(asctime)s - %(levelname)s : %(name)s:%(pathname)s:%(lineno)4d: %(message)s
-format=%(asctime)s - %(levelname)s : %(name)s:%(lineno)4d: %(message)s
+#format=%(asctime)s - %(levelname)s : %(name)s:%(lineno)4d: %(message)s
+format=%(asctime)s - %(levelname)s: %(message)s
 datefmt=%H:%M:%S
 

src/sas/qtgui/MainWindow/MainWindow.py

@@ -10 +10 @@
 from sas.qtgui.UI import main_resources_rc
 from .UI.MainWindowUI import Ui_MainWindow
-
-# Initialize logging
-import sas.qtgui.Utilities.SasviewLogger
 
 class MainSasViewWindow(QMainWindow, Ui_MainWindow):

src/sas/qtgui/Perspectives/Fitting/FittingWidget.py

@@ -106 +106 @@
         # Globals
         self.initializeGlobals()
-
-        # Set up desired logging level
-        logging.disable(LocalConfig.DISABLE_LOGGING)
 
         # data index for the batch set

src/sas/qtgui/Utilities/LocalConfig.py

@@ -136 +136 @@
 USING_TWISTED = True
 
-# Logging levels to disable, if any
-DISABLE_LOGGING = logging.DEBUG
-
 # Time out for updating sasview
 UPDATE_TIMEOUT = 2
 
 # Logging levels to disable, if any
-DISABLE_LOGGING = logging.DEBUG
+DISABLE_LOGGING = logging.NOTSET
 
 def printEVT(message):

src/sas/qtgui/Utilities/SasviewLogger.py

@@ -7 +7 @@
 
 class XStream(QObject):
+    """
+    Imitates, loosely, an `io.TextIOWrapper` class in order to intercept
+    messages going to stdout and stderr.
+
+    To intercept messages to stdout, use:
+
+    .. code-block:: python
+       XStream.stdout().messageWritten.mySignalHandler()
+
+    All messages to stdout will now also be emitted to your handler. Use
+    `XStream.stderr()` in the same way to intercept stderr messages.
+
+    An additional function, `XStream.write_log()`, emits a message only to the
+    messageWritten signal, and not the stdout or stderr streams. It is intended
+    for separation of log handling between console and Qt, as reflected in the
+    name.
+    """
     _stdout = None
     _stderr = None
     messageWritten = pyqtSignal(str)
+
+    _real_stream = None
 
     def flush(self):
@@ -18 +37 @@
 
     def write(self, msg):
+        """
+        'msg' is emitted in the messageWritten signal, and is also written to
+        the original stream. This means stdout/stderr messages have been
+        redirected to a custom location (e.g. in-widget), but also reach
+        console output.
+
+        :param msg: message to write
+        :return: None
+        """
+        if(not self.signalsBlocked()):
+            self.messageWritten.emit(str(msg))
+        self._real_stream.write(msg)
+
+    def write_log(self, msg):
+        """
+        'msg' is only emitted in the messageWritten signal, not in the original
+        stdout/stderr stream, for the purposes of logging. Use in, e.g. a
+        custom logging handler's emit() function.
+
+        :param msg: message to write
+        :return: None
+        """
         if(not self.signalsBlocked()):
             self.messageWritten.emit(str(msg))
@@ -23 +64 @@
     @staticmethod
     def stdout():
+        """
+        Creates imitation of sys.stdout.
+        :return: An XStream instance that interfaces exactly like sys.stdout,
+                 but, has redirection capabilities through the
+                 messageWritten(str) signal.
+        """
         if(not XStream._stdout):
             XStream._stdout = XStream()
+            XStream._stdout._real_stream = sys.stdout
             sys.stdout = XStream._stdout
         return XStream._stdout
@@ -30 +78 @@
     @staticmethod
     def stderr():
+        """
+        Creates imitation of sys.stderr.
+        :return: An XStream instance that interfaces exactly like sys.stderr,
+                 but, has redirection capabilities through the
+                 messageWritten(str) signal.
+        """
         if(not XStream._stderr):
             XStream._stderr = XStream()
+            XStream._stderr._real_stream = sys.stderr
             sys.stderr = XStream._stderr
         return XStream._stderr
 
+
 class QtHandler(logging.Handler):
     """
-    Version of logging handler
-    "emitting" the message to custom stdout()
+    Version of logging handler "emitting" the message to custom stdout()
     """
     def __init__(self):
@@ -46 +101 @@
         record = self.format(record)
         if record:
-            XStream.stdout().write('%s\n'%record)
+            XStream.stdout().write_log('%s\n'%record)
 
 
@@ -52 +107 @@
 logger = logging.getLogger()
 
-# Add the file handler
-logging.basicConfig(level=logging.INFO,
-                    format='%(asctime)s %(levelname)s %(message)s',
-                    filename=os.path.join(os.path.expanduser("~"),
-                                          'sasview.log'))
 # Add the qt-signal logger
 handler = QtHandler()
-handler.setFormatter(logging.Formatter("%(levelname)s: %(message)s"))
+handler.setFormatter(logging.Formatter(
+    fmt="%(asctime)s - %(levelname)s: %(message)s",
+    datefmt="%H:%M:%S"
+))
 logger.addHandler(handler)