コード例 #1
0
    def get(self):
        problem_solving = VideoPlaylist.get_query_for_playlist_title("GMAT: Problem Solving")
        data_sufficiency = VideoPlaylist.get_query_for_playlist_title("GMAT Data Sufficiency")
        template_values = {
                            'data_sufficiency': data_sufficiency,
                            'problem_solving': problem_solving,
        }

        self.render_jinja2_template('gmat.html', template_values)
コード例 #2
0
ファイル: youtube_sync.py プロジェクト: johnfelipe/server
    def copyTopicsToPlaylist(self):
        topic_list = Topic.get_content_topics()

        for topic in topic_list:
            playlist = Playlist.all().filter("title =",
                                             topic.standalone_title).get()
            if playlist:
                logging.info("Copying topic " + topic.standalone_title +
                             " to playlist.")
                child_keys = topic.child_keys
                vps = VideoPlaylist.all().filter(
                    "playlist =",
                    playlist).order("video_position").fetch(10000)

                playlist_keys = []
                for vp in vps:
                    try:
                        playlist_keys.append(vp.video.key())
                    except db.ReferencePropertyResolveError:
                        logging.info(
                            "Found reference to missing video in VideoPlaylist!"
                        )

                topic_keys = [
                    key for key in topic.child_keys if key.kind() == "Video"
                ]

                if playlist_keys == topic_keys:
                    logging.info(
                        "Child keys identical. No changes will be made.")
                else:
                    #                    logging.info("PLAYLIST: " + repr([str(key) for key in playlist_keys]))
                    #                    logging.info("TOPIC:    " + repr([str(key) for key in topic_keys]))

                    logging.info("Deleting old VideoPlaylists...")
                    db.delete(vps)

                    vps = []
                    for i, child_key in enumerate(topic.child_keys):
                        if child_key.kind() == "Video":
                            vps.append(
                                VideoPlaylist(video=child_key,
                                              playlist=playlist,
                                              video_position=i,
                                              live_association=True))

                    logging.info("Creating new VideoPlaylists...")
                    db.put(vps)
            else:
                logging.info("Playlist matching topic " +
                             topic.standalone_title + " not found.")
コード例 #3
0
def get_playlist_videos_json(playlist_title):
    query = Playlist.all()
    query.filter('title =', playlist_title)
    playlist = query.get()

    video_query = Video.all()
    video_query.filter('playlists = ', playlist_title)
    video_key_dict = Video.get_dict(video_query, lambda video: video.key())

    video_playlist_query = VideoPlaylist.all()
    video_playlist_query.filter('playlist =', playlist)
    video_playlist_query.filter('live_association =', True)
    video_playlist_key_dict = VideoPlaylist.get_key_dict(video_playlist_query)

    return json.dumps(get_playlist_video_api_dicts(playlist, video_key_dict, video_playlist_key_dict), indent=4)
コード例 #4
0
ファイル: api.py プロジェクト: mahadalislam/old-khan
def get_playlist_videos(playlist_title):
    query = Playlist.all()
    query.filter('title =', playlist_title)
    playlist = query.get()
    query = VideoPlaylist.all()
    query.filter('playlist =', playlist)
    query.filter('live_association = ', True)
    query.order('video_position')
    videos = []
    for pv in query.fetch(500):
        v = pv.video
        video_dict = {
            'youtube_id':
            v.youtube_id,
            'youtube_url':
            v.url,
            'title':
            v.title,
            'description':
            v.description,
            'keywords':
            v.keywords,
            'readable_id':
            v.readable_id,
            'ka_url':
            "http://www.khanacademy.org/video/%s?playlist=%s" %
            (v.readable_id, urllib.quote_plus(playlist_title)),
            'video_position':
            pv.video_position,
            'views':
            v.views,
        }
        videos.append(video_dict)
    return json.dumps(videos, indent=4)
コード例 #5
0
def get_video_library_json_compressed():
    playlist_api_dicts = []
    playlists = get_all_topic_playlists()
    video_key_dict = Video.get_dict(Video.all(), lambda video: video.key())

    video_playlist_query = VideoPlaylist.all()
    video_playlist_query.filter('live_association =', True)
    video_playlist_key_dict = VideoPlaylist.get_key_dict(video_playlist_query)

    for playlist in playlists:
        playlist_api_dict = JsonApiDict.playlist(playlist)
        playlist_api_dict["videos"] = get_playlist_video_api_dicts(playlist, video_key_dict, video_playlist_key_dict)
        playlist_api_dicts.append(playlist_api_dict)

    # We compress this huge json payload so it'll fit in memcache
    return zlib.compress(json.dumps(playlist_api_dicts, indent=4))
コード例 #6
0
ファイル: autocomplete.py プロジェクト: adamwulf/old-khan
def video_title_dicts():
    live_video_dict = {}
    for video_playlist in VideoPlaylist.all().filter('live_association = ', True):
        live_video_dict[VideoPlaylist.video.get_value_for_datastore(video_playlist)] = True

    live_videos = filter(lambda video: video.key() in live_video_dict, Video.all())
    return map(lambda video: {"title": video.title, "url": "/video/%s" % video.readable_id}, live_videos)
コード例 #7
0
def get_video_library_json_compressed():
    playlist_api_dicts = []
    playlists = get_all_topic_playlists()
    video_key_dict = Video.get_dict(Video.all(), lambda video: video.key())

    video_playlist_query = VideoPlaylist.all()
    video_playlist_query.filter('live_association =', True)
    video_playlist_key_dict = VideoPlaylist.get_key_dict(video_playlist_query)

    for playlist in playlists:
        playlist_api_dict = JsonApiDict.playlist(playlist)
        playlist_api_dict["videos"] = get_playlist_video_api_dicts(
            playlist, video_key_dict, video_playlist_key_dict)
        playlist_api_dicts.append(playlist_api_dict)

    # We compress this huge json payload so it'll fit in memcache
    return zlib.compress(json.dumps(playlist_api_dicts, indent=4))
コード例 #8
0
def get_playlist_videos_json(playlist_title):
    query = Playlist.all()
    query.filter('title =', playlist_title)
    playlist = query.get()

    video_query = Video.all()
    video_query.filter('playlists = ', playlist_title)
    video_key_dict = Video.get_dict(video_query, lambda video: video.key())

    video_playlist_query = VideoPlaylist.all()
    video_playlist_query.filter('playlist =', playlist)
    video_playlist_query.filter('live_association =', True)
    video_playlist_key_dict = VideoPlaylist.get_key_dict(video_playlist_query)

    return json.dumps(get_playlist_video_api_dicts(playlist, video_key_dict,
                                                   video_playlist_key_dict),
                      indent=4)
コード例 #9
0
 def get(self):
     query = VideoPlaylist.all()
     all_video_playlists = query.fetch(200)
     video_playlists_to_delete = []
     for video_playlist in all_video_playlists:
         if video_playlist.live_association != True:
             video_playlists_to_delete.append(video_playlist)
     db.delete(video_playlists_to_delete)
コード例 #10
0
ファイル: youtube_sync.py プロジェクト: johnfelipe/server
    def commitLiveAssociations(self):
        association_generation = int(Setting.last_youtube_sync_generation_start())

        video_playlists_to_put = []
        for video_playlist in VideoPlaylist.all():
            live = (video_playlist.last_live_association_generation >= association_generation)
            if video_playlist.live_association != live:
                video_playlist.live_association = live
                video_playlists_to_put.append(video_playlist)

        db.put(video_playlists_to_put)
コード例 #11
0
ファイル: youtube_sync.py プロジェクト: johnfelipe/server
    def commitLiveAssociations(self):
        association_generation = int(
            Setting.last_youtube_sync_generation_start())

        video_playlists_to_put = []
        for video_playlist in VideoPlaylist.all():
            live = (video_playlist.last_live_association_generation >=
                    association_generation)
            if video_playlist.live_association != live:
                video_playlist.live_association = live
                video_playlists_to_put.append(video_playlist)

        db.put(video_playlists_to_put)
コード例 #12
0
def video_title_dicts():
    live_video_dict = {}
    for video_playlist in VideoPlaylist.all().filter('live_association = ',
                                                     True):
        live_video_dict[VideoPlaylist.video.get_value_for_datastore(
            video_playlist)] = True

    live_videos = filter(lambda video: video.key() in live_video_dict,
                         Video.all())
    return map(
        lambda video: {
            "title": video.title,
            "url": "/video/%s" % video.readable_id
        }, live_videos)
コード例 #13
0
    def get(self):
        playlist_title = "SAT Preparation"
        query = Playlist.all()
        query.filter('title =', playlist_title)
        playlist = query.get()
        query = VideoPlaylist.all()
        query.filter('playlist =', playlist)
        query.filter('live_association = ', True) #need to change this to true once I'm done with all of my hacks
        query.order('video_position')
        playlist_videos = query.fetch(500)

        template_values = {
                'videos': playlist_videos,
        }

        self.render_jinja2_template('sat.html', template_values)
コード例 #14
0
ファイル: youtube_sync.py プロジェクト: johnfelipe/server
    def copyTopicsToPlaylist(self):
        topic_list = Topic.get_content_topics()

        for topic in topic_list:
            playlist = Playlist.all().filter("title =", topic.standalone_title).get()
            if playlist:
                logging.info("Copying topic " + topic.standalone_title + " to playlist.")
                child_keys = topic.child_keys
                vps = VideoPlaylist.all().filter("playlist =", playlist).order("video_position").fetch(10000)

                playlist_keys = []
                for vp in vps:
                    try:
                        playlist_keys.append(vp.video.key())
                    except db.ReferencePropertyResolveError:
                        logging.info("Found reference to missing video in VideoPlaylist!")

                topic_keys = [key for key in topic.child_keys if key.kind() == "Video"]

                if playlist_keys == topic_keys:
                    logging.info("Child keys identical. No changes will be made.")
                else:
#                    logging.info("PLAYLIST: " + repr([str(key) for key in playlist_keys]))
#                    logging.info("TOPIC:    " + repr([str(key) for key in topic_keys]))

                    logging.info("Deleting old VideoPlaylists...")
                    db.delete(vps)

                    vps = []
                    for i, child_key in enumerate(topic.child_keys):
                        if child_key.kind() == "Video":
                            vps.append(VideoPlaylist(
                                video=child_key,
                                playlist=playlist,
                                video_position=i,
                                live_association = True
                                ))

                    logging.info("Creating new VideoPlaylists...")
                    db.put(vps)
            else:
                logging.info("Playlist matching topic " + topic.standalone_title + " not found.")
コード例 #15
0
ファイル: api.py プロジェクト: adamwulf/old-khan
def get_playlist_videos(playlist_title):
    query = Playlist.all()
    query.filter('title =', playlist_title)
    playlist = query.get()
    query = VideoPlaylist.all()
    query.filter('playlist =', playlist)
    query.filter('live_association = ', True)
    query.order('video_position')
    videos = []
    for pv in query.fetch(500):
        v = pv.video
        video_dict = {'youtube_id':  v.youtube_id,
                      'youtube_url': v.url,
                      'title': v.title, 
                      'description': v.description,
                      'keywords': v.keywords,                         
                      'readable_id': v.readable_id,
                      'ka_url': "http://www.khanacademy.org/video/%s?playlist=%s" % (v.readable_id, urllib.quote_plus(playlist_title)),
                      'video_position': pv.video_position,
                      'views': v.views,
                     }                         
        videos.append(video_dict)                        
    return json.dumps(videos, indent=4)
コード例 #16
0
ファイル: library.py プロジェクト: KhanWorld/KhanAcademy
def library_content_html():
    # No cache found -- regenerate HTML
    smart_history = getSmartHistoryContent()

    all_playlists = []

    dict_videos = {}
    dict_videos_counted = {}
    dict_playlists = {}
    dict_playlists_by_title = {}
    dict_video_playlists = {}

    async_queries = [
        Video.all(),
        Playlist.all(),
        VideoPlaylist.all().filter('live_association = ', True).order('video_position'),
    ]

    results = util.async_queries(async_queries)

    for video in results[0].get_result():
        dict_videos[video.key()] = video

    for playlist in results[1].get_result():
        dict_playlists[playlist.key()] = playlist
        if playlist.title in topics_list:
            dict_playlists_by_title[playlist.title] = playlist

    for video_playlist in results[2].get_result():
        playlist_key = VideoPlaylist.playlist.get_value_for_datastore(video_playlist)
        video_key = VideoPlaylist.video.get_value_for_datastore(video_playlist)

        if dict_videos.has_key(video_key) and dict_playlists.has_key(playlist_key):
            video = dict_videos[video_key]
            playlist = dict_playlists[playlist_key]
            fast_video_playlist_dict = {"video":video, "playlist":playlist}

            if dict_video_playlists.has_key(playlist_key):
                dict_video_playlists[playlist_key].append(fast_video_playlist_dict)
            else:
                dict_video_playlists[playlist_key] = [fast_video_playlist_dict]

            if dict_playlists_by_title.has_key(playlist.title):
                # Only count videos in topics_list
                dict_videos_counted[video.youtube_id] = True

    # Update count of all distinct videos associated w/ a live playlist
    Setting.count_videos(len(dict_videos_counted.keys()))

    for topic in topics_list:
        if topic in dict_playlists_by_title:
            playlist = dict_playlists_by_title[topic]
            playlist_key = playlist.key()
            playlist_videos = dict_video_playlists.get(playlist_key) or []

            if not playlist_videos:
                logging.error('Playlist %s has no videos!', playlist.title)

            playlist_data = {
                     'title': topic,
                     'topic': topic,
                     'playlist': playlist,
                     'videos': playlist_videos,
                     'next': None
                     }

            all_playlists.append(playlist_data)

    playlist_data_prev = None
    for playlist_data in all_playlists:
        if playlist_data_prev:
            playlist_data_prev['next'] = playlist_data
        playlist_data_prev = playlist_data

    # Separating out the columns because the formatting is a little different on each column
    template_values = {
        'App' : App,
        'all_playlists': all_playlists,
        'smart_history': smart_history,
        }

    html = shared_jinja.get().render_template("library_content_template.html", **template_values)

    # Set shared date of last generated content
    Setting.cached_library_content_date(str(datetime.datetime.now()))

    return html
コード例 #17
0
 def get(self):
     query = VideoPlaylist.all()
     all_video_playlists = query.fetch(100000)
     for video_playlist in all_video_playlists:
         video_playlist.live_association = False
     db.put(all_video_playlists)
コード例 #18
0
def library_content_html():
    # No cache found -- regenerate HTML
    smart_history = getSmartHistoryContent()

    all_playlists = []

    dict_videos = {}
    dict_videos_counted = {}
    dict_playlists = {}
    dict_playlists_by_title = {}
    dict_video_playlists = {}

    async_queries = [
        Video.all(),
        Playlist.all(),
        VideoPlaylist.all().filter('live_association = ',
                                   True).order('video_position'),
    ]

    results = util.async_queries(async_queries)

    for video in results[0].get_result():
        dict_videos[video.key()] = video

    for playlist in results[1].get_result():
        dict_playlists[playlist.key()] = playlist
        if playlist.title in topics_list:
            dict_playlists_by_title[playlist.title] = playlist

    for video_playlist in results[2].get_result():
        playlist_key = VideoPlaylist.playlist.get_value_for_datastore(
            video_playlist)
        video_key = VideoPlaylist.video.get_value_for_datastore(video_playlist)

        if dict_videos.has_key(video_key) and dict_playlists.has_key(
                playlist_key):
            video = dict_videos[video_key]
            playlist = dict_playlists[playlist_key]
            fast_video_playlist_dict = {"video": video, "playlist": playlist}

            if dict_video_playlists.has_key(playlist_key):
                dict_video_playlists[playlist_key].append(
                    fast_video_playlist_dict)
            else:
                dict_video_playlists[playlist_key] = [fast_video_playlist_dict]

            if dict_playlists_by_title.has_key(playlist.title):
                # Only count videos in topics_list
                dict_videos_counted[video.youtube_id] = True

    # Update count of all distinct videos associated w/ a live playlist
    Setting.count_videos(len(dict_videos_counted.keys()))

    for topic in topics_list:
        if topic in dict_playlists_by_title:
            playlist = dict_playlists_by_title[topic]
            playlist_key = playlist.key()
            playlist_videos = dict_video_playlists.get(playlist_key) or []

            if not playlist_videos:
                logging.error('Playlist %s has no videos!', playlist.title)

            playlist_data = {
                'title': topic,
                'topic': topic,
                'playlist': playlist,
                'videos': playlist_videos,
                'next': None
            }

            all_playlists.append(playlist_data)

    playlist_data_prev = None
    for playlist_data in all_playlists:
        if playlist_data_prev:
            playlist_data_prev['next'] = playlist_data
        playlist_data_prev = playlist_data

    # Separating out the columns because the formatting is a little different on each column
    template_values = {
        'App': App,
        'all_playlists': all_playlists,
        'smart_history': smart_history,
    }

    html = shared_jinja.get().render_template("library_content_template.html",
                                              **template_values)

    # Set shared date of last generated content
    Setting.cached_library_content_date(str(datetime.datetime.now()))

    return html
コード例 #19
0
ファイル: youtube_sync.py プロジェクト: johnfelipe/server
    def updateVideoAndPlaylistData(self):
        yt_service = gdata.youtube.service.YouTubeService()

        # Now that we run these queries from the App Engine servers, we need to 
        # explicitly specify our developer_key to avoid being lumped together w/ rest of GAE and
        # throttled by YouTube's "Too many request" quota
        yt_service.developer_key = "AI39si6ctKTnSR_Vx7o7GpkpeSZAKa6xjbZz6WySzTvKVYRDAO7NHBVwofphk82oP-OSUwIZd0pOJyNuWK8bbOlqzJc9OFozrQ"
        yt_service.client_id = "n/a"

        video_youtube_id_dict = Video.get_dict(Video.all(), lambda video: video.youtube_id)
        video_playlist_key_dict = VideoPlaylist.get_key_dict(VideoPlaylist.all())

        association_generation = int(Setting.last_youtube_sync_generation_start())

        logging.info("Fetching playlists")
        playlist_start_index = 1
        playlist_feed = yt_service.GetYouTubePlaylistFeed(uri='http://gdata.youtube.com/feeds/api/users/KhanAcademyHebrew/playlists?start-index=%s&max-results=50' % playlist_start_index)

        while len(playlist_feed.entry) > 0:

            for playlist in playlist_feed.entry:
                logging.info("Playlist: %s", playlist.id.text)

                playlist_id = playlist.id.text.replace('http://gdata.youtube.com/feeds/api/users/KhanAcademyHebrew/playlists/', '')
                playlist_uri = playlist.id.text.replace('users/KhanAcademyHebrew/', '')
                query = Playlist.all()
                query.filter('youtube_id =', playlist_id)
                playlist_data = query.get()
                if not playlist_data:
                    playlist_data = Playlist(youtube_id=playlist_id)
                    logging.info('Creating Playlist: %s', playlist.title.text)
                playlist_data.url = playlist_uri
                playlist_data.title = playlist.title.text.decode("utf-8")
                playlist_data.description = playlist.description.text.decode("utf-8")

                playlist_data.tags = []
                for category in playlist.category:
                    if "tags.cat" in category.scheme:
                        playlist_data.tags.append(category.term)

                playlist_data.put()
                
                for i in range(0, 10):
                    start_index = i * 50 + 1
                    video_feed = yt_service.GetYouTubePlaylistVideoFeed(uri=playlist_uri + '?start-index=' + str(start_index) + '&max-results=50')
                    video_data_list = []

                    if len(video_feed.entry) <= 0:
                        # No more videos in playlist
                        break

                    for video in video_feed.entry:
                        if not video.media.player:
                            logging.warning("Could not parse video - skipping... (%s, %s)", video, video.media)
                            continue

                        video_id = cgi.parse_qs(urlparse(video.media.player.url).query)['v'][0].decode('utf-8')

                        video_data = None
                        if video_youtube_id_dict.has_key(video_id):
                            video_data = video_youtube_id_dict[video_id]
                            logging.info('Found Video: %s (%s)', video.media.title.text.decode('utf-8'), video_id)
                        
                        if not video_data:
                            video_data = Video(youtube_id=video_id)
                            logging.info('Creating Video: %s (%s)', video.media.title.text.decode('utf-8'), video_id)

                        video_data.title = video.media.title.text.decode('utf-8')
                        video_data.url = video.media.player.url.decode('utf-8')
                        video_data.duration = int(video.media.duration.seconds)

                        if video.statistics:
                            video_data.views = int(video.statistics.view_count)

                        if video.media.description.text is not None:
                            video_data.description = video.media.description.text.decode('utf-8')
                        else:
                            video_data.decription = ' '

                        if video.media.keywords.text:
                            video_data.keywords = video.media.keywords.text.decode('utf-8')
                        else:
                            video_data.keywords = ''

                        video_data.position = video.position
                        video_data_list.append(video_data)
                    db.put(video_data_list)

                    playlist_videos = []
                    for video_data in video_data_list:                
                        playlist_video = None
                        if video_playlist_key_dict.has_key(playlist_data.key()):
                            if video_playlist_key_dict[playlist_data.key()].has_key(video_data.key()):
                                playlist_video = video_playlist_key_dict[playlist_data.key()][video_data.key()]

                        if not playlist_video:
                            playlist_video = VideoPlaylist(playlist=playlist_data.key(), video=video_data.key())
                            logging.info('Creating VideoPlaylist: %s, %s', playlist_data.title, video_data.title)
                        else:
                            logging.info('Updating VideoPlaylist: %s, %s', playlist_video.playlist.title, playlist_video.video.title)
                        playlist_video.last_live_association_generation = association_generation
                        playlist_video.video_position = int(video_data.position.text)
                        playlist_videos.append(playlist_video)
                    db.put(playlist_videos)

            # Check next set of playlists

            playlist_start_index += 50
            playlist_feed = yt_service.GetYouTubePlaylistFeed(uri='http://gdata.youtube.com/feeds/api/users/KhanAcademyHebrew/playlists?start-index=%s&max-results=50' % playlist_start_index)
コード例 #20
0
ファイル: youtube_sync.py プロジェクト: hebkhan/server
    def updateVideoAndPlaylistData(self):
        yt_service = YouTubeService()

        video_youtube_id_dict = Video.get_dict(Video.all(), lambda video: video.youtube_id)
        video_playlist_key_dict = VideoPlaylist.get_key_dict(VideoPlaylist.all())

        association_generation = int(Setting.last_youtube_sync_generation_start())

        logging.info("Fetching playlists")
        playlist_start_index = 1
        playlist_feed = yt_service.GetYouTubePlaylistFeed(
            uri="http://gdata.youtube.com/feeds/api/users/KhanAcademyHebrew/playlists?start-index=%s&max-results=50"
            % playlist_start_index
        )

        while len(playlist_feed.entry) > 0:

            for playlist in playlist_feed.entry:
                logging.info("Playlist: %s", playlist.id.text)

                playlist_id = playlist.id.text.replace(
                    "http://gdata.youtube.com/feeds/api/users/KhanAcademyHebrew/playlists/", ""
                )
                playlist_uri = playlist.id.text.replace("users/KhanAcademyHebrew/", "")
                query = Playlist.all()
                query.filter("youtube_id =", playlist_id)
                playlist_data = query.get()
                if not playlist_data:
                    playlist_data = Playlist(youtube_id=playlist_id)
                    logging.info("Creating Playlist: %s", playlist.title.text)
                playlist_data.url = playlist_uri
                playlist_data.title = playlist.title.text.decode("utf-8")
                playlist_data.description = playlist.description.text.decode("utf-8")

                playlist_data.tags = []
                for category in playlist.category:
                    if "tags.cat" in category.scheme:
                        playlist_data.tags.append(category.term)

                playlist_data.put()

                for i in range(0, 10):
                    start_index = i * 50 + 1
                    video_feed = yt_service.GetYouTubePlaylistVideoFeed(
                        uri=playlist_uri + "?start-index=" + str(start_index) + "&max-results=50"
                    )
                    video_data_list = []

                    if len(video_feed.entry) <= 0:
                        # No more videos in playlist
                        break

                    for video in video_feed.entry:
                        if not video.media.player:
                            logging.warning("Could not parse video - skipping... (%s, %s)", video, video.media)
                            continue

                        video_id = cgi.parse_qs(urlparse(video.media.player.url).query)["v"][0].decode("utf-8")

                        video_data = None
                        if video_youtube_id_dict.has_key(video_id):
                            video_data = video_youtube_id_dict[video_id]
                            logging.info("Found Video: %s (%s)", video.media.title.text.decode("utf-8"), video_id)

                        if not video_data:
                            video_data = Video(youtube_id=video_id)
                            logging.info("Creating Video: %s (%s)", video.media.title.text.decode("utf-8"), video_id)

                        video_data.title = video.media.title.text.decode("utf-8")
                        video_data.url = video.media.player.url.decode("utf-8")
                        video_data.duration = int(video.media.duration.seconds)

                        if video.statistics:
                            video_data.views = int(video.statistics.view_count)

                        if video.media.description.text is not None:
                            video_data.description = video.media.description.text.decode("utf-8")
                        else:
                            video_data.decription = " "

                        if video.media.keywords.text:
                            video_data.keywords = video.media.keywords.text.decode("utf-8")
                        else:
                            video_data.keywords = ""

                        video_data.position = video.position
                        video_data_list.append(video_data)
                    db.put(video_data_list)

                    playlist_videos = []
                    for video_data in video_data_list:
                        playlist_video = None
                        if video_playlist_key_dict.has_key(playlist_data.key()):
                            if video_playlist_key_dict[playlist_data.key()].has_key(video_data.key()):
                                playlist_video = video_playlist_key_dict[playlist_data.key()][video_data.key()]

                        if not playlist_video:
                            playlist_video = VideoPlaylist(playlist=playlist_data.key(), video=video_data.key())
                            logging.info("Creating VideoPlaylist: %s, %s", playlist_data.title, video_data.title)
                        else:
                            logging.info(
                                "Updating VideoPlaylist: %s, %s",
                                playlist_video.playlist.title,
                                playlist_video.video.title,
                            )
                        playlist_video.last_live_association_generation = association_generation
                        playlist_video.video_position = int(video_data.position.text)
                        playlist_videos.append(playlist_video)
                    db.put(playlist_videos)

            # Check next set of playlists

            playlist_start_index += 50
            playlist_feed = yt_service.GetYouTubePlaylistFeed(
                uri="http://gdata.youtube.com/feeds/api/users/KhanAcademyHebrew/playlists?start-index=%s&max-results=50"
                % playlist_start_index
            )
コード例 #21
0
    def get(self, readable_id=""):

        # This method displays a video in the context of a particular playlist.
        # To do that we first need to find the appropriate playlist.  If we aren't
        # given the playlist title in a query param, we need to find a playlist that
        # the video is a part of.  That requires finding the video, given it readable_id
        # or, to support old URLs, it's youtube_id.
        video = None
        playlist = None
        video_id = self.request.get('v')
        playlist_title = self.request_string('playlist', default="") or self.request_string('p', default="")

        readable_id = urllib.unquote(readable_id)
        readable_id = re.sub('-+$', '', readable_id)  # remove any trailing dashes (see issue 1140)

        # If either the readable_id or playlist title is missing,
        # redirect to the canonical URL that contains them
        redirect_to_canonical_url = False
        if video_id: # Support for old links
            query = Video.all()
            query.filter('youtube_id =', video_id)
            video = query.get()

            if not video:
                raise MissingVideoException("Missing video w/ youtube id '%s'" % video_id)

            readable_id = video.readable_id
            playlist = video.first_playlist()

            if not playlist:
                raise MissingVideoException("Missing video w/ youtube id '%s'" % video_id)

            redirect_to_canonical_url = True

        if playlist_title is not None and len(playlist_title) > 0:
            query = Playlist.all().filter('title =', playlist_title)
            key_id = 0
            for p in query:
                if p.key().id() > key_id and not p.youtube_id.endswith('_player'):
                    playlist = p
                    key_id = p.key().id()

        # If a playlist_title wasn't specified or the specified playlist wasn't found
        # use the first playlist for the requested video.
        if playlist is None:
            # Get video by readable_id just to get the first playlist for the video
            video = Video.get_for_readable_id(readable_id)
            if video is None:
                raise MissingVideoException("Missing video '%s'" % readable_id)

            playlist = video.first_playlist()
            if not playlist:
                raise MissingVideoException("Missing video '%s'" % readable_id)

            redirect_to_canonical_url = True

        exid = self.request_string('exid', default=None)

        if redirect_to_canonical_url:
            qs = {'playlist': playlist.title}
            if exid:
                qs['exid'] = exid

            urlpath = "/video/%s" % urllib.quote(readable_id)
            url = urlparse.urlunparse(('', '', urlpath, '', urllib.urlencode(qs), ''))
            self.redirect(url, True)
            return

        # If we got here, we have a readable_id and a playlist_title, so we can display
        # the playlist and the video in it that has the readable_id.  Note that we don't
        # query the Video entities for one with the requested readable_id because in some
        # cases there are multiple Video objects in the datastore with the same readable_id
        # (e.g. there are 2 "Order of Operations" videos).

        videos = VideoPlaylist.get_cached_videos_for_playlist(playlist)
        previous_video = None
        next_video = None
        for v in videos:
            if v.readable_id == readable_id:
                v.selected = 'selected'
                video = v
            elif video is None:
                previous_video = v
            elif next_video is None:
                next_video = v

        if video is None:
            raise MissingVideoException("Missing video '%s'" % readable_id)

        if App.offline_mode:
            video_path = "/videos/" + get_mangled_playlist_name(playlist_title) + "/" + video.readable_id + ".flv"
        else:
            video_path = video.download_video_url()

        if video.description == video.title:
            video.description = None

        related_exercises = video.related_exercises()
        button_top_exercise = None
        if related_exercises:
            def ex_to_dict(exercise):
                return {
                    'name': exercise.display_name,
                    'url': exercise.relative_url,
                }
            button_top_exercise = ex_to_dict(related_exercises[0])

        user_video = UserVideo.get_for_video_and_user_data(video, UserData.current(), insert_if_missing=True)

        awarded_points = 0
        if user_video:
            awarded_points = user_video.points

        template_values = {
                            'playlist': playlist,
                            'video': video,
                            'videos': videos,
                            'video_path': video_path,
                            'video_points_base': consts.VIDEO_POINTS_BASE,
                            'button_top_exercise': button_top_exercise,
                            'related_exercises': [], # disabled for now
                            'previous_video': previous_video,
                            'next_video': next_video,
                            'selected_nav_link': 'watch',
                            'awarded_points': awarded_points,
                            'issue_labels': ('Component-Videos,Video-%s' % readable_id),
                            'author_profile': 'https://plus.google.com/103970106103092409324'
                        }
        template_values = qa.add_template_values(template_values, self.request)

        bingo(['struggling_videos_landing',
               'homepage_restructure_videos_landing'])
        self.render_jinja2_template('viewvideo.html', template_values)
コード例 #22
0
ファイル: youtube_sync.py プロジェクト: johnfelipe/server
    def updateVideoAndPlaylistData(self):
        yt_service = gdata.youtube.service.YouTubeService()

        # Now that we run these queries from the App Engine servers, we need to
        # explicitly specify our developer_key to avoid being lumped together w/ rest of GAE and
        # throttled by YouTube's "Too many request" quota
        yt_service.developer_key = "AI39si6ctKTnSR_Vx7o7GpkpeSZAKa6xjbZz6WySzTvKVYRDAO7NHBVwofphk82oP-OSUwIZd0pOJyNuWK8bbOlqzJc9OFozrQ"
        yt_service.client_id = "n/a"

        video_youtube_id_dict = Video.get_dict(Video.all(),
                                               lambda video: video.youtube_id)
        video_playlist_key_dict = VideoPlaylist.get_key_dict(
            VideoPlaylist.all())

        association_generation = int(
            Setting.last_youtube_sync_generation_start())

        logging.info("Fetching playlists")
        playlist_start_index = 1
        playlist_feed = yt_service.GetYouTubePlaylistFeed(
            uri=
            'http://gdata.youtube.com/feeds/api/users/KhanAcademyHebrew/playlists?start-index=%s&max-results=50'
            % playlist_start_index)

        while len(playlist_feed.entry) > 0:

            for playlist in playlist_feed.entry:
                logging.info("Playlist: %s", playlist.id.text)

                playlist_id = playlist.id.text.replace(
                    'http://gdata.youtube.com/feeds/api/users/KhanAcademyHebrew/playlists/',
                    '')
                playlist_uri = playlist.id.text.replace(
                    'users/KhanAcademyHebrew/', '')
                query = Playlist.all()
                query.filter('youtube_id =', playlist_id)
                playlist_data = query.get()
                if not playlist_data:
                    playlist_data = Playlist(youtube_id=playlist_id)
                    logging.info('Creating Playlist: %s', playlist.title.text)
                playlist_data.url = playlist_uri
                playlist_data.title = playlist.title.text.decode("utf-8")
                playlist_data.description = playlist.description.text.decode(
                    "utf-8")

                playlist_data.tags = []
                for category in playlist.category:
                    if "tags.cat" in category.scheme:
                        playlist_data.tags.append(category.term)

                playlist_data.put()

                for i in range(0, 10):
                    start_index = i * 50 + 1
                    video_feed = yt_service.GetYouTubePlaylistVideoFeed(
                        uri=playlist_uri + '?start-index=' + str(start_index) +
                        '&max-results=50')
                    video_data_list = []

                    if len(video_feed.entry) <= 0:
                        # No more videos in playlist
                        break

                    for video in video_feed.entry:
                        if not video.media.player:
                            logging.warning(
                                "Could not parse video - skipping... (%s, %s)",
                                video, video.media)
                            continue

                        video_id = cgi.parse_qs(
                            urlparse(
                                video.media.player.url).query)['v'][0].decode(
                                    'utf-8')

                        video_data = None
                        if video_youtube_id_dict.has_key(video_id):
                            video_data = video_youtube_id_dict[video_id]
                            logging.info(
                                'Found Video: %s (%s)',
                                video.media.title.text.decode('utf-8'),
                                video_id)

                        if not video_data:
                            video_data = Video(youtube_id=video_id)
                            logging.info(
                                'Creating Video: %s (%s)',
                                video.media.title.text.decode('utf-8'),
                                video_id)

                        video_data.title = video.media.title.text.decode(
                            'utf-8')
                        video_data.url = video.media.player.url.decode('utf-8')
                        video_data.duration = int(video.media.duration.seconds)

                        if video.statistics:
                            video_data.views = int(video.statistics.view_count)

                        if video.media.description.text is not None:
                            video_data.description = video.media.description.text.decode(
                                'utf-8')
                        else:
                            video_data.decription = ' '

                        if video.media.keywords.text:
                            video_data.keywords = video.media.keywords.text.decode(
                                'utf-8')
                        else:
                            video_data.keywords = ''

                        video_data.position = video.position
                        video_data_list.append(video_data)
                    db.put(video_data_list)

                    playlist_videos = []
                    for video_data in video_data_list:
                        playlist_video = None
                        if video_playlist_key_dict.has_key(
                                playlist_data.key()):
                            if video_playlist_key_dict[
                                    playlist_data.key()].has_key(
                                        video_data.key()):
                                playlist_video = video_playlist_key_dict[
                                    playlist_data.key()][video_data.key()]

                        if not playlist_video:
                            playlist_video = VideoPlaylist(
                                playlist=playlist_data.key(),
                                video=video_data.key())
                            logging.info('Creating VideoPlaylist: %s, %s',
                                         playlist_data.title, video_data.title)
                        else:
                            logging.info('Updating VideoPlaylist: %s, %s',
                                         playlist_video.playlist.title,
                                         playlist_video.video.title)
                        playlist_video.last_live_association_generation = association_generation
                        playlist_video.video_position = int(
                            video_data.position.text)
                        playlist_videos.append(playlist_video)
                    db.put(playlist_videos)

            # Check next set of playlists

            playlist_start_index += 50
            playlist_feed = yt_service.GetYouTubePlaylistFeed(
                uri=
                'http://gdata.youtube.com/feeds/api/users/KhanAcademyHebrew/playlists?start-index=%s&max-results=50'
                % playlist_start_index)