qml: clean up

electrum/gui/qml/qeapp.py

@@ -97,7 +97,9 @@ class QEAppController(QObject):
                     + '/../icons/electrum.png')
             notification.notify('Electrum', message, app_icon=icon, app_name='Electrum')
         except ImportError:
-            self.logger.error('Notification: needs plyer; `sudo python3 -m pip install plyer`')
+            self.logger.warning('Notification: needs plyer; `sudo python3 -m pip install plyer`')
+        except Exception as e:
+            self.logger.error(repr(e))
 
     @pyqtSlot(str, str)
     def doShare(self, data, title):

electrum/gui/qml/qechanneldetails.py

@@ -10,7 +10,7 @@ from electrum.lnchannel import ChanCloseOption
 
 from .qewallet import QEWallet
 from .qetypes import QEAmount
-from .util import QtEventListener, qt_event_listener
+from .util import QtEventListener, qt_event_listener, event_listener
 
 class QEChannelDetails(QObject, QtEventListener):
 
@@ -28,7 +28,7 @@ class QEChannelDetails(QObject, QtEventListener):
         self.register_callbacks()
         self.destroyed.connect(lambda: self.on_destroy())
 
-    @qt_event_listener
+    @event_listener
     def on_event_channel(self, wallet, channel):
         if wallet == self._wallet.wallet and self._channelid == channel.channel_id.hex():
             self.channelChanged.emit()

electrum/gui/qml/qechannellistmodel.py

@@ -82,7 +82,6 @@ class QEChannelListModel(QAbstractListModel, QtEventListener):
         item['capacity'] = QEAmount(amount_sat=lnc.get_capacity())
         item['can_send'] = QEAmount(amount_msat=lnc.available_to_spend(LOCAL))
         item['can_receive'] = QEAmount(amount_msat=lnc.available_to_spend(REMOTE))
-        self._logger.debug(repr(item))
         return item
 
     numOpenChannelsChanged = pyqtSignal()
@@ -101,7 +100,6 @@ class QEChannelListModel(QAbstractListModel, QtEventListener):
 
         lnchannels = self.wallet.lnworker.channels
         for channel in lnchannels.values():
-            self._logger.debug(repr(channel))
             item = self.channel_to_model(channel)
             channels.append(item)
 
@@ -120,7 +118,6 @@ class QEChannelListModel(QAbstractListModel, QtEventListener):
 
     def do_update(self, modelindex, channel):
         modelitem = self.channels[modelindex]
-        #self._logger.debug(repr(modelitem))
         modelitem.update(self.channel_to_model(channel))
 
         mi = self.createIndex(modelindex, 0)

electrum/gui/qml/qedaemon.py

@@ -232,7 +232,7 @@ class QEDaemon(AuthMixin, QObject):
     @pyqtSlot(str)
     def set_password(self, password):
         assert self._use_single_password
-        self._logger.debug('about to set password to %s for ALL wallets' % password)
+        self._logger.debug('about to set password for ALL wallets')
         self.daemon.update_password_for_directory(old_password=self._password, new_password=password)
         self._password = password
 

electrum/gui/qml/qefx.py

@@ -9,7 +9,7 @@ from electrum.simple_config import SimpleConfig
 from electrum.bitcoin import COIN
 
 from .qetypes import QEAmount
-from .util import QtEventListener, qt_event_listener
+from .util import QtEventListener, qt_event_listener, event_listener
 
 class QEFX(QObject, QtEventListener):
     def __init__(self, fxthread: FxThread, config: SimpleConfig, parent=None):
@@ -26,13 +26,13 @@ class QEFX(QObject, QtEventListener):
     def on_destroy(self):
         self.unregister_callbacks()
 
-    @qt_event_listener
+    @event_listener
     def on_event_on_quotes(self, *args):
         self._logger.debug('new quotes')
         self.quotesUpdated.emit()
 
     historyUpdated = pyqtSignal()
-    @qt_event_listener
+    @event_listener
     def on_event_on_history(self, *args):
         self._logger.debug('new history')
         self.historyUpdated.emit()

electrum/gui/qml/qewallet.py

@@ -81,15 +81,11 @@ class QEWallet(AuthMixin, QObject, QtEventListener):
         self.notification_timer.setInterval(500)  # msec
         self.notification_timer.timeout.connect(self.notify_transactions)
 
-        #self._network_signal.connect(self.on_network_qt)
-        interests = ['wallet_updated', 'new_transaction', 'status', 'verified',
-                     'on_history', 'channel', 'channels_updated', 'payment_failed',
-                     'payment_succeeded', 'invoice_status', 'request_status']
         # To avoid leaking references to "self" that prevent the
         # window from being GC-ed when closed, callbacks should be
         # methods of this class only, and specifically not be
         # partials, lambdas or methods of subobjects.  Hence...
-        #register_callback(self.on_network, interests)
+
         self.register_callbacks()
         self.destroyed.connect(lambda: self.on_destroy())
 
@@ -97,38 +93,18 @@ class QEWallet(AuthMixin, QObject, QtEventListener):
     def isUptodate(self):
         return self.wallet.is_up_to_date()
 
-    def on_network(self, event, *args):
-        if event in ['new_transaction', 'payment_succeeded']:
-            # Handle in GUI thread (_network_signal -> on_network_qt)
-            self._network_signal.emit(event, args)
-        else:
-            self.on_network_qt(event, args)
-
-    def on_network_qt(self, event, args=None):
-        # note: we get events from all wallets! args are heterogenous so we can't
-        # shortcut here
-        if event != 'status':
-            wallet = args[0]
-            if wallet == self.wallet:
-                self._logger.debug('event %s' % event)
-
     @event_listener
     def on_event_status(self, *args, **kwargs):
-        #if event == 'status':
-            self.isUptodateChanged.emit()
-
+        self.isUptodateChanged.emit()
 
-    #    elif event == 'request_status':
     @event_listener
     def on_event_request_status(self, wallet, key, status):
-            #wallet, key, status = args
         if wallet == self.wallet:
             self._logger.debug('request status %d for key %s' % (status, key))
             self.requestStatusChanged.emit(key, status)
-    #    elif event == 'invoice_status':
+
     @event_listener
     def on_event_invoice_status(self, wallet, key):
-            #wallet, key = args
         if wallet == self.wallet:
             self._logger.debug('invoice status update for key %s' % key)
             # FIXME event doesn't pass the new status, so we need to retrieve
@@ -139,7 +115,6 @@ class QEWallet(AuthMixin, QObject, QtEventListener):
             else:
                 self._logger.debug(f'No invoice found for key {key}')
 
-        #elif event == 'new_transaction':
     @qt_event_listener
     def on_event_new_transaction(self, *args):
         wallet, tx = args
@@ -147,56 +122,39 @@ class QEWallet(AuthMixin, QObject, QtEventListener):
             self.add_tx_notification(tx)
             self.historyModel.init_model() # TODO: be less dramatic
 
-
-    #    elif event == 'verified':
     @qt_event_listener
     def on_event_verified(self, wallet, txid, info):
-            #wallet, txid, info = args
         if wallet == self.wallet:
             self.historyModel.update_tx(txid, info)
 
-
-    #    elif event == 'wallet_updated':
     @event_listener
     def on_event_wallet_updated(self, wallet):
-            #wallet, = args
         if wallet == self.wallet:
             self._logger.debug('wallet %s updated' % str(wallet))
             self.balanceChanged.emit()
 
-    #    elif event == 'channel':
     @event_listener
     def on_event_channel(self, wallet, channel):
-            #wallet, channel = args
-            if wallet == self.wallet:
-                self.balanceChanged.emit()
+        if wallet == self.wallet:
+            self.balanceChanged.emit()
 
-    #    elif event == 'channels_updated':
     @event_listener
     def on_event_channels_updated(self, wallet):
-            #wallet, = args
         if wallet == self.wallet:
             self.balanceChanged.emit()
-    #    elif event == 'payment_succeeded':
 
     @qt_event_listener
     def on_event_payment_succeeded(self, wallet, key):
-            #wallet, key = args
         if wallet == self.wallet:
             self.paymentSucceeded.emit(key)
             self.historyModel.init_model() # TODO: be less dramatic
 
-    #    elif event == 'payment_failed':
     @event_listener
     def on_event_payment_failed(self, wallet, key, reason):
-            #wallet, key, reason = args
         if wallet == self.wallet:
             self.paymentFailed.emit(key, reason)
-        #else:
-            #self._logger.debug('unhandled event: %s %s' % (event, str(args)))
 
     def on_destroy(self):
-        #unregister_callback(self.on_network)
         self.unregister_callbacks()
 
     def add_tx_notification(self, tx):
@@ -545,8 +503,6 @@ class QEWallet(AuthMixin, QObject, QtEventListener):
         if storage.is_encrypted_with_hw_device():
             return
 
-        self._logger.debug(f'Ok to set password from {self.password} to {password} for wallet with path {storage.path}')
-
         try:
             self.wallet.update_password(self.password, password, encrypt_storage=True)
             self.password = password