Prioritizing Error messages over Busy Indicators

Also did various forms of cleanup, putting notify_busy in the utils,
consolidating duplicate code, etc.

diff --git a/src/session.py b/src/session.py
index f867f0d..345fdc5 100644 (file)
--- a/src/session.py
+++ b/src/session.py
@@ -15,6 +15,7 @@ except ImportError:
 from PyQt4 import QtCore
 
 from util import qore_utils
+from util import qui_utils
 from util import concurrent
 from util import misc as misc_utils
 
@@ -24,15 +25,6 @@ import constants
 _moduleLogger = logging.getLogger(__name__)
 
 
-@contextlib.contextmanager
-def notify_busy(log, message):
-       log.push_busy(message)
-       try:
-               yield
-       finally:
-               log.pop(message)
-
-
 class _DraftContact(object):
 
        def __init__(self, title, description, numbersWithDescriptions):
@@ -147,7 +139,7 @@ class Draft(QtCore.QObject):
                self.sendingMessage.emit()
                try:
                        with self._busy("Sending Text"):
-                               with notify_busy(self._errorLog, "Sending Text"):
+                               with qui_utils.notify_busy(self._errorLog, "Sending Text"):
                                        yield (
                                                self._backend[0].send_sms,
                                                (numbers, text),
@@ -162,7 +154,7 @@ class Draft(QtCore.QObject):
                self.calling.emit()
                try:
                        with self._busy("Calling"):
-                               with notify_busy(self._errorLog, "Calling"):
+                               with qui_utils.notify_busy(self._errorLog, "Calling"):
                                        yield (
                                                self._backend[0].call,
                                                (number, ),
@@ -176,7 +168,7 @@ class Draft(QtCore.QObject):
        def _cancel(self):
                self.cancelling.emit()
                try:
-                       with notify_busy(self._errorLog, "Cancelling"):
+                       with qui_utils.notify_busy(self._errorLog, "Cancelling"):
                                yield (
                                        self._backend[0].cancel,
                                        (),
@@ -330,7 +322,7 @@ class Session(QtCore.QObject):
                assert self.state == self.LOGGEDIN_STATE, "DND requires being logged in (currently %s" % self.state
                oldDnd = self._dnd
                try:
-                       with notify_busy(self._errorLog, "Setting DND Status"):
+                       with qui_utils.notify_busy(self._errorLog, "Setting DND Status"):
                                yield (
                                        self._backend[0].set_dnd,
                                        (dnd, ),
@@ -379,7 +371,7 @@ class Session(QtCore.QObject):
                        self.callbackNumberChanged.emit(self._callback)
 
        def _login(self, username, password):
-               with notify_busy(self._errorLog, "Logging In"):
+               with qui_utils.notify_busy(self._errorLog, "Logging In"):
                        self._loggedInTime = self._LOGGINGIN_TIME
                        self.stateChange.emit(self.LOGGINGIN_STATE)
                        finalState = self.LOGGEDOUT_STATE
@@ -568,7 +560,7 @@ class Session(QtCore.QObject):
 
        def _update_contacts(self):
                try:
-                       with notify_busy(self._errorLog, "Updating Contacts"):
+                       with qui_utils.notify_busy(self._errorLog, "Updating Contacts"):
                                self._contacts = yield (
                                        self._backend[0].get_contacts,
                                        (),
@@ -582,7 +574,7 @@ class Session(QtCore.QObject):
 
        def _update_messages(self):
                try:
-                       with notify_busy(self._errorLog, "Updating Messages"):
+                       with qui_utils.notify_busy(self._errorLog, "Updating Messages"):
                                self._messages = yield (
                                        self._backend[0].get_messages,
                                        (),
@@ -596,7 +588,7 @@ class Session(QtCore.QObject):
 
        def _update_history(self):
                try:
-                       with notify_busy(self._errorLog, "Updating History"):
+                       with qui_utils.notify_busy(self._errorLog, "Updating History"):
                                self._history = yield (
                                        self._backend[0].get_recent,
                                        (),

diff --git a/src/util/qui_utils.py b/src/util/qui_utils.py
index e422344..0249874 100644 (file)
--- a/src/util/qui_utils.py
+++ b/src/util/qui_utils.py
@@ -1,5 +1,6 @@
 import sys
 import contextlib
+import datetime
 import logging
 
 from PyQt4 import QtCore
@@ -19,15 +20,25 @@ def notify_error(log):
                log.push_exception()
 
 
+@contextlib.contextmanager
+def notify_busy(log, message):
+       log.push_busy(message)
+       try:
+               yield
+       finally:
+               log.pop(message)
+
+
 class ErrorMessage(object):
 
-       LEVEL_BUSY = "busy"
-       LEVEL_INFO = "info"
-       LEVEL_ERROR = "error"
+       LEVEL_ERROR = 0
+       LEVEL_BUSY = 1
+       LEVEL_INFO = 2
 
        def __init__(self, message, level):
                self._message = message
                self._level = level
+               self._time = datetime.datetime.now()
 
        @property
        def level(self):
@@ -37,6 +48,9 @@ class ErrorMessage(object):
        def message(self):
                return self._message
 
+       def __repr__(self):
+               return "%s.%s(%r, %r)" % (__name__, self.__class__.__name__, self._message, self._level)
+
 
 class QErrorLog(QtCore.QObject):
 
@@ -82,6 +96,8 @@ class QErrorLog(QtCore.QObject):
 
        def _push_message(self, message, level):
                self._messages.append(ErrorMessage(message, level))
+               # Sort is defined as stable, so this should be fine
+               self._messages.sort(key=lambda x: x.level)
                self.messagePushed.emit()
 
        def __len__(self):
@@ -142,6 +158,12 @@ class ErrorDisplay(object):
        def toplevel(self):
                return self._widget
 
+       def _show_error(self):
+               error = self._errorLog.peek_message()
+               self._message.setText(error.message)
+               self._severityLabel.setPixmap(self._icons[error.level])
+               self._widget.show()
+
        @QtCore.pyqtSlot()
        @QtCore.pyqtSlot(bool)
        @misc.log_exception(_moduleLogger)
@@ -151,11 +173,7 @@ class ErrorDisplay(object):
        @QtCore.pyqtSlot()
        @misc.log_exception(_moduleLogger)
        def _on_message_pushed(self):
-               if 1 <= len(self._errorLog) and self._widget.isHidden():
-                       error = self._errorLog.peek_message()
-                       self._message.setText(error.message)
-                       self._severityLabel.setPixmap(self._icons[error.level])
-                       self._widget.show()
+               self._show_error()
 
        @QtCore.pyqtSlot()
        @misc.log_exception(_moduleLogger)
@@ -164,9 +182,7 @@ class ErrorDisplay(object):
                        self._message.setText("")
                        self._widget.hide()
                else:
-                       error = self._errorLog.peek_message()
-                       self._message.setText(error.message)
-                       self._severityLabel.setPixmap(self._icons[error.level])
+                       self._show_error()
 
 
 class QHtmlDelegate(QtGui.QStyledItemDelegate):