self._client = None

         self._account = account

         self.name = account

         self._user = app.config.get_per('accounts', self._account, 'name')

         self.password = None

         self._client.set_ignored_tls_errors(self._get_ignored_ssl_errors())

             self._client.set_connection_types([ConnectionType.PLAIN])

         proxy = get_user_proxy(self._account)

         self.get_module('Chatstate').enabled = True

         self.get_module('MAM').reset_state()

         app.nec.push_incoming_event(NetworkEvent('stanza-sent',

                                                  account=self._account,

                                                  stanza=stanza))

         app.nec.push_incoming_event(NetworkEvent('stanza-received',

                                                  account=self._account,

                                                  stanza=stanza))

         return modules.get(self._account, name)

     @helpers.call_counter

         log.info('Connect machine state: %s', self._connect_machine_calls)

         if self._connect_machine_calls == 1:

             self.get_module('MetaContacts').get_metacontacts()

     def _abort_reconnect(self):

         self._set_state(ClientState.DISCONNECTED)

         self._disable_reconnect_timer()

         if self._destroy_client:

             self._client.destroy()

         if restart:

             self._connect_machine_calls = 0

         self._connect_machine_calls += 1

     return helper

 def get_sync_threshold(jid, archive_info):

 from gajim.common.types import EventHandlersDict  # pylint: disable=W0611

 from gajim.common.types import PluginEvents  # pylint: disable=W0611

 from gajim.plugins.gui import GajimPluginConfigDialog

     subclasses.

     '''

     def __init__(self) -> None:

         self.config = GajimPluginConfig(self)

         '''

         self.config_dialog = GajimPluginConfigDialog(self)

         self.init()

     def save_config(self) -> None:

         self.config.save()

     def load_config(self) -> None:

         self.config.load()

         return False

     def local_file_path(self, file_name):

         return os.path.join(self.__path__, file_name)

     def init(self):

         pass

     def activate(self):

         pass

     def deactivate(self):

         pass

 class GajimPluginConfig():

     def __init__(self, plugin):

         self.plugin = plugin

         self.FILE_PATH = os.path.join(

             configpaths.get('PLUGINS_CONFIG_DIR'), self.plugin.short_name)

         self.data = {}

     def __getitem__(self, key):

         if not key in self.data:

             self.data[key] = self.plugin.config_default_values[key][0]

         return self.data[key]

     def __setitem__(self, key, value):

         self.data[key] = value

         self.save()

     def __delitem__(self, key):

         del self.data[key]

         self.save()

     def __contains__(self, key):

         return key in self.data

     def items(self):

         return self.data.items()

     def save(self):

         fd = open(self.FILE_PATH, 'wb')

         pickle.dump(self.data, fd)

         fd.close()

     def load(self):

         if os.path.isfile(self.FILE_PATH):

             fd = open(self.FILE_PATH, 'rb')

 from gajim.common.helpers import Singleton

 from gajim.plugins import plugins_i18n

 from gajim.plugins.helpers import GajimPluginActivateException

 from gajim.plugins.gajimplugin import GajimPlugin, GajimPluginException

                'destructors' (classes that register GUI extension points)

     '''

     def __init__(self):

         self.plugins = []

         '''

             pc = self.scan_dir_for_plugins(path)

             self.add_plugins(pc)

     def _plugin_has_entry_in_global_config(self, plugin):

         if app.config.get_per('plugins', plugin.short_name) is None:

             return False

         return True

     def _create_plugin_entry_in_global_config(self, plugin):

         app.config.add_per('plugins', plugin.short_name)

     def _remove_plugin_entry_in_global_config(self, plugin):

         app.config.del_per('plugins', plugin.short_name)

     def update_plugins(self, replace=True, activate=False, plugin_name=None):

         '''

         Move plugins from the downloaded folder to the user plugin folder

         return updated_plugins

     def init_plugins(self):

         self._activate_all_plugins_from_global_config()

     def add_plugin(self, plugin_class):

         '''

         :todo: what about adding plug-ins that are already added? Module reload

                      plugin.name, plugin.version,

                      plugin.__module__, plugin.short_name)

     def remove_plugin(self, plugin):

         '''

         removes the plugin from the plugin list and deletes all loaded modules

         for module_to_remove in modules_to_remove:

             del sys.modules[module_to_remove]

     def add_plugins(self, plugin_classes):

         for plugin_class in plugin_classes:

             self.add_plugin(plugin_class)

     def get_active_plugin(self, plugin_name):

         for plugin in self.active_plugins:

             if plugin.short_name == plugin_name:

                 return plugin

         return None

     def extension_point(self, gui_extpoint_name, *args):

         '''

         Invokes all handlers (from plugins) for a particular extension point, but

         self._execute_all_handlers_of_gui_extension_point(gui_extpoint_name,

             *args)

     def gui_extension_point(self, gui_extpoint_name, *args):

         '''

         Invokes all handlers (from plugins) for particular GUI extension point

         self._execute_all_handlers_of_gui_extension_point(gui_extpoint_name,

             *args)

     def remove_gui_extension_point(self, gui_extpoint_name, *args):

         '''

         Removes GUI extension point from collection held by `PluginManager`.

             if disconnect_handler is not None:

                 disconnect_handler(args[0])

     def _add_gui_extension_point_call_to_list(self, gui_extpoint_name, *args):

         '''

         Adds GUI extension point call to list of calls.

             self.gui_extension_points.setdefault(gui_extpoint_name, []).append(

                 args)

     def _execute_all_handlers_of_gui_extension_point(self, gui_extpoint_name,

     *args):

         if gui_extpoint_name in self.gui_extension_points_handlers:

                             handler = handler[:4]

                         con.connection.unregister_handler(*handler)

     def activate_plugin(self, plugin):

         '''

         :param plugin: plugin to be activated

         for plugin_object in self.active_plugins:

             self.deactivate_plugin(plugin_object)

     def _add_gui_extension_points_handlers_from_plugin(self, plugin):

         for gui_extpoint_name, gui_extpoint_handlers in \

         plugin.gui_extension_points.items():

         if plugin.encryption_name:

             self.encryption_plugins[plugin.encryption_name] = plugin

     def _handle_all_gui_extension_points_with_plugin(self, plugin):

         for gui_extpoint_name, gui_extpoint_handlers in \

         plugin.gui_extension_points.items():

                                         handler, exc_info=True)

     def _activate_all_plugins(self):

         '''

         Activates all plugins in `plugins`.

     def _set_plugin_active_in_global_config(self, plugin, active=True):

         app.config.set_per('plugins', plugin.short_name, 'active', active)

     def scan_dir_for_plugins(self, path, scan_dirs=True, package=False):

         r'''

         Scans given directory for plugin classes.