GitLab

at 2021-12-19T13:30:51+01:00

Util: Typing

Gstreamer helper: Typing

CallWidget: Typing

 # You should have received a copy of the GNU General Public License

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

-from typing import Optional  # pylint: disable=unused-import

+from __future__ import annotations

+from typing import Any

+from typing import List

+from typing import Optional

 import logging

 import time

 from gi.repository import GObject

+from gi.repository import Gdk

 from gi.repository import Gtk

 from nbxmpp.namespaces import Namespace

 from gajim.common import app

+from gajim.common import types

 from gajim.common.const import JingleState

 from gajim.common.const import KindConstant

 from gajim.common.helpers import AdditionalDataDict

 from gajim.common.i18n import _

+from gajim.common.jingle_rtp import JingleAudio

 from gajim.common.nec import NetworkEvent

 from .gstreamer import create_gtk_widget

         ),

     }

-    def __init__(self, account, contact):

+    def __init__(self, account: str, contact: types.BareContact) -> None:

         Gtk.Box.__init__(self)

         self.set_no_show_all(True)

         # having to show a new call row

         self._incoming_video_event = None

-        self._jingle = {

+        self._jingle: dict(str, JingleObject) = {

             'audio': JingleObject(

                 JingleState.NULL,

                 self._update_audio),

         self.add(self._ui.av_box)

         self.connect('destroy', self._on_destroy)

-        dtmf = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '*', '0', '#']

+        dtmf: list(str) = [

+            '1', '2', '3', '4', '5', '6', '7', '8', '9', '*', '0', '#']

         for key in dtmf:

             button = self._ui.get_object(key + '_button')

-            button.connect('pressed', self._on_num_button_pressed, key)

-            button.connect('released', self._on_num_button_released)

+            button.connect(

+                'button-press-event', self._on_num_button_press, key)

+            button.connect('button-release-event', self._on_num_button_release)

         self._ui.connect_signals(self)

-    def _on_destroy(self, *args):

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

         for jingle_type in ('audio', 'video'):

             self._close_jingle_content(jingle_type, shutdown=True)

         self._jingle.clear()

-    def detect_av(self):

+    def detect_av(self) -> None:

         if (self._contact.supports(Namespace.JINGLE_ICE_UDP) and

                 app.is_installed('FARSTREAM')):

             self._jingle['audio'].available = self._contact.supports(

             self._jingle['audio'].available = False

             self._jingle['video'].available = False

-    def get_jingle_available(self, content_type):

+    def get_jingle_available(self, content_type: str) -> bool:

         return self._jingle[content_type].available

-    def _on_call_with_mic(self, _button):

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

         self._on_jingle_button_toggled(['audio'])

         self._ui.av_start_box.hide()

-    def _on_call_with_mic_and_cam(self, _button):

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

         self._on_jingle_button_toggled(['audio', 'video'])

         self._ui.av_start_box.hide()

-    def _on_answer_video_clicked(self, button):

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

         self.accept_call(self._incoming_video_event)

         self._incoming_video_event = None

         button.hide()

-    def _on_end_call_clicked(self, _widget):

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

         self._close_jingle_content('audio')

         self._close_jingle_content('video')

         self._ui.jingle_audio_state.set_no_show_all(True)

         self.hide()

         self.emit('call-ended')

-    def _on_video(self, *args):

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

         self._on_jingle_button_toggled(['video'])

-    def _on_jingle_button_toggled(self, jingle_types):

+    def _on_jingle_button_toggled(self, jingle_types: List[str]) -> None:

         if all(item in jingle_types for item in ['audio', 'video']):

             # Both 'audio' and 'video' in jingle_types

             sid = self._client.get_module('Jingle').start_audio_video(

                 self._set_jingle_state('video', JingleState.CONNECTING, sid)

                 self._store_outgoing_call(sid)

-    def _store_outgoing_call(self, sid):

+    def _store_outgoing_call(self, sid: str) -> None:

         additional_data = AdditionalDataDict()

         additional_data.set_value('gajim', 'sid', sid)

         app.storage.archive.insert_into_logs(

             KindConstant.CALL_OUTGOING,

             additional_data=additional_data)

-    def _on_num_button_pressed(self, _widget, num):

+    def _on_num_button_press(self,

+                             _button: Gtk.Button,

+                             _event: Gdk.EventButton,

+                             num: int

+                             ) -> None:

         self._get_audio_content().start_dtmf(num)

-    def _on_num_button_released(self, _released):

+    def _on_num_button_release(self,

+                               _button: Gtk.Button,

+                               _event: Gdk.EventButton

+                               ) -> None:

         self._get_audio_content().stop_dtmf()

-    def _on_mic_volume_changed(self, _widget, value):

+    def _on_mic_volume_changed(self,

+                               _button: Gtk.VolumeButton,

+                               value: float

+                               ) -> None:

         self._get_audio_content().set_mic_volume(value / 100)

         app.settings.set('audio_input_volume', int(value))

-    def _on_output_volume_changed(self, _widget, value):

+    def _on_output_volume_changed(self,

+                                  _button: Gtk.VolumeButton,

+                                  value: float

+                                  ) -> None:

         self._get_audio_content().set_out_volume(value / 100)

         app.settings.set('audio_output_volume', int(value))

             self._on_jingle_error(event)

     def _on_jingle_request(self, event):

-        content_types = []

+        content_types: list(str) = []

         for item in event.contents:

             content_types.append(item.media)

         if not any(item in ('audio', 'video') for item in content_types):

                 JingleState.ERROR,

                 reason=event.reason)

-    def start_call(self):

+    def start_call(self) -> None:

         audio_state = self._jingle['audio'].state

         video_state = self._jingle['video'].state

         if audio_state == JingleState.NULL and video_state == JingleState.NULL:

         if video is not None:

             session.approve_content('video')

-    def decline_call(self, session):

+    @staticmethod

+    def decline_call(session):

         if not session:

             return

             if video is not None:

                 session.reject_content('video')

-    def _update_audio(self):

+    def _update_audio(self) -> None:

         audio_state = self._jingle['audio'].state

         video_state = self._jingle['video'].state

         if self._jingle['video'].available:

         if not self._jingle['audio'].sid:

             self._ui.audio_buttons_box.set_sensitive(False)

-    def _update_video(self):

+    def _update_video(self) -> None:

         audio_state = self._jingle['audio'].state

         video_state = self._jingle['video'].state

         jingle.sid = new_sid

         jingle.update()

-    def _stop_jingle(self, sid=None, reason=None):

+    def _stop_jingle(self,

+                     sid: Optional[str] = None,

+                     reason: Optional[str] = None

+                     ) -> None:

         audio_sid = self._jingle['audio'].sid

         video_sid = self._jingle['video'].sid

         if audio_sid and sid in (audio_sid, None):

         if video_sid and sid in (video_sid, None):

             self._close_jingle_content('video')

-    def _close_jingle_content(self, jingle_type: str,

-                              shutdown: Optional[bool] = False) -> None:

+    def _close_jingle_content(self,

+                              jingle_type: str,

+                              shutdown: Optional[bool] = False

+                              ) -> None:

         jingle = self._jingle[jingle_type]

         if not jingle.sid:

             return

             jingle.state = JingleState.NULL

             jingle.update()

-    def _get_audio_content(self):

+    def _get_audio_content(self) -> Optional[JingleAudio]:

         session = self._client.get_module('Jingle').get_jingle_session(

             self._contact.jid, self._jingle['audio'].sid)

         return session.get_content('audio')

 # You should have received a copy of the GNU General Public License

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

+from typing import Optional

+from typing import Tuple

+

+from gi.repository import Gtk

 try:

     from gi.repository import Gst

 except Exception:

     pass

-def create_gtk_widget():

+def create_gtk_widget() -> Tuple[Optional[Gst.Element],

+                                 Optional[Gtk.Widget],

+                                 Optional[str]]:

     gtkglsink = Gst.ElementFactory.make('gtkglsink', None)

     if gtkglsink is not None:

         glsinkbin = Gst.ElementFactory.make('glsinkbin', None)

 from importlib import import_module

 from functools import wraps

 from functools import lru_cache

+from pathlib import Path

 try:

     from PIL import Image

 from gi.repository import GLib

 from gi.repository import Pango

 from gi.repository import GdkPixbuf

+import cairo

 import nbxmpp

+from nbxmpp import JID

 from nbxmpp.structs import LocationData

 from gajim.common import app

     return _icon_theme.has_icon(name)

-def load_icon(icon_name, widget=None, size=16, pixbuf=False,

-              scale=None, flags=Gtk.IconLookupFlags.FORCE_SIZE):

+def load_icon(icon_name: str,

+              widget: Optional[Any] = None,

+              size: int = 16,

+              pixbuf: bool = False,

+              scale: Optional[int] = None,

+              flags: Gtk.IconLookupFlags = Gtk.IconLookupFlags.FORCE_SIZE

+              ) -> Optional[Union[GdkPixbuf.Pixbuf, cairo.Surface]]:

     if widget is not None:

         scale = widget.get_scale_factor()

             icon_name, size, scale, flags)

         if iconinfo is None:

             log.info('No icon found for %s', icon_name)

-            return

+            return None

         if pixbuf:

             return iconinfo.load_icon()

         return iconinfo.load_surface(None)

     except GLib.GError as error:

         log.error('Unable to load icon %s: %s', icon_name, str(error))

+    return None

-def get_app_icon_list(scale_widget):

+def get_app_icon_list(scale_widget: Any) -> List[GdkPixbuf.Pixbuf]:

     pixbufs = []

     for size in (16, 32, 48, 64, 128):

         pixbuf = load_icon('org.gajim.Gajim', scale_widget, size, pixbuf=True)

         name = 'notinroster'

     if iconset is not None:

-        return '%s-%s' % (iconset, name)

+        return f'{iconset}-{name}'

     if transport is not None:

-        return '%s-%s' % (transport, name)

+        return f'{transport}-{name}'

     iconset = app.settings.get('iconset')

     if not iconset:

         iconset = 'dcraven'

-    return '%s-%s' % (iconset, name)

+    return f'{iconset}-{name}'

 def load_user_iconsets() -> None:

     return buf.rstrip().upper()

-def find_widget(name, container):

+def find_widget(name: str, container: Gtk.Widget) -> Optional[Gtk.Widget]:

     for child in container.get_children():

         if Gtk.Buildable.get_name(child) == name:

             return child

 class MultiLineLabel(Gtk.Label):

-    def __init__(self, *args, **kwargs):

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

         Gtk.Label.__init__(self, *args, **kwargs)

         self.set_line_wrap(True)

         self.set_line_wrap_mode(Pango.WrapMode.WORD_CHAR)

 class MaxWidthComboBoxText(Gtk.ComboBoxText):

-    def __init__(self, *args, **kwargs):

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

         Gtk.ComboBoxText.__init__(self, *args, **kwargs)

-        self._max_width = 100

+        self._max_width: int = 100

         text_renderer = self.get_cells()[0]

         text_renderer.set_property('ellipsize', Pango.EllipsizeMode.END)

-    def set_max_size(self, size):

+    def set_max_size(self, size: int) -> None:

         self._max_width = size

-    def do_get_preferred_width(self):

+    def do_get_preferred_width(self) -> Tuple[int, int]:

         minimum_width, natural_width = Gtk.ComboBoxText.do_get_preferred_width(

             self)

                                GdkPixbuf.InterpType.BILINEAR)

-def scale_pixbuf_from_data(data: bytes, size: int) -> Optional[GdkPixbuf.Pixbuf]:

+def scale_pixbuf_from_data(data: bytes,

+                           size: int

+                           ) -> Optional[GdkPixbuf.Pixbuf]:

     pixbuf = get_pixbuf_from_data(data)

     return scale_pixbuf(pixbuf, size)

-def load_pixbuf(path, size=None):

+def load_pixbuf(path: Union[str, Path],

+                size: Optional[int] = None

+                ) -> Optional[GdkPixbuf.Pixbuf]:

     try:

         if size is None:

             return GdkPixbuf.Pixbuf.new_from_file(str(path))

     return windows

-def get_app_window(name, account=None, jid=None):

+def get_app_window(name: str,

+                   account: Optional[str] = None,

+                   jid: Optional[Union[str, JID]] = None

+                   ) -> Optional[Gtk.Window]:

     for win in app.app.get_windows():

         if type(win).__name__ != name:

             continue

     return None

-def open_window(name, **kwargs):

+def open_window(name: str, **kwargs: Any) -> Gtk.Window:

     window = get_app_window(name,

                             kwargs.get('account'),

                             kwargs.get('jid'))

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

Commits:

3 changed files:

Changes: