class Reader(object):
def __init__(self, login, passwd):
self._googlereader = GoogleReader()
self._googlereader.identify(login=login, passwd=passwd)
if not (self._googlereader.login()):
raise "Can't login"
self._database = ReaderDatabase('reader.sqlite3')
def synchro(self):
xmlfeed = self._googlereader.get_feed(n=200)
self._database.start_add_session()
for entry in xmlfeed.get_entries():
self._database.add_item(
google_id=entry['google_id'].encode('utf-8'),
original_id=entry['original_id'].encode('utf-8'),
link=entry['link'].encode('utf-8'),
content=entry['content'].encode('utf-8'),
title=entry['title'].encode('utf-8'),
author=entry['author'].encode('utf-8'),
published=entry['published'],
updated=entry['updated'],
crawled=entry['crawled'],
)
for term in entry['categories']:
label = entry['categories'][term]
self._database.add_item_categorie(
google_id=entry['google_id'].encode('utf-8'),
categorie_name=term.encode('utf-8'),
categorie_shortname=label.encode('utf-8'),
)
self._database.stop_add_session()
class Reader(object) :
def __init__(self,login,passwd) :
self._googlereader = GoogleReader()
self._googlereader.identify(login=login,passwd=passwd)
if not(self._googlereader.login()) :
raise "Can't login"
self._database = ReaderDatabase('reader.sqlite3')
def synchro(self) :
xmlfeed = self._googlereader.get_feed(n=200)
self._database.start_add_session()
for entry in xmlfeed.get_entries() :
self._database.add_item(
google_id=entry['google_id'].encode('utf-8'),
original_id=entry['original_id'].encode('utf-8'),
link=entry['link'].encode('utf-8'),
content=entry['content'].encode('utf-8'),
title=entry['title'].encode('utf-8'),
author=entry['author'].encode('utf-8'),
published=entry['published'],
updated=entry['updated'],
crawled=entry['crawled'],
)
for term in entry['categories'] :
label = entry['categories'][term]
self._database.add_item_categorie(
google_id=entry['google_id'].encode('utf-8'),
categorie_name=term.encode('utf-8'),
categorie_shortname=label.encode('utf-8'),
)
self._database.stop_add_session()
def recommend_with_google(request):
"""
Make a recommendation by parsing the user's google reader feeds
"""
form = GoogleLoginForm(request.POST)
if form.is_valid():
cache_key = "feed-hashes-%s" % form.cleaned_data.get("username")
feed_hashes = cache.get(cache_key)
if not feed_hashes:
reader = GoogleReader()
reader.identify(form.cleaned_data.get("username"), form.cleaned_data.get("password"))
if reader.login():
feeds = reader.get_subscription_list()
client = PostRank()
feed_hashes = []
for feed in feeds.get("subscriptions"):
if feed.get("id"):
feed_hash = client.get_feed_hash(feed.get("id")[5:])
if feed_hash:
feed_hashes.append(feed_hash)
cache.set(cache_key, feed_hashes, 24 * 60 * 60)
else:
if request.is_ajax():
template = "google_error.html"
else:
template = "google_error_page.html"
return render_to_response("recommender/%s" % template, {
}, context_instance=RequestContext(request))
if feed_hashes:
recommendations = client.get_recommendations(feed_hashes, limit=5)
if recommendations:
if request.is_ajax():
template = "results.html"
else:
template = "results_page.html"
return render_to_response("recommender/%s" % template, {
"results": recommendations,
}, context_instance=RequestContext(request))
return render_to_response("recommender/google.html", {
"recommend_form": form,
}, context_instance=RequestContext(request))
class GoogleBase(object):
_SORT_PREFIXE = 'sort:'
def __init__(self, config):
self._config = config
self._filter = self._config['filter']
self.__googlereader = None
def _get_googlereader(self):
if self.__googlereader is None:
login_info = {
'login': self._config['login'],
'passwd': self._config['passwd']
}
http_proxy = None
proxy_host = self._config['proxy_host']
if (proxy_host is not None) and (proxy_host != ''):
http_proxy = (proxy_host, "%s" % self._config['proxy_port'])
self.__googlereader = GoogleReader(
agent='pyrfeed-framework-contact:pyrfeed_at_gmail/%s' %
pyrfeed_version,
http_proxy=http_proxy)
self.__googlereader.identify(**login_info)
if not (self.__googlereader.login()):
raise Exception("Can't login")
return self.__googlereader
def get_shortname(self, longname):
if longname.startswith(CONST.ATOM_PREFIXE_LABEL):
shortname = 'label:' + longname[len(CONST.ATOM_PREFIXE_LABEL):]
elif longname.startswith(CONST.ATOM_PREFIXE_STATE_GOOGLE):
shortname = 'state:' + longname[len(CONST.ATOM_PREFIXE_STATE_GOOGLE
):]
elif longname.startswith(CONST.ATOM_GET_FEED):
shortname = 'feed:' + longname[len(CONST.ATOM_GET_FEED):]
else:
shortname = longname
return shortname
def get_longname(self, shortname):
if shortname.startswith('label:'):
longname = CONST.ATOM_PREFIXE_LABEL + shortname[len('label:'):]
elif shortname.startswith('state:'):
longname = CONST.ATOM_PREFIXE_STATE_GOOGLE + shortname[len('state:'
):]
elif longname.startswith('feed:'):
shortname = CONST.ATOM_GET_FEED + longname[len('feed:'):]
else:
longname = shortname
return longname
def get_filter(self):
return self._filter
def set_filter(self, filter_command):
self._filter = filter_command
def _format_content(self, content, title, date):
fdate = time.strftime(self._config['datefmt'], time.gmtime(date))
return "<h1>%s</h1><p align='right'><font size='-1'>%s</font></p><br align='left'>%s" % (
title, fdate, content)
def get_feed_args_default(self):
"""Get the default arguments for get_feed, based on current configuration"""
get_feed_args = {}
max_count = self._config['google/max_count']
if not (self._config['google/include_read']):
get_feed_args['exclude_target'] = CONST.ATOM_STATE_READ
if self._config['url']:
get_feed_args['url'] = self._config['url']
if self._config['label']:
get_feed_args[
'feed'] = CONST.ATOM_PREFIXE_LABEL + self._config['label']
elif self._config['feed']:
get_feed_args['feed'] = self._config['feed']
get_feed_args['count'] = max_count
return get_feed_args
def get_reader():
reader = GoogleReader()
reader.identify('*****@*****.**', '02515633tzf')
reader.login()
return reader
class GoogleBase(object) :
_SORT_PREFIXE = 'sort:'
def __init__(self,config) :
self._config = config
self._filter = self._config['filter']
self.__googlereader = None
def _get_googlereader(self) :
if self.__googlereader is None :
login_info = { 'login' : self._config['login'], 'passwd' : self._config['passwd'] }
http_proxy = None
proxy_host = self._config['proxy_host']
if (proxy_host is not None) and (proxy_host!='') :
http_proxy = (proxy_host,"%s" % self._config['proxy_port'])
self.__googlereader = GoogleReader(agent='pyrfeed-framework-contact:pyrfeed_at_gmail/%s' % pyrfeed_version,http_proxy=http_proxy)
self.__googlereader.identify(**login_info)
if not(self.__googlereader.login()) :
raise Exception("Can't login")
return self.__googlereader
def get_shortname(self,longname) :
if longname.startswith(CONST.ATOM_PREFIXE_LABEL) :
shortname = 'label:' + longname[len(CONST.ATOM_PREFIXE_LABEL):]
elif longname.startswith(CONST.ATOM_PREFIXE_STATE_GOOGLE) :
shortname = 'state:' + longname[len(CONST.ATOM_PREFIXE_STATE_GOOGLE):]
elif longname.startswith(CONST.ATOM_GET_FEED) :
shortname = 'feed:' + longname[len(CONST.ATOM_GET_FEED):]
else :
shortname = longname
return shortname
def get_longname(self,shortname) :
if shortname.startswith('label:') :
longname = CONST.ATOM_PREFIXE_LABEL + shortname[len('label:'):]
elif shortname.startswith('state:') :
longname = CONST.ATOM_PREFIXE_STATE_GOOGLE + shortname[len('state:'):]
elif longname.startswith('feed:') :
shortname = CONST.ATOM_GET_FEED + longname[len('feed:'):]
else :
longname = shortname
return longname
def get_filter(self) :
return self._filter
def set_filter(self,filter_command) :
self._filter = filter_command
def _format_content(self,content,title,date) :
fdate = time.strftime(self._config['datefmt'],time.gmtime( date ))
return "<h1>%s</h1><p align='right'><font size='-1'>%s</font></p><br align='left'>%s" % (title,fdate,content)
def get_feed_args_default(self) :
"""Get the default arguments for get_feed, based on current configuration"""
get_feed_args = {}
max_count = self._config['google/max_count']
if not(self._config['google/include_read']) :
get_feed_args['exclude_target'] = CONST.ATOM_STATE_READ
if self._config['url'] :
get_feed_args['url'] = self._config['url']
if self._config['label'] :
get_feed_args['feed'] = CONST.ATOM_PREFIXE_LABEL + self._config['label']
elif self._config['feed'] :
get_feed_args['feed'] = self._config['feed']
get_feed_args['count'] = max_count
return get_feed_args
class Reader(object):
def __init__(self, email, password):
self.reader = GoogleReader()
self.reader.identify(email, password)
if not self.reader.login():
raise Exception(u'Failed to login to Google Reader')
self.clear_cache()
def clear_cache(self):
self.cache = {}
@cache('subscriptions')
def get_subscriptions(self):
subscriptions = {}
for x in self.reader.get_subscription_list()['subscriptions']:
subscriptions[x['id']] = x
return subscriptions
@cache('feed_title')
def get_feed_title(self):
return self.get_unread_feed().get_title()
@cache('unread_feed')
def get_unread_feed(self):
return self.reader.get_feed(count=CONF.unread.max_count,
exclude_target=CONST.ATOM_STATE_READ)
@cache('unread_entries')
def get_unread_entries(self):
subscriptions = self.get_subscriptions()
entries = []
for entry in self.get_unread_feed().get_entries():
if self.ad_filter(entry): continue
id = entry['sources'].keys()[0]
entry['subscription_id'] = id
entry['subscription_title'] = subscriptions[id]['title']
entry['pinned'] = False
# XXX
cat = entry['categories']
entry['starred'] = cat.has_key(CONST.ATOM_STATE_STARRED)
# FIXME fresh? or unread?
entry['unread'] = cat.has_key(CONST.ATOM_STATE_FRESH)
entries.append(entry)
ChildThread(self.decode, entries).start()
return entries
@cache('unread_counts')
def get_unread_counts(self):
counts = {}
for x in self.reader.get_unread_count_list()['unreadcounts']:
counts[x['id']] = x['count']
return counts
@cache('unread_count')
def get_unread_count(self):
for k,v in self.get_unread_counts().iteritems():
if k.endswith('/state/com.google/reading-list'): return v
return 0
def get_pinned_count(self):
return len(self.get_pinned_entries())
@cache('starred_count')
def get_starred_count(self):
return len(filter(lambda x: x['starred'], self.get_unread_entries()))
@cache('pinned_entries')
def get_pinned_entries(self):
return []
def toggle_pin(self, entry):
entry['pinned'] = not entry['pinned']
if entry['pinned']: self.get_pinned_entries().append(entry)
else: self.get_pinned_entries().remove(entry)
def toggle_star(self, entry):
# XXX
if entry['starred']:
ChildThread(self.reader.del_star, entry['google_id']).start()
self.cache['starred_count'] -= 1
else:
ChildThread(self.reader.add_star, entry['google_id']).start()
self.cache['starred_count'] += 1
entry['starred'] = not entry['starred']
def set_read(self, entry):
if not entry['unread']: return
ChildThread(self.reader.set_read, entry['google_id']).start()
entry['unread'] = False
self.cache['unread_count'] -= 1
def set_unread(self, entry):
if entry['unread']: return
ChildThread(self.reader.set_unread, entry['google_id']).start()
entry['unread'] = True
self.cache['unread_count'] += 1
def toggle_read(self, entry):
if entry['unread']: self.set_read(entry)
else: self.set_unread(entry)
def ad_filter(self, entry):
if not CONF.ad_filter.enable: return False
if CONF.ad_filter.pattern.match(entry['title']):
Thread(target=self.reader.set_read, args=(entry['google_id'],)).run()
return True
return False
def decode(self, entries):
for entry in entries:
cmd = 'w3m -dump -T text/html'
proc = Popen(cmd, shell=True, stdin=PIPE, stdout=PIPE)
proc.stdin.write(entry['content'].encode('utf-8'))
proc.stdin.close()
entry['content'] = proc.stdout.readlines()
