GitLab

at 2022-01-23T20:33:06+01:00

Remove dead code

Main: Refactor event handling

- Add dedicated methods for some events
- Add type annotations
- Events: Use JID object instead of string

Main: Reduce event imports

 # {account: {room_jid: {'invities': []}}}

 automatic_rooms: dict[str, dict[str, dict[str, list[str]]]] = {}

 

-# list of contacts that has just signed in

-newly_added: dict[str, list[str]] = {}

-

 # list of contacts that has just signed out

 to_be_removed: dict[str, list[str]] = {}

 

     from gajim.common.client import Client

 

 

+MainEventT = Union['PresenceReceived',

+                   'MessageSent',

+                   'MamMessageReceived',

+                   'GcMessageReceived',

+                   'MessageUpdated',

+                   'ReceiptReceived',

+                   'DisplayedReceived',

+                   'MessageError',

+                   'MucDiscoUpdate',

+                   'JingleConnectedReceived',

+                   'JingleDisconnectedReceived',

+                   'JingleErrorReceived',

+                   'FileRequestSent']

+

+

 @dataclass

 class ApplicationEvent:

     name: str

 class MessageSent(ApplicationEvent):

     name: str = field(init=False, default='message-sent')

     account: str

-    jid: str

+    jid: JID

     message: str

     message_id: str

     chatstate: Optional[str]

     name: str = field(init=False, default='file-request-sent')

     account: str

     file_props: FileProp

-    jid: str

+    jid: JID

 

 

 @dataclass

 class MessageUpdated(ApplicationEvent):

     name: str = field(init=False, default='message-updated')

     account: str

-    jid: str

+    jid: JID

     msgtxt: str

     properties: Any

     correct_id: str

 class MamMessageReceived(ApplicationEvent):

     name: str = field(init=False, default='mam-message-received')

     account: str

-    jid: str

+    jid: JID

     msgtxt: str

     properties: Any

     additional_data: AdditionalDataDict

     conn: 'Client'

     stanza: Any

     account: str

-    jid: str

+    jid: JID

     msgtxt: str

     properties: Any

     additional_data: AdditionalDataDict

 class MessageError(ApplicationEvent):

     name: str = field(init=False, default='message-error')

     account: str

-    jid: str

+    jid: JID

     room_jid: str

     message_id: str

     error: Any

 class ReceiptReceived(ApplicationEvent):

     name: str = field(init=False, default='receipt-received')

     account: str

-    jid: str

+    jid: JID

     receipt_id: str

 

 

     conn: 'Client'

     account: str

     fjid: str

-    jid: str

+    jid: JID

     sid: str

     resource: str

     jingle_session: Any

     need_add_in_roster: bool

     popup: bool

     ptype: str

-    jid: str

+    jid: JID

     resource: str

     id_: str

     fjid: str

     id_: str

     fjid: str

     account: str

-    jid: str

+    jid: JID

     file_props: FileProp

 

 

         fjid = con.get_module('Bytestream')._ft_get_from(stanza)

         account = con.name

         jid = app.get_jid_without_resource(fjid)

-

+        jid = JID.from_string(jid)

         if not content:

             return

 

     def _raise_event(self, name: str, **kwargs):

         jid, resource = app.get_room_and_nick_from_fjid(

             str(self.peerjid))

-

+        jid = JID.from_string(jid)

         event_class = JINGLE_EVENTS[name]

 

         app.ged.raise_event(

 

         event_attr = {

             'account': self._account,

-            'jid': str(properties.jid.bare),

+            'jid': properties.jid.new_as_bare(),

             'msgtxt': properties.body,

             'properties': properties,

             'additional_data': additional_data,

             'account': self._account,

             'additional_data': additional_data,

             'fjid': fjid,

-            'jid': fjid if properties.is_muc_pm else jid,

+            'jid': from_ if properties.is_muc_pm else from_.new_as_bare(),

             'resource': resource,

             'stanza_id': stanza_id,

             'unique_id': stanza_id or message_id,

             'need_add_in_roster': False,

             'popup': False,

             'ptype': properties.type.value,

-            'jid': properties.jid.bare,

+            'jid': properties.jid.new_as_bare(),

             'resource': properties.jid.resource,

             'id_': properties.id,

             'fjid': str(properties.jid),

     def _on_file_request_received(self,

                                   event: events.FileRequestReceivedEvent

                                   ) -> None:

-        row = self._chats.get((event.account, JID.from_string(event.jid)))

+        row = self._chats.get((event.account, event.jid))

         if row is None:

             return

         row.set_timestamp(time.time())

 from nbxmpp import JID

 

 from gajim.common import app

+from gajim.common import events

 from gajim.common import ged

 from gajim.common.const import Direction

-from gajim.common.events import ApplicationEvent

-from gajim.common.events import MucAdded

-from gajim.common.events import HttpAuth

-from gajim.common.events import PasswordRequired

-from gajim.common.events import PlainConnection

-from gajim.common.events import RosterItemExchangeEvent

-from gajim.common.events import AllowGajimUpdateCheck

-from gajim.common.events import GajimUpdateAvailable

-from gajim.common.events import AccountEnabled

-from gajim.common.events import AccountDisabled

-from gajim.common.events import ShowChanged

-from gajim.common.events import SignedIn

+from gajim.common.ged import EventHelper

 from gajim.common.helpers import ask_for_status_message

 from gajim.common.i18n import _

-from gajim.common.ged import EventHelper

 from gajim.common.modules.bytestream import is_transfer_active

 

 from .account_side_bar import AccountSideBar

         self.register_events([

             ('presence-received', ged.GUI1, self._on_event),

             ('message-sent', ged.GUI1, self._on_event),

-            ('message-received', ged.CORE, self._on_event),

+            ('message-received', ged.CORE, self._on_message_received),

             ('mam-message-received', ged.CORE, self._on_event),

             ('gc-message-received', ged.CORE, self._on_event),

             ('message-updated', ged.CORE, self._on_event),

             ('receipt-received', ged.GUI1, self._on_event),

             ('displayed-received', ged.GUI1, self._on_event),

             ('message-error', ged.GUI1, self._on_event),

-            ('muc-creation-failed', ged.GUI1, self._on_event),

-            ('muc-self-presence', ged.GUI1, self._on_event),

-            ('muc-voice-request', ged.GUI1, self._on_event),

             ('muc-disco-update', ged.GUI1, self._on_event),

-            ('jingle-request-received', ged.GUI1, self._on_event),

+            ('jingle-request-received', ged.GUI1, self._on_jingle_request),

             ('jingle-connected-received', ged.GUI1, self._on_event),

             ('jingle-disconnected-received', ged.GUI1, self._on_event),

             ('jingle-error-received', ged.GUI1, self._on_event),

-            ('file-request-received', ged.GUI1, self._on_event),

+            ('file-request-received', ged.GUI1, self._on_file_request),

             ('file-request-sent', ged.GUI1, self._on_event),

             ('our-show', ged.GUI1, self._on_our_show),

             ('signed-in', ged.GUI1, self._on_signed_in),

                     app.settings.get('trayicon') != 'always'):

                 self.show_all()

 

-    def _on_account_enabled(self, event: AccountEnabled) -> None:

+    def _on_account_enabled(self, event: events.AccountEnabled) -> None:

         self._account_side_bar.add_account(event.account)

         self._main_stack.add_account_page(event.account)

 

-    def _on_account_disabled(self, event: AccountDisabled) -> None:

+    def _on_account_disabled(self, event: events.AccountDisabled) -> None:

         workspace_id = self._workspace_side_bar.get_first_workspace()

         self.activate_workspace(workspace_id)

         self._account_side_bar.remove_account(event.account)

         self._main_stack.remove_chats_for_account(event.account)

 

     @staticmethod

-    def _on_our_show(event: ShowChanged) -> None:

+    def _on_our_show(event: events.ShowChanged) -> None:

         if event.show == 'offline':

             app.app.set_account_actions_state(event.account)

             app.app.update_app_actions_state()

 

     @staticmethod

-    def _on_signed_in(event: SignedIn) -> None:

+    def _on_signed_in(event: events.SignedIn) -> None:

         app.app.set_account_actions_state(event.account, True)

         app.app.update_app_actions_state()

 

-    def _on_allow_gajim_update(self, event: AllowGajimUpdateCheck) -> None:

+    def _on_allow_gajim_update(self,

+                               event: events.AllowGajimUpdateCheck) -> None:

         self.add_app_message(event.name)

 

-    def _on_gajim_update_available(self, event: GajimUpdateAvailable) -> None:

+    def _on_gajim_update_available(self,

+                                   event: events.GajimUpdateAvailable) -> None:

         self.add_app_message(event.name, event.version)

 

     @staticmethod

-    def _on_roster_item_exchange(event: RosterItemExchangeEvent) -> None:

+    def _on_roster_item_exchange(event: events.RosterItemExchangeEvent) -> None:

         open_window('RosterItemExchange',

                     account=event.client.account,

                     action=event.action,

                     jid_from=event.jid)

 

     @staticmethod

-    def _on_plain_connection(event: PlainConnection) -> None:

+    def _on_plain_connection(event: events.PlainConnection) -> None:

         ConfirmationDialog(

             _('Insecure Connection'),

             _('Insecure Connection'),

                                callback=event.connect)]).show()

 

     @staticmethod

-    def _on_password_required(event: PasswordRequired) -> None:

+    def _on_password_required(event: events.PasswordRequired) -> None:

         open_window('PasswordDialog', event=event)

 

     @staticmethod

-    def _on_http_auth(event: HttpAuth) -> None:

+    def _on_http_auth(event: events.HttpAuth) -> None:

         def _response(answer: str) -> None:

             event.client.get_module('HTTPAuth').build_http_auth_answer(

                 event.stanza, answer)

                                callback=_response,

                                args=['yes'])]).show()

 

-    def _on_muc_added(self, event: MucAdded) -> None:

+    def _on_muc_added(self, event: events.MucAdded) -> None:

         if self.chat_exists(event.account, event.jid):

             return

 

 

     def _add_group_chat(self,

                         _action: Gio.SimpleAction,

-                        param: Optional[GLib.Variant]) -> None:

+                        param: GLib.Variant) -> None:

 

         account, jid, select = param.unpack()

         self.add_group_chat(account, JID.from_string(jid), select)

 

         self._set_startup_finished()

 

-    def _on_event(self, event: ApplicationEvent) -> None:

-        if event.name == 'update-roster-avatar':

+    def _on_event(self, event: events.MainEventT) -> None:

+        if not self.chat_exists(event.account, event.jid):

             return

 

+        self._main_stack.process_event(event)

+

+    def _on_message_received(self, event: events.MessageReceived) -> None:

         if not self.chat_exists(event.account, event.jid):

-            if event.name == 'message-received':

-                if not event.properties.body:

-                    # Don’t open control on chatstate etc.

-                    return

-                if event.properties.is_muc_pm:

-                    self.add_private_chat(event.account,

-                                          event.properties.jid)

-                else:

-                    jid = event.properties.jid.new_as_bare()

-                    self.add_chat(event.account, jid, 'contact')

-            elif event.name == 'jingle-request-received':

-                content_types = []

-                for item in event.contents:

-                    content_types.append(item.media)

-                if 'audio' in content_types or 'video' in content_types:

-                    # AV Call received, open chat control

-                    self.add_chat(event.account, event.jid, 'contact')

-            elif event.name == 'file-request-received':

-                # Jingle file transfer, open chat control

-                self.add_chat(event.account, event.jid, 'contact')

-            else:

-                # No chat is open, dont handle any gui events

+            if not event.properties.body:

+                # Don’t open control on chatstate etc.

                 return

 

+            if event.properties.is_muc_pm:

+                self.add_private_chat(event.account,

+                                      event.properties.jid)

+

+            else:

+                jid = event.properties.jid.new_as_bare()

+                self.add_chat(event.account, jid, 'contact')

+

+        self._main_stack.process_event(event)

+

+    def _on_jingle_request(self, event: events.JingleRequestReceived) -> None:

+        if not self.chat_exists(event.account, event.jid):

+            for item in event.contents:

+                if item.media in ('audio', 'video'):

+                    self.add_chat(event.account, event.jid, 'contact')

+                    break

+

+        self._main_stack.process_event(event)

+

+    def _on_file_request(self, event: events.FileRequestReceivedEvent) -> None:

+        if not self.chat_exists(event.account, event.jid):

+            self.add_chat(event.account, event.jid, 'contact')

+

         self._main_stack.process_event(event)

 

     def quit(self) -> None:

                 app.app.start_shutdown(message=message)

                 return

             # check if there is an active file transfer

-            files_props = app.interface.instances['file_transfers'].\

-                files_props

+            files_props = app.interface.instances['file_transfers'].files_props

             transfer_active = False

             for x in files_props:

                 for y in files_props[x]:

         self._create_core_handlers_list()

         self._register_core_handlers()

 

-        self.instances = {}

+        self.instances: dict[str, Any] = {}

 

         for acc in app.connections:

             self.instances[acc] = {

                 'disco': {}

             }

             app.automatic_rooms[acc] = {}

-            app.newly_added[acc] = []

             app.to_be_removed[acc] = []

             app.nicks[acc] = app.settings.get_account_setting(acc, 'name')

 

         }

 

         app.automatic_rooms[account] = {}

-        app.newly_added[account] = []

         app.to_be_removed[account] = []

         app.nicks[account] = app.settings.get_account_setting(account, 'name')

         app.settings.set_account_setting(account, 'active', True)

         del app.nicks[account]

         del app.automatic_rooms[account]

         del app.to_be_removed[account]

-        del app.newly_added[account]

 

     def remove_account(self, account: str) -> None:

         if app.settings.get_account_setting(account, 'active'):

         "gajim/gtk/groupchat_nick.py",

         "gajim/gtk/groupchat_settings.py",

         "gajim/gtk/groupchat_state.py",

+        "gajim/gtk/main.py",

         "gajim/gtk/main_stack.py",

         "gajim/gtk/manage_sounds.py",

         "gajim/gtk/notification.py",

Philipp Hörist pushed to branch master at gajim / gajim

Commits:

11 changed files:

Changes: