name = content['name']

             creator = content['creator']

             if (creator, name) not in self.contents:

                 self.__send_error(stanza,

                                   'bad-request',

                                   text=text,

         if reason not in ('success', 'cancel', 'decline'):

             self.__dispatch_error(reason, text)

         if text:

         else:

             # TODO

             text = reason

                          type_: str | None = None

                          ) -> None:

         if text:

         if type_ != 'modify':

             self._raise_event('jingle-error-received', reason=text or error)

                      text: str | None = None,

                      type_: str | None = None

                      ) -> None:

         err = err_stanza.getTag('error')

         if type_:

             err.setAttr('type', type_)

     def __getattr__(self, key: str) -> Any:

         if key not in self._nbxmpp_methods:

             raise AttributeError(

         if not app.account_is_connected(self._account):

             self._log.warning('Account not connected, can’t use %s', key)

         transfer.size = len(result.payload)

         fragment = binascii.hexlify(result.iv + result.key).decode()

         transfer.set_uri_transform_func(

         transfer.set_encrypted_data(result.payload)

         GLib.idle_add(callback, transfer)

         slon = p_('positive longitude', '%sE') % fmt(lon)

     else:

         slon = p_('negative longitude', '%sW') % fmt(-lon)

 def filename_from_uri(uri: str) -> str:

             settings TEXT

     );

 _SignalCallable = Callable[[Any, str, str | None, JID | None], Any]

                  ) -> None:

         if type_ not in ('chat', 'groupchat', 'normal', 'headline'):

         if not message and chatstate is None and marker is None:

             raise ValueError('Trying to send message without content')

         if 'JID' in field_type:

             return JID, f'{variant_str}s'

     def to_variant(self) -> GLib.Variant:

         __types = {}

                 continue

             if not isinstance(value, field_t):

             conversion_func = self._type_to_variant_funcs.get(field_t)

             if conversion_func is not None:

                 value = vdict[field_name]

                 conversion_func = cls._variant_to_type_funcs.get(value_t_name)

                 if conversion_func is None:

                 vdict[field_name] = conversion_func(value)

         return cls(**vdict)

         if index == index_:

             return byte_index

 def process(text: str | bytes, level: int = 0) -> ParsingResult:

 from __future__ import annotations

 import re

 from gi.repository import GLib

         return (f'%0{width}d' % i_minutes) + f':{i_seconds:02d}'

     return f'0:{i_seconds:02d}'

 def check_version(dep_name: str, current_ver: str, min_ver: str) -> None:

     if V(current_ver) < V(min_ver):

 def _check_required_deps() -> None:

     try:

         import nbxmpp

     except ImportError as error:

     try:

         import gi

     except ImportError as error:

     try:

         gi.require_versions({'GLib': '2.0',

                              'Pango': '1.0',

                              'PangoCairo': '1.0'})

     except ValueError as error:

     try:

         import cairo

     except ImportError as error:

     from gi.repository import Gtk

     from gi.repository import GLib

     glib_ver = '.'.join(map(str, [GLib.MAJOR_VERSION,

         btbv_label = Gtk.Label()

         btbv_label.set_xalign(0)

         btbv_label.set_markup(markup)

         self.add(btbv_label)

             # Incorporate profile name into application id

             # to have a single app instance for each profile.

             profile = profile.get_string()

             self.set_application_id(app_id)

             configpaths.set_profile(profile)

 from gajim.common import app

 from gajim.common.helpers import get_x509_cert_from_gio_cert

 from gajim.common.i18n import _

 from gajim.gtk.builder import get_builder

         self._expires = cert.not_valid_after.strftime('%c %Z')

         sha1_bytes = cert.fingerprint(hashes.SHA1())

         sha256_bytes = cert.fingerprint(hashes.SHA256())

         public_key = cert.public_key()

         self._pk_algorithm = ''

         for index, account in enumerate(accounts):

             color = app.settings.get_account_setting(account, 'account_color')

             css_class = f'gajim_class_{index}'

             self._dynamic_dict[account] = css_class

         self._dynamic_provider.load_from_data(css.encode())

     Get an agent's address for displaying in the GUI

     '''

     if node:

     return str(jid)

             service_name = addr.split('.')[0]

         # Or load it

         if icon_exists(icon_name):

             return icon_name

         return 'gajim-agent-jabber'

     def add_self_line(self):

         addr = get_agent_address(self.jid, self.node)

         # Guess which kind of service this is

         identities = []

         type_ = app.get_transport_name_from_jid(self.jid,

         # Row text

         addr = get_agent_address(jid, node)

         if 'name' in item:

         else:

         # Guess which kind of service this is

         identities = []

         type_ = app.get_transport_name_from_jid(

     def _update_item(self, iter_, jid, node, item):

         addr = get_agent_address(jid, node)

         if 'name' in item:

         else:

         self.model[iter_][3] = descr

     def _update_info(self, iter_, jid, node, identities, features, data):

         addr = get_agent_address(jid, node)

         if not identities:

         else:

             name = identities[0].name or ''

             if name:

             else:

         # Update progress

         self._progress += 1

     def _parse_endpoint(self, request: HTTPRequest) -> str:

         if not request.is_complete():

         try:

             data = json.loads(request.get_data())

         except Exception as error:

         endpoint = data.get('sentry_endpoint')

         if endpoint is None:

         if error.condition == 'gone':

             reason = error.get_text(get_rfc5646_lang())

             if reason:

         self._show_error_page(text)

     def _set_error_from_code(self, error_code: str) -> None:

         if not self._row.active:

             css_class = 'omemo-inactive-color'

         image.get_style_context().add_class(css_class)

         self._css_class = css_class

     red = int(rgba.red * 255)

     green = int(rgba.green * 255)

     blue = int(rgba.blue * 255)

 def convert_rgb_to_hex(rgb_string: str) -> str:

         tag = LOCATION_DATA.get(attr)

         if tag is None:

             continue

     return location_string.strip()

     wordsize = fplen // 8

     buf = ''

     for char in range(0, fplen, wordsize):

     buf = textwrap.fill(buf, width=36)

     return buf.rstrip().upper()

         url = match.group()

         if '://' not in url:

             url = 'https://' + url

     return URL_REGEX.sub(_to_href, string)

   "SIM201", # Use x instead of not x

   "SIM212", # Use `value if value else ''` instead of `'' if not value else value`

   "SIM300", # Yoda conditions are discouraged use x instead

   "UP032",  # Use f-string instead of `format` call

   "UP034",  # Avoid extraneous parentheses

   "UP035",  # Import from `collections.abc` instead: `Callable`