GitLab

at 2022-01-11T15:19:17+01:00

Preferences: Typing

NotificationManager: Typing

PasswordDialog: Typing

SSLErrorDialog: Typing

 @catch_exceptions

-def open_file(path: str) -> None:

+def open_file(path: Union[str, Path]) -> None:

     if os.name == 'nt':

         os.startfile(path)

     else:

 from typing import Any

 from typing import Optional

 from typing import Union

+from typing import cast

 from gi.repository import Gio

 from gi.repository import GLib

         self._client.get_module('Presence').unsubscribed(jid)

     def _get_notification_row(self, jid: str) -> Optional[NotificationRow]:

-        for row in self.get_children():

+        rows = cast(list[NotificationRow], self.get_children())

+        for row in rows:

             if row.jid == jid:

                 return row

         return None

         accept_button.set_valign(Gtk.Align.CENTER)

         accept_button.set_action_name(

             f'win.subscription-accept-{self._account}')

-        accept_button.set_action_target_value(GLib.Variant('s', str(self.jid)))

+        accept_button.set_action_target_value(GLib.Variant('s', self.jid))

         self.grid.attach(accept_button, 3, 1, 1, 2)

         more_image = Gtk.Image.new_from_icon_name(

         more_button = Gtk.MenuButton()

         more_button.set_valign(Gtk.Align.CENTER)

         more_button.add(more_image)

-        subscription_menu = get_subscription_menu(self._account, self.jid)

+        subscription_menu = get_subscription_menu(

+            self._account, JID.from_string(self.jid))

         more_button.set_menu_model(subscription_menu)

         self.grid.attach(more_button, 4, 1, 1, 2)

 from gi.repository import Gdk

 from gajim.common import app

+from gajim.common.events import PasswordRequired

 from gajim.common.i18n import _

 from gajim.common.passwords import save_password

 from gajim.common.passwords import KEYRING_AVAILABLE

 class PasswordDialog(Gtk.ApplicationWindow):

-    def __init__(self, account, event):

+    def __init__(self, account: str, event: PasswordRequired) -> None:

         Gtk.ApplicationWindow.__init__(self)

         self.set_application(app.app)

         self.set_type_hint(Gdk.WindowTypeHint.DIALOG)

         self.account = account

         self._client = app.get_client(account)

-        self.event = event

+        self._event = event

         self.connect('key-press-event', self._on_key_press)

         self._ui.connect_signals(self)

         self._process_event()

-    def _on_key_press(self, _widget, event):

+    def _on_key_press(self, _widget: Gtk.Widget, event: Gdk.EventKey) -> None:

         if event.keyval == Gdk.KEY_Escape:

             self.destroy()

-    def _process_event(self):

+    def _process_event(self) -> None:

         own_jid = self._client.get_own_jid().bare

         account_name = app.settings.get_account_setting(

             self.account, 'name')

-        if self.event.name == 'password-required':

+        if self._event.name == 'password-required':

             self._ui.header.set_text(_('Password Required'))

             self._ui.message_label.set_text(

                 _('Please enter your password for\n'

             if not KEYRING_AVAILABLE:

                 self._ui.keyring_hint.show()

-        if self.event.name == 'client-cert-passphrase':

+        if self._event.name == 'client-cert-passphrase':

             self._ui.header.set_text(_('Certificate Password Required'))

             self._ui.message_label.set_text(

                 _('Please enter your certificate password for '

                     'jid': own_jid,

                     'account': account_name})

-    def _on_ok(self, _button):

+    def _on_ok(self, _button: Gtk.Button) -> None:

         password = self._ui.pass_entry.get_text()

-        if self.event.name == 'password-required':

+        if self._event.name == 'password-required':

             app.settings.set_account_setting(

                 self.account,

                 'savepass',

                 self._ui.save_pass_checkbutton.get_active())

             save_password(self.account, password)

-            self.event.on_password(password)

+            self._event.on_password(password)

             self.destroy()

-        if self.event.name == 'client-cert-passphrase':

-            self.event.conn.on_client_cert_passphrase(

+        if self._event.name == 'client-cert-passphrase':

+            self._event.conn.on_client_cert_passphrase(

                 password,

-                self.event.con,

-                self.event.port,

-                self.event.secure_tuple)

+                self._event.con,

+                self._event.port,

+                self._event.secure_tuple)

             self.destroy()

-    def _on_cancel(self, _button):

-        if self.event.name == 'client-cert-passphrase':

-            self.event.conn.on_client_cert_passphrase(

+    def _on_cancel(self, _button: Gtk.Button) -> None:

+        if self._event.name == 'client-cert-passphrase':

+            self._event.conn.on_client_cert_passphrase(

                 '',

-                self.event.con,

-                self.event.port,

-                self.event.secure_tuple)

+                self._event.con,

+                self._event.port,

+                self._event.secure_tuple)

         self.destroy()
 # You should have received a copy of the GNU General Public License

 # along with Gajim. If not, see <http://www.gnu.org/licenses/>.

+from __future__ import annotations

+from typing import Any

+from typing import Optional

+from typing import cast

+

 import logging

 import sys

 class Preferences(Gtk.ApplicationWindow):

-    def __init__(self):

+    def __init__(self) -> None:

         Gtk.ApplicationWindow.__init__(self)

         self.set_application(app.app)

         self.set_position(Gtk.WindowPosition.CENTER)

         self._ui = get_builder('preferences.ui')

-        self._video_preview = None

+        self._video_preview: Optional[VideoPreview] = None

         self._prefs = {}

         side_bar_switcher = SideBarSwitcher()

             pref_box.add(pref)

             self._prefs[ui_name] = pref

-    def _add_video_preview(self):

+    def _add_video_preview(self) -> None:

         if sys.platform == 'win32':

             return

         self._video_preview = VideoPreview()

         self._ui.video.add(self._video_preview.widget)

-    def _on_key_press(self, _widget, event):

+    def _on_key_press(self, _widget: Gtk.Widget, event: Gdk.EventKey) -> None:

         if event.keyval == Gdk.KEY_Escape:

             self.destroy()

-    def get_video_preview(self):

+    def get_video_preview(self) -> Optional[VideoPreview]:

         return self._video_preview

     @staticmethod

-    def _on_features_clicked(_widget, _response):

+    def _on_features_clicked(_widget: Gtk.InfoBar,

+                             _response: Gtk.ResponseType

+                             ) -> None:

         open_window('Features')

-    def update_theme_list(self):

+    def update_theme_list(self) -> None:

         self._prefs['themes'].update_theme_list()

-    def update_proxy_list(self):

+    def update_proxy_list(self) -> None:

         self._prefs['miscellaneous'].update_proxy_list()

     @staticmethod

-    def _check_emoji_theme():

+    def _check_emoji_theme() -> None:

         # Ensure selected emoji theme is valid

         emoji_themes = helpers.get_available_emoticon_themes()

         settings_theme = app.settings.get('emoticons_theme')

         if settings_theme not in emoji_themes:

             app.settings.set('emoticons_theme', 'font')

-    def _on_destroy(self, _widget):

+    def _on_destroy(self, _widget: Gtk.Widget) -> None:

         self._prefs.clear()

         app.check_finalize(self)

 class PreferenceBox(SettingsBox):

-    def __init__(self, settings):

+    def __init__(self, settings: list[Setting]) -> None:

         SettingsBox.__init__(self, None)

         self.get_style_context().add_class('settings-border')

         self.set_selection_mode(Gtk.SelectionMode.NONE)

 class WindowBehaviour(PreferenceBox):

-    def __init__(self, *args):

+    def __init__(self, *args: Any) -> None:

         main_window_on_startup_items = {

             'always': _('Always'),

 class Chats(PreferenceBox):

-    def __init__(self, *args):

+    def __init__(self, *args: Any) -> None:

         speller_desc = None

         if not app.is_installed('GSPELL'):

         PreferenceBox.__init__(self, settings)

     @staticmethod

-    def _speller_available():

+    def _speller_available() -> bool:

         return app.is_installed('GSPELL')

     @staticmethod

-    def _on_use_speller(value, *args):

+    def _on_use_speller(value: bool, *args: Any) -> None:

         if not value:

             return

 class GroupChats(PreferenceBox):

-    def __init__(self, *args):

+    def __init__(self, *args: Any) -> None:

         settings = [

             Setting(SettingKind.POPOVER,

         PreferenceBox.__init__(self, settings)

     @staticmethod

-    def _on_sort_by_show_in_muc(*args):

+    def _on_sort_by_show_in_muc(_value: bool, *args: Any) -> None:

         for ctrl in app.window.get_controls():

             if ctrl.is_groupchat:

                 ctrl.roster.invalidate_sort()

     @staticmethod

-    def _on_show_status_in_roster(*args):

+    def _on_show_status_in_roster(_value: bool, *args: Any) -> None:

         for ctrl in app.window.get_controls():

             if ctrl.is_groupchat:

                 ctrl.roster.draw_contacts()

     @staticmethod

-    def _reset_join_left(button):

+    def _reset_join_left(button: Gtk.Button) -> None:

         button.set_sensitive(False)

         app.settings.set_group_chat_settings('print_join_left', None)

     @staticmethod

-    def _reset_print_status(button):

+    def _reset_print_status(button: Gtk.Button) -> None:

         button.set_sensitive(False)

         app.settings.set_group_chat_settings('print_status', None)

 class FilePreview(PreferenceBox):

-    def __init__(self, *args):

+    def __init__(self, *args: Any) -> None:

         sizes = {

             262144: '256 KiB',

             524288: '512 KiB',

 class VisualNotifications(PreferenceBox):

-    def __init__(self, *args):

+    def __init__(self, *args: Any) -> None:

         trayicon_items = {

             'never': _('Hide icon'),

             'on_event': _('Only show for pending events'),

         PreferenceBox.__init__(self, settings)

     @staticmethod

-    def _on_trayicon(value, *args):

+    def _on_trayicon(value: str, *args: Any) -> None:

         if value == 'never':

             app.interface.hide_systray()

         elif value == 'on_event':

 class NotificationsDialog(SettingsDialog):

-    def __init__(self, account, parent):

+    def __init__(self, account: str, parent: Preferences) -> None:

         settings = [

             Setting(SettingKind.SWITCH,

 class Sounds(PreferenceBox):

-    def __init__(self, *args):

+    def __init__(self, *args: Any) -> None:

         settings = [

             Setting(SettingKind.SWITCH,

         PreferenceBox.__init__(self, settings)

-    def _on_manage_sounds(self, *args):

+    def _on_manage_sounds(self, _button: Gtk.Button) -> None:

         open_window('ManageSounds', transient_for=self.get_toplevel())

 class StatusMessage(PreferenceBox):

-    def __init__(self, *args):

+    def __init__(self, *args: Any) -> None:

         settings = [

             Setting(SettingKind.SWITCH,

 class AutomaticStatus(PreferenceBox):

-    def __init__(self, *args):

+    def __init__(self, *args: Any) -> None:

         settings = [

             Setting(SettingKind.AUTO_AWAY,

         PreferenceBox.__init__(self, settings)

     @staticmethod

-    def _get_auto_away():

+    def _get_auto_away() -> bool:

         return app.settings.get('autoaway')

     @staticmethod

-    def _get_auto_xa():

+    def _get_auto_xa() -> bool:

         return app.settings.get('autoxa')

 class AutoAwayDialog(SettingsDialog):

-    def __init__(self, account, parent):

+    def __init__(self, account: str, parent: Preferences) -> None:

         settings = [

             Setting(SettingKind.SWITCH,

 class AutoExtendedAwayDialog(SettingsDialog):

-    def __init__(self, account, parent):

+    def __init__(self, account: str, parent: Preferences) -> None:

         settings = [

             Setting(SettingKind.SWITCH,

 class Themes(PreferenceBox):

-    def __init__(self, *args):

+    def __init__(self, *args: Any) -> None:

         theme_items = self._get_theme_items()

         PreferenceBox.__init__(self, settings)

     @staticmethod

-    def _get_theme_items():

+    def _get_theme_items() -> list[str]:

         theme_items = ['default']

         for settings_theme in app.css_config.themes:

             theme_items.append(settings_theme)

         return theme_items

-    def update_theme_list(self):

+    def update_theme_list(self) -> None:

         self.get_setting('roster_theme').update_entries(self._get_theme_items())

-    def _on_edit_themes(self, *args):

+    def _on_edit_themes(self, _button: Gtk.Button) -> None:

         open_window('Themes', transient=self.get_toplevel())

     @staticmethod

-    def _on_theme_changed(value, *args):

+    def _on_theme_changed(value: str, *args: Any) -> None:

         app.css_config.change_theme(value)

         app.ged.raise_event(ThemeUpdate())

         app.ged.raise_event(StyleChanged())

     @staticmethod

-    def _on_dark_theme(value, *args):

+    def _on_dark_theme(value: str, *args: Any) -> None:

         app.css_config.set_dark_theme(int(value))

         app.ged.raise_event(StyleChanged())

 class Emoji(PreferenceBox):

-    def __init__(self, *args):

+    def __init__(self, *args: Any) -> None:

         if sys.platform not in ('win32', 'darwin'):

             PreferenceBox.__init__(self, [])

             return

-        emoji_themes_items = []

+        emoji_themes_items: list[str] = []

         for theme in helpers.get_available_emoticon_themes():

             emoji_themes_items.append(theme)

         PreferenceBox.__init__(self, settings)

-    def _on_emoticons_theme(self, *args):

+    def _on_emoticons_theme(self, *args: Any) -> None:

         emoji_chooser.load()

         self._toggle_emoticons()

     @staticmethod

-    def _toggle_emoticons():

+    def _toggle_emoticons() -> None:

         for ctrl in app.window.get_controls():

             ctrl.toggle_emoticons()

 class Server(PreferenceBox):

-    def __init__(self, *args):

+    def __init__(self, *args: Any) -> None:

         settings = [

 class StunServerDialog(SettingsDialog):

-    def __init__(self, account, parent):

+    def __init__(self, account: str, parent: Preferences) -> None:

         settings = [

             Setting(SettingKind.SWITCH,

 class Audio(PreferenceBox):

-    def __init__(self, *args):

+    def __init__(self, *args: Any) -> None:

         deps_installed = app.is_installed('AV')

         self.set_sensitive(deps_installed)

     @staticmethod

-    def _create_av_combo_items(items_dict):

+    def _create_av_combo_items(items_dict: dict[str, str]) -> dict[str, str]:

         items = enumerate(sorted(

             items_dict.items(),

             key=lambda x: '' if x[1].startswith('auto') else x[0].lower()))

-        combo_items = {}

+        combo_items: dict[str, str] = {}

         for _index, (name, value) in items:

             combo_items[value] = name

         return combo_items

 class Video(PreferenceBox):

-    def __init__(self, *args):

+    def __init__(self, *args: Any) -> None:

         deps_installed = app.is_installed('AV')

         self.set_sensitive(deps_installed)

     @staticmethod

-    def _on_video_input_changed(_value, *args):

-        preview = get_app_window('Preferences').get_video_preview()

+    def _on_video_input_changed(_value: str, *args: Any) -> None:

+        pref_win = cast(Preferences, get_app_window('Preferences'))

+        preview = pref_win.get_video_preview()

         if preview is None or not preview.is_active:

             # changed signal gets triggered when we fill the combobox

             return

         preview.refresh()

     @staticmethod

-    def _toggle_live_preview(value, *args):

-        preview = get_app_window('Preferences').get_video_preview()

+    def _toggle_live_preview(value: bool, *args: Any) -> None:

+        pref_win = cast(Preferences, get_app_window('Preferences'))

+        preview = pref_win.get_video_preview()

         preview.toggle_preview(value)

     @staticmethod

-    def _create_av_combo_items(items_dict):

+    def _create_av_combo_items(items_dict: dict[str, str]) -> dict[str, str]:

         items = enumerate(sorted(

             items_dict.items(),

             key=lambda x: '' if x[1].startswith('auto') else x[0].lower()))

-        combo_items = {}

+        combo_items: dict[str, str] = {}

         for _index, (name, value) in items:

             combo_items[value] = name

         return combo_items

 class Miscellaneous(PreferenceBox):

-    def __init__(self, pref_window):

+    def __init__(self, pref_window: Preferences) -> None:

         self._hints_list = [

             'start_chat',

         ]

         reset_button.set_sensitive(self._check_hints_reset)

     @staticmethod

-    def _get_proxies():

+    def _get_proxies() -> dict[str, str]:

         return {proxy: proxy for proxy in app.settings.get_proxies()}

     @staticmethod

-    def _on_proxy_edit(*args):

+    def _on_proxy_edit(*args: Any) -> None:

         open_window('ManageProxies')

-    def update_proxy_list(self):

+    def update_proxy_list(self) -> None:

         self.get_setting('global_proxy').update_entries(self._get_proxies())

-    def _check_hints_reset(self):

+    def _check_hints_reset(self) -> bool:

         for hint in self._hints_list:

-            if app.settings.get('show_help_%s' % hint) is False:

+            if app.settings.get(f'show_help_{hint}') is False:

                 return True

         return False

-    def _on_reset_hints(self, button):

+    def _on_reset_hints(self, button: Gtk.Button) -> None:

         for hint in self._hints_list:

-            app.settings.set('show_help_%s' % hint, True)

+            app.settings.set(f'show_help_{hint}', True)

         button.set_sensitive(False)

 class Advanced(PreferenceBox):

-    def __init__(self, pref_window):

+    def __init__(self, pref_window: Preferences) -> None:

         settings = [

             Setting(SettingKind.SWITCH,

             'clicked', self._on_advanced_config_editor)

     @staticmethod

-    def _on_debug_logging(value, *args):

+    def _on_debug_logging(value: bool, *args: Any) -> None:

         app.set_debug_mode(value)

     @staticmethod

-    def _on_open_debug_logs(*args):

+    def _on_open_debug_logs(*args: Any) -> None:

         open_file(configpaths.get('DEBUG'))

     @staticmethod

-    def _on_advanced_config_editor(*args):

+    def _on_advanced_config_editor(*args: Any) -> None:

         open_window('AdvancedConfig')
             self._ui.connect_button.set_no_show_all(True)

             self._ui.connect_button.hide()

-    def _on_view_cert_clicked(self, _button):

+    def _on_view_cert_clicked(self, _button: Gtk.Button) -> None:

         open_window('CertificateDialog',

                     account=self.account,

                     transient_for=self,

                     cert=self._cert)

-    def _on_add_certificate_toggled(self, checkbutton):

+    def _on_add_certificate_toggled(self,

+                                    checkbutton: Gtk.CheckButton

+                                    ) -> None:

         self._ui.connect_button.set_sensitive(checkbutton.get_active())

-    def _on_connect_clicked(self, _button):

+    def _on_connect_clicked(self, _button: Gtk.Button) -> None:

         if self._ui.add_certificate_checkbutton.get_active():

             app.cert_store.add_certificate(self._cert)

 from __future__ import annotations

 from typing import NamedTuple

+from typing import Optional

 from typing import Any

 from typing import Union

+from typing import cast

 from enum import IntEnum

 from .dialogs import DialogButton

 from .dialogs import ConfirmationDialog

 from .builder import get_builder

+from .preferences import Preferences

 from .util import get_app_window

             row = Option(option, value)

             self._ui.option_listbox.add(row)

-    def _add_option(self, _listbox: Gtk.ListBox, row: Gtk.ListBoxRow) -> None:

+    def _add_option(self, _listbox: Gtk.ListBox, row: Option) -> None:

         # Add theme if there is none

         store, _ = self._ui.theme_treeview.get_selection().get_selected()

         first = store.get_iter_first()

     @staticmethod

     def _update_preferences_window() -> None:

-        window = get_app_window('Preferences')

+        window = cast(Optional[Preferences], get_app_window('Preferences'))

         if window is not None:

             window.update_theme_list()

 from gajim.common.events import FileProgress

 from gajim.common.events import FileError

 from gajim.common.events import MucAdded

+from gajim.common.events import PasswordRequired

 from gajim.common.zeroconf import connection_zeroconf

 from gajim.common.helpers import ask_for_status_message

 from gajim.common.structs import OutgoingMessage

         open_window('PasswordDialog', account=event.conn.name, event=event)

     @staticmethod

-    def handle_event_password_required(event):

+    def handle_event_password_required(event: PasswordRequired) -> None:

         open_window('PasswordDialog', account=event.conn.name, event=event)

     @staticmethod

Daniel Brötzmann pushed to branch master at gajim / gajim

Commits:

7 changed files:

Changes: