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 _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 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 __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 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 activate(self, obj):
try:
Popen(['pass', 'show', '-c', obj.name], stdout=PIPE)
except OSError as e:
if debug:
print_debug(e)
pass
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 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 _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 __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 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 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 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 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 _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 _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_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 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 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 __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 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_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 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
