Changeset 5dba493 in sasview


Ignore:
Timestamp:
Jul 11, 2018 8:47:52 AM (6 weeks ago)
Author:
tcbennun
Branches:
ESS_GUI_iss957
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:
6 edited

Legend:

Unmodified
Added
Removed
  • src/sas/logger_config.py

    rcee5c78 r5dba493  
    88import pkg_resources 
    99 
     10import sas.qtgui.Utilities.LocalConfig as LocalConfig 
    1011 
    1112''' 
     
    2930            logging.captureWarnings(True) 
    3031            logger = logging.getLogger(self.name) 
     32 
     33        # use this as a final override if the need arises 
     34        logging.disable(LocalConfig.DISABLE_LOGGING) 
     35 
    3136        return logger 
    3237 
     
    3843        self._update_all_logs_to_debug(logger) 
    3944        logging.captureWarnings(True) 
     45 
     46        # use this as a final override if the need arises 
     47        logging.disable(LocalConfig.DISABLE_LOGGING) 
     48 
    4049        return logger 
    4150 
     
    4958        ''' 
    5059        for handler in logger.handlers or logger.parent.handlers: 
    51             #handler.setLevel(logging.DEBUG) 
    52             handler.setLevel(logging.WARNING) 
     60            handler.setLevel(logging.DEBUG) 
    5361        for name, _ in logging.Logger.manager.loggerDict.items(): 
    54             #logging.getLogger(name).setLevel(logging.DEBUG) 
    55             logging.getLogger(name).setLevel(logging.WARNING) 
     62            logging.getLogger(name).setLevel(logging.DEBUG) 
    5663 
    5764    def _find_config_file(self, filename="logging.ini"): 
  • src/sas/logging.ini

    r7c105e8 r5dba493  
    1212#format=%(asctime)s - %(name)s - %(levelname)s - %(message)s 
    1313#format=%(asctime)s - %(levelname)s : %(name)s:%(pathname)s:%(lineno)4d: %(message)s 
    14 format=%(asctime)s - %(levelname)s : %(name)s:%(lineno)4d: %(message)s 
     14#format=%(asctime)s - %(levelname)s : %(name)s:%(lineno)4d: %(message)s 
     15format=%(asctime)s - %(levelname)s: %(message)s 
    1516datefmt=%H:%M:%S 
    1617 
  • src/sas/qtgui/MainWindow/MainWindow.py

    ra3221b6 r5dba493  
    1010from sas.qtgui.UI import main_resources_rc 
    1111from .UI.MainWindowUI import Ui_MainWindow 
    12  
    13 # Initialize logging 
    14 import sas.qtgui.Utilities.SasviewLogger 
    1512 
    1613class MainSasViewWindow(QMainWindow, Ui_MainWindow): 
  • src/sas/qtgui/Perspectives/Fitting/FittingWidget.py

    re20870b r5dba493  
    106106        # Globals 
    107107        self.initializeGlobals() 
    108  
    109         # Set up desired logging level 
    110         logging.disable(LocalConfig.DISABLE_LOGGING) 
    111108 
    112109        # data index for the batch set 
  • src/sas/qtgui/Utilities/LocalConfig.py

    ra0ed202 r5dba493  
    136136USING_TWISTED = True 
    137137 
    138 # Logging levels to disable, if any 
    139 DISABLE_LOGGING = logging.DEBUG 
    140  
    141138# Time out for updating sasview 
    142139UPDATE_TIMEOUT = 2 
    143140 
    144141# Logging levels to disable, if any 
    145 DISABLE_LOGGING = logging.DEBUG 
     142DISABLE_LOGGING = logging.NOTSET 
    146143 
    147144def printEVT(message): 
  • src/sas/qtgui/Utilities/SasviewLogger.py

    r4992ff2 r5dba493  
    77 
    88class XStream(QObject): 
     9    """ 
     10    Imitates, loosely, an `io.TextIOWrapper` class in order to intercept 
     11    messages going to stdout and stderr. 
     12 
     13    To intercept messages to stdout, use: 
     14 
     15    .. code-block:: python 
     16       XStream.stdout().messageWritten.mySignalHandler() 
     17 
     18    All messages to stdout will now also be emitted to your handler. Use 
     19    `XStream.stderr()` in the same way to intercept stderr messages. 
     20 
     21    An additional function, `XStream.write_log()`, emits a message only to the 
     22    messageWritten signal, and not the stdout or stderr streams. It is intended 
     23    for separation of log handling between console and Qt, as reflected in the 
     24    name. 
     25    """ 
    926    _stdout = None 
    1027    _stderr = None 
    1128    messageWritten = pyqtSignal(str) 
     29 
     30    _real_stream = None 
    1231 
    1332    def flush(self): 
     
    1837 
    1938    def write(self, msg): 
     39        """ 
     40        'msg' is emitted in the messageWritten signal, and is also written to 
     41        the original stream. This means stdout/stderr messages have been 
     42        redirected to a custom location (e.g. in-widget), but also reach 
     43        console output. 
     44 
     45        :param msg: message to write 
     46        :return: None 
     47        """ 
     48        if(not self.signalsBlocked()): 
     49            self.messageWritten.emit(str(msg)) 
     50        self._real_stream.write(msg) 
     51 
     52    def write_log(self, msg): 
     53        """ 
     54        'msg' is only emitted in the messageWritten signal, not in the original 
     55        stdout/stderr stream, for the purposes of logging. Use in, e.g. a 
     56        custom logging handler's emit() function. 
     57 
     58        :param msg: message to write 
     59        :return: None 
     60        """ 
    2061        if(not self.signalsBlocked()): 
    2162            self.messageWritten.emit(str(msg)) 
     
    2364    @staticmethod 
    2465    def stdout(): 
     66        """ 
     67        Creates imitation of sys.stdout. 
     68        :return: An XStream instance that interfaces exactly like sys.stdout, 
     69                 but, has redirection capabilities through the 
     70                 messageWritten(str) signal. 
     71        """ 
    2572        if(not XStream._stdout): 
    2673            XStream._stdout = XStream() 
     74            XStream._stdout._real_stream = sys.stdout 
    2775            sys.stdout = XStream._stdout 
    2876        return XStream._stdout 
     
    3078    @staticmethod 
    3179    def stderr(): 
     80        """ 
     81        Creates imitation of sys.stderr. 
     82        :return: An XStream instance that interfaces exactly like sys.stderr, 
     83                 but, has redirection capabilities through the 
     84                 messageWritten(str) signal. 
     85        """ 
    3286        if(not XStream._stderr): 
    3387            XStream._stderr = XStream() 
     88            XStream._stderr._real_stream = sys.stderr 
    3489            sys.stderr = XStream._stderr 
    3590        return XStream._stderr 
    3691 
     92 
    3793class QtHandler(logging.Handler): 
    3894    """ 
    39     Version of logging handler 
    40     "emitting" the message to custom stdout() 
     95    Version of logging handler "emitting" the message to custom stdout() 
    4196    """ 
    4297    def __init__(self): 
     
    46101        record = self.format(record) 
    47102        if record: 
    48             XStream.stdout().write('%s\n'%record) 
     103            XStream.stdout().write_log('%s\n'%record) 
    49104 
    50105 
     
    52107logger = logging.getLogger() 
    53108 
    54 # Add the file handler 
    55 logging.basicConfig(level=logging.INFO, 
    56                     format='%(asctime)s %(levelname)s %(message)s', 
    57                     filename=os.path.join(os.path.expanduser("~"), 
    58                                           'sasview.log')) 
    59109# Add the qt-signal logger 
    60110handler = QtHandler() 
    61 handler.setFormatter(logging.Formatter("%(levelname)s: %(message)s")) 
     111handler.setFormatter(logging.Formatter( 
     112    fmt="%(asctime)s - %(levelname)s: %(message)s", 
     113    datefmt="%H:%M:%S" 
     114)) 
    62115logger.addHandler(handler) 
Note: See TracChangeset for help on using the changeset viewer.