def update_user_interests(date_from, date_to): active_users = readonly_session.query(UserActivity.user).filter( UserActivity.date_actioned.between(date_from, date_to)).subquery() activity_categories = readonly_session.query( UserActivity.user, Channel.category, func.count(func.distinct(Channel.id)) ).outerjoin( VideoInstance, (UserActivity.object_type == 'video_instance') & (UserActivity.object_id == VideoInstance.id) ).filter( ((UserActivity.object_type == 'channel') & (UserActivity.object_id == Channel.id)) | (VideoInstance.channel == Channel.id) ).filter( UserActivity.user.in_(active_users), Channel.category != None ).group_by('1, 2').order_by('1, 3 desc') for user, categories in groupby(activity_categories, lambda x: x[0]): UserInterest.query.filter_by(user=user).delete() db.session.execute(UserInterest.__table__.insert(), [ dict(user=user, explicit=False, category=category, weight=weight) for user, category, weight in categories ][:10])
def index_old(self): from gviz_data_table import Table from rockpack.mainsite.services.user.models import User, UserActivity user_count = readonly_session.query(func.count(User.id)).\ filter(User.refresh_token != '').scalar() header = ('user count', 'max lifetime', 'avg lifetime', 'stddev lifetime', 'max active days', 'avg active days', 'stddev active days') lifetime = func.date_part('days', func.max(UserActivity.date_actioned) - func.min(UserActivity.date_actioned)).label('lifetime') active_days = func.count(func.distinct(func.date( UserActivity.date_actioned))).label('active_days') activity = readonly_session.query(UserActivity.user, lifetime, active_days).\ group_by(UserActivity.user) ctx = {} for key, having_expr in ('all', None), ('1day', lifetime > 1), ('7day', lifetime > 7): data = activity.having(having_expr).from_self( func.count('*'), func.max(lifetime), func.avg(lifetime), func.stddev_samp(lifetime), func.max(active_days), func.avg(active_days), func.stddev_samp(active_days) ).one() table = Table([ dict(id='metric', type=str), dict(id='value', type=float), dict(id='%', type=str), ]) pdata = ('%d%%' % (data[0] * 100 / user_count),) + ('',) * 6 table.extend(zip(*(header, map(float, data), pdata))) ctx['ret_%s_data' % key] = table.encode() return self.render('admin/retention_stats_old.html', **ctx)
def get_query(self, date_from, date_to): from rockpack.mainsite.services.video.models import Video dates = readonly_session.query( func.date(Video.date_added).distinct().label('date_added') ).filter( Video.date_added.between(date_from, date_to) ).subquery() counts = readonly_session.query( func.date(Video.date_added).label('date_added'), func.count().label('count') ).filter( Video.link_title.isnot(None) ).group_by( func.date(Video.date_added) ).subquery() query = readonly_session.query( dates.c.date_added, func.sum(counts.c.count) ).filter( counts.c.date_added < dates.c.date_added ).group_by( dates.c.date_added ) return query
def get_users_categories(user_ids=None, start=None, stop=None): from rockpack.mainsite.services.video import models from rockpack.mainsite.services.user.models import User query = db.session.query(User, models.Channel, func.count(models.VideoInstance.id)).outerjoin( models.Channel, (models.Channel.owner == User.id) & (models.Channel.deleted == False) & (models.Channel.visible == True) & (models.Channel.public == True) ).outerjoin( models.VideoInstance, (models.VideoInstance.channel == models.Channel.id) & (models.VideoInstance.deleted == False) ).options( lazyload(models.Channel.category_rel), contains_eager(models.Channel.owner_rel) ) if start: updated_channels = readonly_session.query(distinct(models.Channel.id))\ .filter(models.Channel.date_updated.between(start, stop)) updated_instances = readonly_session.query(distinct(models.VideoInstance.channel))\ .filter(models.VideoInstance.date_updated.between(start, stop)) updated_users = readonly_session.query(distinct(models.Channel.id))\ .join(User, User.id == models.Channel.owner)\ .filter(User.date_updated.between(start, stop)) unioned = updated_channels.union_all(updated_instances, updated_users).subquery() query = query.filter(models.Channel.id.in_(unioned)) query = query.group_by(User.id, models.Channel.id).order_by(User.id) if user_ids: query = query.filter(User.id.in_(user_ids)) category_map = {} for user, channel, video_count in query: if channel and channel.category and condition_for_category(user, channel, video_count): category_map.setdefault(user, []).append(channel.category) else: category_map.setdefault(user, []) app.logger.info('User category map size: %d', len(category_map)) return category_map
def index(self): from rockpack.mainsite.services.video.models import Category ctx = {} parent = aliased(Category) cat_group = readonly_session.query( Category.name, # order is important parent.name, Category.id ).filter( Category.parent == parent.id ).group_by( parent.name, Category.name, Category.id ).order_by(parent.name, Category.name) cat_map = [] for (child_name, parent_name, child_id) in cat_group: users = search.UserSearch() users.add_term('category', child_id) users.set_paging(1, 0) users.users() cat_map.append( (parent_name, child_name, users.total, '/admin/stats/usercategories/%s/' % child_id)) ctx['cat_map'] = cat_map return self.render('admin/user_cat_stats.html', **ctx)
def index(self): from gviz_data_table import Table from rockpack.mainsite.services.user.models import User, UserActivity, UserAccountEvent if request.args.get('activity') == 'activity': activity_model, activity_date = UserActivity, UserActivity.date_actioned else: activity_model, activity_date = UserAccountEvent, UserAccountEvent.event_date try: interval_count = int(request.args['interval_count']) except Exception: interval_count = 10 interval = request.args.get('interval') if interval not in ('week', 'month'): interval = 'week' cohort = func.date_part(interval, User.date_joined) cohort_label = func.min(func.date(User.date_joined)) active_interval = (func.date_part(interval, activity_date) - cohort).label('active_interval') q = readonly_session.query(User).filter( User.date_joined > LAUNCHDATE, User.refresh_token != '') if request.args.get('gender') in ('m', 'f'): q = q.filter(User.gender == request.args['gender']) if request.args.get('locale') in app.config['ENABLED_LOCALES']: q = q.filter(User.locale == request.args['locale']) if request.args.get('age') in ('13-18', '18-25', '25-35', '35-45', '45-55'): age1, age2 = map(int, request.args['age'].split('-')) q = q.filter(between( func.age(User.date_of_birth), text("interval '%d years'" % age1), text("interval '%d years'" % age2) )) active_users = dict( ((c, int(w)), u) for c, w, u in q.join( activity_model, (activity_model.user == User.id) & (activity_date >= User.date_joined) ).group_by(cohort, active_interval).values( cohort, active_interval, func.count(func.distinct(activity_model.user)) ) ) table = Table( [dict(id='cohort', type=date)] + [dict(id='%s%d' % (interval, i), type=str) for i in range(interval_count)] ) totals = q.group_by(cohort).order_by(cohort) for c, l, t in totals.values(cohort, cohort_label, func.count()): data = [] for i in range(interval_count): a = active_users.get((c, i), '') data.append(a and '%d%% (%d)' % (ceil(a * 100.0 / t), a)) table.append([l] + data) return self.render('admin/retention_stats.html', data=table.encode())
def create_new_repack_notifications(date_from=None, date_to=None, user_notifications=None): packer_channel = aliased(Channel, name="source_channel") packer_user = aliased(User, name="packer_user") repacker_channel = aliased(Channel, name="repacker_channel") repacker_user = aliased(User, name="repacker_user") activity_window = readonly_session.query(VideoInstance, packer_channel, repacker_channel, repacker_user).join( packer_channel, packer_channel.id == VideoInstance.source_channel ).join( packer_user, packer_user.id == packer_channel.owner ).join( repacker_channel, (repacker_channel.id == VideoInstance.channel) & (repacker_channel.favourite == False) & (repacker_channel.public == True) ).join( repacker_user, repacker_user.id == repacker_channel.owner ) if date_from: activity_window = activity_window.filter(VideoInstance.date_added >= date_from) if date_to: activity_window = activity_window.filter(VideoInstance.date_added < date_to) for video_instance, packer_channel, repacker_channel, repacker in activity_window: user, type, body = repack_message(repacker, repacker_channel, video_instance) _add_user_notification(packer_channel.owner, video_instance.date_added, type, body) if user_notifications is not None and type in app.config['PUSH_NOTIFICATION_MAP']: user_notifications.setdefault(packer_channel.owner, None)
def users(self, cat_id): ctx = {} page_size = 50 users = search.UserSearch() users.add_term('category', cat_id) users.set_paging(int(request.args.get('p', 0)) * page_size, page_size - 1) result = users.users() from rockpack.mainsite.services.video.models import Category parent = aliased(Category) query = readonly_session.query( Category.name, # order is important parent.name, Category.id ).filter( Category.parent == parent.id, Category.id == cat_id ) ctx['next_page'] = int(request.args.get('p', 1)) + 1 ctx['category'] = query.one() ctx['single_cat'] = True ctx['users'] = result return self.render('admin/user_cat_stats.html', **ctx)
def import_average_category(self, channel_ids=None, start=None, stop=None, automatic_flush=True): from rockpack.mainsite.services.video.models import VideoInstance, Channel query = readonly_session.query(VideoInstance.category, Channel.id).join(Channel, Channel.id == VideoInstance.channel).order_by(Channel.id) if channel_ids: query = query.filter(Channel.id.in_(channel_ids)) if start: query = query.filter(Channel.date_updated.between(start, stop)) category_map = {} for instance_cat, channel_id in query: channel_cat_counts = category_map.setdefault(channel_id, {}) current_count = channel_cat_counts.setdefault(instance_cat, 0) channel_cat_counts[instance_cat] = current_count + 1 app.logger.info('Channel category map size: %d', len(category_map)) ec = ESChannel.updater(bulk=True) for channel_id, c_map in category_map.iteritems(): ec.set_document_id(channel_id) ec.add_field('category', main_category(c_map)) ec.update() ec.reset() if automatic_flush: self.conn.flush_bulk(forced=True)
def get_query(self, date_from, date_to): from rockpack.mainsite.services.video.models import Channel, VideoInstance from rockpack.mainsite.services.user.models import User, UserActivity from rockpack.mainsite.services.share.models import ShareLink activity = readonly_session.query( func.coalesce(VideoInstance.channel, UserActivity.object_id).label('channel'), UserActivity.action.label('action'), literal(0).label('click_count') ).select_from( UserActivity ).outerjoin( VideoInstance, VideoInstance.id == UserActivity.object_id ).filter( UserActivity.date_actioned.between(date_from, date_to) ) shares = readonly_session.query( func.coalesce(VideoInstance.channel, ShareLink.object_id).label('channel'), literal('share').label('action'), ShareLink.click_count.label('click_count') ).select_from( ShareLink ).outerjoin( VideoInstance, VideoInstance.id == ShareLink.object_id ).filter( ShareLink.date_created.between(date_from, date_to) ) activity = activity.union_all(shares).subquery() query = readonly_session.query( *self._cols(Channel, User, activity) ).select_from( Channel ).join( activity, activity.c.channel == Channel.id ).join( User, User.id == Channel.owner ) return self._agg_query(query, Channel, User, activity)
def get_query(self, date_from, date_to): from rockpack.mainsite.services.video.models import Video, VideoInstance from rockpack.mainsite.services.user.models import UserActivity from rockpack.mainsite.services.share.models import ShareLink activity = readonly_session.query( UserActivity.object_id.label('video_instance'), UserActivity.action.label('action'), literal(0).label('click_count') ).filter( UserActivity.object_type == 'video_instance', UserActivity.date_actioned.between(date_from, date_to) ) shares = readonly_session.query( ShareLink.object_id.label('video_instance'), literal('share').label('action'), ShareLink.click_count.label('click_count') ).filter( ShareLink.object_type == 'video_instance', ShareLink.date_created.between(date_from, date_to) ) activity = activity.union_all(shares).subquery() query = readonly_session.query( Video.id, Video.title, func.count(activity.c.video_instance), func.count(VideoInstance.id.distinct()), *([func.sum(func.cast(activity.c.action == c, Integer)) for c in self.counts[2:-1]] + [func.sum(activity.c.click_count)]) ).join( VideoInstance, VideoInstance.video == Video.id ).join( activity, activity.c.video_instance == VideoInstance.id ).group_by( Video.id ) return query
def index(self): from gviz_data_table import Table from rockpack.mainsite.services.user.models import User from .models import AppDownloadRecord ctx = {} for action in 'download', 'update': table = Table((dict(id='date', type=date), dict(id='count', type=long))) table.extend( readonly_session.query(AppDownloadRecord).filter_by(action=action). group_by('1').order_by('1'). values(AppDownloadRecord.date, func.sum(AppDownloadRecord.count)) ) ctx['%s_data' % action] = table.encode() table = Table([dict(id='date', type=date)] + [dict(id=i, type=long) for i in 'Total', 'US', 'UK', 'Other'])
def create_unavailable_notifications(date_from=None, date_to=None, user_notifications=None): activity_window = readonly_session.query(VideoInstance, Video, Channel).join( Video, Video.id == VideoInstance.video ).join( Channel, Channel.id == VideoInstance.channel ).options( joinedload(Channel.owner_rel) ).filter( Video.visible == False ) if date_from: activity_window = activity_window.filter(Video.date_updated >= date_from) if date_to: activity_window = activity_window.filter(Video.date_updated < date_to) for video_instance, video, channel in activity_window: user, message_type, message = unavailable_video_message(channel, video_instance) _add_user_notification(user, video.date_updated, message_type, message) if user_notifications is not None and message_type in app.config['PUSH_NOTIFICATION_MAP']: user_notifications.setdefault(user, None)
def _post_activity_to_recommender(date_from, date_to): weights = ( (UserActivity.action == 'subscribe', 10), (UserActivity.action == 'star', 5), (UserActivity.action == 'select', 5), (UserActivity.action == 'unsubscribe', -5), ) activity = readonly_session.query( UserActivity.user, Channel.id, case(weights, else_=1) ).outerjoin( VideoInstance, (UserActivity.object_type == 'video_instance') & (UserActivity.object_id == VideoInstance.id) ).filter( ((UserActivity.object_type == 'channel') & (UserActivity.object_id == Channel.id)) | (VideoInstance.channel == Channel.id) ) if date_from: activity = activity.filter(UserActivity.date_actioned.between(date_from, date_to)) from rockpack.mainsite.core import recommender recommender.load_activity(activity.yield_per(1000))
def set_most_influential_for_video(video_ids): child = aliased(VideoInstance, name="child") query = ( readonly_session.query( VideoInstance.id, VideoInstance.video, child.source_channel, func.count(VideoInstance.id) ) .outerjoin(child, (VideoInstance.video == child.video) & (VideoInstance.channel == child.source_channel)) .join(Video, (Video.id == VideoInstance.video) & (Video.visible == True) & (VideoInstance.deleted == False)) .join(Channel, (Channel.id == VideoInstance.channel) & (Channel.public == True)) ) query = query.filter(Video.id.in_(video_ids)) query = query.group_by(VideoInstance.id, VideoInstance.video, child.source_channel) instance_counts = {} influential_index = {} for _id, video, source_channel, count in query.yield_per(6000): # Set the count for the video instance instance_counts[(_id, video)] = count # If the count is higher for the same video that # the previous instance, mark this instance as the # influential one for this video i_id, i_count = influential_index.get(video, [None, 0]) # Count will always be at least 1 # but should really be zero if no children if not source_channel and count == 1: count = 0 if (count > i_count) or (count == i_count) and not source_channel: influential_index.update({video: (_id, count)}) for (_id, video), count in instance_counts.iteritems(): if influential_index.get(video, "")[0] == _id: VideoInstance.query.filter(VideoInstance.id == _id).update({"most_influential": True}) break
for action in 'download', 'update': table = Table((dict(id='date', type=date), dict(id='count', type=long))) table.extend( readonly_session.query(AppDownloadRecord).filter_by(action=action). group_by('1').order_by('1'). values(AppDownloadRecord.date, func.sum(AppDownloadRecord.count)) ) ctx['%s_data' % action] = table.encode() table = Table([dict(id='date', type=date)] + [dict(id=i, type=long) for i in 'Total', 'US', 'UK', 'Other']) table.extend( readonly_session.query(User).filter( User.date_joined > LAUNCHDATE, User.refresh_token != None). group_by('1').order_by('1'). values( func.date(User.date_joined), func.count('*'), func.sum(func.cast(User.locale == 'en-us', Integer)), func.sum(func.cast(User.locale == 'en-gb', Integer)), func.sum(func.cast(User.locale.notin_(('en-us', 'en-gb')), Integer)), ) ) ctx['reg_data'] = table.encode() return self.render('admin/app_stats.html', **ctx) class ActivityStatsView(StatsView): @expose('/') def index(self): from gviz_data_table import Table from rockpack.mainsite.services.user.models import UserActivity table = Table([dict(id='date', type=date)] +
def load_users_into_mailchimp(): """Load records from user table to mailchimp list.""" from mailchimp import Mailchimp excluded_users = UserFlag.query.filter( UserFlag.flag.in_(('bouncing', 'unsub3'))).with_entities(UserFlag.user) users = readonly_session.query( User.id, User.username, User.email, User.first_name, User.last_name, User.gender, User.locale, User.date_joined, ParentCategory.name.label('interest_name'), func.sum(UserInterest.weight).label('interest_weight'), ).filter( User.is_active == True, User.email != '', User.id.notin_(excluded_users), ).outerjoin( UserInterest, UserInterest.user == User.id ).outerjoin( Category, Category.id == UserInterest.category ).outerjoin( ParentCategory, ParentCategory.id == Category.parent ).group_by( User.id, ParentCategory.id ) # TODO: chunking batch = [] for userid, group in groupby(users.order_by(User.id), lambda u: u[0]): usergroup = list(group) user = usergroup[0] merge_vars = dict( fname=user.first_name, lname=user.last_name, username=user.username, gender={'m': 'Male', 'f': 'Female'}.get(user.gender, 'Unknown'), locale=user.locale, datejoined=datetime.strftime(user.date_joined, '%m/%d/%Y'), ) interests = [u.interest_name for u in usergroup if u.interest_name] if interests: merge_vars['groupings'] = [dict(name='Interest', groups=interests)] batch.append(dict( email=dict(email=user.email), email_type='html', merge_vars=merge_vars, )) conn = Mailchimp(app.config['MAILCHIMP_TOKEN']) response = conn.lists.batch_subscribe( app.config['MAILCHIMP_LISTID'], batch, double_optin=False, update_existing=True, replace_interests=True) if response['error_count']: app.logger.error('Error loading users into mailchimp: %s', response['errors'][0]['error']) else: app.logger.info('Loaded users into mailchimp: %d added, %d updated', response['add_count'], response['update_count'])
def import_channel_share(self, automatic_flush=True): from rockpack.mainsite.services.share.models import ShareLink from rockpack.mainsite.services.user.models import UserActivity, User from rockpack.mainsite.services.video.models import VideoInstance, Channel total = 0 missing = 0 start_time = time.time() def _normalised(val, max_val, min_val): try: return (val - min_val) / (abs(max_val) - abs(min_val)) except (ZeroDivisionError, decimal.DivisionByZero, decimal.InvalidOperation): return 0 def _update_channel_id(id, val, max_val, min_val): channel_dict[id] = channel_dict.setdefault(id, 0) + _normalised(val, max_val, min_val) # The strength of actions decay until any older than zulu have no effect zulu = datetime.now() - timedelta(days=app.config.get('CHANNEL_RANK_ZULU', 1)) time_since_zulu = (datetime.utcnow() - zulu).total_seconds() for locale in ['en-gb', 'en-us']: app.logger.debug('starting for %s', locale) channel_dict = {} channel_shares = {} summation = func.sum( (time_since_zulu - (func.extract('epoch', datetime.utcnow()) - func.extract('epoch', UserActivity.date_actioned))) / time_since_zulu ) # activity for channels from videos query = readonly_session.query( distinct(Channel.id).label('channel_id'), summation.label('summed') ).join( VideoInstance, VideoInstance.channel == Channel.id ).join( UserActivity, UserActivity.object_id == VideoInstance.id ).join( User, User.id == UserActivity.user ).filter( UserActivity.action == 'star', UserActivity.object_type == 'video_instance', UserActivity.date_actioned > zulu, User.locale == locale ).group_by(Channel.id) summed = query.subquery().columns.summed q_max, q_min = UserActivity.query.session.query(func.max(summed), func.min(summed)).one() for id, count in query.yield_per(6000): channel_dict.setdefault(id, {}) channel_dict[id]['user_activity'] = [count, _normalised(count, q_max, q_min)] channel_dict[id]['norm_user_activity'] = _normalised(count, q_max, q_min) app.logger.debug('user activity done') summation = func.sum( (time_since_zulu - (func.extract('epoch', datetime.utcnow()) - func.extract('epoch', ShareLink.date_created))) / time_since_zulu ) # activity for channel shares query = readonly_session.query( distinct(Channel.id).label('channel_id'), summation.label('summed') ).join( ShareLink, ShareLink.object_id == Channel.id ).join( User, User.id == ShareLink.user ).filter( Channel.deleted == False, Channel.public == True, ShareLink.object_type == 'channel', ShareLink.date_created > zulu, ShareLink.click_count > 0, User.locale == locale ).group_by(Channel.id) summed = query.subquery().columns.summed q_max, q_min = ShareLink.query.session.query(func.max(summed), func.min(summed)).one() channel_share_vals = (q_max, q_min) for id, count in query.yield_per(6000): channel_dict.setdefault(id, {}) channel_shares[id] = count channel_dict[id]['share_link_channel'] = [count, _normalised(count, q_max, q_min)] app.logger.debug('channel shares done') # activity for videos shares of channels query = readonly_session.query( distinct(Channel.id).label('channel_id'), summation.label('summed') ).join( VideoInstance, VideoInstance.channel == Channel.id ).join( ShareLink, ShareLink.object_id == VideoInstance.id ).join( User, User.id == ShareLink.user ).filter( Channel.deleted == False, Channel.public == True, ShareLink.object_type == 'video_instance', ShareLink.date_created > zulu, ShareLink.click_count > 0, User.locale == locale ).group_by(Channel.id) summed = query.subquery().columns.summed q_max, q_min = ShareLink.query.session.query(func.max(summed), func.min(summed)).one() for id, count in query.yield_per(6000): channel_dict.setdefault(id, {}) channel_dict[id]['share_link_video'] = [count, _normalised(count, q_max, q_min)] val = channel_shares.get(id, 0) # We may get None returned in the data if None in channel_share_vals: channel_share_vals = [0, 0] channel_dict[id]['norm_share_link_channel'] = channel_dict[id].setdefault('norm_share_link_channel', 0) + _normalised(count + val, q_max + channel_share_vals[0], q_min + channel_share_vals[1]) app.logger.debug('video shares done') app.logger.debug('... updating elasticsearch for %s ...', locale) done = 1 i_total = len(channel_dict) ec = ESChannel.updater(bulk=True) for id, _dict in channel_dict.iteritems(): try: count = 0 for k, v in _dict.iteritems(): if k.startswith('norm'): count += v if count == 0: continue ec.set_document_id(id) ec.add_field('normalised_rank[\'%s\']' % locale, float(count)) ec.update() except exceptions.DocumentMissingException: missing += 1 finally: ec.reset() total += 1 if app.logger.isEnabledFor(logging.DEBUG): self.print_percent_complete(done, i_total) done += 1 if automatic_flush: ESChannel.flush() app.logger.debug('%s total updates in two passes. finished in %s seconds (%s channels not in es)', total, time.time() - start_time, missing)
def import_dolly_repin_counts(self, prefix=None, start=None, stop=None, automatic_flush=True): from rockpack.mainsite.services.video.models import VideoInstance, Video with app.test_request_context(): child = aliased(VideoInstance, name='child') query = readonly_session.query( VideoInstance.id, VideoInstance.video, child.source_channel, func.count(VideoInstance.id) ).outerjoin( child, (VideoInstance.video == child.video) & (VideoInstance.channel == child.source_channel) ).join( Video, (Video.id == VideoInstance.video) & (Video.visible == True) & (VideoInstance.deleted == False)) if prefix: query = query.filter(VideoInstance.id.like(prefix.replace('_', '\\_') + '%')) if start: video_ids = VideoInstance.query.filter( VideoInstance.date_updated.between(start, stop) ).with_entities(VideoInstance.video).subquery() query = query.filter(Video.id.in_(video_ids)) query = query.group_by(VideoInstance.id, VideoInstance.video, child.source_channel) instance_counts = {} influential_index = {} total = query.count() done = 1 for _id, video, source_channel, count in query.yield_per(6000): # Set the count for the video instance instance_counts[(_id, video)] = count # If the count is higher for the same video that # the previous instance, mark this instance as the # influential one for this video i_id, i_count = influential_index.get(video, [None, 0]) # Count will always be at least 1 # but should really be zero if no children if not source_channel and count == 1: count = 0 if (count > i_count) or\ (count == i_count) and not source_channel: influential_index.update({video: (_id, count,)}) if app.logger.isEnabledFor(logging.DEBUG): self.print_percent_complete(done, total) done += 1 total = len(instance_counts) done = 1 ec = ESVideo.updater(bulk=True) for (_id, video), count in instance_counts.iteritems(): ec.set_document_id(_id) ec.add_field('child_instance_count', count) ec.add_field('most_influential', True if influential_index.get(video, '')[0] == _id else False) ec.update() ec.reset() if app.logger.isEnabledFor(logging.DEBUG): self.print_percent_complete(done, total) done += 1 if automatic_flush: ESVideo.flush()
def index(self): from rockpack.mainsite.services.video import models channels = readonly_session.query(models.Channel) public = channels.join(models.ChannelLocaleMeta).filter( models.ChannelLocaleMeta.visible == True, models.Channel.public == True) parent = aliased(models.Category) cat_group = readonly_session.query( models.Category.name, # order is important parent.name, func.count(models.VideoInstance.id) ).outerjoin(models.VideoInstance).filter( models.Category.parent == parent.id ).group_by( parent.name, models.Category.name ).order_by(parent.name, models.Category.name) cat_count = cat_group.count() kwargs = dict(now=datetime.now().strftime('%Y-%m-%d'), cat_group=cat_group.all(), cat_count=cat_count, is_dolly=app.config.get('DOLLY')) if not app.config.get('DOLLY'): channel_group = readonly_session.query( models.ChannelLocaleMeta.locale, parent.name, models.Category.name, func.count(models.ChannelLocaleMeta.id) ).filter( models.Category.parent == parent.id, models.Channel.category == models.Category.id ).filter( models.Category.parent != 1 ).join( models.Channel, models.Channel.id == models.ChannelLocaleMeta.channel ).filter( models.Channel.public == True ).group_by( models.Category.parent_category, models.Category.name, parent.name, models.ChannelLocaleMeta.locale ).order_by(parent.name.desc()) channel_count = channel_group.count() channels_today = channels.filter( models.Channel.date_added >= datetime.now().strftime('%Y-%m-%d')).count() kwargs.update(dict( total_channels=channels.count(), total_channels_today=channels_today, public_channels=public.count(), channels_today=channels_today, channel_group=channel_group.all(), channel_count=channel_count)) return self.render( 'admin/stats.html', **kwargs )