def timeline(request): user = request.user if not user.is_authenticated() or 'twitter_tokens' not in request.session: return render_to_response('landing.html') twitter_tokens = request.session['twitter_tokens'] tp = TwitterUserProfile.objects.get(id=twitter_tokens['user_id']) api = get_authorized_twython(twitter_tokens) statuses = Status.construct_from_dicts(api.getFriendsTimeline(include_rts=True)) cache_timeline_backfill.delay(tp, twitter_tokens, statuses) friends = api.getFriendsStatus() Rating.appendTo(statuses, tp) return render_to_response('twitter/timeline.html', { 'statuses': statuses, 'friends': friends, 'feedtype': 'normal' }, context_instance=RequestContext(request))
def public_profile(request, username): if request.user.is_authenticated() and 'twitter_tokens' in request.session: twitter_tokens = request.session['twitter_tokens'] api = get_authorized_twython(twitter_tokens) else: # Require login return HttpResponseRedirect("/") friend = api.showUser(screen_name=username) friends = api.getFriendsStatus() prof = request.user.get_profile() tp = TwitterUserProfile.objects.get(user=prof) follow_request_sent = True is_true_friend = friend['following'] is_me = tp.id == friend['id'] if not is_true_friend: is_true_friend = False outgoing = api.friendshipsOutgoing() follow_request_sent = False if friend['id'] in outgoing['ids']: # if we have already requested to follow this person follow_request_sent = True if friend['protected'] and not is_true_friend: statuses = None else: try: statuses = Status.construct_from_dicts(api.getUserTimeline(screen_name=username)) Rating.appendTo(statuses, tp) except TwythonError: statuses = None return render_to_response('twitter/public_profile.html', { 'friends': friends, 'username': username, 'friend': friend, 'is_true_friend' : is_true_friend, 'is_me' : is_me, 'profile_protected' : friend['protected'], 'follow_request_sent': follow_request_sent, 'statuses' : statuses, }, context_instance=RequestContext(request))
def cache_timeline_backfill_callback(sender, **kwargs): """ Backfill cached timeline from the oldest tweet in statuses to the cached_time in TwitterUserProfile or 72 hours, whichever is sooner""" statuses, tp = kwargs['statuses'], kwargs['twitter_user_profile'] twitter_tokens = kwargs['twitter_tokens'] api = get_authorized_twython(twitter_tokens) oldest_time = datetime.now()-timedelta(hours=72) """ backfill_start = min(statuses, key=lambda x: x.created_at) backfill_end = max([tp.cached_time, oldest_time]) if backfill_start < backfill_end: return """ backfill_maxid = min(statuses, key=lambda x: x.id).id try: backfill_minid = max(tp.cached_statuses.filter(created_at__gt=oldest_time), key=lambda x: x.id).id if backfill_maxid < backfill_minid: return except IndexError: backfill_minid = None # print "backfill minid: " + str(backfill_minid) # print "backfill maxid: " + str(backfill_maxid) cache_timeline_signal.send(sender=sender, statuses=statuses, twitter_user_profile=tp) finished = False total_num_statuses = len(statuses) while not finished: recieved_statuses = Status.construct_from_dicts( api.getFriendsTimeline(count=200, include_rts=True, max_id=backfill_maxid, min_id=backfill_minid)) total_num_statuses += len(recieved_statuses) cache_timeline_signal.send(sender=sender, statuses=recieved_statuses, twitter_user_profile=tp) if total_num_statuses >= 600 or len(recieved_statuses) < 200: finished = True else: backfill_maxid = statuses[-1].id
def normal_timeline(api, tp, page, maxid): if tp.cached_maxid >= maxid >= tp.cached_minid: return tp.cached_statuses.filter(id__lt=maxid)[:20] else: return Status.construct_from_dicts(api.getFriendsTimeline(page=page))
def cache_timeline_backfill(tp, twitter_tokens, statuses): """ Backfill cached timeline from the oldest tweet in statuses to the cached_time in TwitterUserProfile or 72 hours, whichever is sooner""" api = get_authorized_twython(twitter_tokens) cutoff_time = datetime.utcnow()-timedelta(hours=72) if not statuses: statuses = Status.construct_from_dicts(api.getFriendsTimeline(include_rts=True)) backfill_maxid = min(statuses, key=lambda x: x.id).id backfill_newestid = max(statuses, key=lambda x: x.id).id # Maxid and minid indicate contiguous cached status ids minid = getattr(tp, 'cached_minid', 0) maxid = getattr(tp, 'cached_maxid', 0) # No new tweets at all if backfill_newestid == maxid: return # Only one page of new tweets - just cache these if backfill_maxid < maxid: cache_statuses(statuses, tp) return # Cache as far back as 800 tweets or 72 hours worth num_apicalls = 1 finished = False total_num_statuses = len(statuses) while not finished: print "backfill minid: " + str(maxid) print "backfill maxid: " + str(backfill_maxid) recieved_statuses = Status.construct_from_dicts( api.getFriendsTimeline(count=200, include_rts=True, max_id=backfill_maxid, min_id=maxid)) num_apicalls += 1 total_num_statuses += len(recieved_statuses) statuses.extend(recieved_statuses) oldest_status = min(recieved_statuses, key=lambda x: x.id) if (oldest_status.created_at < cutoff_time or oldest_status.id <= maxid or num_apicalls >= 5): finished = True else: backfill_maxid = oldest_status.id # Set new minid, maxid for contiguous cached statuses if oldest_status.id <= maxid: tp.cached_minid = minid else: tp.cached_minid = oldest_status.id tp.cached_maxid = backfill_newestid tp.save() # If less than 50 rated statuses: force train user classifier if Rating.objects.filter(user=tp).count() < 50: force_train(tp) # print "num apicalls: " + str(num_apicalls) cache_statuses(statuses, tp)