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
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)))
