libervia-desktop-kivy: cagou/core/cagou

comparison cagou/core/cagou_main.py @ 312:772c170b47a9

Python3 port: /!\ Cagou now runs with Python 3.6+ Port has been done in the same way as for backend (check backend commit b2d067339de3 message for details).

author	Goffi <goffi@goffi.org>
date	Tue, 13 Aug 2019 19:14:22 +0200
parents	f55b60659ec1
children	86566968837a

comparison

equal deleted inserted replaced

-:a0d978d3ce84
+:772c170b47a9
 import glob
 import sys
 from sat.core.i18n import _
 from . import kivy_hack
 kivy_hack.do_hack()
-from constants import Const as C
+from .constants import Const as C
 from sat.core import log as logging
 log = logging.getLogger(__name__)
 from sat.core import exceptions
 from sat_frontends.quick_frontend.quick_app import QuickApp
 from sat_frontends.quick_frontend import quick_widgets
 elif bridge_name in ('pb', 'embedded'):
 kivy.support.install_twisted_reactor()
 from kivy.app import App
 from kivy.lang import Builder
 from kivy import properties
-import xmlui
+from . import xmlui
-from profile_manager import ProfileManager
+from .profile_manager import ProfileManager
 from kivy.clock import Clock
 from kivy.uix.label import Label
 from kivy.uix.boxlayout import BoxLayout
 from kivy.uix.floatlayout import FloatLayout
 from kivy.uix.screenmanager import (ScreenManager, Screen,
 from kivy.core.window import Window
 from kivy.animation import Animation
 from kivy.metrics import dp
 from kivy import utils as kivy_utils
 from kivy.config import Config as KivyConfig
-from cagou_widget import CagouWidget
+from .cagou_widget import CagouWidget
 from . import widgets_handler
 from .common import IconButton
 from . import menu
 from . import dialog
 from importlib import import_module
 import cagou.kv
 try:
 from plyer import notification
 except ImportError:
 notification = None
-log.warning(_(u"Can't import plyer, some features disabled"))
+log.warning(_("Can't import plyer, some features disabled"))
 ## platform specific settings ##
 if kivy_utils.platform == "android":
 def open(self, widget):
 self.clear_widgets()
 for n in self.notes:
 kwargs = {
-u'title': n.title,
+'title': n.title,
-u'message': n.message,
+'message': n.message,
-u'level': n.level
+'level': n.level
 }
 if n.symbol is not None:
-kwargs[u'symbol'] = n.symbol
+kwargs['symbol'] = n.symbol
 if n.action is not None:
-kwargs[u'action'] = n.action
+kwargs['action'] = n.action
 self.add_widget(NoteDrop(title=n.title, message=n.message, level=n.level,
 symbol=n.symbol, action=n.action))
 self.add_widget(self.clear_btn)
 super(NotesDrop, self).open(widget)
 """
 self.notifs_icon.addNotif(callback, *args, **kwargs)
 def addNote(self, title, message, level, symbol, action):
 kwargs = {
-u'title': title,
+'title': title,
-u'message': message,
+'message': message,
-u'level': level
+'level': level
 }
 if symbol is not None:
-kwargs[u'symbol'] = symbol
+kwargs['symbol'] = symbol
 if action is not None:
-kwargs[u'action'] = action
+kwargs['action'] = action
 note = Note(**kwargs)
 self.notes.append(note)
 if self.notes_event is None:
 self.notes_event = Clock.schedule_interval(self._displayNextNote, 5)
 self._displayNextNote()
 # a settings screen when pressing F1 or platform specific key
 return
 def build(self):
 Window.bind(on_keyboard=self.key_input)
-wid = CagouRootWidget(Label(text=u"Loading please wait"))
+wid = CagouRootWidget(Label(text="Loading please wait"))
 if sys.platform == 'android':
 # we don't want menu on Android
 wid.root_menus.height = 0
 return wid
 service.start(mActivity, argument)
 self.service = service
 bridge_module = dynamic_import.bridge(bridge_name, 'sat_frontends.bridge')
 if bridge_module is None:
-log.error(u"Can't import {} bridge".format(bridge_name))
+log.error("Can't import {} bridge".format(bridge_name))
 sys.exit(3)
 else:
-log.debug(u"Loading {} bridge".format(bridge_name))
+log.debug("Loading {} bridge".format(bridge_name))
 super(Cagou, self).__init__(bridge_factory=bridge_module.Bridge,
 xmlui=xmlui,
 check_options=quick_utils.check_options,
 connect_bridge=False)
 self._import_kv()
 'downloads_dir')
 if not os.path.exists(self.downloads_dir):
 try:
 os.makedirs(self.downloads_dir)
 except OSError as e:
-log.warnings(_(u"Can't create downloads dir: {reason}").format(reason=e))
+log.warnings(_("Can't create downloads dir: {reason}").format(reason=e))
 self.app.default_avatar = os.path.join(self.media_dir, "misc/default_avatar.png")
 self.app.icon = os.path.join(self.media_dir,
 "icons/muchoslava/png/cagou_profil_bleu_96.png")
 self._plg_wids = []  # main widgets plugins
 self._plg_wids_transfer = []  # transfer widgets plugins
 'no_certificate_validation',
 C.BOOL_FALSE))
 if not self.tls_validation:
 from cagou.core import patches
 patches.apply()
-log.warning(u"SSL certificate validation is disabled, this is unsecure!")
+log.warning("SSL certificate validation is disabled, this is unsecure!")
 @property
 def visible_widgets(self):
-for w_list in self._visible_widgets.itervalues():
+for w_list in self._visible_widgets.values():
 for w in w_list:
 yield w
 @QuickApp.sync.setter
 def sync(self, state):
 else:
 raise exceptions.InternalError("base.kv is missing")
 for kv_file in kv_files:
 Builder.load_file(kv_file)
-log.debug(u"kv file {} loaded".format(kv_file))
+log.debug("kv file {} loaded".format(kv_file))
 def _import_plugins(self):
 """import all plugins"""
 self.default_wid = None
 plugins_path = os.path.dirname(cagou.plugins.__file__)
-plugin_glob = u"plugin*." + C.PLUGIN_EXT
+plugin_glob = "plugin*." + C.PLUGIN_EXT
 plug_lst = [os.path.splitext(p)[0] for p in
 map(os.path.basename, glob.glob(os.path.join(plugins_path,
 plugin_glob)))]
 imported_names_main = set()  # used to avoid loading 2 times
 for plug in plug_lst:
 plugin_path = 'cagou.plugins.' + plug
 # we get type from plugin name
 suff = plug[7:]
-if u'_' not in suff:
+if '_' not in suff:
-log.error(u"invalid plugin name: {}, skipping".format(plug))
+log.error("invalid plugin name: {}, skipping".format(plug))
 continue
-plugin_type = suff[:suff.find(u'_')]
+plugin_type = suff[:suff.find('_')]
 # and select the variable to use according to type
 if plugin_type == C.PLUG_TYPE_WID:
 imported_names = imported_names_main
 default_factory = self._defaultFactoryMain
 elif plugin_type == C.PLUG_TYPE_TRANSFER:
 imported_names = imported_names_transfer
 default_factory = self._defaultFactoryTransfer
 else:
-log.error(u"unknown plugin type {type_} for plugin {file_}, skipping"
+log.error("unknown plugin type {type_} for plugin {file_}, skipping"
 .format(
 type_ = plugin_type,
 file_ = plug
 ))
 continue
 plugin_info['plugin_file'] = plug
 plugin_info['plugin_type'] = plugin_type
 if 'platforms' in plugin_info:
 if sys.platform not in plugin_info['platforms']:
-log.info(u"{plugin_file} is not used on this platform, skipping"
+log.info("{plugin_file} is not used on this platform, skipping"
 .format(**plugin_info))
 continue
 # import name is used to differentiate plugins
 if 'import_name' not in plugin_info:
 plugin_info['import_name'] = plug
 if plugin_info['import_name'] in imported_names:
-log.warning(_(u"there is already a plugin named {}, "
+log.warning(_("there is already a plugin named {}, "
-u"ignoring new one").format(plugin_info['import_name']))
+"ignoring new one").format(plugin_info['import_name']))
 continue
 if plugin_info['import_name'] == C.WID_SELECTOR:
 if plugin_type != C.PLUG_TYPE_WID:
-log.error(u"{import_name} import name can only be used with {type_} "
+log.error("{import_name} import name can only be used with {type_} "
-u"type, skipping {name}".format(type_=C.PLUG_TYPE_WID,
+"type, skipping {name}".format(type_=C.PLUG_TYPE_WID,
 **plugin_info))
 continue
 # if WidgetSelector exists, it will be our default widget
 self.default_wid = plugin_info
 name_start = 8 + len(plugin_type)
 plugin_info['name'] = plug[name_start:]
 # we need to load the kv file
 if 'kv_file' not in plugin_info:
-plugin_info['kv_file'] = u'{}.kv'.format(plug)
+plugin_info['kv_file'] = '{}.kv'.format(plug)
 kv_path = os.path.join(plugins_path, plugin_info['kv_file'])
 if not os.path.exists(kv_path):
-log.debug(u"no kv found for {plugin_file}".format(**plugin_info))
+log.debug("no kv found for {plugin_file}".format(**plugin_info))
 else:
 Builder.load_file(kv_path)
 # what is the main class ?
 main_cls = getattr(mod, plugin_info['main'])
 if 'factory' not in plugin_info:
 plugin_info['factory'] = default_factory
 # icons
 for size in ('small', 'medium'):
-key = u'icon_{}'.format(size)
+key = 'icon_{}'.format(size)
 try:
 path = plugin_info[key]
 except KeyError:
 path = C.DEFAULT_WIDGET_ICON.format(media=self.media_dir)
 else:
 path = C.DEFAULT_WIDGET_ICON.format(media=self.media_dir)
 plugin_info[key] = path
 plugins_set.append(plugin_info)
 if not self._plg_wids:
-log.error(_(u"no widget plugin found"))
+log.error(_("no widget plugin found"))
 return
 # we want widgets sorted by names
 self._plg_wids.sort(key=lambda p: p['name'].lower())
 self._plg_wids_transfer.sort(key=lambda p: p['name'].lower())
 if type_ == C.PLUG_TYPE_WID:
 return self._plg_wids
 elif type_ == C.PLUG_TYPE_TRANSFER:
 return self._plg_wids_transfer
 else:
-raise KeyError(u"{} plugin type is unknown".format(type_))
+raise KeyError("{} plugin type is unknown".format(type_))
 def getPluggedWidgets(self, type_=C.PLUG_TYPE_WID, except_cls=None):
 """get available widgets plugin infos
 @param type_(unicode): type of widgets to get
 exist and be of the same value in requested plugin info
 @return (dict, None): found plugin info or None
 """
 plugins_set = self._getPluginsSet(type_)
 for plugin_info in plugins_set:
-for k, w in kwargs.iteritems():
+for k, w in kwargs.items():
 try:
 if plugin_info[k] != w:
 continue
 except KeyError:
 continue
 return plugin_info
 ## widgets handling
 def newWidget(self, widget):
-log.debug(u"new widget created: {}".format(widget))
+log.debug("new widget created: {}".format(widget))
 if isinstance(widget, quick_chat.QuickChat) and widget.type == C.CHAT_GROUP:
-self.addNote(u"", _(u"room {} has been joined").format(widget.target))
+self.addNote("", _("room {} has been joined").format(widget.target))
 def switchWidget(self, old, new):
 """Replace old widget by new one
 old(CagouWidgetn None): CagouWidget instance or a child
 if isinstance(w, CagouWidget):
 to_change = w
 break
 if to_change is None:
-raise exceptions.InternalError(u"no CagouWidget found when "
+raise exceptions.InternalError("no CagouWidget found when "
-u"trying to switch widget")
+"trying to switch widget")
 wrapper = to_change.parent
 while wrapper is not None and not(isinstance(wrapper, widgets_handler.WHWrapper)):
 wrapper = wrapper.parent
 if wrapper is None:
-raise exceptions.InternalError(u"no wrapper found")
+raise exceptions.InternalError("no wrapper found")
 wrapper.changeWidget(new)
 self.selected_widget = new
 def _addVisibleWidget(self, widget):
 if isinstance(widget, quick_widgets.QuickWidget):
 for w in self.widgets.getWidgetInstances(widget):
 if w.parent is None and w != widget:
 to_delete.append(w)
 for w in to_delete:
-log.debug(u"cleaning widget: {wid}".format(wid=w))
+log.debug("cleaning widget: {wid}".format(wid=w))
 self.widgets.deleteWidget(w)
 def getOrClone(self, widget):
 """Get a QuickWidget if it has not parent set else clone it
 # FIXME: Q&D way to get chat plugin, should be replaced by a clean method
 #        in host
 plg_infos = [p for p in self.getPluggedWidgets()
 if action in p['import_name']][0]
 except IndexError:
-log.warning(u"No plugin widget found to do {action}".format(action=action))
+log.warning("No plugin widget found to do {action}".format(action=action))
 else:
 factory = plg_infos['factory']
 self.switchWidget(None,
 factory(plg_infos, target=target, profiles=profiles))
 def _menusGetCb(self, backend_menus):
 main_menu = self.app.root.root_menus
 self.menus.addMenus(backend_menus)
 self.menus.addMenu(C.MENU_GLOBAL,
-(_(u"Help"), _(u"About")),
+(_("Help"), _("About")),
 callback=main_menu.onAbout)
 main_menu.update(C.MENU_GLOBAL)
 ## bridge handlers ##
 for widget in self.widgets.getWidgets(quick_chat.QuickChat, profiles=(profile,)):
 if widget.type == C.CHAT_ONE2ONE and widget.target == bare_jid:
 widget.onOTRState(state, dest_jid, profile)
 def _debugHandler(self, action, parameters, profile):
-if action == u"visible_widgets_dump":
+if action == "visible_widgets_dump":
 from pprint import pformat
-log.info(u"Visible widgets dump:\n{data}".format(
+log.info("Visible widgets dump:\n{data}".format(
 data=pformat(self._visible_widgets)))
 else:
 return super(Cagou, self)._debugHandler(action, parameters, profile)
 ## misc ##
 def plugging_profiles(self):
 self.app.root.changeWidget(widgets_handler.WidgetsHandler())
 self.bridge.menusGet("", C.NO_SECURITY_LIMIT, callback=self._menusGetCb)
 def setPresenceStatus(self, show='', status=None, profile=C.PROF_KEY_NONE):
-log.info(u"Profile presence status set to {show}/{status}".format(show=show,
+log.info("Profile presence status set to {show}/{status}".format(show=show,
 status=status))
 def errback(self, failure_, title=_('error'),
-message=_(u'error while processing: {msg}')):
+message=_('error while processing: {msg}')):
 self.addNote(title, message.format(msg=failure_), level=C.XMLUI_DATA_LVL_WARNING)
 def addNote(self, title, message, level=C.XMLUI_DATA_LVL_INFO, symbol=None,
 action=None):
 """add a note (message which disappear) to root widget's header"""
 False,
 answer_data)
 )
 self.addNotifWidget(wid)
 else:
-log.warning(_(u"unknown dialog type: {dialog_type}").format(dialog_type=type))
+log.warning(_("unknown dialog type: {dialog_type}").format(dialog_type=type))
-def desktop_notif(self, message, title=u'', duration=5000):
+def desktop_notif(self, message, title='', duration=5000):
+global notification
 if notification is not None:
 try:
 notification.notify(title=title,
 message=message,
 app_name=C.APP_NAME,
 app_icon=self.app.icon,
 timeout = duration)
 except Exception as e:
-log.warning(_(u"Can't use notifications, disabling: {msg}").format(
+log.warning(_("Can't use notifications, disabling: {msg}").format(
 msg = e))
-global notification
 notification = None

Mercurial > libervia-desktop-kivy

comparison cagou/core/cagou_main.py @ 312:772c170b47a9