def setup(self): st = QSettings("blain", "blain") st.setValue("_", 0) st.sync() settingspath = dirname(str(st.fileName())) self.db = db = Database(location=pathjoin(settingspath, "blain.sqlite")) setup_models(db)
class MicroblogThread(QThread): def __init__(self, app, user, service, updateusers = True): QThread.__init__(self, app) self.app = app self.user = user self.service = service self.updateusers = updateusers self.friends = QSettings("blain", "%s-%s-friends" % (user, service)) def run(self): if not self.service or not self.user: self.quit() return trys = 0 page = -1 new_friends = None try: friendscount = api_call(self.service, 'users/show', {'id': self.user})['friends_count'] except: print_exc() self.end() return while friendscount > 0: page = next_page(self.service, page, new_friends) print "Fetching from friends page %i, %i updates remaining (%s)" % \ (page, friendscount, self.service),"[%i]"%trys new_friends = get_friends(self.service, self.user, page) stop = False friendscount -= len(new_friends) if len(new_friends) == 0: trys += 1 for friend in new_friends: id = str(friend['screen_name']) if self.friends.contains(id): print id, "(found)", self.service stop = True else: print id, "(new)", self.service dump = json.dumps(friend) self.friends.setValue(id, dump) if stop or trys > 3: break #self.yieldCurrentThread() print "friends list up-to-date. (%s)" % self.service self.end() def end(self): self.app.killThread.emit("__%s__" % self.service) # update all users if self.updateusers: for user in self.friends.allKeys() + [self.user]: self.app.updateUser.emit(self.service, user) self.app.updates.updates.friends(self.service, user) print "done." self.quit()
def settingsValue( key, default): syslog.syslog( syslog.LOG_DEBUG, "DEBUG settingsValue %s, default: %s" % (key, str(default))) s = QSettings() var = s.value(key, default) if not s.contains(key): s.setValue( key, var) syslog.syslog( syslog.LOG_DEBUG, "DEBUG settingsValue %s, value: %s" % (key, var.toString())) return var
def write_settings(self): logging.debug('Writing settings') settings = QSettings() settings.clear() for k in self._settings_dict: if k in self.defaults: if self._settings_dict[k] != self.defaults[k]: settings.setValue(k, self._settings_dict[k]) else: msg = 'Setting key {} not found in defaults'.format(k) logging.warning(msg) settings.setValue(k, self._settings_dict[k])
def on_backup_folder_button_clicked(self): backup_path = self.backup_folder_edit.text() if len(backup_path) == 0: backup_path = QDir.tempPath() backup_path = QFileDialog.getExistingDirectory(self, self.tr("Select Backup Folder"), backup_path, QFileDialog.ShowDirsOnly | QFileDialog.DontResolveSymlinks) if len(backup_path) == 0: return self.backup_folder_edit.setText(backup_path) settings = QSettings("GCI", "vertex-tools") settings.beginGroup("BackupSettings") settings.setValue("backup_path", backup_path) settings.endGroup()
class GroupsThread(QThread): def __init__(self, app, user, updategroups = True): QThread.__init__(self, app) self.app = app self.user = user self.updategroups = updategroups self.groups = QSettings("blain", "%s-groups" % user) def run(self): if not self.user: self.quit() return trys = 0 new_groups = None while trys < 4: trys += 1 new_groups = get_group(self.user) if new_groups is not None: break if new_groups is None: self.end() return for group in new_groups: id = str(group['nickname']) if self.groups.contains(id): print id, "(found)" else: print id, "(new)" dump = json.dumps(clean_urls(group)) self.groups.setValue(id, dump) print "groups list up-to-date. (%s)" % self.user self.end() def end(self): self.app.killThread.emit("%s groups" % self.user) # update all groups if self.updategroups: for group in self.groups.allKeys(): self.app.updateGroup.emit(group) self.app.updates.updates.groups(self.user) print "done." self.quit()
class Config: def __init__(self, organization, product): self.config = QSettings(organization, product) def setValue(self, option, value): self.config.setValue(option, QVariant(value)) self.config.sync() def getBoolValue(self, option): default = self._initValue(option, False) return self.config.value(option, QVariant(default)).toBool() def getNumValue(self, option): default = self._initValue(option, 0) return self.config.value(option, QVariant(default)).toInt()[0] def _initValue(self, option, value): if defaults.has_key(option): return defaults[option] return value
def closeEvent(self, QCloseEvent): settings = QSettings() settings.setValue('width', QVariant(self.settings['width'])) settings.setValue('color', QVariant(self.settings['color'])) settings.setValue('x_grid', QVariant(self.settings['x_grid'])) settings.setValue('y_grid', QVariant(self.settings['y_grid'])) settings.setValue('grid_opacity', QVariant(self.settings['grid_opacity']))
def setSettingsValue( key, val): syslog.syslog( syslog.LOG_DEBUG, "DEBUG setSettingsValue %s, value: %s" % (key, str(val))) s = QSettings() s.setValue( key, val)
class Updater: def __init__(self, app): if not hasattr(app, 'preferences'): print("update: need 'preferences' from app.") exit(1) self.app = app self.update = {} self.timers = [] self.updates = drug() self.timer = QTimer(app) self.settings = QSettings("blain", "timers") def connect(self): win = self.app.window.ui win.actionDoUpdates.triggered.connect(self.do) win.actionUpdate_now.triggered.connect(self.all) self.timer.timeout.connect(self.timer_step) self.app.window.ui.actionDoUpdates.setChecked( self.app.preferences.settings.value("timer/active",True).toBool()) def setup(self): app, st, pref = self.app, self.settings, self.app.preferences.settings self.update['user'] = app.updateUser.emit self.update['friends'] = lambda *args: \ app.updateMicroblogging.emit(args[0], app.preferences.settings.value(\ "account/"+args[0]+"/id").toString(),\ False, *args[2:]) friends = drug(twitter = [], identica = []) if pref.contains("account/twitter/id"): friends.twitter = map(unicode, QSettings("blain", "%s-twitter-friends" % pref.value("account/twitter/id").\ toString()).allKeys()) if pref.contains("account/identica/id"): friends.identica = map(unicode, QSettings("blain", "%s-identica-friends" % pref.value("account/identica/id").\ toString()).allKeys()) # format: (timestamp, func, service, user, *args) self.timers = timers = [ unicode(st.value(str(i)).toString()) for i in range(st.value("count",0).toInt()[0]) ] # add timer entries new_friends = ['twitter', 'identica'] new_friend = {'twitter':friends.twitter , 'identica':friends.identica} for timer in map(lambda t: unicode(t).split(","), timers): if timer[1] == 'user': if timer[3] in new_friend[timer[2]]: new_friend[timer[2]].remove(timer[3]) elif timer[1] == 'friends': if timer[2] in new_friends: new_friends.remove(timer[2]) for service in new_friends: timers.append("{0},friends,{1},".format(time(),service)) for service in new_friend: for i, user in enumerate(new_friend[service]): new_friend[service][i] = "{0},user,{1},{2}".\ format(time(),service,user) if new_friend['twitter'] or new_friend['identica']: timers.extend(list(sum(zip(new_friend['identica'], new_friend['twitter']), ()))) if len(new_friend['twitter']) > len(new_friend['identica']): timers.extend(new_friend['twitter'][len(new_friend['identica']):]) else: timers.extend(new_friend['identica'][len(new_friend['twitter']):]) st.setValue('count',len(timers)) for i in range(len(timers)): st.setValue(str(i), timers[i]) self.timers = list(map(lambda t: [float(t[0])] + t[1:], map(lambda t: unicode(t).split(","), timers))) self.updates.user = self.user self.updates.friends = self.friends self.timer.setInterval( pref.value("timer/interval",1e4).toInt()[0]) # 10 sec if pref.value("timer/active", True).toBool(): self.timer.start() def user(self, service, user, count , ok): # new_updates count service, user = unicode(service), unicode(user) cur, n = None, -1 for i, timer in enumerate(self.timers): if timer[1] == "user" and timer[2] == service and timer[3] == user: n, cur = i, timer break if cur is None: return cur[0] = time() - (not ok) * 5 - count / len(self.timers) self.settings.setValue(str(n), ",".join(map(unicode, cur))) def friends(self, service, user): # new_updates count service, user = unicode(service), unicode(user) cur, n = None, -1 for i, timer in enumerate(self.timers): if timer[1] == "friends" and timer[2] == service: n, cur = i, timer break if cur is None: return cur[0] = time() self.settings.setValue(str(n), ",".join(map(unicode, cur))) def timer_step(self): print "* timer update" cur = self.timers[0] for timer in self.timers: if timer[0] < cur[0]: cur = timer print cur self.update[cur[1]](*cur[2:]) def twitter(self, start = True): self.app.threads.updateMicroblogging('twitter', self.app.preferences.ui.twitteridEdit.text()) if start: self.app.threads.start('twitter') def identica(self, start = True): self.app.threads.updateMicroblogging('identica', self.app.preferences.ui.identicaidEdit.text()) if start: self.app.threads.start('identica') def do(self, checked): if checked: self.timer.start() else: self.timer.stop() self.app.preferences.settings.setValue("timer/active", checked) def all(self): self.identica(False) self.twitter(False) self.app.threads.start('identica', 'twitter')
class Updater: def __init__(self, app): if not hasattr(app, 'preferences'): print("update: need 'preferences' from app.") exit(1) if not hasattr(app, 'accounts'): print("update: need 'accounts' from app.") exit(1) self.app = app self.update = {} self.timers = [] self.updates = drug() self.timer = QTimer(app) self.settings = QSettings("blain", "timers") def connect(self): win = self.app.window.ui win.actionDoUpdates.triggered.connect(self.do) win.actionUpdate_now.triggered.connect(self.all) self.timer.timeout.connect(self.timer_step) self.app.window.ui.actionDoUpdates.setChecked( self.app.preferences.settings.value("timer/active",False).toBool()) def setup(self): app, st, pref = self.app, self.settings, self.app.preferences.settings account_id = {} # thread starting functions self.update['user'] = app.updateUser.emit self.update['group'] = app.updateGroup.emit self.update['groups'] = lambda *args: \ app.updateGroups.emit(*(args[:2]+(False,)+args[3:])) self.update['friends'] = lambda *args: \ app.updateFriends.emit(*(args[:2]+(False,)+args[3:])) # read existing friends and groups friends, friends_list, groups, groups_list = {}, {}, {}, {} for account in self.app.accounts.get(): if account.service not in friends: friends[account.service] = {} if account.service not in friends_list: friends_list[account.service] = [] friends_list[account.service].append(account.name) friends[account.service][account.name] = \ list(map(unicode, account.friends.allKeys())) + [account.name] if account.groups is not None: if account.service not in groups: groups[account.service] = {} if account.service not in groups_list: groups_list[account.service] = [] groups_list[account.service].append(account.name) groups[account.service][account.name] = \ list(map(unicode, account.groups.allKeys())) # read existing timer events # format: (timestamp, func, service, account, user, *args) timers = [ unicode(st.value(str(i)).toString()) for i in range(st.value("count",0).toInt()[0]) ] #find new timer events user_leveled = {'user': friends, 'group': groups} account_leveled = {'friends': friends_list, 'groups': groups_list} for timer in map(lambda t: unicode(t).split(","), timers): if timer[1] == 'user' or timer[1] == 'group': # choose current data service_level = user_leveled[timer[1]] # dive data levels if timer[2] in service_level: account_level = service_level[timer[2]] if timer[3] in account_level: user_level = account_level[timer[3]] if timer[4] in user_level: # event found, remove it user_level.remove(timer[4]) elif timer[1] == 'friends' or timer[1] == 'groups': # choose current data service_level = account_leveled[timer[1]] # dive data levels if timer[2] in service_level: account_level = service_level[timer[2]] if timer[3] in account_level: # event found, remove it account_level.remove(timer[3]) # save left overs t = time() # add new group lists timers.extend([ u"{0},groups,{1},{2},".format(t, service, account) for service in groups_list for account in groups_list[service] ]) # add new friend lists timers.extend([ u"{0},friends,{1},{2},".format(t, service, account) for service in friends_list for account in friends_list[service] ]) # add new groups timers.extend([ u"{0},group,{1},{2},{3}".format(t,service,account,group) for service in groups for account in groups[service] for group in groups[service][account] ]) # add new friends timers.extend([ u"{0},user,{1},{2},{3}".format(t,service,account,user) for service in friends for account in friends[service] for user in friends[service][account] ]) # add some random to the order so twitter # wont get called to often in a row hopfully if len(timers) != st.value("count", 0).toInt()[0]: shuffle(timers) # inplace # save new timers st.setValue('count',len(timers)) for i, timer in enumerate(timers): st.setValue(str(i), timer) # more python readable format timers = [ unicode(t).split(",") for t in timers ] timers = [ [float(t[0])] + t[1:] for t in timers ] self.timers = timers # start timers self.updates.user = self.user self.updates.group = self.group self.updates.groups = self.groups self.updates.friends = self.friends self.timer.setInterval( pref.value("timer/interval",1e4).toInt()[0]) # 10 sec if pref.value("timer/active", True).toBool(): self.timer.start() def add_timer(self, func, service, account, user, *args): timer = ",".join(map(unicode, [time(), func, service, account, user])) if args: timer += "," + ",".join(map(unicode, args)) self.settings.setValue(str(len(self.timers)), timer) timer = timer.split(",") self.timers.append([float(timer[0])] + timer[1:]) self.settings.setValue("count", len(self.timers)) def remove_timer(self, func, service, account, user): found, cur = [], ",".join(map(unicode, [func, service, account, user])) for i, timer in enumerate(self.timers): if cur in ",".join(map(unicode, timer)): found.append(i) if not found: return for i in reversed(found): self.timers.pop(i) self.settings.setValue('count',len(self.timers)) for i, timer in enumerate(self.timers[found[0]:]): self.settings.setValue(str(i+found[0]),",".join(map(unicode,timer))) def new_updates(self, account, new_time, break_): # new_updates count cur, n, service, accid = None, -1, account.service, account.name for i, timer in enumerate(self.timers): if service == timer[2] and accid == timer[3] and break_(timer): n, cur = i, timer break if cur is None: return cur[0] = new_time self.settings.setValue(str(n), ",".join(map(unicode, cur))) def user(self, account, user, count, ok): # new_updates count if count: self.app.notifier.notify_by_mode( amount = count, user = user) self.new_updates(account, time() - (not ok) * 5 - count / len(self.timers), lambda t: t[1] == "user" and t[4] == user) def group(self, account, group, count, ok): # new_updates count if count: self.app.notifier.notify_by_mode( amount = count, user = "******" + group) self.new_updates(account, time() - (not ok) * 5 - count / len(self.timers), lambda t: t[1] == "group" and t[4] == group) def groups(self, account): # new_updates count self.new_updates(account, time(), lambda t: t[1] == "groups") def friends(self, account): # new_updates count self.new_updates(account, time(), lambda t: t[1] == "friends") def timer_step(self): cur = self.timers[0] for timer in self.timers: if timer[0] < cur[0]: cur = timer print "* timer update", cur self.update[cur[1]](*cur[2:]) def account(self, account, start = True): acc = account.service, account.name ids = [u"{0}{1}friends".format(*acc)] self.app.threads.updateFriends(*acc) if account.groups is not None: ids.append(u"{0}{1}groups".format(*acc)) self.app.threads.updateGroups(*acc) if start: self.app.threads.start(*ids) return [] return ids def do(self, checked): if checked: self.timer.start() else: self.timer.stop() self.app.preferences.settings.setValue("timer/active", checked) def all(self): self.app.threads.start( *sum([ self.account(account,False) for account in self.app.accounts.get() ],[]))
class Updater: def __init__(self, app): if not hasattr(app, 'preferences'): print("update: need 'preferences' from app.") exit(1) self.app = app self.update = {} self.timers = [] self.updates = drug() self.timer = QTimer(app) self.settings = QSettings("blain", "timers") def connect(self): win = self.app.window.ui win.actionDoUpdates.triggered.connect(self.do) win.actionUpdate_now.triggered.connect(self.all) self.timer.timeout.connect(self.timer_step) self.app.window.ui.actionDoUpdates.setChecked( self.app.preferences.settings.value("timer/active",True).toBool()) def setup(self): app, st, pref = self.app, self.settings, self.app.preferences.settings account_id = {} # thread starting functions self.update['user'] = app.updateUser.emit self.update['group'] = lambda *args: app.updateGroup.emit(*args[1:]) self.update['groups'] = lambda *args: \ app.updateGroups.emit(args[1], False, *args[2:]) self.update['friends'] = lambda *args: \ app.updateMicroblogging.emit(args[0], account_id[service], False, *args[2:]) # read existing friends friends = {} for service in ["twitter", "identica"]: friends[service] = [] if pref.contains("account/%s/id" % service): account_id[service] = pref.value( "account/%s/id" % service).toString() friends[service] = map(unicode, QSettings("blain", "%s-%s-friends" % (account_id[service], service)).allKeys()) friends = drug(**friends) # read existing groups groups = [] if pref.contains("account/identica/id"): groups = map(unicode, QSettings("blain", "%s-groups" % account_id['identica']).allKeys()) # format: (timestamp, func, service, user, *args) timers = [ unicode(st.value(str(i)).toString()) for i in range(st.value("count",0).toInt()[0]) ] # find new timer entries new_friend = {'twitter':friends.twitter , 'identica':friends.identica} new_friends = new_friend.keys() new_group = groups new_groups = True for timer in map(lambda t: unicode(t).split(","), timers): if timer[1] == 'user': if timer[3] in new_friend[timer[2]]: new_friend[timer[2]].remove(timer[3]) elif timer[1] == 'friends': if timer[2] in new_friends: new_friends.remove(timer[2]) elif timer[1] == 'groups': new_groups = False elif timer[1] == 'group': if timer[3] in new_group: new_group.remove(timer[3]) # add new friend lists for service in new_friends: timers.append("{0},friends,{1},".format(time(), service)) # add groups update timer if new_groups and 'identica' in account_id: timers.append("{0},groups,,{1}".\ format(time(), account_id['identica'])) # add new groups for group in new_group: timers.append("{0},group,,{1}".format(time(), group)) # add new friends for service in new_friend: for i, user in enumerate(new_friend[service]): new_friend[service][i] = "{0},user,{1},{2}".\ format(time(),service,user) # zip list(friends) of both services together if new_friend['twitter'] or new_friend['identica']: timers.extend(list(sum(zip(new_friend['identica'], new_friend['twitter']), ()))) if len(new_friend['twitter']) > len(new_friend['identica']): timers.extend(new_friend['twitter'][len(new_friend['identica']):]) else: timers.extend(new_friend['identica'][len(new_friend['twitter']):]) # save new timers st.setValue('count',len(timers)) for i in range(len(timers)): st.setValue(str(i), timers[i]) # more python readable format timers = [ unicode(t).split(",") for t in timers ] timers = [ [float(t[0])] + t[1:] for t in timers ] self.timers = timers # start timers self.updates.user = self.user self.updates.group = self.group self.updates.groups = self.groups self.updates.friends = self.friends self.timer.setInterval( pref.value("timer/interval",1e4).toInt()[0]) # 10 sec if pref.value("timer/active", True).toBool(): self.timer.start() def new_updates(self, service, user, new_time, break_): # new_updates count cur, n = None, -1 for i, timer in enumerate(self.timers): if break_(timer): n, cur = i, timer break if cur is None: return cur[0] = new_time self.settings.setValue(str(n), ",".join(map(unicode, cur))) def user(self, service, user, count , ok): # new_updates count if count: self.app.notifier.notify_by_mode( amount = count, user = user) service, user = unicode(service), unicode(user) self.new_updates(service, user, time() - (not ok) * 5 - count / len(self.timers), lambda t: t[1] == "user" and t[2] == service and t[3] == user) def group(self, _, group, count , ok): # new_updates count if count: self.app.notifier.notify_by_mode( amount = count, user = "******" + group) user = unicode(group) self.new_updates("identica", group, time() - (not ok) * 5 - count / len(self.timers), lambda t: t[1] == "group" and t[3] == group) def groups(self, user): # new_updates count user = unicode(user) self.new_updates('identica', user, time(), lambda t: t[1] == "groups") def friends(self, service, user): # new_updates count service, user = unicode(service), unicode(user) self.new_updates(service, user, time(), lambda t: t[1] == "friends" and t[2] == service) def timer_step(self): print "* timer update" cur = self.timers[0] for timer in self.timers: if timer[0] < cur[0]: cur = timer print cur self.update[cur[1]](*cur[2:]) def twitter(self, start = True): self.app.threads.updateMicroblogging('twitter', self.app.preferences.ui.twitteridEdit.text()) ids = ['__twitter__'] if start: self.app.threads.start(*ids) return [] return ids def identica(self, start = True): user = self.app.preferences.ui.identicaidEdit.text() self.app.threads.updateMicroblogging('identica', user) self.app.threads.updateGroups(user) ids = ['__identica__', '%s groups' % user] if start: self.app.threads.start(*ids) return [] return ids def do(self, checked): if checked: self.timer.start() else: self.timer.stop() self.app.preferences.settings.setValue("timer/active", checked) def all(self): self.app.threads.start(*(self.identica(False) + self.twitter(False)))