import string

 import webbrowser

 from string import Template

 from datetime import datetime

 from datetime import timedelta

 from urllib.parse import unquote

     except Exception as error:

         raise InvalidFormat(error)

 def idn_to_ascii(host: str) -> str:

     """

     Convert IDN (Internationalized Domain Names) to ACE (ASCII-compatible

             converted_labels.append('')

     return ".".join(converted_labels)

 def ascii_to_idn(host: str) -> str:

     """

     Convert ACE (ASCII-compatible encoding) to IDN (Internationalized Domain

         converted_labels.append(idna.ToUnicode(label))

     return ".".join(converted_labels)

 def parse_resource(resource: str) -> Optional[str]:

     """

     except UnicodeError:

         raise InvalidFormat('Invalid character in resource.')

 def get_uf_show(show: str, use_mnemonic: bool = False) -> str:

     if use_mnemonic:

         return SHOW_STRING_MNEMONIC[show]

     return SHOW_STRING[show]

 def get_uf_sub(sub: str) -> str:

     if sub == 'none':

         uf_sub = Q_('?Subscription we already have:None')

     return uf_sub

 def get_uf_ask(ask: Union[str, None]) -> str:

     if ask is None:

         uf_ask = Q_('?Ask (for Subscription):None')

     return uf_ask

 def get_uf_role(role: Union[Role, str], plural: bool = False) -> str:

     ''' plural determines if you get Moderators or Moderator'''

     if not isinstance(role, str):

         return _('Visitor')

     return ''

 def get_uf_affiliation(affiliation: Union[Affiliation, str],

                        plural: bool = False

                        ) -> str:

         return _('Member')

     return ''

 def get_uf_relative_time(timestamp: float) -> str:

     date_time = datetime.fromtimestamp(timestamp)

     now = datetime.now()

                         minutes)

     return _('Just now')

 def to_one_line(msg: str) -> str:

     msg = msg.replace('\\', '\\\\')

     # 'test\\ntest\\\\ntest'

     return msg

 def from_one_line(msg: str) -> str:

     # (?<!\\) is a lookbehind assertion which asks anything but '\'

     # to match the regexp that follows it

     # 'test\ntest\\ntest'

     return msg

 def get_uf_chatstate(chatstate: str) -> str:

     """

     Remove chatstate jargon and returns user friendly messages

     if chatstate == 'composing':

         return _('is composing a message…')

     if chatstate == 'paused':

         return _('paused composing a message')

     if chatstate == 'gone':

         return _('has closed the chat window or tab')

     return ''

 def exec_command(command: str,

                  use_shell: bool = False,

                  posix: bool = True

         process = subprocess.Popen(args)

         app.thread_interface(process.wait)

 def build_command(executable: str, parameter: str) -> str:

     # we add to the parameter (can hold path with spaces)

     # "" so we have good parsing from shell

     command = f'{executable} "{parameter}"'

     return command

 def get_file_path_from_dnd_dropped_uri(uri: str) -> str:

     path = path.strip('\r\n\x00')  # remove \r\n and NULL

     # get the path to file

     if re.match('^file:///[a-zA-Z]:/', path):  # windows

         path = path[5:]  # 5 is len('file:')

     return path

 def sanitize_filename(filename: str) -> str:

     """

     Make sure the filename we will write does contain only acceptable and latin

     return filename

 def reduce_chars_newlines(text: str, max_chars: int = 0,

                           max_lines: int = 0) -> str:

     """

             return dir_

     return None

     """

     Remove knowns paths from a sound file

             return name

     return file_

 def play_sound_file(str_path_to_soundfile: str, loop: bool = False) -> None:

     path_to_soundfile = check_soundfile_path(str_path_to_soundfile)

     if path_to_soundfile is None:

     from gajim.common import sound

     sound.play(path_to_soundfile, loop)

 def get_client_status(account: str) -> str:

     client = app.get_client(account)

     if client.state.is_disconnected:

     return client.status

 def get_global_show() -> str:

     maxi = 0

     for account in app.connections:

             maxi = index

     return SHOW_LIST[maxi]

 def get_global_status_message() -> str:

     maxi = 0

     status_message = ''

             status_message = con.status_message

     return status_message

 def statuses_unified() -> bool:

     """

     Test if all statuses are the same

         return None

     return parse_jid(str(iq_obj.getFrom()))

 def get_jid_from_iq(iq_obj: Iq) -> Optional[str]:

     """

     Return the jid (without resource) from an iq

         return None

     return app.get_jid_without_resource(jid)

 def get_auth_sha(sid: str, initiator: str, target: str) -> str:

     """

     Return sha of sid + initiator + target used for proxy auth

     return hashlib.sha1(

         (f'{sid}{initiator}{target}').encode('utf-8')).hexdigest()

 def remove_invalid_xml_chars(string_: str) -> str:

     if string_:

         string_ = re.sub(INVALID_XML_CHARS_REGEX, '', string_)

     return string_

 def get_random_string(count: int = 16) -> str:

     """

     Create random string of count length

     return False

     features: list[str] = []

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

     app.plugin_manager.extension_point('update_caps', account, features)

     return features

 def jid_is_blocked(account: str, jid: str) -> bool:

     con = app.connections[account]

     return jid in con.get_module('Blocking').blocked

 def get_subscription_request_msg(account: Optional[str] = None) -> str:

     message = _('I would like to add you to my contact list.')

     if account is None:

     message = _('Hello, I am $name. %s') % message

     return Template(message).safe_substitute({'name': app.nicks[account]})

                         reason: Optional[str]) -> str:

     client = app.get_client(account)

     contact = client.get_module('Contacts').get_contact(

         moderator_jid, groupchat=True)

         text += ' ' + _('Reason: %s') % reason

     return text

 def get_global_proxy() -> Optional[ProxyData]:

     proxy_name = app.settings.get('global_proxy')

     if not proxy_name:

         return None

     return get_proxy(proxy_name)

 def get_account_proxy(account: str, fallback=True) -> Optional[ProxyData]:

     proxy_name = app.settings.get_account_setting(account, 'proxy')

     if proxy_name:

         return get_global_proxy()

     return None

 def get_proxy(proxy_name: str) -> Optional[ProxyData]:

     try:

         settings = app.settings.get_proxy_settings(proxy_name)

                      username=username,

                      password=password)

 def version_condition(current_version: str, required_version: str) -> bool:

     if V(current_version) < V(required_version):

         return False

     return True

 def get_available_emoticon_themes() -> list[str]:

     files: list[Path] = []

     for folder in configpaths.get('EMOTICONS').iterdir():

     emoticons_themes += [file.stem for file in files if file.suffix == '.png']

     return sorted(emoticons_themes)

 def call_counter(func):

     def helper(self, restart=False):

         if restart:

         return func(self)

     return helper

 def load_json(path: Path,

               key: Optional[str] = None,

               default: Optional[Any] = None) -> Any: