libervia-backend: sat_frontends/quick_frontend/quick

comparison sat_frontends/quick_frontend/quick_app.py @ 4037:524856bd7b19

massive refactoring to switch from camelCase to snake_case: historically, Libervia (SàT before) was using camelCase as allowed by PEP8 when using a pre-PEP8 code, to use the same coding style as in Twisted. However, snake_case is more readable and it's better to follow PEP8 best practices, so it has been decided to move on full snake_case. Because Libervia has a huge codebase, this ended with a ugly mix of camelCase and snake_case. To fix that, this patch does a big refactoring by renaming every function and method (including bridge) that are not coming from Twisted or Wokkel, to use fully snake_case. This is a massive change, and may result in some bugs.

author	Goffi <goffi@goffi.org>
date	Sat, 08 Apr 2023 13:54:42 +0200
parents	509f7a1c67dc
children	2594e1951cf7

comparison

equal deleted inserted replaced

-:c4464d7ae97b
+:524856bd7b19
 return autodisconnect
 def plug(self):
 """Plug the profile to the host"""
 # first of all we create the contact lists
-self.host.contact_lists.addProfile(self.profile)
+self.host.contact_lists.add_profile(self.profile)
 # we get the essential params
-self.bridge.asyncGetParamA(
+self.bridge.param_get_a_async(
 "JabberID",
 "Connection",
 profile_key=self.profile,
 callback=self._plug_profile_jid,
-errback=self._getParamError,
+errback=self._get_param_error,
 )
 def _plug_profile_jid(self, jid_s):
 self.whoami = jid.JID(jid_s)  # resource might change after the connection
 log.info(f"Our current jid is: {self.whoami}")
-self.bridge.isConnected(self.profile, callback=self._plug_profile_isconnected)
+self.bridge.is_connected(self.profile, callback=self._plug_profile_isconnected)
-def _autodisconnectEb(self, failure_):
+def _autodisconnect_eb(self, failure_):
 # XXX: we ignore error on this parameter, as Libervia can't access it
 log.warning(
 _("Error while trying to get autodisconnect param, ignoring: {}").format(
 failure_
 )
 self._plug_profile_autodisconnect("false")
 def _plug_profile_isconnected(self, connected):
 self.connected = connected
 if connected:
-self.host.profileConnected(self.profile)
+self.host.profile_connected(self.profile)
-self.bridge.asyncGetParamA(
+self.bridge.param_get_a_async(
 "autodisconnect",
 "Connection",
 profile_key=self.profile,
 callback=self._plug_profile_autodisconnect,
-errback=self._autodisconnectEb,
+errback=self._autodisconnect_eb,
 )
 def _plug_profile_autodisconnect(self, autodisconnect):
 if C.bool(autodisconnect):
 self._autodisconnect = True
-self.bridge.asyncGetParamA(
+self.bridge.param_get_a_async(
 "autoconnect",
 "Connection",
 profile_key=self.profile,
 callback=self._plug_profile_autoconnect,
-errback=self._getParamError,
+errback=self._get_param_error,
 )
 def _plug_profile_autoconnect(self, value_str):
 autoconnect = C.bool(value_str)
 if autoconnect and not self.connected:
 def _plug_profile_afterconnect(self):
 # Profile can be connected or not
 # we get cached data
 self.connected = True
-self.host.bridge.getFeatures(
+self.host.bridge.features_get(
 profile_key=self.profile,
-callback=self._plug_profile_getFeaturesCb,
+callback=self._plug_profile_get_features_cb,
-errback=self._plug_profile_getFeaturesEb,
+errback=self._plug_profile_get_features_eb,
 )
-def _plug_profile_getFeaturesEb(self, failure):
+def _plug_profile_get_features_eb(self, failure):
 log.error("Couldn't get features: {}".format(failure))
-self._plug_profile_getFeaturesCb({})
+self._plug_profile_get_features_cb({})
-def _plug_profile_getFeaturesCb(self, features):
+def _plug_profile_get_features_cb(self, features):
 self.host.features = features
-self.host.bridge.getEntitiesData([], ProfileManager.cache_keys_to_get,
+self.host.bridge.entities_data_get([], ProfileManager.cache_keys_to_get,
 profile=self.profile,
-callback=self._plug_profile_gotCachedValues,
+callback=self._plug_profile_got_cached_values,
-errback=self._plug_profile_failedCachedValues)
+errback=self._plug_profile_failed_cached_values)
-def _plug_profile_failedCachedValues(self, failure):
+def _plug_profile_failed_cached_values(self, failure):
 log.error("Couldn't get cached values: {}".format(failure))
-self._plug_profile_gotCachedValues({})
+self._plug_profile_got_cached_values({})
-def _plug_profile_gotCachedValues(self, cached_values):
+def _plug_profile_got_cached_values(self, cached_values):
 contact_list = self.host.contact_lists[self.profile]
 # add the contact list and its listener
 for entity_s, data in cached_values.items():
 for key, value in data.items():
-self.host.entityDataUpdatedHandler(entity_s, key, value, self.profile)
+self.host.entity_data_updated_handler(entity_s, key, value, self.profile)
 if not self.connected:
-self.host.setPresenceStatus(C.PRESENCE_UNAVAILABLE, "", profile=self.profile)
+self.host.set_presence_status(C.PRESENCE_UNAVAILABLE, "", profile=self.profile)
 else:
 contact_list.fill()
-self.host.setPresenceStatus(profile=self.profile)
+self.host.set_presence_status(profile=self.profile)
 # The waiting subscription requests
-self.bridge.getWaitingSub(
+self.bridge.sub_waiting_get(
-self.profile, callback=self._plug_profile_gotWaitingSub
+self.profile, callback=self._plug_profile_got_waiting_sub
 )
-def _plug_profile_gotWaitingSub(self, waiting_sub):
+def _plug_profile_got_waiting_sub(self, waiting_sub):
 for sub in waiting_sub:
-self.host.subscribeHandler(waiting_sub[sub], sub, self.profile)
+self.host.subscribe_handler(waiting_sub[sub], sub, self.profile)
-self.bridge.mucGetRoomsJoined(
+self.bridge.muc_get_rooms_joined(
-self.profile, callback=self._plug_profile_gotRoomsJoined
+self.profile, callback=self._plug_profile_got_rooms_joined
 )
-def _plug_profile_gotRoomsJoined(self, rooms_args):
+def _plug_profile_got_rooms_joined(self, rooms_args):
 # Now we open the MUC window where we already are:
 for room_args in rooms_args:
-self.host.mucRoomJoinedHandler(*room_args, profile=self.profile)
+self.host.muc_room_joined_handler(*room_args, profile=self.profile)
 # Presence must be requested after rooms are filled
-self.host.bridge.getPresenceStatuses(
+self.host.bridge.presence_statuses_get(
-self.profile, callback=self._plug_profile_gotPresences
+self.profile, callback=self._plug_profile_got_presences
 )
-def _plug_profile_gotPresences(self, presences):
+def _plug_profile_got_presences(self, presences):
 for contact in presences:
 for res in presences[contact]:
 jabber_id = ("%s/%s" % (jid.JID(contact).bare, res)) if res else contact
 show = presences[contact][res][0]
 priority = presences[contact][res][1]
 statuses = presences[contact][res][2]
-self.host.presenceUpdateHandler(
+self.host.presence_update_handler(
 jabber_id, show, priority, statuses, self.profile
 )
 # At this point, profile should be fully plugged
 # and we launch frontend specific method
-self.host.profilePlugged(self.profile)
+self.host.profile_plugged(self.profile)
-def _getParamError(self, failure):
+def _get_param_error(self, failure):
 log.error(_("Can't get profile parameter: {msg}").format(msg=failure))
 class ProfilesManager(object):
 """Class managing collection of profiles"""
 host = self._profiles[profile].host
 host.contact_lists[profile].unplug()
 del self._profiles[profile]
-def chooseOneProfile(self):
+def choose_one_profile(self):
 return list(self._profiles.keys())[0]
 class QuickApp(object):
 """This class contain the main methods needed for the frontend"""
 AUTO_RESYNC = True
 def __init__(self, bridge_factory, xmlui, check_options=None, connect_bridge=True):
 """Create a frontend application
-@param bridge_factory: method to use to create the Bridge
+@param bridge_factory: method to use to create the bridge
 @param xmlui: xmlui module
 @param check_options: method to call to check options (usually command line
 arguments)
 """
 self.xmlui = xmlui
 ## bridge ##
 self.bridge = bridge_factory()
 ProfileManager.bridge = self.bridge
 if connect_bridge:
-self.connectBridge()
+self.connect_bridge()
 # frontend notifications
 self._notif_id = 0
 self._notifications = {}
 # watched progresses and associated callbacks
 #: available encryptions
 self.encryption_plugins = []
 # state of synchronisation with backend
 self._sync = True
-def connectBridge(self):
+def connect_bridge(self):
-self.bridge.bridgeConnect(callback=self._bridgeCb, errback=self._bridgeEb)
+self.bridge.bridge_connect(callback=self._bridge_cb, errback=self._bridge_eb)
-def _namespacesGetCb(self, ns_map):
+def _namespaces_get_cb(self, ns_map):
 self.ns_map = ns_map
-def _namespacesGetEb(self, failure_):
+def _namespaces_get_eb(self, failure_):
 log.error(_("Can't get namespaces map: {msg}").format(msg=failure_))
-def _encryptionPluginsGetCb(self, plugins_ser):
+def _encryption_plugins_get_cb(self, plugins_ser):
 self.encryption_plugins = data_format.deserialise(plugins_ser, type_check=list)
-def _encryptionPluginsGetEb(self, failure_):
+def _encryption_plugins_get_eb(self, failure_):
 log.warning(_("Can't retrieve encryption plugins: {msg}").format(msg=failure_))
-def onBridgeConnected(self):
+def on_bridge_connected(self):
-self.bridge.getReady(self.onBackendReady)
+self.bridge.ready_get(self.on_backend_ready)
-def _bridgeCb(self):
+def _bridge_cb(self):
-self.registerSignal("connected")
+self.register_signal("connected")
-self.registerSignal("disconnected")
+self.register_signal("disconnected")
-self.registerSignal("actionNew")
+self.register_signal("action_new")
-self.registerSignal("newContact")
+self.register_signal("contact_new")
-self.registerSignal("messageNew")
+self.register_signal("message_new")
 if self.ENCRYPTION_HANDLERS:
-self.registerSignal("messageEncryptionStarted")
+self.register_signal("message_encryption_started")
-self.registerSignal("messageEncryptionStopped")
+self.register_signal("message_encryption_stopped")
-self.registerSignal("presenceUpdate")
+self.register_signal("presence_update")
-self.registerSignal("subscribe")
+self.register_signal("subscribe")
-self.registerSignal("paramUpdate")
+self.register_signal("param_update")
-self.registerSignal("contactDeleted")
+self.register_signal("contact_deleted")
-self.registerSignal("entityDataUpdated")
+self.register_signal("entity_data_updated")
-self.registerSignal("progressStarted")
+self.register_signal("progress_started")
-self.registerSignal("progressFinished")
+self.register_signal("progress_finished")
-self.registerSignal("progressError")
+self.register_signal("progress_error")
-self.registerSignal("mucRoomJoined", iface="plugin")
+self.register_signal("muc_room_joined", iface="plugin")
-self.registerSignal("mucRoomLeft", iface="plugin")
+self.register_signal("muc_room_left", iface="plugin")
-self.registerSignal("mucRoomUserChangedNick", iface="plugin")
+self.register_signal("muc_room_user_changed_nick", iface="plugin")
-self.registerSignal("mucRoomNewSubject", iface="plugin")
+self.register_signal("muc_room_new_subject", iface="plugin")
-self.registerSignal("chatStateReceived", iface="plugin")
+self.register_signal("chat_state_received", iface="plugin")
-self.registerSignal("messageState", iface="plugin")
+self.register_signal("message_state", iface="plugin")
-self.registerSignal("psEvent", iface="plugin")
+self.register_signal("ps_event", iface="plugin")
 # useful for debugging
-self.registerSignal("_debug", iface="core")
+self.register_signal("_debug", iface="core")
 # FIXME: do it dynamically
-quick_games.Tarot.registerSignals(self)
+quick_games.Tarot.register_signals(self)
-quick_games.Quiz.registerSignals(self)
+quick_games.Quiz.register_signals(self)
-quick_games.Radiocol.registerSignals(self)
+quick_games.Radiocol.register_signals(self)
-self.onBridgeConnected()
+self.on_bridge_connected()
-def _bridgeEb(self, failure):
+def _bridge_eb(self, failure):
 if isinstance(failure, exceptions.BridgeExceptionNoService):
 print((_("Can't connect to SàT backend, are you sure it's launched ?")))
 sys.exit(C.EXIT_BACKEND_NOT_FOUND)
 elif isinstance(failure, exceptions.BridgeInitError):
 print((_("Can't init bridge")))
 sys.exit(C.EXIT_BRIDGE_ERROR)
 else:
 print((_("Error while initialising bridge: {}".format(failure))))
-def onBackendReady(self):
+def on_backend_ready(self):
 log.info("backend is ready")
-self.bridge.namespacesGet(
+self.bridge.namespaces_get(
-callback=self._namespacesGetCb, errback=self._namespacesGetEb)
+callback=self._namespaces_get_cb, errback=self._namespaces_get_eb)
 # we cache available encryption plugins, as we'll use them on each
 # new chat widget
-self.bridge.encryptionPluginsGet(
+self.bridge.encryption_plugins_get(
-callback=self._encryptionPluginsGetCb,
+callback=self._encryption_plugins_get_cb,
-errback=self._encryptionPluginsGetEb)
+errback=self._encryption_plugins_get_eb)
 @property
 def current_profile(self):
 """Profile that a user would expect to use"""
 try:
 return self.selected_widget.profile
 except (TypeError, AttributeError):
-return self.profiles.chooseOneProfile()
+return self.profiles.choose_one_profile()
 @property
 def visible_widgets(self):
 """Widgets currently visible
 """
 if self._selected_widget == wid:
 return
 self._selected_widget = wid
 try:
-onSelected = wid.onSelected
+on_selected = wid.on_selected
 except AttributeError:
 pass
 else:
-onSelected()
+on_selected()
-self.callListeners("selected", wid)
+self.call_listeners("selected", wid)
 # backend state management
 @property
 def sync(self):
 try:
 w.sync = False
 except AttributeError:
 pass
-def registerSignal(
+def register_signal(
 self, function_name, handler=None, iface="core", with_profile=True
 ):
 """Register a handler for a signal
 @param function_name (str): name of the signal to handle
 @param with_profile (boolean): True if the signal concerns a specific profile,
 in that case the profile name has to be passed by the caller
 """
 log.debug("registering signal {name}".format(name=function_name))
 if handler is None:
-handler = getattr(self, "{}{}".format(function_name, "Handler"))
+handler = getattr(self, "{}{}".format(function_name, "_handler"))
 if not with_profile:
 self.bridge.register_signal(function_name, handler, iface)
 return
-def signalReceived(*args, **kwargs):
+def signal_received(*args, **kwargs):
 profile = kwargs.get("profile")
 if profile is None:
 if not args:
 raise exceptions.ProfileNotSetError
 profile = args[-1]
 (function_name, handler, args, kwargs)
 )
 return  # we ignore signal for profiles we don't manage
 handler(*args, **kwargs)
-self.bridge.register_signal(function_name, signalReceived, iface)
+self.bridge.register_signal(function_name, signal_received, iface)
 def addListener(self, type_, callback, profiles_filter=None):
 """Add a listener for an event
 /!\ don't forget to remove listener when not used anymore (e.g. if you delete a
 - widgetDeleted: all instances of a widget with specific hash have been
 deleted
 args: (widget_deleted,)
 - menu: called when a menu item is added or removed
 args: (type_, path, path_i18n, item) were values are:
-type_: same as in [sat.core.sat_main.SAT.importMenu]
+type_: same as in [sat.core.sat_main.SAT.import_menu]
-path: same as in [sat.core.sat_main.SAT.importMenu]
+path: same as in [sat.core.sat_main.SAT.import_menu]
 path_i18n: translated path (or None if the item is removed)
 item: instance of quick_menus.MenuItemBase or None if the item is
 removed
 - gotMenus: called only once when menu are available (no arg)
-- progressFinished: called when a progressing action has just finished
+- progress_finished: called when a progressing action has just finished
 args:  (progress_id, metadata, profile)
-- progressError: called when a progressing action failed
+- progress_error: called when a progressing action failed
 args: (progress_id, error_msg, profile):
 @param callback: method to call on event
 @param profiles_filter (set[unicode]): if set and not empty, the
 listener will be callable only by one of the given profiles.
 """
 if not ignore_missing:
 log.error(
 f"Trying to remove an inexisting listener (type = {type_}): "
 f"{callback}")
-def callListeners(self, type_, *args, **kwargs):
+def call_listeners(self, type_, *args, **kwargs):
 """Call the methods which listen type_ event. If a profiles filter has
 been register with a listener and profile argument is not None, the
 listener will be called only if profile is in the profiles filter list.
 @param type_: same as for [addListener]
 def check_profile(self, profile):
 """Tell if the profile is currently followed by the application, and ready"""
 return profile in self.ready_profiles
-def postInit(self, profile_manager):
+def post_init(self, profile_manager):
 """Must be called after initialization is done, do all automatic task
 (auto plug profile)
 @param profile_manager: instance of a subclass of
 Quick_frontend.QuickProfileManager
 """
 if self.options and self.options.profile:
 profile_manager.autoconnect([self.options.profile])
-def profilePlugged(self, profile):
+def profile_plugged(self, profile):
 """Method called when the profile is fully plugged
 This will launch frontend specific workflow
 /!\ if you override the method and don't call the parent, be sure to add the
 "Calling cached signal [%s] with args %s and kwargs %s"
 % (function_name, args, kwargs)
 )
 handler(*args, **kwargs)
-self.callListeners("profilePlugged", profile=profile)
+self.call_listeners("profile_plugged", profile=profile)
 if not self._plugs_in_progress:
-self.contact_lists.lockUpdate(False)
+self.contact_lists.lock_update(False)
-def profileConnected(self, profile):
+def profile_connected(self, profile):
 """Called when a plugged profile is connected
-it is called independently of profilePlugged (may be called before or after
+it is called independently of profile_plugged (may be called before or after
-profilePlugged)
+profile_plugged)
 """
 pass
 def connect(self, profile, callback=None, errback=None):
 if not callback:
 fullname = "error"
 if (
 module.startswith("twisted.words.protocols.jabber")
 and failure.condition == "not-authorized"
 ):
-self.launchAction(C.CHANGE_XMPP_PASSWD_ID, {}, profile=profile)
+self.action_launch(C.CHANGE_XMPP_PASSWD_ID, {}, profile=profile)
 else:
-self.showDialog(message, fullname, "error")
+self.show_dialog(message, fullname, "error")
 self.bridge.connect(profile, callback=callback, errback=errback)
 def plug_profiles(self, profiles):
 """Tell application which profiles must be used
 @param profiles: list of valid profile names
 """
-self.contact_lists.lockUpdate()
+self.contact_lists.lock_update()
 self._plugs_in_progress.update(profiles)
 self.plugging_profiles()
 for profile in profiles:
 self.profiles.plug(profile)
 self.profiles.unplug(profile)
 def clear_profile(self):
 self.profiles.clear()
-def newWidget(self, widget):
+def new_widget(self, widget):
 raise NotImplementedError
 # bridge signals hanlers
-def connectedHandler(self, jid_s, profile):
+def connected_handler(self, jid_s, profile):
 """Called when the connection is made.
 @param jid_s (unicode): the JID that we were assigned by the server,
 as the resource might differ from the JID we asked for.
 """
 log.debug(_("Connected"))
 self.profiles[profile].whoami = jid.JID(jid_s)
-self.setPresenceStatus(profile=profile)
+self.set_presence_status(profile=profile)
 # FIXME: fill() is already called for all profiles when doing self.sync = True
 #        a per-profile fill() should be done once, see below note
 self.contact_lists[profile].fill()
 # if we were already displaying widgets, they must be resynchronized
 # FIXME: self.sync is for all profiles
 #        while (dis)connection is per-profile.
 #        A mechanism similar to sync should be available
 #        on a per-profile basis
 self.sync = True
-self.profileConnected(profile)
+self.profile_connected(profile)
-def disconnectedHandler(self, profile):
+def disconnected_handler(self, profile):
 """called when the connection is closed"""
 log.debug(_("Disconnected"))
 self.contact_lists[profile].disconnect()
-# FIXME: see note on connectedHandler
+# FIXME: see note on connected_handler
 self.sync = False
-self.setPresenceStatus(C.PRESENCE_UNAVAILABLE, "", profile=profile)
+self.set_presence_status(C.PRESENCE_UNAVAILABLE, "", profile=profile)
-def actionNewHandler(self, action_data, id_, security_limit, profile):
+def action_new_handler(self, action_data, id_, security_limit, profile):
-self.actionManager(action_data, user_action=False, profile=profile)
+self.action_manager(action_data, user_action=False, profile=profile)
-def newContactHandler(self, jid_s, attributes, groups, profile):
+def contact_new_handler(self, jid_s, attributes, groups, profile):
 entity = jid.JID(jid_s)
 groups = list(groups)
-self.contact_lists[profile].setContact(entity, groups, attributes, in_roster=True)
+self.contact_lists[profile].set_contact(entity, groups, attributes, in_roster=True)
-def messageNewHandler(
+def message_new_handler(
 self, uid, timestamp, from_jid_s, to_jid_s, msg, subject, type_, extra_s,
 profile):
 from_jid = jid.JID(from_jid_s)
 to_jid = jid.JID(to_jid_s)
 extra = data_format.deserialise(extra_s)
 mess_to_jid = to_jid if from_me else from_jid
 target = mess_to_jid.bare
 contact_list = self.contact_lists[profile]
 try:
-is_room = contact_list.isRoom(target)
+is_room = contact_list.is_room(target)
 except exceptions.NotFound:
 is_room = False
 if target.resource and not is_room:
 # we avoid resource locking, but we must keep resource for private MUC
 # messages
 target = target
 # we want to be sure to have at least one QuickChat instance
-self.widgets.getOrCreateWidget(
+self.widgets.get_or_create_widget(
 quick_chat.QuickChat,
 target,
 type_ = C.CHAT_GROUP if is_room else C.CHAT_ONE2ONE,
 on_new_widget = None,
 profile = profile,
 not from_jid in contact_list
 and from_jid.bare != self.profiles[profile].whoami.bare
 ):
 # XXX: needed to show entities which haven't sent any
 #     presence information and which are not in roster
-contact_list.setContact(from_jid)
+contact_list.set_contact(from_jid)
 # we dispatch the message in the widgets
-for widget in self.widgets.getWidgets(
+for widget in self.widgets.get_widgets(
 quick_chat.QuickChat, target=target, profiles=(profile,)
 ):
-widget.messageNew(
+widget.message_new(
 uid, timestamp, from_jid, mess_to_jid, msg, subject, type_, extra, profile
 )
-def messageEncryptionStartedHandler(self, destinee_jid_s, plugin_data, profile):
+def message_encryption_started_handler(self, destinee_jid_s, plugin_data, profile):
 destinee_jid = jid.JID(destinee_jid_s)
 plugin_data = data_format.deserialise(plugin_data)
-for widget in self.widgets.getWidgets(quick_chat.QuickChat,
+for widget in self.widgets.get_widgets(quick_chat.QuickChat,
 target=destinee_jid.bare,
 profiles=(profile,)):
-widget.messageEncryptionStarted(plugin_data)
+widget.message_encryption_started(plugin_data)
-def messageEncryptionStoppedHandler(self, destinee_jid_s, plugin_data, profile):
+def message_encryption_stopped_handler(self, destinee_jid_s, plugin_data, profile):
 destinee_jid = jid.JID(destinee_jid_s)
-for widget in self.widgets.getWidgets(quick_chat.QuickChat,
+for widget in self.widgets.get_widgets(quick_chat.QuickChat,
 target=destinee_jid.bare,
 profiles=(profile,)):
-widget.messageEncryptionStopped(plugin_data)
+widget.message_encryption_stopped(plugin_data)
-def messageStateHandler(self, uid, status, profile):
+def message_state_handler(self, uid, status, profile):
-for widget in self.widgets.getWidgets(quick_chat.QuickChat, profiles=(profile,)):
+for widget in self.widgets.get_widgets(quick_chat.QuickChat, profiles=(profile,)):
-widget.onMessageState(uid, status, profile)
+widget.on_message_state(uid, status, profile)
-def messageSend(self, to_jid, message, subject=None, mess_type="auto", extra=None, callback=None, errback=None, profile_key=C.PROF_KEY_NONE):
+def message_send(self, to_jid, message, subject=None, mess_type="auto", extra=None, callback=None, errback=None, profile_key=C.PROF_KEY_NONE):
 if not subject and not extra and (not message or message == {'': ''}):
 log.debug("Not sending empty message")
 return
 if subject is None:
 callback = (
 lambda __=None: None
 )  # FIXME: optional argument is here because pyjamas doesn't support callback
 #        without arg with json proxy
 if errback is None:
-errback = lambda failure: self.showDialog(
+errback = lambda failure: self.show_dialog(
 message=failure.message, title=failure.fullname, type="error"
 )
 if not self.trigger.point("messageSendTrigger", to_jid, message, subject, mess_type, extra, callback, errback, profile_key=profile_key):
 return
-self.bridge.messageSend(
+self.bridge.message_send(
 str(to_jid),
 message,
 subject,
 mess_type,
 data_format.serialise(extra),
 profile_key,
 callback=callback,
 errback=errback,
 )
-def setPresenceStatus(self, show="", status=None, profile=C.PROF_KEY_NONE):
+def set_presence_status(self, show="", status=None, profile=C.PROF_KEY_NONE):
 raise NotImplementedError
-def presenceUpdateHandler(self, entity_s, show, priority, statuses, profile):
+def presence_update_handler(self, entity_s, show, priority, statuses, profile):
 # XXX: this log is commented because it's really too verbose even for DEBUG logs
 #      but it is kept here as it may still be useful for troubleshooting
 # log.debug(
 #     _(
 #         u"presence update for %(entity)s (show=%(show)s, priority=%(priority)s, "
 # )
 entity = jid.JID(entity_s)
 if entity == self.profiles[profile].whoami:
 if show == C.PRESENCE_UNAVAILABLE:
-self.setPresenceStatus(C.PRESENCE_UNAVAILABLE, "", profile=profile)
+self.set_presence_status(C.PRESENCE_UNAVAILABLE, "", profile=profile)
 else:
 # FIXME: try to retrieve user language status before fallback to default
 status = statuses.get(C.PRESENCE_STATUSES_DEFAULT, None)
-self.setPresenceStatus(show, status, profile=profile)
+self.set_presence_status(show, status, profile=profile)
 return
-self.callListeners("presence", entity, show, priority, statuses, profile=profile)
+self.call_listeners("presence", entity, show, priority, statuses, profile=profile)
-def mucRoomJoinedHandler(
+def muc_room_joined_handler(
 self, room_jid_s, occupants, user_nick, subject, statuses, profile):
 """Called when a MUC room is joined"""
 log.debug(
 "Room [{room_jid}] joined by {profile}, users presents:{users}".format(
 room_jid=room_jid_s, profile=profile, users=list(occupants.keys())
 )
 )
 room_jid = jid.JID(room_jid_s)
-self.contact_lists[profile].setSpecial(room_jid, C.CONTACT_SPECIAL_GROUP)
+self.contact_lists[profile].set_special(room_jid, C.CONTACT_SPECIAL_GROUP)
-self.widgets.getOrCreateWidget(
+self.widgets.get_or_create_widget(
 quick_chat.QuickChat,
 room_jid,
 type_=C.CHAT_GROUP,
 nick=user_nick,
 occupants=occupants,
 subject=subject,
 statuses=statuses,
 profile=profile,
 )
-def mucRoomLeftHandler(self, room_jid_s, profile):
+def muc_room_left_handler(self, room_jid_s, profile):
 """Called when a MUC room is left"""
 log.debug(
 "Room [%(room_jid)s] left by %(profile)s"
 % {"room_jid": room_jid_s, "profile": profile}
 )
 room_jid = jid.JID(room_jid_s)
-chat_widget = self.widgets.getWidget(quick_chat.QuickChat, room_jid, profile)
+chat_widget = self.widgets.get_widget(quick_chat.QuickChat, room_jid, profile)
 if chat_widget:
-self.widgets.deleteWidget(
+self.widgets.delete_widget(
 chat_widget, all_instances=True, explicit_close=True)
-self.contact_lists[profile].removeContact(room_jid)
+self.contact_lists[profile].remove_contact(room_jid)
-def mucRoomUserChangedNickHandler(self, room_jid_s, old_nick, new_nick, profile):
+def muc_room_user_changed_nick_handler(self, room_jid_s, old_nick, new_nick, profile):
 """Called when an user joined a MUC room"""
 room_jid = jid.JID(room_jid_s)
-chat_widget = self.widgets.getOrCreateWidget(
+chat_widget = self.widgets.get_or_create_widget(
 quick_chat.QuickChat, room_jid, type_=C.CHAT_GROUP, profile=profile
 )
-chat_widget.changeUserNick(old_nick, new_nick)
+chat_widget.change_user_nick(old_nick, new_nick)
 log.debug(
 "user [%(old_nick)s] is now known as [%(new_nick)s] in room [%(room_jid)s]"
 % {"old_nick": old_nick, "new_nick": new_nick, "room_jid": room_jid}
 )
-def mucRoomNewSubjectHandler(self, room_jid_s, subject, profile):
+def muc_room_new_subject_handler(self, room_jid_s, subject, profile):
 """Called when subject of MUC room change"""
 room_jid = jid.JID(room_jid_s)
-chat_widget = self.widgets.getOrCreateWidget(
+chat_widget = self.widgets.get_or_create_widget(
 quick_chat.QuickChat, room_jid, type_=C.CHAT_GROUP, profile=profile
 )
-chat_widget.setSubject(subject)
+chat_widget.set_subject(subject)
 log.debug(
 "new subject for room [%(room_jid)s]: %(subject)s"
 % {"room_jid": room_jid, "subject": subject}
 )
-def chatStateReceivedHandler(self, from_jid_s, state, profile):
+def chat_state_received_handler(self, from_jid_s, state, profile):
 """Called when a new chat state (XEP-0085) is received.
 @param from_jid_s (unicode): JID of a contact or C.ENTITY_ALL
 @param state (unicode): new state
 @param profile (unicode): current profile
 """
 from_jid = jid.JID(from_jid_s)
-for widget in self.widgets.getWidgets(quick_chat.QuickChat, target=from_jid.bare,
+for widget in self.widgets.get_widgets(quick_chat.QuickChat, target=from_jid.bare,
 profiles=(profile,)):
-widget.onChatState(from_jid, state, profile)
+widget.on_chat_state(from_jid, state, profile)
 def notify(self, type_, entity=None, message=None, subject=None, callback=None,
 cb_args=None, widget=None, profile=C.PROF_KEY_NONE):
 """Trigger an event notification
 if widget is not None:
 notif_data[widget] = widget
 type_notifs.append(notif_data)
 self._notifications[self._notif_id] = notif_data
 self._notif_id += 1
-self.callListeners("notification", entity, notif_data, profile=profile)
+self.call_listeners("notification", entity, notif_data, profile=profile)
-def getNotifs(self, entity=None, type_=None, exact_jid=None, profile=C.PROF_KEY_NONE):
+def get_notifs(self, entity=None, type_=None, exact_jid=None, profile=C.PROF_KEY_NONE):
 """return notifications for given entity
 @param entity(jid.JID, None, C.ENTITY_ALL): jid of the entity to check
 bare jid to get all notifications, full jid to filter on resource
 None to get general notifications
 for notif in notifs:
 if exact_jid and notif["entity"] != entity:
 continue
 yield notif
-def clearNotifs(self, entity, type_=None, profile=C.PROF_KEY_NONE):
+def clear_notifs(self, entity, type_=None, profile=C.PROF_KEY_NONE):
 """return notifications for given entity
 @param entity(jid.JID, None): bare jid of the entity to check
 None to clear general notifications (but keep entities ones)
 @param type_(unicode, None): notification type to filter
 del notif_dict[key]
 else:
 del notif_dict[key][type_]
 except KeyError:
 return
-self.callListeners("notificationsClear", entity, type_, profile=profile)
+self.call_listeners("notificationsClear", entity, type_, profile=profile)
-def psEventHandler(self, category, service_s, node, event_type, data, profile):
+def ps_event_handler(self, category, service_s, node, event_type, data, profile):
 """Called when a PubSub event is received.
 @param category(unicode): event category (e.g. "PEP", "MICROBLOG")
 @param service_s (unicode): pubsub service
 @param node (unicode): pubsub node
 return
 # FIXME: check if [] make sense (instead of None)
 _groups = data.get("group")
-for wid in self.widgets.getWidgets(quick_blog.QuickBlog):
+for wid in self.widgets.get_widgets(quick_blog.QuickBlog):
-wid.addEntryIfAccepted(service_s, node, data, _groups, profile)
+wid.add_entry_if_accepted(service_s, node, data, _groups, profile)
 try:
 comments_node, comments_service = (
 data["comments_node"],
 data["comments_service"],
 )
 except KeyError:
 pass
 else:
-self.bridge.mbGet(
+self.bridge.mb_get(
 comments_service,
 comments_node,
 C.NO_LIMIT,
 [],
 {"subscribe": C.BOOL_TRUE},
 profile=profile,
 )
 elif event_type == C.PS_RETRACT:
-for wid in self.widgets.getWidgets(quick_blog.QuickBlog):
+for wid in self.widgets.get_widgets(quick_blog.QuickBlog):
-wid.deleteEntryIfPresent(service_s, node, data["id"], profile)
+wid.delete_entry_if_present(service_s, node, data["id"], profile)
 pass
 else:
 log.warning("Unmanaged PubSub event type {}".format(event_type))
-def registerProgressCbs(self, progress_id, callback, errback):
+def register_progress_cbs(self, progress_id, callback, errback):
 """Register progression callbacks
 @param progress_id(unicode): id of the progression to check
 @param callback(callable, None): method to call when progressing action
 successfuly finished.
 None to ignore
 """
 callbacks = self._progress_ids.setdefault(progress_id, [])
 callbacks.append((callback, errback))
-def progressStartedHandler(self, pid, metadata, profile):
+def progress_started_handler(self, pid, metadata, profile):
 log.info("Progress {} started".format(pid))
-def progressFinishedHandler(self, pid, metadata, profile):
+def progress_finished_handler(self, pid, metadata, profile):
 log.info("Progress {} finished".format(pid))
 try:
 callbacks = self._progress_ids.pop(pid)
 except KeyError:
 pass
 else:
 for callback, __ in callbacks:
 if callback is not None:
 callback(metadata, profile=profile)
-self.callListeners("progressFinished", pid, metadata, profile=profile)
+self.call_listeners("progress_finished", pid, metadata, profile=profile)
-def progressErrorHandler(self, pid, err_msg, profile):
+def progress_error_handler(self, pid, err_msg, profile):
 log.warning("Progress {pid} error: {err_msg}".format(pid=pid, err_msg=err_msg))
 try:
 callbacks = self._progress_ids.pop(pid)
 except KeyError:
 pass
 else:
 for __, errback in callbacks:
 if errback is not None:
 errback(err_msg, profile=profile)
-self.callListeners("progressError", pid, err_msg, profile=profile)
+self.call_listeners("progress_error", pid, err_msg, profile=profile)
 def _subscribe_cb(self, answer, data):
 entity, profile = data
 type_ = "subscribed" if answer else "unsubscribed"
 self.bridge.subscription(type_, str(entity.bare), profile_key=profile)
-def subscribeHandler(self, type, raw_jid, profile):
+def subscribe_handler(self, type, raw_jid, profile):
 """Called when a subsciption management signal is received"""
 entity = jid.JID(raw_jid)
 if type == "subscribed":
 # this is a subscription confirmation, we just have to inform user
 # TODO: call self.getEntityMBlog to add the new contact blogs
-self.showDialog(
+self.show_dialog(
 _("The contact {contact} has accepted your subscription").format(
 contact=entity.bare
 ),
 _("Subscription confirmation"),
 )
 elif type == "unsubscribed":
 # this is a subscription refusal, we just have to inform user
-self.showDialog(
+self.show_dialog(
 _("The contact {contact} has refused your subscription").format(
 contact=entity.bare
 ),
 _("Subscription refusal"),
 "error",
 )
 elif type == "subscribe":
 # this is a subscriptionn request, we have to ask for user confirmation
 # TODO: use sat.stdui.ui_contact_list to display the groups selector
-self.showDialog(
+self.show_dialog(
 _(
 "The contact {contact} wants to subscribe to your presence"
 ".\nDo you accept ?"
 ).format(contact=entity.bare),
 _("Subscription confirmation"),
 "yes/no",
 answer_cb=self._subscribe_cb,
 answer_data=(entity, profile),
 )
-def _debugHandler(self, action, parameters, profile):
+def _debug_handler(self, action, parameters, profile):
 if action == "widgets_dump":
 from pprint import pformat
 log.info("Widgets dump:\n{data}".format(data=pformat(self.widgets._widgets)))
 else:
 log.warning("Unknown debug action: {action}".format(action=action))
-def showDialog(self, message, title, type="info", answer_cb=None, answer_data=None):
+def show_dialog(self, message, title, type="info", answer_cb=None, answer_data=None):
 """Show a dialog to user
 Frontends must override this method
 @param message(unicode): body of the dialog
 @param title(unicode): title of the dialog
 @param answer_data(object): data to link on callback
 """
 # FIXME: misnamed method + types are not well chosen. Need to be rethought
 raise NotImplementedError
-def showAlert(self, message):
+def show_alert(self, message):
 # FIXME: doesn't seems used anymore, to remove?
 pass  # FIXME
-def dialogFailure(self, failure):
+def dialog_failure(self, failure):
 log.warning("Failure: {}".format(failure))
-def progressIdHandler(self, progress_id, profile):
+def progress_id_handler(self, progress_id, profile):
 """Callback used when an action result in a progress id"""
 log.info("Progress ID received: {}".format(progress_id))
-def isHidden(self):
+def is_hidden(self):
 """Tells if the frontend window is hidden.
 @return bool
 """
 raise NotImplementedError
-def paramUpdateHandler(self, name, value, namespace, profile):
+def param_update_handler(self, name, value, namespace, profile):
 log.debug(
 _("param update: [%(namespace)s] %(name)s = %(value)s")
 % {"namespace": namespace, "name": name, "value": value}
 )
 if (namespace, name) == ("Connection", "JabberID"):
 log.debug(_("Changing JID to %s") % value)
 self.profiles[profile].whoami = jid.JID(value)
 elif (namespace, name) == ("General", C.SHOW_OFFLINE_CONTACTS):
-self.contact_lists[profile].showOfflineContacts(C.bool(value))
+self.contact_lists[profile].show_offline_contacts(C.bool(value))
 elif (namespace, name) == ("General", C.SHOW_EMPTY_GROUPS):
-self.contact_lists[profile].showEmptyGroups(C.bool(value))
+self.contact_lists[profile].show_empty_groups(C.bool(value))
-def contactDeletedHandler(self, jid_s, profile):
+def contact_deleted_handler(self, jid_s, profile):
 target = jid.JID(jid_s)
-self.contact_lists[profile].removeContact(target)
+self.contact_lists[profile].remove_contact(target)
-def entityDataUpdatedHandler(self, entity_s, key, value_raw, profile):
+def entity_data_updated_handler(self, entity_s, key, value_raw, profile):
 entity = jid.JID(entity_s)
 value = data_format.deserialise(value_raw, type_check=None)
 if key == "nicknames":
 assert isinstance(value, list) or value is None
 if entity in self.contact_lists[profile]:
-self.contact_lists[profile].setCache(entity, "nicknames", value)
+self.contact_lists[profile].set_cache(entity, "nicknames", value)
-self.callListeners("nicknames", entity, value, profile=profile)
+self.call_listeners("nicknames", entity, value, profile=profile)
 elif key == "avatar" and self.AVATARS_HANDLER:
 assert isinstance(value, dict) or value is None
-self.contact_lists[profile].setCache(entity, "avatar", value)
+self.contact_lists[profile].set_cache(entity, "avatar", value)
-self.callListeners("avatar", entity, value, profile=profile)
+self.call_listeners("avatar", entity, value, profile=profile)
-def actionManager(self, action_data, callback=None, ui_show_cb=None, user_action=True,
+def action_manager(self, action_data, callback=None, ui_show_cb=None, user_action=True,
 progress_cb=None, progress_eb=None, profile=C.PROF_KEY_NONE):
 """Handle backend action
-@param action_data(dict): action dict as sent by launchAction or returned by an
+@param action_data(dict): action dict as sent by action_launch or returned by an
 UI action
 @param callback(None, callback): if not None, callback to use on XMLUI answer
 @param ui_show_cb(None, callback): if not None, method to call to show the XMLUI
 @param user_action(bool): if True, the action is a result of a user interaction
-else the action come from backend direclty (i.e. actionNew).
+else the action come from backend direclty (i.e. action_new).
 This is useful to know if the frontend can display a popup immediately (if
 True) or if it should add it to a queue that the user can activate later.
 @param progress_cb(None, callable): method to call when progression is finished.
 Only make sense if a progress is expected in this action
 @param progress_eb(None, callable): method to call when something went wrong
 progress_id = action_data.pop("progress")
 except KeyError:
 pass
 else:
 if progress_cb or progress_eb:
-self.registerProgressCbs(progress_id, progress_cb, progress_eb)
+self.register_progress_cbs(progress_id, progress_cb, progress_eb)
-self.progressIdHandler(progress_id, profile)
+self.progress_id_handler(progress_id, profile)
 # we ignore metadata
 action_data = {
 k: v for k, v in action_data.items() if not k.startswith("meta_")
 }
 "Not all keys in action_data are managed ({keys})".format(
 keys=", ".join(list(action_data.keys()))
 )
 )
-def _actionCb(self, data, callback, callback_id, profile):
+def _action_cb(self, data, callback, callback_id, profile):
 if callback is None:
-self.actionManager(data, profile=profile)
+self.action_manager(data, profile=profile)
 else:
 callback(data=data, cb_id=callback_id, profile=profile)
-def launchAction(
+def action_launch(
 self, callback_id, data=None, callback=None, profile=C.PROF_KEY_NONE
 ):
 """Launch a dynamic action
 @param callback_id: id of the action to launch
 @param data: data needed only for certain actions
 @param callback(callable, None): will be called with the resut
-if None, self.actionManager will be called
+if None, self.action_manager will be called
 else the callable will be called with the following kw parameters:
 - data: action_data
 - cb_id: callback id
 - profile: %(doc_profile)s
 @param profile: %(doc_profile)s
 """
 if data is None:
 data = dict()
-action_cb = lambda data: self._actionCb(data, callback, callback_id, profile)
+action_cb = lambda data: self._action_cb(data, callback, callback_id, profile)
-self.bridge.launchAction(
+self.bridge.action_launch(
-callback_id, data, profile, callback=action_cb, errback=self.dialogFailure
+callback_id, data, profile, callback=action_cb, errback=self.dialog_failure
 )
-def launchMenu(
+def launch_menu(
 self,
 menu_type,
 path,
 data=None,
 callback=None,
 @param menu_type(unicode): type of the menu to launch
 @param path(iterable[unicode]): path to the menu
 @param data: data needed only for certain actions
 @param callback(callable, None): will be called with the resut
-if None, self.actionManager will be called
+if None, self.action_manager will be called
 else the callable will be called with the following kw parameters:
 - data: action_data
 - cb_id: (menu_type, path) tuple
 - profile: %(doc_profile)s
 @param profile: %(doc_profile)s
 """
 if data is None:
 data = dict()
-action_cb = lambda data: self._actionCb(
+action_cb = lambda data: self._action_cb(
 data, callback, (menu_type, path), profile
 )
-self.bridge.menuLaunch(
+self.bridge.menu_launch(
 menu_type,
 path,
 data,
 security_limit,
 profile,
 callback=action_cb,
-errback=self.dialogFailure,
+errback=self.dialog_failure,
 )
 def disconnect(self, profile):
 log.info("disconnecting")
-self.callListeners("disconnect", profile=profile)
+self.call_listeners("disconnect", profile=profile)
 self.bridge.disconnect(profile)
-def onExit(self):
+def on_exit(self):
 """Must be called when the frontend is terminating"""
 to_unplug = []
 for profile, profile_manager in self.profiles.items():
 if profile_manager.connected and profile_manager.autodisconnect:
 # The user wants autodisconnection

Mercurial > libervia-backend

comparison sat_frontends/quick_frontend/quick_app.py @ 4037:524856bd7b19