Changeset 5dba493 in sasview

Timestamp:

Jul 11, 2018 6:47:52 AM (6 years ago)

Author:

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

Children:

158a0c7

Parents:

4dd5766

Message:

rework XStream to continue to write to stdout/stderr alongside redirection; make logging level setting consistent; make log configuration more consistent

Location:

src/sas

Files:

• 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/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)