def load_plugin_icon(plugin_name, icon_name, icon_data): "Load icon from @icon_data into the name @icon_name" for size in (24, 96): pixbuf = get_pixbuf_from_data(icon_data, size, size) gtk.icon_theme_add_builtin_icon(icon_name, size, pixbuf) pretty.print_debug(__name__, "Loading icon", icon_name, "at", size, "for", plugin_name)
def _load_abook_sqlite(filename): ''' Load contacts from abook.sqlite filename. Thunderbird (like firefox) lock database, so it mus be opened as immutable and read-only. Also changes may be not visible immediate - require close sqlite file by thunderbird. ''' dbfpath = filename.replace("?", "%3f").replace("#", "%23") dbfpath = "file:" + dbfpath + "?immutable=1&mode=ro" for _ in range(2): try: pretty.print_debug(__name__, "_load_abook_sqlite load:", dbfpath) with closing(sqlite3.connect(dbfpath, uri=True, timeout=1)) as conn: cur = conn.cursor() cur.execute(_ABOOK_CONTACTS_SQL) for (first_name, last_name, display_name, primary_email, second_email) in cur: if not display_name: display_name = ' '.join((first_name, last_name)) if display_name: display_name = display_name.strip() for email in (primary_email, second_email): if email: yield (display_name or email[:email.find('@')], email) return except sqlite3.Error as err: # Something is wrong with the database # wait short time and try again pretty.print_debug(__name__, "_load_abook_sqlite error:", str(err)) time.sleep(1)
def _remove(self, src): self._invalidate_root() self.toplevel_sources.discard(src) self.sources.discard(src) self.rescanner.set_catalog(self.sources) self._finalize_source(src) pretty.print_debug(__name__, "Remove", repr(src))
def get_guake(): try: bus = dbus.SessionBus() dbusObj = bus.get_object('org.guake.RemoteControl', '/org/guake/RemoteControl') return dbus.Interface(dbusObj, dbus_interface='org.guake.RemoteControl') except dbus.exceptions.DBusException, err: pretty.print_debug(err)
def resolve_unique_id(puid, excluding=None): """ Resolve unique id @puid The caller (if a Source) should pass itself as @excluding, so that recursion into itself is avoided. """ if excluding is not None: with _exclusion(excluding): return resolve_unique_id(puid, None) if puid is None: return None if isinstance(puid, SerializedObject): try: return puid.reconstruct() except Exception as exc: pretty.print_debug(__name__, type(exc).__name__, exc) return None sc = GetSourceController() obj = _find_obj_in_catalog(puid, sc._firstlevel) if obj is not None: return obj other_sources = set(sc.sources) - set(sc._firstlevel) obj = _find_obj_in_catalog(puid, other_sources) return obj
def _translate(text, lang): ''' Translate @text to @lang. ''' query_param = urllib.urlencode(dict(v="1.0",langpair="|"+lang, q=text.encode('utf-8'))) try: if ssl_support.is_supported(): conn = ssl_support.VerifiedHTTPSConnection(_GOOGLE_TRANSLATE_HOST, timeout=5) pretty.print_debug(__name__, "Connected to", _GOOGLE_TRANSLATE_HOST, "using SSL") else: conn = httplib.HTTPConnection(_GOOGLE_TRANSLATE_HOST, timeout=5) conn.request("POST", _GOOGLE_TRANSLATE_PATH, query_param, _HEADER) resp = conn.getresponse() if resp.status != 200: raise ValueError('invalid response %d, %s' % (resp.status, resp.reason)) response_data = resp.read() encoding = _parse_encoding_header(resp) response_data = response_data.decode(encoding, 'replace') pretty.print_debug(__name__, "Translate response:", repr(response_data)) try: resp = json_decoder(response_data) yield resp['responseData']['translatedText'], '' except: pretty.print_exc(__name__) yield text, '' except socket.timeout: yield _("Google Translate connection timed out"), "" except (httplib.HTTPException, ValueError), err: pretty.print_error(__name__, '_translate error', repr(text), lang, err) yield _("Error connecting to Google Translate"), ""
def _translate(text, lang): ''' Translate @text to @lang. ''' query_param = urllib.urlencode( dict(v="1.0", langpair="|" + lang, q=text.encode('utf-8'))) try: if ssl_support.is_supported(): conn = ssl_support.VerifiedHTTPSConnection(_GOOGLE_TRANSLATE_HOST, timeout=5) pretty.print_debug(__name__, "Connected to", _GOOGLE_TRANSLATE_HOST, "using SSL") else: conn = httplib.HTTPConnection(_GOOGLE_TRANSLATE_HOST, timeout=5) conn.request("POST", _GOOGLE_TRANSLATE_PATH, query_param, _HEADER) resp = conn.getresponse() if resp.status != 200: raise ValueError('invalid response %d, %s' % (resp.status, resp.reason)) response_data = resp.read() encoding = _parse_encoding_header(resp) response_data = response_data.decode(encoding, 'replace') pretty.print_debug(__name__, "Translate response:", repr(response_data)) try: resp = json_decoder(response_data) yield resp['responseData']['translatedText'], '' except: pretty.print_exc(__name__) yield text, '' except socket.timeout: yield _("Google Translate connection timed out"), "" except (httplib.HTTPException, ValueError), err: pretty.print_error(__name__, '_translate error', repr(text), lang, err) yield _("Error connecting to Google Translate"), ""
def bind_key(keystr, keybinding_target=KEYBINDING_DEFAULT): """ Bind @keystr, unbinding any previous key for @keybinding_target. If @keystr is a false value, any previous key will be unbound. """ keybinding_target = int(keybinding_target) if Keybinder is None: return False def callback(keystr): return GetKeyboundObject()._keybinding(keybinding_target) if not _is_sane_keybinding(keystr): pretty.print_error(__name__, "Refusing to bind key", repr(keystr)) return False succ = True if keystr: try: succ = Keybinder.bind(keystr, callback) pretty.print_debug(__name__, "binding", repr(keystr)) GetKeyboundObject().emit_bound_key_changed(keystr, True) except KeyError as exc: pretty.print_error(__name__, exc) succ = False if succ: old_keystr = get_currently_bound_key(keybinding_target) if old_keystr and old_keystr != keystr: Keybinder.unbind(old_keystr) pretty.print_debug(__name__, "unbinding", repr(old_keystr)) GetKeyboundObject().emit_bound_key_changed(old_keystr, False) _register_bound_key(keystr, keybinding_target) return succ
def _load_languages(): ''' Load available languages from Google. Generator: (lang_code, lang name) ''' user_language = locale.getlocale(locale.LC_MESSAGES)[0] pretty.print_debug(__name__, '_load_languages') try: conn = httplib.HTTPConnection(_GOOGLE_TRANS_LANG_HOST) conn.connect() conn.sock.settimeout(10) # set timeout to 10 sec headers = { "Accept-Language": "%s, en;q=0.7" % user_language, } conn.request("GET", _GOOGLE_TRANS_LANG_PATH, headers=headers) resp = conn.getresponse() if resp.status != 200: raise ValueError('invalid response %d, %s' % (resp.status, resp.reason)) result = resp.read().decode(_parse_encoding_header(resp), "replace") result = _RE_GET_LANG_SELECT.findall(result) if result: for key, name in _RE_GET_LANG.findall(result[0]): yield key, name except socket.timeout: pretty.print_error(__name__, 'Timed out when loading languages') except (httplib.HTTPException, ValueError, socket.error), err: pretty.print_error(__name__, '_load_languages error', type(err), err)
def activate(self, leaf, iobj=None): from kupfer import scheduler # make a timer that will fire when Kupfer exits interval = utils.parse_time_interval(iobj.object) pretty.print_debug(__name__, "Run %s in %s seconds" % (leaf, interval)) timer = scheduler.Timer(True) timer.set(interval, leaf.run)
def __init__(self, argv, finish_callback, timeout_s, stdin=None): self.stdout = [] self.stderr = [] self.stdin = [] self.timeout = False self.killed = False self.finished = False self.finish_callback = finish_callback argv = _argv_to_locale(argv) pretty.print_debug(__name__, "AsyncCommand:", argv) flags = (glib.SPAWN_SEARCH_PATH | glib.SPAWN_DO_NOT_REAP_CHILD) pid, stdin_fd, stdout_fd, stderr_fd = \ glib.spawn_async(argv, standard_output=True, standard_input=True, standard_error=True, flags=flags) if stdin: self.stdin[:] = self._split_string(stdin, self.max_input_buf) in_io_flags = glib.IO_OUT | glib.IO_ERR | glib.IO_HUP | glib.IO_NVAL glib.io_add_watch(stdin_fd, in_io_flags, self._in_io_callback, self.stdin) else: os.close(stdin_fd) io_flags = glib.IO_IN | glib.IO_ERR | glib.IO_HUP | glib.IO_NVAL glib.io_add_watch(stdout_fd, io_flags, self._io_callback, self.stdout) glib.io_add_watch(stderr_fd, io_flags, self._io_callback, self.stderr) self.pid = pid glib.child_watch_add(pid, self._child_callback) if timeout_s is not None: glib.timeout_add_seconds(timeout_s, self._timeout_callback)
def getClient(): client = mpd.MPDClient() if mpdConnect(client) and mpdAuth(client): pretty.print_debug(__name__, 'Got connected!') else: pretty.print_debug(__name__, 'fail to connect MPD server.') return client
def bind_key(keystr, keybinding_target=KEYBINDING_DEFAULT): """ Bind @keystr, unbinding any previous key for @keybinding_target. If @keystr is a false value, any previous key will be unbound. """ try: import keybinder except ImportError: pretty.print_error( __name__, "Could not import keybinder, " "keybindings disabled!") return False keybinding_target = int(keybinding_target) callback = lambda: GetKeyboundObject()._keybinding(keybinding_target) if not _is_sane_keybinding(keystr): pretty.print_error(__name__, "Refusing to bind key", repr(keystr)) return False succ = True if keystr: try: succ = keybinder.bind(keystr, callback) pretty.print_debug(__name__, "binding", repr(keystr)) GetKeyboundObject().emit_bound_key_changed(keystr, True) except KeyError, exc: pretty.print_error(__name__, exc) succ = False
def get_hotot(): try: bus = dbus.SessionBus() dbusObj = bus.get_object('org.hotot.service', '/org/hotot/service') return dbus.Interface(dbusObj, dbus_interface='org.hotot.service') except dbus.exceptions.DBusException, err: pretty.print_debug(err)
def get_file_results_sparql(searchobj, query, max_items=50, order_by="rank", location=None, **kwargs): clean_query = sparql_escape(query) if location: location_filter = \ 'FILTER(tracker:uri-is-descendant ("%s", nie:url (?s)))' % sparql_escape(location) else: location_filter = "" sql = ("""SELECT tracker:coalesce (nie:url (?s), ?s) WHERE { ?s fts:match "%(query)s" . ?s tracker:available true . %(location_filter)s } %(order_by)s OFFSET 0 LIMIT %(limit)d""" % dict( query=clean_query, location_filter=location_filter, order_by=ORDER_BY[order_by], limit=int(max_items)) ) pretty.print_debug(__name__, sql) results = searchobj.SparqlQuery(sql, **kwargs) if results is None: return new_file = Gio.File.new_for_uri for result in results: try: yield FileLeaf(new_file(result[0]).get_path()) except Exception: # This very vague exception is from getpath continue
def _import_plugin_fake(modpath, error=None): """ Return an object that has the plugin info attributes we can rescue from a plugin raising on import. @error: If applicable, a tuple of exception info """ loader = pkgutil.get_loader(modpath) if not loader: return None code = loader.get_code(modpath) if not code: return None try: filename = loader.get_filename() except AttributeError: try: filename = loader.archive + loader.prefix except AttributeError: filename = "<%s>" % modpath env = { "__name__": modpath, "__file__": filename, } code = _truncate_code(code, info_attributes) try: eval(code, env) except Exception, exc: pretty.print_debug(__name__, "Loading", modpath, exc)
def __eq__(self, other): try: return (type(self) == type(other) and str(self) == str(other) and path.samefile(self.object, other.object)) except OSError as exc: pretty.print_debug(__name__, exc) return False
def ensure_display_open(cls, display): """ Return GdkDisplay for name @display. Return default if @display is None. """ def norm_name(name): "normalize display name" if name[-2] == ":": return name + ".0" return name dm = gtk.gdk.display_manager_get() if display: new_display = None for disp in dm.list_displays(): if norm_name(disp.get_name()) == norm_name(display): new_display = disp break if new_display is None: pretty.print_debug(__name__, "Opening display in ensure_display_open", display) new_display = gtk.gdk.Display(display) else: new_display = gtk.gdk.display_get_default() ## Hold references to all open displays cls._open_displays = set(dm.list_displays()) return new_display
def _prune_register(): """ Remove items with chance (len/25000) Assuming homogenous records (all with score one) we keep: x_n+1 := x_n * (1 - chance) To this we have to add the expected number of added mnemonics per invocation, est. 10, and we can estimate a target number of saved mnemonics. """ import random random.seed() rand = random.random goalitems = 500 flux = 2.0 alpha = flux/goalitems**2 chance = min(0.1, len(_register)*alpha) for leaf, mn in _get_mnemonic_items(_register): if rand() > chance: continue mn.decrement() if not mn: del _register[leaf] l = len(_register) pretty.print_debug(__name__, "Pruned register (%d mnemonics)" % l)
def get_hamster(): try: bus = dbus.SessionBus() dbusObj = bus.get_object('org.gnome.Hamster', '/org/gnome/Hamster') return dbus.Interface(dbusObj, dbus_interface='org.gnome.Hamster') except dbus.exceptions.DBusException, err: pretty.print_debug(err)
def activate(self, obj): try: Popen(['pass', 'show', '-c', obj.name], stdout=PIPE) except OSError as e: if debug: print_debug(e) pass
def spawn_async(argv, in_dir="."): pretty.print_debug(__name__, "Spawn commandline", argv, in_dir) try: return gobject.spawn_async (argv, working_directory=in_dir, flags=gobject.SPAWN_SEARCH_PATH) except gobject.GError, exc: pretty.print_debug(__name__, "spawn_async", argv, exc)
def use_theme(enabled): pretty.print_debug(__name__, "updating setting to", enabled) s = Gtk.Settings.get_default() if enabled is None: s.reset_property(PREFER_DARK) else: s.set_property(PREFER_DARK, enabled)
def bind_key(keystr, keybinding_target=KEYBINDING_DEFAULT): """ Bind @keystr, unbinding any previous key for @keybinding_target. If @keystr is a false value, any previous key will be unbound. """ try: import keybinder except ImportError: pretty.print_error(__name__, "Could not import keybinder, " "keybindings disabled!") return False keybinding_target = int(keybinding_target) callback = lambda : GetKeyboundObject()._keybinding(keybinding_target) if not _is_sane_keybinding(keystr): pretty.print_error(__name__, "Refusing to bind key", repr(keystr)) return False succ = True if keystr: try: succ = keybinder.bind(keystr, callback) pretty.print_debug(__name__, "binding", repr(keystr)) GetKeyboundObject().emit_bound_key_changed(keystr, True) except KeyError, exc: pretty.print_error(__name__, exc) succ = False
def get_contacts(): ''' load all contacts ''' pretty.print_debug(__name__, 'get_contacts start') contacts = None start_time = time.time() try: gd_client = get_gclient() if gd_client is None: return None contacts = [] query = gdata.contacts.service.ContactsQuery() query.max_results = 9999 # load all contacts for entry in gd_client.GetContactsFeed(query.ToUri()).entry: common_name = kupferstring.tounicode(entry.title.text) for email in entry.email: if email.address: image = None if __kupfer_settings__['loadicons']: image = gd_client.GetPhoto(entry) email = email.address contacts.append( GoogleContact(email, common_name or email, image)) except (gdata.service.BadAuthentication, gdata.service.CaptchaRequired), err: pretty.print_error(__name__, 'get_contacts error', 'authentication error', err) contacts = [InvalidCredentialsLeaf(__name__, __kupfer_name__)]
def activate(self, leaf): expr = leaf.object.lstrip("= ") # try to add missing parantheses brackets_missing = expr.count("(") - expr.count(")") if brackets_missing > 0: expr += ")" * brackets_missing environment = dict(math.__dict__) environment.update(cmath.__dict__) # define some constants missing if self.last_result is not None: environment["_"] = self.last_result environment["help"] = Help() environment["kupfer"] = KupferSurprise("inf") # make the builtins inaccessible environment["__builtins__"] = {} pretty.print_debug(__name__, "Evaluating", repr(expr)) try: result = eval(expr, environment) resultstr = format_result(result) self.last_result = result except IgnoreResultException: return except Exception, exc: pretty.print_error(__name__, type(exc).__name__, exc) resultstr = unicode(exc)
def __init__(self, argv, finish_callback, timeout_s, stdin=None, env=""): self.stdout = [] self.stderr = [] self.stdin = [] self.timeout = False self.killed = False self.finished = False self.finish_callback = finish_callback argv = _argv_to_locale(argv) pretty.print_debug(__name__, "AsyncCommand:", argv) # get default environment var if not given env = env or ['='.join(kv) for kv in os.environ.iteritems()] flags = (glib.SPAWN_SEARCH_PATH | glib.SPAWN_DO_NOT_REAP_CHILD) pid, stdin_fd, stdout_fd, stderr_fd = \ glib.spawn_async(argv, standard_output=True, standard_input=True, standard_error=True, flags=flags, envp=env) if stdin: self.stdin[:] = self._split_string(stdin, self.max_input_buf) in_io_flags = glib.IO_OUT | glib.IO_ERR | glib.IO_HUP | glib.IO_NVAL glib.io_add_watch(stdin_fd, in_io_flags, self._in_io_callback, self.stdin) else: os.close(stdin_fd) io_flags = glib.IO_IN | glib.IO_ERR | glib.IO_HUP | glib.IO_NVAL glib.io_add_watch(stdout_fd, io_flags, self._io_callback, self.stdout) glib.io_add_watch(stderr_fd, io_flags, self._io_callback, self.stderr) self.pid = pid glib.child_watch_add(pid, self._child_callback) if timeout_s is not None: glib.timeout_add_seconds(timeout_s, self._timeout_callback)
def show_url(url): """Open any @url with default viewer""" try: pretty.print_debug(__name__, "show_url", url) return Gtk.show_uri(Gdk.Screen.get_default(), url, Gtk.get_current_event_time()) except GLib.GError as exc: pretty.print_error(__name__, "Gtk.show_uri:", exc)
def ensure_display_open(cls, display): """ Return GdkDisplay for name @display. Return default if @display is None. """ def norm_name(name): "normalize display name" if name[-2] == ":": return name+".0" return name dm = gtk.gdk.display_manager_get() if display: new_display = None for disp in dm.list_displays(): if norm_name(disp.get_name()) == norm_name(display): new_display = disp break if new_display is None: pretty.print_debug(__name__, "Opening display in ensure_display_open", display) new_display = gtk.gdk.Display(display) else: new_display = gtk.gdk.display_get_default() ## Hold references to all open displays cls._open_displays = set(dm.list_displays()) return new_display
def monitor_directories(self, *directories, **kwargs): """Register @directories for monitoring; On changes, the Source will be marked for update. This method returns a monitor token that has to be stored for the monitor to be active. The token will be a false value if nothing could be monitored. Nonexisting directories are skipped, if not passing the kwarg @force """ tokens = [] force = kwargs.get('force', False) for directory in directories: gfile = Gio.File.new_for_path(directory) if not force and not gfile.query_exists(): continue try: monitor = gfile.monitor_directory(Gio.FileMonitorFlags.NONE, None) except GLib.GError as exc: pretty.print_debug(__name__, "FilesystemWatchMixin", exc) continue if monitor: monitor.connect("changed", self.__directory_changed) tokens.append(monitor) return NonpersistentToken(tokens)
def _create_dbus_connection(SERVICE_NAME, OBJECT_NAME, IFACE_NAME, activate=False): ''' Create dbus connection to EDS Addressbook @activate: true=starts EDS Addressbook if not running usually eds addressbook subprocesses starts at boot and keep running in the background ''' interface = None obj = None sbus = dbus.SessionBus() try: #check for running pidgin (code from note.py) proxy_obj = sbus.get_object('org.freedesktop.DBus', '/org/freedesktop/DBus') dbus_iface = dbus.Interface(proxy_obj, 'org.freedesktop.DBus') if activate or dbus_iface.NameHasOwner(SERVICE_NAME): obj = sbus.get_object(SERVICE_NAME, OBJECT_NAME) if obj: interface = dbus.Interface(obj, IFACE_NAME) except dbus.exceptions.DBusException as err: pretty.print_debug(__name__, err) return interface
def _prune_register(): """ Remove items with chance (len/25000) Assuming homogenous records (all with score one) we keep: x_n+1 := x_n * (1 - chance) To this we have to add the expected number of added mnemonics per invocation, est. 10, and we can estimate a target number of saved mnemonics. """ import random random.seed() rand = random.random goalitems = 500 flux = 2.0 alpha = flux / goalitems**2 chance = min(0.1, len(_register) * alpha) for leaf, mn in _get_mnemonic_items(_register): if rand() > chance: continue mn.decrement() if not mn: del _register[leaf] l = len(_register) pretty.print_debug(__name__, "Pruned register (%d mnemonics)" % l)
def get_contacts(): ''' load all contacts ''' pretty.print_debug(__name__, 'get_contacts start') contacts = None start_time = time.time() try: gd_client = get_gclient() if gd_client is None: return None contacts = [] query = gdata.contacts.service.ContactsQuery() query.max_results = 9999 # load all contacts for entry in gd_client.GetContactsFeed(query.ToUri()).entry: common_name = kupferstring.tounicode(entry.title.text) for email in entry.email: if email.address: image = None if __kupfer_settings__['loadicons']: image = gd_client.GetPhoto(entry) email = email.address contacts.append(GoogleContact(email, common_name or email, image)) except (gdata.service.BadAuthentication, gdata.service.CaptchaRequired), err: pretty.print_error(__name__, 'get_contacts error', 'authentication error', err) contacts = [InvalidCredentialsLeaf(__name__, __kupfer_name__)]
def get_items(self): if self.playlists: try: for playlist in self.playlists.GetPlaylists( 0, 20, Playlist_Ordering.LAST_PLAY_DATE, False): yield PlaylistLeaf(playlist, self.mpris_uri) except Exception as exc: pretty.print_debug(__name__, 'exceptions', exc)
def launch_commandline(cli, name=None, in_terminal=False): " Raises SpawnError " argv = desktop_parse.parse_argv(cli) pretty.print_error(__name__, "Launch commandline is deprecated ") pretty.print_debug(__name__, "Launch commandline (in_terminal=", in_terminal, "):", argv, sep="") if in_terminal: return spawn_in_terminal(argv) return spawn_async(argv)
def get_searchobject(sname, opath, sinface): bus = dbus.SessionBus() searchobj = None try: tobj = bus.get_object(sname, opath) searchobj = dbus.Interface(tobj, sinface) except dbus.DBusException, exc: pretty.print_debug(__name__, exc)
def _pickle_register(self, reg, pickle_file): ## Write to tmp then rename over for atomicity tmp_pickle_file = "%s.%s" % (pickle_file, os.getpid()) pretty.print_debug(__name__, "Saving to %s" % (pickle_file, )) with open(tmp_pickle_file, "wb") as output: output.write(pickle.dumps(reg, pickle.HIGHEST_PROTOCOL)) os.rename(tmp_pickle_file, pickle_file) return True
def _get_tmpl_dir(self): tmpl_dir = GLib.get_user_special_dir(GLib.UserDirectory.DIRECTORY_TEMPLATES) if tmpl_dir == os.path.expanduser("~"): tmpl_dir = None if not tmpl_dir: tmpl_dir = os.path.expanduser(DEFAULT_TMPL_DIR) pretty.print_debug(__name__, tmpl_dir) return tmpl_dir
def activate(self, leaf, iobj, ctx): from kupfer import scheduler # make a timer that will fire when Kupfer exits interval = utils.parse_time_interval(iobj.object) pretty.print_debug(__name__, "Run %s in %s seconds" % (leaf, interval)) timer = scheduler.Timer(True) args = (ctx, ) if leaf.wants_context() else () timer.set(interval, leaf.run, *args)
def activate(self, leaf, iobj, ctx): from kupfer import scheduler # make a timer that will fire when Kupfer exits interval = utils.parse_time_interval(iobj.object) pretty.print_debug(__name__, "Run %s in %s seconds" % (leaf, interval)) timer = scheduler.Timer(True) args = (ctx,) if leaf.wants_context() else () timer.set(interval, leaf.run, *args)
def clean_up_unarchived_files(cls): if not cls.unarchived_files: return pretty.print_info(__name__, "Removing extracted archives..") for filetree in set(cls.unarchived_files): pretty.print_debug(__name__, "Removing", os.path.basename(filetree)) shutil.rmtree(filetree, onerror=cls._clean_up_error_handler) cls.unarchived_files = []
def get_hamster(): try: bus = dbus.SessionBus() dbusObj = bus.get_object('org.gnome.Hamster', '/org/gnome/Hamster') return dbus.Interface(dbusObj, dbus_interface='org.gnome.Hamster') except dbus.exceptions.DBusException as err: pretty.print_debug(err) return None
def __eq__(self, other): try: return (type(self) == type(other) and unicode(self) == unicode(other) and path.samefile(self.object, other.object)) except OSError, exc: pretty.print_debug(__name__, exc) return False
def try_again(self, retry): app_ended_interval = __kupfer_settings__["app_ended_interval"] app_end_timeout = __kupfer_settings__["app_end_timeout"] max_run_times = app_end_timeout / app_ended_interval pretty.print_debug( __name__, 'app_ended_interval %s, app_end_timeout %s, retry %s, max_run_times %s' % (app_ended_interval, app_end_timeout, retry, max_run_times)) return retry <= max_run_times - 1
def update_fact(self, leaf): fact = format_fact_string(leaf.activity, leaf.category, leaf.description, leaf.tags) pretty.print_debug( __name__, "Going to update fact %d: %s" % (leaf.fact_id, fact)) leaf.fact_id = get_hamster().UpdateFact(leaf.fact_id, fact, leaf.starttime, leaf.endtime, False) return leaf
def _icon_render_change(setctl, *arguments): global _IconRenderer renderer_dict = setctl.get_preferred_alternative('icon_renderer') renderer = renderer_dict.get("renderer") if not renderer or renderer is _IconRenderer: return pretty.print_debug(__name__, "Using", renderer) _icon_theme_changed(None) _IconRenderer = renderer