Add type hints to blueman.main

blueman/gui/applet/PluginDialog.py

@@ -1,6 +1,6 @@
 from gettext import gettext as _
 import logging
-from typing import TYPE_CHECKING, List, Type
+from typing import TYPE_CHECKING, List, Type, Dict
 
 from blueman.Constants import *
 from blueman.gui.GenericList import GenericList, ListDataDict
@@ -191,7 +191,7 @@ def on_selection_changed(self, selection: Gtk.TreeSelection) -> None:
         model, tree_iter = selection.get_selected()
 
         name = self.list.get(tree_iter, "name")["name"]
-        cls = self.applet.Plugins.get_classes()[name]
+        cls: Type[AppletPlugin] = self.applet.Plugins.get_classes()[name]
         self.plugin_name.props.label = "<b>" + name + "</b>"
         self.icon.props.icon_name = cls.__icon__
         self.author_txt.props.label = cls.__author__
@@ -223,7 +223,7 @@ def on_selection_changed(self, selection: Gtk.TreeSelection) -> None:
     def on_prefs_toggled(self, _button: Gtk.ToggleButton) -> None:
         model, tree_iter = self.list.selection.get_selected()
         name = self.list.get(tree_iter, "name")["name"]
-        cls = self.applet.Plugins.get_classes()[name]
+        cls: Type[AppletPlugin] = self.applet.Plugins.get_classes()[name]
 
         self.update_config_widget(cls)
 
@@ -252,7 +252,7 @@ def update_config_widget(self, cls: Type[AppletPlugin]) -> None:
             self.main_container.add(self.content_grid)
 
     def populate(self) -> None:
-        classes = self.applet.Plugins.get_classes()
+        classes: Dict[str, Type[AppletPlugin]] = self.applet.Plugins.get_classes()
         loaded = self.applet.Plugins.get_loaded()
         for name, cls in classes.items():
             if cls.is_configurable():
@@ -266,7 +266,7 @@ def plugin_state_changed(self, _plugins: PluginManager, name: str, loaded: bool)
         row = self.list.get_conditional(name=name)
         self.list.set(row[0], active=loaded)
 
-        cls = self.applet.Plugins.get_classes()[name]
+        cls: Type[AppletPlugin] = self.applet.Plugins.get_classes()[name]
         if not loaded:
             self.update_config_widget(cls)
             self.b_prefs.props.sensitive = False

blueman/main/Adapter.py

@@ -2,7 +2,7 @@
 import os.path
 import logging
 import gettext
-from typing import Dict, TYPE_CHECKING
+from typing import Dict, TYPE_CHECKING, Optional, Any
 
 from blueman.Constants import UI_PATH
 from blueman.Functions import *
@@ -11,8 +11,9 @@
 
 import gi
 gi.require_version("Gtk", "3.0")
+gi.require_version("Gdk", "3.0")
 gi.require_version("Pango", "1.0")
-from gi.repository import Gtk
+from gi.repository import Gtk, Gio, Gdk
 from gi.repository import Pango
 
 
@@ -29,15 +30,15 @@ class Tab(TypedDict):
 
 
 class BluemanAdapters(Gtk.Application):
-    def __init__(self, selected_hci_dev, socket_id):
+    def __init__(self, selected_hci_dev: Optional[str], socket_id: Optional[int]) -> None:
         super().__init__(application_id="org.blueman.Adapters")
 
         self.socket_id = socket_id
         self.selected_hci_dev = selected_hci_dev
 
         self.notebook = Gtk.Notebook(visible=True)
 
-        self.window = None
+        self.window: Optional[Gtk.ApplicationWindow] = None
 
         self.tabs: Dict[str, "Tab"] = {}
         self._adapters: Dict[str, Adapter] = {}
@@ -68,8 +69,8 @@ def __init__(self, selected_hci_dev, socket_id):
                 logging.error('Error: the selected adapter does not exist')
         self.notebook.show_all()
 
-    def do_activate(self):
-        def app_release(_plug, event):
+    def do_activate(self) -> None:
+        def app_release(_plug: Gtk.Plug, _event: Gdk.Event) -> bool:
             self.release()
             return False
 
@@ -88,76 +89,74 @@ def app_release(_plug, event):
 
         self.window.present_with_time(Gtk.get_current_event_time())
 
-    def on_property_changed(self, adapter, name, value, path):
+    def on_property_changed(self, _adapter: Adapter, name: str, value: Any, path: str) -> None:
         hci_dev = os.path.basename(path)
         if name == "Discoverable" and value == 0:
             self.tabs[hci_dev]["hidden_radio"].set_active(True)
         elif name == "Alias":
             self.tabs[hci_dev]["label"].set_text(value)
 
-    def on_adapter_added(self, _manager, adapter_path):
+    def on_adapter_added(self, _manager: Manager, adapter_path: str) -> None:
         hci_dev = os.path.basename(adapter_path)
         if hci_dev not in self._adapters:
             self._adapters[hci_dev] = Adapter(obj_path=adapter_path)
 
         self._adapters[hci_dev].connect_signal("property-changed", self.on_property_changed)
         self.add_to_notebook(self._adapters[hci_dev])
 
-    def on_adapter_removed(self, _manager, adapter_path):
+    def on_adapter_removed(self, _manager: Manager, adapter_path: str) -> None:
         hci_dev = os.path.basename(adapter_path)
         self.remove_from_notebook(self._adapters[hci_dev])
 
-    def _on_dbus_name_appeared(self, _connection, name, owner):
+    def _on_dbus_name_appeared(self, _connection: Gio.DBusConnection, name: str, owner: str) -> None:
         logging.info(f"{name} {owner}")
 
-    def _on_dbus_name_vanished(self, _connection, name):
+    def _on_dbus_name_vanished(self, _connection: Gio.DBusConnection, name: str) -> None:
         logging.info(name)
         # FIXME: show error dialog and exit
 
-    def build_adapter_tab(self, adapter):
-        def on_hidden_toggle(radio):
+    def build_adapter_tab(self, adapter: Adapter) -> "Tab":
+        def on_hidden_toggle(radio: Gtk.RadioButton) -> None:
             if not radio.props.active:
                 return
             adapter['DiscoverableTimeout'] = 0
             adapter['Discoverable'] = False
             hscale.set_sensitive(False)
 
-        def on_always_toggle(radio):
+        def on_always_toggle(radio: Gtk.RadioButton) -> None:
             if not radio.props.active:
                 return
             adapter['DiscoverableTimeout'] = 0
             adapter['Discoverable'] = True
             hscale.set_sensitive(False)
 
-        def on_temporary_toggle(radio):
+        def on_temporary_toggle(radio: Gtk.RadioButton) -> None:
             if not radio.props.active:
                 return
             adapter['Discoverable'] = True
             hscale.set_sensitive(True)
             hscale.set_value(3)
 
-        def on_scale_format_value(scale, value):
+        def on_scale_format_value(_scale: Gtk.Scale, value: float) -> str:
             if value == 0:
                 if adapter['Discoverable']:
                     return _("Always")
                 else:
                     return _("Hidden")
             else:
-                return gettext.ngettext("%(minutes)d Minute", "%(minutes)d Minutes", value) % {"minutes": value}
+                return gettext.ngettext("%(minutes)d Minute", "%(minutes)d Minutes", int(value)) % {"minutes": value}
 
-        def on_scale_value_changed(scale):
+        def on_scale_value_changed(scale: Gtk.Scale) -> None:
             val = scale.get_value()
             logging.info(f"value: {val}")
             if val == 0 and adapter['Discoverable']:
                 always_radio.props.active = True
             timeout = int(val * 60)
             adapter['DiscoverableTimeout'] = timeout
 
-        def on_name_changed(entry):
+        def on_name_changed(entry: Gtk.Entry) -> None:
             adapter['Alias'] = entry.get_text()
 
-        ui = {}
-
         builder = Gtk.Builder()
         builder.set_translation_domain("blueman")
         builder.add_from_file(UI_PATH + "/adapters-tab.ui")
@@ -189,13 +188,16 @@ def on_name_changed(entry):
         temporary_radio.connect("toggled", on_temporary_toggle)
         name_entry.connect("changed", on_name_changed)
 
-        ui['grid'] = builder.get_object("grid")
-        ui["hidden_radio"] = hidden_radio
-        ui["always_radio"] = always_radio
-        ui["temparary_radio"] = temporary_radio
-        return ui
+        return {
+            "grid": builder.get_object("grid"),
+            "hidden_radio": hidden_radio,
+            "always_radio": always_radio,
+            "temparary_radio": temporary_radio,
+            "visible": False,
+            "label": Gtk.Label()
+        }
 
-    def add_to_notebook(self, adapter):
+    def add_to_notebook(self, adapter: Adapter) -> None:
         hci_dev = os.path.basename(adapter.get_object_path())
         hci_dev_num = int(hci_dev[3:])
 
@@ -217,7 +219,7 @@ def add_to_notebook(self, adapter):
         label.set_ellipsize(Pango.EllipsizeMode.END)
         self.notebook.insert_page(ui['grid'], label, hci_dev_num)
 
-    def remove_from_notebook(self, adapter):
+    def remove_from_notebook(self, adapter: Adapter) -> None:
         hci_dev = os.path.basename(adapter.get_object_path())
         hci_dev_num = int(hci_dev[3:])
 

blueman/main/Applet.py

@@ -1,3 +1,5 @@
+from typing import Any
+
 from blueman.Functions import *
 from blueman.bluez.Manager import Manager
 from blueman.bluez.Adapter import AnyAdapter
@@ -11,7 +13,7 @@
 
 
 class BluemanApplet(Gio.Application):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__(application_id="org.blueman.Applet", flags=Gio.ApplicationFlags.FLAGS_NONE)
         setup_icon_path()
 
@@ -43,49 +45,49 @@ def __init__(self):
         self._any_device = AnyDevice()
         self._any_device.connect_signal('property-changed', self._on_device_property_changed)
 
-    def do_activate(self):
+    def do_activate(self) -> None:
         if not self._active:
             self.hold()
             self._active = True
 
-    def _on_dbus_name_appeared(self, _connection, name, owner):
+    def _on_dbus_name_appeared(self, _connection: Gio.DBusConnection, name: str, owner: str) -> None:
         logging.info(f"{name} {owner}")
         self.manager_state = True
         self.plugin_run_state_changed = True
         for plugin in self.Plugins.get_loaded_plugins(AppletPlugin):
             plugin.on_manager_state_changed(self.manager_state)
 
-    def _on_dbus_name_vanished(self, _connection, name):
+    def _on_dbus_name_vanished(self, _connection: Gio.DBusConnection, name: str) -> None:
         logging.info(name)
         self.manager_state = False
         self.plugin_run_state_changed = True
         for plugin in self.Plugins.get_loaded_plugins(AppletPlugin):
             plugin.on_manager_state_changed(self.manager_state)
 
-    def _on_adapter_property_changed(self, _adapter, key, value, path):
+    def _on_adapter_property_changed(self, _adapter: AnyAdapter, key: str, value: Any, path: str) -> None:
         for plugin in self.Plugins.get_loaded_plugins(AppletPlugin):
             plugin.on_adapter_property_changed(path, key, value)
 
-    def _on_device_property_changed(self, _device, key, value, path):
+    def _on_device_property_changed(self, _device: AnyDevice, key: str, value: Any, path: str) -> None:
         for plugin in self.Plugins.get_loaded_plugins(AppletPlugin):
             plugin.on_device_property_changed(path, key, value)
 
-    def on_adapter_added(self, _manager, path):
+    def on_adapter_added(self, _manager: Manager, path: str) -> None:
         logging.info(f"Adapter added {path}")
         for plugin in self.Plugins.get_loaded_plugins(AppletPlugin):
             plugin.on_adapter_added(path)
 
-    def on_adapter_removed(self, _manager, path):
+    def on_adapter_removed(self, _manager: Manager, path: str) -> None:
         logging.info(f"Adapter removed {path}")
         for plugin in self.Plugins.get_loaded_plugins(AppletPlugin):
             plugin.on_adapter_removed(path)
 
-    def on_device_created(self, _manager, path):
+    def on_device_created(self, _manager: Manager, path: str) -> None:
         logging.info(f"Device created {path}")
         for plugin in self.Plugins.get_loaded_plugins(AppletPlugin):
             plugin.on_device_created(path)
 
-    def on_device_removed(self, _manager, path):
+    def on_device_removed(self, _manager: Manager, path: str) -> None:
         logging.info(f"Device removed {path}")
         for plugin in self.Plugins.get_loaded_plugins(AppletPlugin):
             plugin.on_device_removed(path)

blueman/main/Config.py

@@ -1,19 +1,22 @@
-from gi.repository import Gio
+from typing import Any, Optional
+
+from gi.repository import Gio, GObject
 import logging
 
 
 class Config(Gio.Settings):
-    def __init__(self, schema_id, path=None):
+    def __init__(self, schema_id: str, path: Optional[str] = None) -> None:
         # Add backwards compat with pygobject < 3.11.2
         if Gio.Settings.__init__.__name__ == "new_init":
             super().__init__(schema_id=schema_id, path=path)
         else:
             super().__init__(schema=schema_id, path=path)
 
-    def bind_to_widget(self, key, widget, prop, flags=Gio.SettingsBindFlags.DEFAULT):
+    def bind_to_widget(self, key: str, widget: GObject.Object, prop: str,
+                       flags: Gio.SettingsBindFlags = Gio.SettingsBindFlags.DEFAULT) -> None:
         self.bind(key, widget, prop, flags)
 
-    def __setitem__(self, key, value):
+    def __setitem__(self, key: str, value: Any) -> None:
         if not self.is_writable(key):
             logging.error("GSetting not writable, settings not saved")
         super().__setitem__(key, value)

blueman/main/DBusProxies.py

@@ -8,7 +8,8 @@ class DBusProxyFailed(Exception):
 
 
 class ProxyBase(Gio.DBusProxy, metaclass=SingletonGObjectMeta):
-    def __init__(self, name, interface_name, object_path='/', systembus=False, flags=0, *args, **kwargs):
+    def __init__(self, name: str, interface_name: str, object_path: str = "/", systembus: bool = False,
+                 flags: Gio.DBusProxyFlags = 0) -> None:
         if systembus:
             bustype = Gio.BusType.SYSTEM
         else:
@@ -19,8 +20,7 @@ def __init__(self, name, interface_name, object_path='/', systembus=False, flags
             g_interface_name=interface_name,
             g_object_path=object_path,
             g_bus_type=bustype,
-            g_flags=flags,
-            *args, **kwargs
+            g_flags=flags
         )
 
         try:
@@ -30,31 +30,31 @@ def __init__(self, name, interface_name, object_path='/', systembus=False, flags
 
 
 class Mechanism(ProxyBase):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__(name='org.blueman.Mechanism', interface_name='org.blueman.Mechanism',
                          object_path="/org/blueman/mechanism", systembus=True)
 
 
 class AppletService(ProxyBase):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__(name='org.blueman.Applet', interface_name='org.blueman.Applet',
                          object_path="/org/blueman/Applet")
 
 
 class ManagerService(ProxyBase):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__(name="org.blueman.Manager", interface_name="org.freedesktop.Application",
                          object_path="/org/blueman/Manager",
                          flags=Gio.DBusProxyFlags.DO_NOT_AUTO_START_AT_CONSTRUCTION)
 
     def _call_action(self, name: str) -> None:
-        def call_finish(proxy, resp):
+        def call_finish(proxy: "ManagerService", resp: Gio.AsyncResult) -> None:
             proxy.call_finish(resp)
 
         param = GLib.Variant('(sava{sv})', (name, [], {}))
         self.call('ActivateAction', param, Gio.DBusProxyFlags.NONE, -1, None, call_finish)
 
-    def startstop(self):
+    def startstop(self) -> None:
         if self.get_name_owner() is None:
             self._call_action("Activate")
         else: