libervia-backend: sat_frontends/quick_frontend/quick

comparison sat_frontends/quick_frontend/quick_chat.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	78b5f356900c
children	4b842c1fb686

comparison

equal deleted inserted replaced

-:c4464d7ae97b
+:524856bd7b19
 self.to_jid = to_jid
 self.message = msg
 self.subject = subject
 self.type = type_
 self.extra = extra
-self.nick = self.getNick(from_jid)
+self.nick = self.get_nick(from_jid)
 self._status = None
 # own_mess is True if message was sent by profile's jid
 self.own_mess = (
 (from_jid.resource == self.parent.nick)
 if self.parent.type == C.CHAT_GROUP
 if self.parent.type == C.CHAT_GROUP and not self.own_mess:
 for m in msg.values():
 if self.parent.nick.lower() in m.lower():
 self._mention = True
 break
-self.handleMe()
+self.handle_me()
 self.widgets = set()  # widgets linked to this message
 def __str__(self):
 return "Message<{mess_type}>  [{time}]{nick}> {message}".format(
 mess_type=self.type,
 contact_list = self.host.contact_lists[self.profile]
 try:
 return contact_list.getCache(entity, "avatar")
 except (exceptions.NotFound, KeyError):
 # we don't check the result as the avatar listener will be called
-self.host.bridge.avatarGet(entity, True, self.profile)
+self.host.bridge.avatar_get(entity, True, self.profile)
 return None
 @property
 def encrypted(self):
 return self.extra.get("encrypted", False)
-def getNick(self, entity):
+def get_nick(self, entity):
 """Return nick of an entity when possible"""
 contact_list = self.host.contact_lists[self.profile]
 if self.type == C.MESS_TYPE_INFO and self.info_type in ROOM_USER_MOVED:
 try:
 return self.extra["user_nick"]
 except KeyError:
 log.error("extra data is missing user nick for uid {}".format(self.uid))
 return ""
-# FIXME: converted getSpecials to list for pyjamas
+# FIXME: converted get_specials to list for pyjamas
 if self.parent.type == C.CHAT_GROUP or entity in list(
-contact_list.getSpecials(C.CONTACT_SPECIAL_GROUP)
+contact_list.get_specials(C.CONTACT_SPECIAL_GROUP)
 ):
 return entity.resource or ""
 if entity.bare in contact_list:
 try:
 nicknames = contact_list.getCache(entity, "nicknames")
 except (exceptions.NotFound, KeyError):
 # we check result as listener will be called
-self.host.bridge.identityGet(
+self.host.bridge.identity_get(
 entity.bare, ["nicknames"], True, self.profile)
 return entity.node or entity
 if nicknames:
 return nicknames[0]
 if status != self._status:
 self._status = status
 for w in self.widgets:
 w.update({"status": status})
-def handleMe(self):
+def handle_me(self):
 """Check if messages starts with "/me " and change them if it is the case
 if several messages (different languages) are presents, they all need to start with "/me "
 """
 # TODO: XHTML-IM /me are not handled
 self.encrypted = False  # True if this session is currently encrypted
 self._locked = False
 # True when resync is in progress, avoid resynchronising twice when resync is called
 # and history is still being updated. For internal use only
 self._resync_lock = False
-self.setLocked()
+self.set_locked()
 if type_ == C.CHAT_GROUP:
 if target.resource:
 raise exceptions.InternalError(
 "a group chat entity can't have a resource"
 )
 if nick is None:
 raise exceptions.InternalError("nick must not be None for group chat")
 self.nick = nick
 self.occupants = {}
-self.setOccupants(occupants)
+self.set_occupants(occupants)
 else:
 if occupants is not None or nick is not None:
 raise exceptions.InternalError(
 "only group chat can have occupants or nick"
 )
 lt.tm_wday,
 lt.tm_yday,
 lt.tm_isdst,
 )  # struct_time of day changing time
 if self.host.AVATARS_HANDLER:
-self.host.addListener("avatar", self.onAvatar, profiles)
+self.host.addListener("avatar", self.on_avatar, profiles)
-def setLocked(self):
+def set_locked(self):
 """Set locked flag
 To be set when we are waiting for history/search
 """
 # FIXME: we don't use getter/setter here because of pyjamas
 # TODO: use proper getter/setter once we get rid of pyjamas
 if self._locked:
 log.warning("{wid} is already locked!".format(wid=self))
 return
 self._locked = True
-# messageNew signals are cached when locked
+# message_new signals are cached when locked
 self._cache = OrderedDict()
 log.debug("{wid} is now locked".format(wid=self))
-def setUnlocked(self):
+def set_unlocked(self):
 if not self._locked:
 log.debug("{wid} was already unlocked".format(wid=self))
 return
 self._locked = False
 for uid, data in self._cache.items():
 if uid not in self.messages:
-self.messageNew(*data)
+self.message_new(*data)
 else:
 log.debug("discarding message already in history: {data}, ".format(data=data))
 del self._cache
 log.debug("{wid} is now unlocked".format(wid=self))
-def postInit(self):
+def post_init(self):
 """Method to be called by frontend after widget is initialised
 handle the display of history and subject
 """
-self.historyPrint(profile=self.profile)
+self.history_print(profile=self.profile)
 if self.subject is not None:
-self.setSubject(self.subject)
+self.set_subject(self.subject)
 if self.host.ENCRYPTION_HANDLERS:
-self.getEncryptionState()
+self.get_encryption_state()
-def onDelete(self):
+def on_delete(self):
 if self.host.AVATARS_HANDLER:
-self.host.removeListener("avatar", self.onAvatar)
+self.host.removeListener("avatar", self.on_avatar)
 @property
 def contact_list(self):
 return self.host.contact_lists[self.profile]
 @quick_widgets.QuickWidget.sync.setter
 def sync(self, state):
 quick_widgets.QuickWidget.sync.fset(self, state)
 if not state:
-self.setLocked()
+self.set_locked()
-def _resyncComplete(self):
+def _resync_complete(self):
 self.sync = True
 self._resync_lock = False
-def occupantsClear(self):
+def occupants_clear(self):
 """Remove all occupants
 Must be overridden by frontends to clear their own representations of occupants
 """
 self.occupants.clear()
 continue
 last_message = mess
 break
 else:
 # we have no message yet, we can get normal history
-self.historyPrint(callback=self._resyncComplete, profile=self.profile)
+self.history_print(callback=self._resync_complete, profile=self.profile)
 return
 if self.type == C.CHAT_GROUP:
-self.occupantsClear()
+self.occupants_clear()
-self.host.bridge.mucOccupantsGet(
+self.host.bridge.muc_occupants_get(
-str(self.target), self.profile, callback=self.updateOccupants,
+str(self.target), self.profile, callback=self.update_occupants,
 errback=log.error)
-self.historyPrint(
+self.history_print(
 size=C.HISTORY_LIMIT_NONE,
 filters={'timestamp_start': last_message.timestamp},
-callback=self._resyncComplete,
+callback=self._resync_complete,
 profile=self.profile)
 ## Widget management ##
 def __str__(self):
 return "Chat Widget [target: {}, type: {}, profile: {}]".format(
 self.target, self.type, self.profile
 )
 @staticmethod
-def getWidgetHash(target, profiles):
+def get_widget_hash(target, profiles):
 profile = list(profiles)[0]
 return profile + "\n" + str(target.bare)
 @staticmethod
-def getPrivateHash(target, profile):
+def get_private_hash(target, profile):
 """Get unique hash for private conversations
 This method should be used with force_hash to get unique widget for private MUC conversations
 """
 return (str(profile), target)
-def addTarget(self, target):
+def add_target(self, target):
-super(QuickChat, self).addTarget(target)
+super(QuickChat, self).add_target(target)
 if target.resource:
 self.current_target = (
 target
 )  # FIXME: tmp, must use resource priority throught contactList instead
-def recreateArgs(self, args, kwargs):
+def recreate_args(self, args, kwargs):
 """copy important attribute for a new widget"""
 kwargs["type_"] = self.type
 if self.type == C.CHAT_GROUP:
 kwargs["occupants"] = {o.nick: o.data for o in self.occupants.values()}
 kwargs["subject"] = self.subject
 try:
 kwargs["nick"] = self.nick
 except AttributeError:
 pass
-def onPrivateCreated(self, widget):
+def on_private_created(self, widget):
 """Method called when a new widget for private conversation (MUC) is created"""
 raise NotImplementedError
-def getOrCreatePrivateWidget(self, entity):
+def get_or_create_private_widget(self, entity):
 """Create a widget for private conversation, or get it if it already exists
 @param entity: full jid of the target
 """
-return self.host.widgets.getOrCreateWidget(
+return self.host.widgets.get_or_create_widget(
 QuickChat,
 entity,
 type_=C.CHAT_ONE2ONE,
-force_hash=self.getPrivateHash(self.profile, entity),
+force_hash=self.get_private_hash(self.profile, entity),
-on_new_widget=self.onPrivateCreated,
+on_new_widget=self.on_private_created,
 profile=self.profile,
 )  # we force hash to have a new widget, not this one again
 @property
 def target(self):
 return self.current_target.bare
 return self.current_target
 ## occupants ##
-def setOccupants(self, occupants):
+def set_occupants(self, occupants):
 """Set the whole list of occupants"""
 assert len(self.occupants) == 0
 for nick, data in occupants.items():
 # XXX: this log is disabled because it's really too verbose
 #      but kept commented as it may be useful for debugging
 # log.debug(u"adding occupant {nick} to {room}".format(
 #     nick=nick, room=self.target))
 self.occupants[nick] = Occupant(self, data, self.profile)
-def updateOccupants(self, occupants):
+def update_occupants(self, occupants):
 """Update occupants list
-In opposition to setOccupants, this only add missing occupants and remove
+In opposition to set_occupants, this only add missing occupants and remove
 occupants who have left
 """
 # FIXME: occupants with modified status are not handled
 local_occupants = set(self.occupants)
 updated_occupants = set(occupants)
 except KeyError:
 log.warning("Trying to remove an unknown occupant: {}".format(nick))
 else:
 return occupant
-def setUserNick(self, nick):
+def set_user_nick(self, nick):
 """Set the nick of the user, usefull for e.g. change the color of the user"""
 self.nick = nick
-def changeUserNick(self, old_nick, new_nick):
+def change_user_nick(self, old_nick, new_nick):
 """Change nick of a user in group list"""
 log.info("{old} is now known as {new} in room {room_jid}".format(
 old = old_nick,
 new = new_nick,
 room_jid = self.target))
 ## Messages ##
-def manageMessage(self, entity, mess_type):
+def manage_message(self, entity, mess_type):
 """Tell if this chat widget manage an entity and message type couple
 @param entity (jid.JID): (full) jid of the sending entity
-@param mess_type (str): message type as given by messageNew
+@param mess_type (str): message type as given by message_new
 @return (bool): True if this Chat Widget manage this couple
 """
 if self.type == C.CHAT_GROUP:
 if (
 mess_type in (C.MESS_TYPE_GROUPCHAT, C.MESS_TYPE_INFO)
 else:
 if mess_type != C.MESS_TYPE_GROUPCHAT and entity in self.targets:
 return True
 return False
-def updateHistory(self, size=C.HISTORY_LIMIT_DEFAULT, filters=None, profile="@NONE@"):
+def update_history(self, size=C.HISTORY_LIMIT_DEFAULT, filters=None, profile="@NONE@"):
 """Called when history need to be recreated
-Remove all message from history then call historyPrint
+Remove all message from history then call history_print
 Must probably be overriden by frontend to clear widget
 @param size (int): number of messages
 @param filters (str): patterns to filter the history results
 @param profile (str): %(doc_profile)s
 """
-self.setLocked()
+self.set_locked()
 self.messages.clear()
-self.historyPrint(size, filters, profile=profile)
+self.history_print(size, filters, profile=profile)
-def _onHistoryPrinted(self):
+def _on_history_printed(self):
 """Method called when history is printed (or failed)
 unlock the widget, and can be used to refresh or scroll down
 the focus after the history is printed
 """
-self.setUnlocked()
+self.set_unlocked()
-def historyPrint(self, size=C.HISTORY_LIMIT_DEFAULT, filters=None, callback=None,
+def history_print(self, size=C.HISTORY_LIMIT_DEFAULT, filters=None, callback=None,
 profile="@NONE@"):
 """Print the current history
-Note: self.setUnlocked will be called once history is printed
+Note: self.set_unlocked will be called once history is printed
 @param size (int): number of messages
 @param search (str): pattern to filter the history results
 @param callback(callable, None): method to call when history has been printed
 @param profile (str): %(doc_profile)s
 """
 if filters is None:
 filters = {}
 if size == 0:
 log.debug("Empty history requested, skipping")
-self._onHistoryPrinted()
+self._on_history_printed()
 return
 log_msg = _("now we print the history")
 if size != C.HISTORY_LIMIT_DEFAULT:
 log_msg += _(" ({} messages)".format(size))
 log.debug(log_msg)
 # FIXME: info not handled correctly
 filters["types"] = C.MESS_TYPE_GROUPCHAT
 self.history_filters = filters
-def _historyGetCb(history):
+def _history_get_cb(history):
 # day_format = "%A, %d %b %Y"  # to display the day change
 # previous_day = datetime.now().strftime(day_format)
 # message_day = datetime.fromtimestamp(timestamp).strftime(self.day_format)
 # if previous_day != message_day:
-#     self.printDayChange(message_day)
+#     self.print_day_change(message_day)
 #     previous_day = message_day
 for data in history:
 uid, timestamp, from_jid, to_jid, message, subject, type_, extra_s = data
 from_jid = jid.JID(from_jid)
 to_jid = jid.JID(to_jid)
 subject,
 type_,
 extra,
 profile,
 )
-self._onHistoryPrinted()
+self._on_history_printed()
 if callback is not None:
 callback()
-def _historyGetEb(err):
+def _history_get_eb(err):
 log.error(_("Can't get history: {}").format(err))
-self._onHistoryPrinted()
+self._on_history_printed()
 if callback is not None:
 callback()
-self.host.bridge.historyGet(
+self.host.bridge.history_get(
 str(self.host.profiles[profile].whoami.bare),
 str(target),
 size,
 True,
 {k: str(v) for k,v in filters.items()},
 profile,
-callback=_historyGetCb,
+callback=_history_get_cb,
-errback=_historyGetEb,
+errback=_history_get_eb,
 )
-def messageEncryptionGetCb(self, session_data):
+def message_encryption_get_cb(self, session_data):
 if session_data:
 session_data = data_format.deserialise(session_data)
-self.messageEncryptionStarted(session_data)
+self.message_encryption_started(session_data)
-def messageEncryptionGetEb(self, failure_):
+def message_encryption_get_eb(self, failure_):
 log.error(_("Can't get encryption state: {reason}").format(reason=failure_))
-def getEncryptionState(self):
+def get_encryption_state(self):
 """Retrieve encryption state with current target.
-Once state is retrieved, default messageEncryptionStarted will be called if
+Once state is retrieved, default message_encryption_started will be called if
 suitable
 """
 if self.type == C.CHAT_GROUP:
 return
-self.host.bridge.messageEncryptionGet(str(self.target.bare), self.profile,
+self.host.bridge.message_encryption_get(str(self.target.bare), self.profile,
-callback=self.messageEncryptionGetCb,
+callback=self.message_encryption_get_cb,
-errback=self.messageEncryptionGetEb)
+errback=self.message_encryption_get_eb)
-def messageNew(self, uid, timestamp, from_jid, to_jid, msg, subject, type_, extra,
+def message_new(self, uid, timestamp, from_jid, to_jid, msg, subject, type_, extra,
 profile):
 if self._locked:
 self._cache[uid] = (
 uid,
 timestamp,
 if self.type == C.CHAT_GROUP:
 if to_jid.resource and type_ != C.MESS_TYPE_GROUPCHAT:
 # we have a private message, we forward it to a private conversation
 # widget
-chat_widget = self.getOrCreatePrivateWidget(to_jid)
+chat_widget = self.get_or_create_private_widget(to_jid)
-chat_widget.messageNew(
+chat_widget.message_new(
 uid, timestamp, from_jid, to_jid, msg, subject, type_, extra, profile
 )
 return
 if type_ == C.MESS_TYPE_INFO:
 try:
 )
 self.messages[uid] = message
 if "received_timestamp" in extra:
 log.warning("Delayed message received after history, this should not happen")
-self.createMessage(message)
+self.create_message(message)
-def messageEncryptionStarted(self, session_data):
+def message_encryption_started(self, session_data):
 self.encrypted = True
 log.debug(_("message encryption started with {target} using {encryption}").format(
 target=self.target, encryption=session_data['name']))
-def messageEncryptionStopped(self, session_data):
+def message_encryption_stopped(self, session_data):
 self.encrypted = False
 log.debug(_("message encryption stopped with {target} (was using {encryption})")
 .format(target=self.target, encryption=session_data['name']))
-def createMessage(self, message, append=False):
+def create_message(self, message, append=False):
 """Must be implemented by frontend to create and show a new message widget
-This is only called on messageNew, not on history.
+This is only called on message_new, not on history.
-You need to override historyPrint to handle the later
+You need to override history_print to handle the later
 @param message(Message): message data
 """
 raise NotImplementedError
-def isUserMoved(self, message):
+def is_user_moved(self, message):
 """Return True if message is a user left/joined message
 @param message(Message): message to check
 @return (bool): True is message is user moved info message
 """
 except KeyError:
 return False
 else:
 return info_type in ROOM_USER_MOVED
-def handleUserMoved(self, message):
+def handle_user_moved(self, message):
 """Check if this message is a UserMoved one, and merge it when possible
 "merge it" means that info message indicating a user joined/left will be
 grouped if no other non-info messages has been sent since
 @param message(Message): message to check
 @return (bool): True if this message has been merged
 if True, a new MessageWidget must not be created and appended to history
 """
-if self.isUserMoved(message):
+if self.is_user_moved(message):
 for wid in self.message_widgets_rev:
 # we merge in/out messages if no message was sent meanwhile
 if not isinstance(wid, MessageWidget):
 continue
 elif wid.mess_data.type != C.MESS_TYPE_INFO:
 ).format(nick=nick, count=count)
 wid.reentered_count += 1
 return True
 return False
-def printDayChange(self, day):
+def print_day_change(self, day):
 """Display the day on a new line.
 @param day(unicode): day to display (or not if this method is not overwritten)
 """
 # FIXME: not called anymore after refactoring
 pass
 ## Room ##
-def setSubject(self, subject):
+def set_subject(self, subject):
 """Set title for a group chat"""
 if self.type != C.CHAT_GROUP:
 raise exceptions.InternalError(
 "trying to set subject for a non group chat window"
 )
 self.subject = subject
-def changeSubject(self, new_subject):
+def change_subject(self, new_subject):
 """Change the subject of the room
 This change the subject on the room itself (i.e. via XMPP),
-while setSubject change the subject of this widget
+while set_subject change the subject of this widget
 """
-self.host.bridge.mucSubject(str(self.target), new_subject, self.profile)
+self.host.bridge.muc_subject(str(self.target), new_subject, self.profile)
-def addGamePanel(self, widget):
+def add_game_panel(self, widget):
 """Insert a game panel to this Chat dialog.
 @param widget (Widget): the game panel
 """
 raise NotImplementedError
-def removeGamePanel(self, widget):
+def remove_game_panel(self, widget):
 """Remove the game panel from this Chat dialog.
 @param widget (Widget): the game panel
 """
 raise NotImplementedError
 # FIXME: to remove ?
 raise NotImplementedError
 ## events ##
-def onChatState(self, from_jid, state, profile):
+def on_chat_state(self, from_jid, state, profile):
 """A chat state has been received"""
 if self.type == C.CHAT_GROUP:
 nick = from_jid.resource
 try:
 self.occupants[nick].state = state
 "{nick} not found in {room}, ignoring new chat state".format(
 nick=nick, room=self.target.bare
 )
 )
-def onMessageState(self, uid, status, profile):
+def on_message_state(self, uid, status, profile):
 try:
 mess_data = self.messages[uid]
 except KeyError:
 pass
 else:
 mess_data.status = status
-def onAvatar(self, entity, avatar_data, profile):
+def on_avatar(self, entity, avatar_data, profile):
 if self.type == C.CHAT_GROUP:
 if entity.bare == self.target:
 try:
 self.occupants[entity.resource].update({"avatar": avatar_data})
 except KeyError:

Mercurial > libervia-backend

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