import time

 import sys

 from datetime import datetime

 from urllib.parse import unquote

 from nbxmpp.namespaces import Namespace

     @staticmethod

     def _redirect_output():

         date = datetime.today().strftime('%d%m%Y-%H%M%S')

         filename = '%s-debug.log' % date

         fd = open(debug_folder / filename, 'a')

     @staticmethod

     def _cleanup_debug_logs():

         debug_files = list(debug_folder.glob('*-debug.log*'))

         now = time.time()

         for file in debug_files:

 import sys

 import logging

 import uuid

 from collections import namedtuple

 from collections import defaultdict

     css_config = CSSConfig()

 def set_debug_mode(enable: bool) -> None:

     debug_enabled = debug_folder / 'debug-enabled'

     if enable:

         debug_enabled.touch()

             debug_enabled.unlink()

 def get_debug_mode() -> bool:

     debug_enabled = debug_folder / 'debug-enabled'

     return debug_enabled.exists()

     try:

         return bob_cache[algo_hash]

     except KeyError:

         if filepath.exists():

             with open(str(filepath), 'r+b') as file:

                 data = file.read()

 import logging

 from gi.repository import GLib

 from gi.repository import Gio

 class CertificateStore:

     def __init__(self):

         self._certs = []

         self._load_certificates()

 from gajim.common.types import PathTuple

     return _paths[key]

             Path(_paths['PLUGINS_USER'])]

     for key, value in _paths.items():

         path_type = value[2]

         if type_ != path_type:

 def set_config_root(config_root: str) -> None:

 def init() -> None:

 def create_paths() -> None:

     for path in get_paths(PathType.FOLDER):

             print(_('Gajim will now exit'))

             sys.exit()

                 # Create all parent folders

                 # don't use mkdir(parent=True), as it ignores `mode`

                 # when creating the parents

                 if not parent_path.exists():

                     print(('creating %s directory') % parent_path)

                     parent_path.mkdir(mode=0o700)

 class ConfigPaths:

         self._paths = {}  # type: Dict[str, PathTuple]

         self.profile = ''

         self.profile_separation = False

         if os.name == 'nt':

             try:

                 # Documents and Settings\[User Name]\Application Data\Gajim

                 self.config_root = self.cache_root = self.data_root = \

             except KeyError:

                 # win9x, in cwd

         else:

         import pkg_resources

         source_paths = [

         ]

         for path in source_paths:

             self.add(*path)

         location, path, _ = self._paths[key]

         if location == PathLocation.CONFIG:

         if location == PathLocation.CACHE:

         if location == PathLocation.DATA:

         return path

     def items(self) -> Generator[Tuple[str, PathTuple], None, None]:

         for key, value in self._paths.items():

             yield (key, value)

         if os.name == 'nt':

         if self.profile:

             if unique or self.profile_separation:

         return path

     def add(self,

             name: str,

             location: PathLocation = None,

             path_type: PathType = None,

             unique: bool = False) -> None:

             path = self._prepare(path, unique)

         self._paths[name] = (location, path, path_type)

             self.cache_root = self.data_root = self.custom_config_root

         user_dir_paths = [

         ]

         for path in user_dir_paths:

 from urllib.parse import unquote

 from encodings.punycode import punycode_encode

 from functools import wraps

 from packaging.version import Version as V

 from nbxmpp.namespaces import Namespace

                                      (eg: ~/.gajim/sounds/, DATADIR/sounds...).

     :return      the path to file or None if it doesn't exists.

     """

     if dirs is None:

         dirs = [configpaths.get('MY_DATA'),

                 configpaths.get('DATA')]

     for dir_ in dirs:

             return dir_

     return None

         dirs = [configpaths.get('MY_DATA'),

                 configpaths.get('DATA')]

     for dir_ in dirs:

         if abs_:

         if file_ == dir_:

             return name

     return file_

     if path_to_soundfile is None:

         return

     if sys.platform == 'win32':

         import winsound

         try:

     return True

 def get_available_emoticon_themes():

     files = []

         if not folder.is_dir():

             continue

 def call_counter(func):

     def helper(self, restart=False):

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

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

 import nbxmpp

 from nbxmpp.namespaces import Namespace

         if self.use_security:

             security = nbxmpp.simplexml.Node(

                 tag=Namespace.JINGLE_XTLS + ' security')

             cert = load_cert_file(certpath)

             if cert:

                 digest_algo = (cert.get_signature_algorithm()

 import hashlib

 import logging

 import threading

 from enum import IntEnum, unique

             State.CAND_SENT_AND_RECEIVED : StateCandSentAndRecv(self)

         }

             jingle_xtls.make_certs(cert_name, 'gajim')

     def __state_changed(self, nextstate, args=None):

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

 import logging

 from OpenSSL import SSL, crypto

     """

     This is almost identical to the one in nbxmpp.tls_nb

     """

         return None

     try:

         f = open(cert_path)

     elif fingerprint == 'client':

         ctx.set_verify(SSL.VERIFY_PEER, verify_cb or default_callback)

     # Try to load Diffie-Hellman parameters.

     # First try user DH parameters, if this fails load the default DH parameters

     try:

         with open(dh_params_name, "r"):

             ctx.load_tmp_dh(dh_params_name.encode('utf-8'))

     except FileNotFoundError as err:

         try:

             with open(default_dh_params_name, "r"):

         except FileNotFoundError as err:

             log.error('Unable to load default DH parameter file: %s, %s',

                       default_dh_params_name, err)

     if remote_jid:

         store = ctx.get_cert_store()

             load_cert_file(path, cert_store=store)

             log.debug('certificate file %s loaded fingerprint %s',

                       path, fingerprint)

     return certificate

 def send_cert(con, jid_from, sid):

     certificate = read_cert(certpath)

     iq = nbxmpp.Iq('result', to=jid_from)

     iq.setAttr('id', sid)

 def handle_new_cert(con, obj, jid_from):

     jid = app.get_jid_without_resource(jid_from)

     id_ = obj.getAttr('id')

     approve_pending_content(id_)

 def check_cert(jid, fingerprint):

         cert = load_cert_file(certpath)

         if cert:

             digest_algo = cert.get_signature_algorithm().decode('utf-8')\

     key = createKeyPair(TYPE_RSA, 4096)

     req = createCertRequest(key, CN=CN)

     cert = createCertificate(req, req, key, 0, 0, 60*60*24*365*5) # five years

         f.write(crypto.dump_privatekey(crypto.FILETYPE_PEM, key))

         f.write(crypto.dump_certificate(crypto.FILETYPE_PEM, cert))

 if __name__ == '__main__':

 import logging

 import hashlib

 from base64 import b64decode

 import nbxmpp

 from nbxmpp.namespaces import Namespace

         log.warning('No data found: %s', stanza)

         return None

     if algo_hash in app.bob_cache or filepath.exists():

         log.info('BoB data already cached')

         return None

     algo_hash = '%s+%s' % (bob_data.algo, bob_data.hash_)

     if algo_hash in app.bob_cache or filepath.exists():

         log.info('BoB data already cached')

         return None

         return namedtuple("Row", fields)(*row)

     def _connect_database(self) -> None:

         if path.is_dir():

             log.error('%s is a directory but should be a file', path)

             sys.exit()

         pass

     def _migrate_old_config(self) -> None:

         if not config_file.exists():

             return

 import json

 import logging

 import sqlite3 as sqlite

 from collections import namedtuple

 from gajim.common import app

     def __init__(self):

         SqliteStorage.__init__(self,

                                log,

                                ARCHIVE_SQL_STATEMENT)

         self._jid_ids = {}

 import time

 import sqlite3

 import logging

 from collections import namedtuple

 from gajim.common import configpaths

     def __init__(self):

         SqliteStorage.__init__(self,

                                log,

                                CACHE_SQL_STATEMENT)

         self._entity_caps_cache = {}

 from typing import Union

 from typing import TYPE_CHECKING

 import nbxmpp

 from gajim.common.const import PathType, PathLocation

 PEPHandlersDict = Dict[str, List[PEPNotifyCallback]]

 # Configpaths

 # Plugins

 PluginExtensionPoints = Dict[str, Tuple[Optional[Callable[..., None]],

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

 import logging

 from gi.repository import Gdk

 from gi.repository import GLib

     def _create_server_completion(self):

         # Parse servers.json

         self._servers = helpers.load_json(file_path, 'servers', [])

         # Create a separate model for the address entry, because it will

     def _create_server_completion(self):

         # Parse servers.json

         servers = helpers.load_json(file_path, 'servers', [])