def get(self):
exid = self.request.get('exid')
exercise = Exercise.all().filter('name =', exid).get()
exercise_videos = []
for exercise_video in ExerciseVideo.all().filter('exercise =', exercise):
v = exercise_video.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" % (v.readable_id,)
}
exercise_videos.append(video_dict)
self.response.out.write(json.dumps(exercise_videos, indent=4))
def add_related_exercises(videos):
logging.info("%s videos", len(videos))
exercises = {e.key(): e for e in Exercise.get_all_use_cache()}
relations = {}
logging.info("%s exercises", len(exercises))
for exvid in ExerciseVideo.all().run():
ex = exercises.get(exvid.key_for_exercise())
if ex:
relations.setdefault(exvid.key_for_video(), []).append(ex)
for exs in relations.itervalues():
exs.sort(key=lambda e: (e.v_position, e.h_position))
logging.info("%s related videos", len(relations))
for vid in videos:
exs = relations.get(vid.key()) or []
vid.cached_related_exercises = exs
def add_related_exercises(videos):
logging.info("%s videos", len(videos))
exercises = {e.key():e for e in Exercise.get_all_use_cache()}
relations = {}
logging.info("%s exercises", len(exercises))
for exvid in ExerciseVideo.all().run():
ex = exercises.get(exvid.key_for_exercise())
if ex:
relations.setdefault(exvid.key_for_video(),[]).append(ex)
for exs in relations.itervalues():
exs.sort(key=lambda e: (e.v_position, e.h_position))
logging.info("%s related videos", len(relations))
for vid in videos:
exs = relations.get(vid.key()) or []
vid.cached_related_exercises = exs
def get(self):
exid = self.request.get('exid')
exercise = Exercise.all().filter('name =', exid).get()
exercise_videos = []
for exercise_video in ExerciseVideo.all().filter(
'exercise =', exercise):
v = exercise_video.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" % (v.readable_id, )
}
exercise_videos.append(video_dict)
self.response.out.write(json.dumps(exercise_videos, indent=4))
def get(self):
query = self.request.get('page_search_query')
template_values = {'page_search_query': query}
query = query.strip()
if len(query) < search.SEARCH_PHRASE_MIN_LENGTH:
if len(query) > 0:
template_values.update({
'query_too_short': search.SEARCH_PHRASE_MIN_LENGTH
})
self.render_jinja2_template("searchresults.html", template_values)
return
searched_phrases = []
# Do an async query for all ExerciseVideos, since this may be slow
exvids_query = ExerciseVideo.all()
exvids_future = util.async_queries([exvids_query])
# One full (non-partial) search, then sort by kind
all_text_keys = Playlist.full_text_search(
query, limit=50, kind=None,
stemming=Playlist.INDEX_STEMMING,
multi_word_literal=Playlist.INDEX_MULTI_WORD,
searched_phrases_out=searched_phrases)
# Quick title-only partial search
playlist_partial_results = filter(
lambda playlist_dict: query in playlist_dict["title"].lower(),
autocomplete.playlist_title_dicts())
video_partial_results = filter(
lambda video_dict: query in video_dict["title"].lower(),
autocomplete.video_title_dicts())
# Combine results & do one big get!
all_key_list = [str(key_and_title[0]) for key_and_title in all_text_keys]
#all_key_list.extend([result["key"] for result in playlist_partial_results])
all_key_list.extend([result["key"] for result in video_partial_results])
all_key_list = list(set(all_key_list))
all_entities = db.get(all_key_list)
# Filter results by type
playlists = []
videos = []
for entity in all_entities:
if isinstance(entity, Playlist):
playlists.append(entity)
elif isinstance(entity, Video):
videos.append(entity)
elif entity is not None:
logging.error("Unhandled kind in search results: " +
str(type(entity)))
playlist_count = len(playlists)
# Get playlists for videos not in matching playlists
filtered_videos = []
filtered_videos_by_key = {}
for video in videos:
if [(playlist.title in video.playlists) for playlist in playlists].count(True) == 0:
video_playlist = video.first_playlist()
if video_playlist != None:
playlists.append(video_playlist)
filtered_videos.append(video)
filtered_videos_by_key[str(video.key())] = []
else:
filtered_videos.append(video)
filtered_videos_by_key[str(video.key())] = []
video_count = len(filtered_videos)
# Get the related exercises
all_exercise_videos = exvids_future[0].get_result()
exercise_keys = []
for exvid in all_exercise_videos:
video_key = str(ExerciseVideo.video.get_value_for_datastore(exvid))
if video_key in filtered_videos_by_key:
exercise_key = ExerciseVideo.exercise.get_value_for_datastore(exvid)
video_exercise_keys = filtered_videos_by_key[video_key]
video_exercise_keys.append(exercise_key)
exercise_keys.append(exercise_key)
exercises = db.get(exercise_keys)
# Sort exercises with videos
video_exercises = {}
for video_key, exercise_keys in filtered_videos_by_key.iteritems():
video_exercises[video_key] = map(lambda exkey: [exercise for exercise in exercises if exercise.key() == exkey][0], exercise_keys)
# Count number of videos in each playlist and sort descending
for playlist in playlists:
if len(filtered_videos) > 0:
playlist.match_count = [(playlist.title in video.playlists) for video in filtered_videos].count(True)
else:
playlist.match_count = 0
playlists = sorted(playlists, key=lambda playlist: -playlist.match_count)
template_values.update({
'playlists': playlists,
'videos': filtered_videos,
'video_exercises': video_exercises,
'search_string': query,
'video_count': video_count,
'playlist_count': playlist_count,
})
self.render_jinja2_template("searchresults.html", template_values)
def get(self):
query = self.request.get('page_search_query')
template_values = {'page_search_query': query}
query = query.strip()
if len(query) < search.SEARCH_PHRASE_MIN_LENGTH:
if len(query) > 0:
template_values.update({
'query_too_short': search.SEARCH_PHRASE_MIN_LENGTH
})
self.render_jinja2_template("searchresults.html", template_values)
return
# Do an async query for all ExerciseVideos, since this may be slow
exvids_query = ExerciseVideo.all()
exvids_future = util.async_queries([exvids_query])
# One full (non-partial) search, then sort by kind
all_text_keys = Topic.full_text_search(
query, limit=50, kind=None,
stemming=Topic.INDEX_STEMMING,
multi_word_literal=Topic.INDEX_MULTI_WORD)
# Quick title-only partial search
topic_partial_results = filter(
lambda topic_dict: query in topic_dict["title"].lower(),
autocomplete.topic_title_dicts())
video_partial_results = filter(
lambda video_dict: query in video_dict["title"].lower(),
autocomplete.video_title_dicts())
url_partial_results = filter(
lambda url_dict: query in url_dict["title"].lower(),
autocomplete.url_title_dicts())
# Combine results & do one big get!
all_key_list = [str(key_and_title[0]) for key_and_title in all_text_keys]
# all_key_list.extend([result["key"] for result in topic_partial_results])
all_key_list.extend([result["key"] for result in video_partial_results])
all_key_list.extend([result["key"] for result in url_partial_results])
all_key_list = list(set(all_key_list))
# Filter out anything that isn't a Topic, Url or Video
all_key_list = [key for key in all_key_list if db.Key(key).kind() in ["Topic", "Url", "Video"]]
# Get all the entities
all_entities = db.get(all_key_list)
# Group results by type
topics = []
videos = []
for entity in all_entities:
if isinstance(entity, Topic):
topics.append(entity)
elif isinstance(entity, Video):
videos.append(entity)
elif isinstance(entity, Url):
videos.append(entity)
elif entity:
logging.info("Found unknown object " + repr(entity))
topic_count = len(topics)
# Get topics for videos not in matching topics
filtered_videos = []
filtered_videos_by_key = {}
for video in videos:
if [(str(topic.key()) in video.topic_string_keys) for topic in topics].count(True) == 0:
video_topic = video.first_topic()
if video_topic != None:
topics.append(video_topic)
filtered_videos.append(video)
filtered_videos_by_key[str(video.key())] = []
else:
filtered_videos.append(video)
filtered_videos_by_key[str(video.key())] = []
video_count = len(filtered_videos)
# Get the related exercises
all_exercise_videos = exvids_future[0].get_result()
exercise_keys = []
for exvid in all_exercise_videos:
video_key = str(ExerciseVideo.video.get_value_for_datastore(exvid))
if video_key in filtered_videos_by_key:
exercise_key = ExerciseVideo.exercise.get_value_for_datastore(exvid)
video_exercise_keys = filtered_videos_by_key[video_key]
video_exercise_keys.append(exercise_key)
exercise_keys.append(exercise_key)
exercises = db.get(exercise_keys)
# Sort exercises with videos
video_exercises = {}
for video_key, exercise_keys in filtered_videos_by_key.iteritems():
video_exercises[video_key] = map(lambda exkey: [exercise for exercise in exercises if exercise.key() == exkey][0], exercise_keys)
# Count number of videos in each topic and sort descending
if topics:
if len(filtered_videos) > 0:
for topic in topics:
topic.match_count = [(str(topic.key()) in video.topic_string_keys) for video in filtered_videos].count(True)
topics = sorted(topics, key=lambda topic: -topic.match_count)
else:
for topic in topics:
topic.match_count = 0
template_values.update({
'topics': topics,
'videos': filtered_videos,
'video_exercises': video_exercises,
'search_string': query,
'video_count': video_count,
'topic_count': topic_count,
})
self.render_jinja2_template("searchresults.html", template_values)
def get(self):
query = self.request.get('page_search_query')
template_values = {'page_search_query': query}
query = query.strip()
if len(query) < search.SEARCH_PHRASE_MIN_LENGTH:
if len(query) > 0:
template_values.update(
{'query_too_short': search.SEARCH_PHRASE_MIN_LENGTH})
self.render_jinja2_template("searchresults.html", template_values)
return
# Do an async query for all ExerciseVideos, since this may be slow
exvids_query = ExerciseVideo.all()
exvids_future = util.async_queries([exvids_query])
# One full (non-partial) search, then sort by kind
all_text_keys = Topic.full_text_search(
query,
limit=50,
kind=None,
stemming=Topic.INDEX_STEMMING,
multi_word_literal=Topic.INDEX_MULTI_WORD)
# Quick title-only partial search
topic_partial_results = filter(
lambda topic_dict: query in topic_dict["title"].lower(),
autocomplete.topic_title_dicts())
video_partial_results = filter(
lambda video_dict: query in video_dict["title"].lower(),
autocomplete.video_title_dicts())
url_partial_results = filter(
lambda url_dict: query in url_dict["title"].lower(),
autocomplete.url_title_dicts())
# Combine results & do one big get!
all_key_list = [
str(key_and_title[0]) for key_and_title in all_text_keys
]
# all_key_list.extend([result["key"] for result in topic_partial_results])
all_key_list.extend(
[result["key"] for result in video_partial_results])
all_key_list.extend([result["key"] for result in url_partial_results])
all_key_list = list(set(all_key_list))
# Filter out anything that isn't a Topic, Url or Video
all_key_list = [
key for key in all_key_list
if db.Key(key).kind() in ["Topic", "Url", "Video"]
]
# Get all the entities
all_entities = db.get(all_key_list)
# Group results by type
topics = []
videos = []
for entity in all_entities:
if isinstance(entity, Topic):
topics.append(entity)
elif isinstance(entity, Video):
videos.append(entity)
elif isinstance(entity, Url):
videos.append(entity)
elif entity:
logging.info("Found unknown object " + repr(entity))
topic_count = len(topics)
# Get topics for videos not in matching topics
filtered_videos = []
filtered_videos_by_key = {}
for video in videos:
if [(str(topic.key()) in video.topic_string_keys)
for topic in topics].count(True) == 0:
video_topic = video.first_topic()
if video_topic != None:
topics.append(video_topic)
filtered_videos.append(video)
filtered_videos_by_key[str(video.key())] = []
else:
filtered_videos.append(video)
filtered_videos_by_key[str(video.key())] = []
video_count = len(filtered_videos)
# Get the related exercises
all_exercise_videos = exvids_future[0].get_result()
exercise_keys = []
for exvid in all_exercise_videos:
video_key = str(ExerciseVideo.video.get_value_for_datastore(exvid))
if video_key in filtered_videos_by_key:
exercise_key = ExerciseVideo.exercise.get_value_for_datastore(
exvid)
video_exercise_keys = filtered_videos_by_key[video_key]
video_exercise_keys.append(exercise_key)
exercise_keys.append(exercise_key)
exercises = db.get(exercise_keys)
# Sort exercises with videos
video_exercises = {}
for video_key, exercise_keys in filtered_videos_by_key.iteritems():
video_exercises[video_key] = map(
lambda exkey: [
exercise for exercise in exercises
if exercise.key() == exkey
][0], exercise_keys)
# Count number of videos in each topic and sort descending
if topics:
if len(filtered_videos) > 0:
for topic in topics:
topic.match_count = [
(str(topic.key()) in video.topic_string_keys)
for video in filtered_videos
].count(True)
topics = sorted(topics, key=lambda topic: -topic.match_count)
else:
for topic in topics:
topic.match_count = 0
template_values.update({
'topics': topics,
'videos': filtered_videos,
'video_exercises': video_exercises,
'search_string': query,
'video_count': video_count,
'topic_count': topic_count,
})
self.render_jinja2_template("searchresults.html", template_values)
