def topic_words(topics_id):
if access_public_topic(topics_id):
results = topic_word_counts(TOOL_API_KEY,
topics_id,
snapshots_id=None,
timespans_id=None,
foci_id=None,
q=None)
elif is_user_logged_in():
results = topic_word_counts(user_mediacloud_key(), topics_id)[:200]
else:
return jsonify({'status': 'Error', 'message': 'Invalid attempt'})
totals = [
] # important so that these get reset on the client when they aren't requested
logger.info(request.args)
if (is_user_logged_in()) and ('withTotals' in request.args) and (
request.args['withTotals'] == "true"):
# handle requests to return these results
# and also data to compare it to for the whole topic focus
totals = topic_word_counts(user_mediacloud_key(),
topics_id,
timespans_id=None,
q=None)
response = {'list': results, 'totals': totals}
return jsonify(response)
def _topic_summary(topics_id):
if access_public_topic(topics_id):
local_mc = mc
elif is_user_logged_in():
local_mc = user_admin_mediacloud_client()
else:
return jsonify({'status': 'Error', 'message': 'Invalid attempt'})
topic = local_mc.topic(topics_id)
# add in snapshot and latest snapshot job status
topic['snapshots'] = {
'list': local_mc.topicSnapshotList(topics_id),
'jobStatus': mc.topicSnapshotGenerateStatus(topics_id)['job_states'] # need to know if one is running
}
# add in spider job status
topic['spiderJobs'] = local_mc.topicSpiderStatus(topics_id)['job_states']
if is_user_logged_in():
_add_user_favorite_flag_to_topics([topic])
'''
# add in story counts, overall seed and spidered
feedTotal = topic_story_count(local_mc, topics_id) # with q - but not passed in for summary
total = topic_story_count(local_mc, topics_id, timespans_id=None, q=None) # spidered count.. how?
spidered = total - seedTotal
topic['seedStories'] = seedTotal
topic['spideredStories'] = spidered
topic['totaltories'] = total
'''
return topic
def topic_words(topics_id):
sample_size = request.args['sample_size'] if 'sample_size' in request.args else WORD_COUNT_SAMPLE_SIZE
if access_public_topic(topics_id):
results = apicache.topic_word_counts(TOOL_API_KEY, topics_id, sample_size=sample_size,
snapshots_id=None, timespans_id=None, foci_id=None, q=None)
elif is_user_logged_in():
# grab the top words, respecting all the filters
results = apicache.topic_word_counts(user_mediacloud_key(), topics_id, sample_size=sample_size)
else:
return jsonify({'status': 'Error', 'message': 'Invalid attempt'})
totals = [] # important so that these get reset on the client when they aren't requested
logger.debug(request.args)
if (is_user_logged_in()) and ('withTotals' in request.args) and (request.args['withTotals'] == "true"):
# return along with the results for the overall timespan, to facilitate comparison
snapshots_id, timespans_id, foci_id, q = filters_from_args(request.args)
overall_timespan = _find_overall_timespan(topics_id, snapshots_id)
totals = apicache.topic_word_counts(user_mediacloud_key(), topics_id, sample_size=sample_size,
timespans_id=overall_timespan['timespans_id'], foci_id=None, q=None)
response = {
'list': results[:WORD_COUNT_UI_NUM_WORDS],
'totals': totals[:WORD_COUNT_UI_NUM_WORDS],
'sample_size': str(sample_size)
}
return jsonify(response)
def _topic_summary(topics_id):
if access_public_topic(topics_id):
local_mc = mc
elif is_user_logged_in():
local_mc = user_mediacloud_client()
else:
return jsonify({'status': 'Error', 'message': 'Invalid attempt'})
topic = local_mc.topic(topics_id)
# add in snapshot list (with version numbers, by date)
topic['snapshots'] = _topic_snapshot_list(topic)
if is_user_logged_in():
add_user_favorite_flag_to_topics([topic])
return topic
def map_files(topics_id):
files = {'wordMap': 'unsupported', 'linkMap': 'not rendered'}
if access_public_topic(topics_id) or is_user_logged_in():
snapshots_id, timespans_id, foci_id, q = filters_from_args(
request.args)
map_type = MAP_TYPES[0] # no linkMaps yet
status = None
prefix = _get_file_prefix(map_type, topics_id, timespans_id)
lock_filename = prefix + ".lock"
rendered_filename = prefix + ".gexf"
# check if rendered file is there
is_rendered = os.path.isfile(os.path.join(DATA_DIR, rendered_filename))
#logger.warn(os.path.join(DATA_DIR,rendered_filename))
#logger.warn(is_rendered)
if is_rendered:
status = 'rendered'
else:
is_generating = os.path.isfile(
os.path.join(DATA_DIR, lock_filename))
if not is_generating:
_start_generating_map_file(map_type, topics_id, timespans_id)
status = 'generating'
files[map_type] = status
return jsonify(files)
else:
return jsonify({'status': 'Error', 'message': 'Invalid attempt'})
def public_topics_list():
public_topics = sorted_public_topic_list()
if is_user_logged_in():
public_topics = _add_user_favorite_flag_to_topics(public_topics)
# for t in public_topics_list:
# t['detailInfo'] = get_topic_info_per_snapshot_timespan(t['topics_id'])
return jsonify({"topics": public_topics})
def topic_tag_coverage(topics_id, tags_id):
'''
Useful for seeing how many stories in the topic are tagged with a specific tag
'''
if isinstance(tags_id, list): # doesn't repect duck-typing, but quick fix
tags_id_str = "({})".format(" ".join([str(tid) for tid in tags_id]))
else:
tags_id_str = str(tags_id)
# respect any query filter the user has set
query_with_tag = add_to_user_query(
"tags_id_stories:{}".format(tags_id_str))
# now get the counts
if access_public_topic(topics_id):
total = topic_story_count(TOOL_API_KEY, topics_id)
tagged = topic_story_count(
TOOL_API_KEY, topics_id,
q=query_with_tag) # force a count with just the query
elif is_user_logged_in():
total = topic_story_count(user_mediacloud_key(), topics_id)
tagged = topic_story_count(
user_mediacloud_key(), topics_id,
q=query_with_tag) # force a count with just the query
else:
return None
return {'counts': {'count': tagged['count'], 'total': total['count']}}
def _mc_client(admin=False):
# return the user's client handler, or a tool one if not logged in
if is_user_logged_in():
client_to_use = user_mediacloud_client() if not admin else user_admin_mediacloud_client()
else:
client_to_use = mc
return client_to_use
def map_files(topics_id):
files = {
'wordMap': 'unsupported',
'linkMap': 'not rendered'
}
if access_public_topic(topics_id) or is_user_logged_in():
snapshots_id, timespans_id, foci_id, q = filters_from_args(request.args)
map_type = MAP_TYPES[0] # no linkMaps yet
prefix = _get_file_prefix(map_type, topics_id, timespans_id)
lock_filename = prefix+".lock"
rendered_filename = prefix+".gexf"
# check if rendered file is there
is_rendered = os.path.isfile(os.path.join(DATA_DIR, rendered_filename))
# logger.warn(os.path.join(DATA_DIR,rendered_filename))
# logger.warn(is_rendered)
if is_rendered:
status = 'rendered'
else:
lockfile_path = os.path.join(DATA_DIR, lock_filename)
is_generating = os.path.isfile(lockfile_path)
if not is_generating:
status = 'starting'
_start_generating_map_file(map_type, topics_id, timespans_id)
else:
status = 'generating'
files[map_type] = status
return jsonify(files)
else:
return jsonify({'status': 'Error', 'message': 'Invalid attempt'})
def mc_client(admin=False):
# return the user's client handler, or a tool one if not logged in
if is_user_logged_in():
client_to_use = user_mediacloud_client() if not admin else user_admin_mediacloud_client()
else:
client_to_use = mc
return client_to_use
def _topic_snapshot_list(topic):
if access_public_topic(topic['topics_id']):
local_mc = mc
api_key = TOOL_API_KEY
elif is_user_logged_in():
local_mc = user_mediacloud_client()
api_key = user_mediacloud_key()
else:
return {} # prob something smarter we can do here
snapshots = local_mc.topicSnapshotList(topic['topics_id'])
snapshots = sorted(snapshots, key=itemgetter('snapshots_id'))
# add in any missing version numbers
for idx in range(0, len(snapshots)):
if snapshots[idx]['note'] in [None, '']:
snapshots[idx]['note'] = idx + ARRAY_BASE_ONE
# seed_query story count
topic['seed_query_story_count'] = _topic_seed_story_count(topic)
# add foci_count for display
snapshots = _add_snapshot_foci_count(api_key, topic['topics_id'],
snapshots)
snapshots = sorted(snapshots, key=lambda d: d['snapshot_date'])
# extra stuff
snapshot_status = mc.topicSnapshotGenerateStatus(
topic['topics_id'])['job_states'] # need to know if one is running
latest = snapshots[-1] if len(snapshots) > 0 else None
return {
'list': snapshots,
'jobStatus': snapshot_status,
'latestVersion': latest['note'] if latest else 1,
}
def public_topics_list():
public_topics = sorted_public_topic_list()
if is_user_logged_in():
public_topics = _add_user_favorite_flag_to_topics(public_topics)
# for t in public_topics_list:
# t['detailInfo'] = get_topic_info_per_snapshot_timespan(t['topics_id'])
return jsonify({"topics": public_topics})
def topic_filter_cascade_list():
public_topics = sorted_public_topic_list()
# for t in sorted_public_topics:
# t['detailInfo'] = get_topic_info_per_snapshot_timespan(t['topics_id'])
# check if user had favorites or personal
user_topics = []
favorited_topics = []
results = {'link_ids': []}
if is_user_logged_in():
user_mc = user_admin_mediacloud_client()
link_id = request.args.get('linkId')
results = user_mc.topicList(link_id=link_id)
user_topics = results['topics']
favorite_topic_ids = db.get_users_lists(user_name(), 'favorite'
'Topics')
# mark all the public topics as favorite or not
for t in public_topics:
t['isFavorite'] = t['topics_id'] in favorite_topic_ids
# mark all the user's topics as favorite or not
for t in user_topics:
t['isFavorite'] = t['topics_id'] in favorite_topic_ids
# fill in the list of favorite topics (need to hit server because they might no be in the other results)
favorited_topics = [user_mc.topic(tid) for tid in favorite_topic_ids]
for t in favorited_topics:
t['isFavorite'] = True
return jsonify({
'topics': {
'favorite': favorited_topics,
'personal': user_topics,
'public': public_topics
},
'link_ids': results['link_ids']
})
def sorted_public_topic_list():
# needs to support logged in or not
if is_user_logged_in():
local_mc = user_mediacloud_client()
else:
local_mc = mc
public_topics = local_mc.topicList(public=True, limit=51)['topics']
return sorted(public_topics, key=lambda t: t['name'].lower())
def sorted_public_topic_list():
# needs to support logged in or not
if is_user_logged_in():
local_mc = user_mediacloud_client()
else:
local_mc = mc
public_topics_list = local_mc.topicList(public=True)['topics']
return sorted(public_topics_list, key=lambda t: t['name'].lower())
def _topic_summary(topics_id):
if access_public_topic(topics_id):
local_mc = mc
elif is_user_logged_in():
local_mc = user_admin_mediacloud_client()
else:
return jsonify({'status': 'Error', 'message': 'Invalid attempt'})
topic = local_mc.topic(topics_id)
# add in snapshot and latest snapshot job status
topic['snapshots'] = {
'list': local_mc.topicSnapshotList(topics_id),
'jobStatus': mc.topicSnapshotGenerateStatus(topics_id)[
'job_states'] # need to know if one is running
}
if is_user_logged_in():
_add_user_favorite_flag_to_topics([topic])
return topic
def topic_media(topics_id):
if access_public_topic(topics_id):
media_list = topic_media_list(TOOL_API_KEY, topics_id, snapshots_id=None, timespans_id=None, foci_id=None, sort=None, limit=None, link_id=None)
elif is_user_logged_in():
media_list = topic_media_list(user_mediacloud_key(), topics_id)
else:
return jsonify({'status': 'Error', 'message': 'Invalid attempt'})
return jsonify(media_list)
def topic_stories(topics_id):
if access_public_topic(topics_id):
stories = topic_story_list(TOOL_API_KEY, topics_id, snapshots_id=None, timespans_id=None, foci_id=None, q=None)
elif is_user_logged_in():
stories = topic_story_list(user_mediacloud_key(), topics_id)
else:
return jsonify({'status': 'Error', 'message': 'Invalid attempt'})
return jsonify(stories)
def topic_split_story_count(topics_id):
if access_public_topic(topics_id):
results = apicache.topic_split_story_counts(TOOL_API_KEY, topics_id, snapshots_id=None, timespans_id=None, foci_id=None,q=None)
elif is_user_logged_in():
results = apicache.topic_split_story_counts(user_mediacloud_key(), topics_id)
else:
return jsonify({'status': 'Error', 'message': 'Invalid attempt'})
return jsonify({'results': results})
def topic_split_story_count(topics_id):
if access_public_topic(topics_id):
results = apicache.topic_split_story_counts(TOOL_API_KEY, topics_id, snapshots_id=None, timespans_id=None, foci_id=None,q=None)
elif is_user_logged_in():
results = apicache.topic_split_story_counts(user_mediacloud_key(), topics_id)
else:
return jsonify({'status': 'Error', 'message': 'Invalid attempt'})
return jsonify({'results': results})
def topic_words(topics_id):
sample_size = request.args[
'sample_size'] if 'sample_size' in request.args else WORD_COUNT_SAMPLE_SIZE
if access_public_topic(topics_id):
results = apicache.topic_word_counts(TOOL_API_KEY,
topics_id,
sample_size=sample_size,
snapshots_id=None,
timespans_id=None,
foci_id=None,
q=None)
elif is_user_logged_in():
# grab the top words, respecting all the filters
results = apicache.topic_word_counts(user_mediacloud_key(),
topics_id,
sample_size=sample_size)
else:
return jsonify({'status': 'Error', 'message': 'Invalid attempt'})
totals = [
] # important so that these get reset on the client when they aren't requested
logger.debug(request.args)
if (is_user_logged_in()) and ('withTotals' in request.args) and (
request.args['withTotals'] == "true"):
# return along with the results for the overall timespan, to facilitate comparison
snapshots_id, timespans_id, foci_id, q = filters_from_args(
request.args)
overall_timespan = _find_overall_timespan(topics_id, snapshots_id)
totals = apicache.topic_word_counts(
user_mediacloud_key(),
topics_id,
sample_size=sample_size,
timespans_id=overall_timespan['timespans_id'],
foci_id=None,
q=None)
response = {
'list': results[:WORD_COUNT_UI_NUM_WORDS],
'totals': totals[:WORD_COUNT_UI_NUM_WORDS],
'sample_size': str(sample_size)
}
return jsonify(response)
def topic_list():
if not is_user_logged_in():
topics = sorted_public_topic_list()
return jsonify({'topics': {'public': topics}})
else:
user_mc = user_admin_mediacloud_client()
link_id = request.args.get('linkId')
topics = user_mc.topicList(link_id=link_id)
_add_user_favorite_flag_to_topics(topics['topics'])
return jsonify({'topics': {'personal': topics}})
def story_counts(topics_id):
if access_public_topic(topics_id):
local_key = TOOL_API_KEY
elif is_user_logged_in():
local_key = user_mediacloud_key()
else:
return jsonify({'status': 'Error', 'message': 'Invalid attempt'})
total = apicache.topic_story_count(local_key, topics_id, timespans_id=None, snapshots_id=None, q=None, foci_id=None)
filtered = apicache.topic_story_count(local_key, topics_id)
return jsonify({'counts': {'count': filtered['count'], 'total': total['count']}})
def _public_safe_topic_story_count(topics_id, q):
if access_public_topic(topics_id):
total = topic_story_count(TOOL_API_KEY, topics_id, q=add_to_user_query(None))
matching = topic_story_count(TOOL_API_KEY, topics_id, q=add_to_user_query(q)) # force a count with just the query
elif is_user_logged_in():
total = topic_story_count(user_mediacloud_key(), topics_id, q=add_to_user_query(None))
matching = topic_story_count(user_mediacloud_key(), topics_id, q=add_to_user_query(q)) # force a count with just the query
else:
return jsonify({'status': 'Error', 'message': 'Invalid attempt'})
return jsonify({'counts': {'count': matching['count'], 'total': total['count']}})
def story_counts(topics_id):
if access_public_topic(topics_id):
local_key = TOOL_API_KEY
elif is_user_logged_in():
local_key = user_mediacloud_key()
else:
return jsonify({'status': 'Error', 'message': 'Invalid attempt'})
total = topic_story_count(local_key, topics_id, timespans_id=None, q=None)
filtered = topic_story_count(local_key, topics_id) # force a count with just the query
return jsonify({'counts': {'count': filtered['count'], 'total': total['count']}})
def topic_media(topics_id):
if access_public_topic(topics_id):
media_list = apicache.topic_media_list(TOOL_API_KEY, topics_id, snapshots_id=None, timespans_id=None,
foci_id=None, sort=None, limit=None, link_id=None)
elif is_user_logged_in():
media_list = apicache.topic_media_list(user_mediacloud_key(), topics_id)
else:
return jsonify({'status': 'Error', 'message': 'Invalid attempt'})
return jsonify(media_list)
def _topic_summary(topics_id):
local_mc = user_mediacloud_client()
topic = local_mc.topic(topics_id)
# add in snapshot list (with version numbers, by date)
topic['snapshots'] = _topic_snapshot_list(topic)
# add in fake topic_seed_query for web/mediacloud platform
if topic_has_seed_query(topic):
p = platform_for_web_seed_query(topic)
topic['topic_seed_queries'].append(p)
if is_user_logged_in():
add_user_favorite_flag_to_topics([topic])
return topic
def _public_safe_topic_story_count(topics_id, q):
if access_public_topic(topics_id):
total = apicache.topic_story_count(TOOL_API_KEY, topics_id, q=apicache.add_to_user_query(None))
# force a count with just the query
matching = apicache.topic_story_count(TOOL_API_KEY, topics_id, q=apicache.add_to_user_query(q))
elif is_user_logged_in():
total = apicache.topic_story_count(user_mediacloud_key(), topics_id, q=apicache.add_to_user_query(None))
# force a count with just the query
matching = apicache.topic_story_count(user_mediacloud_key(), topics_id, q=apicache.add_to_user_query(q))
else:
return jsonify({'status': 'Error', 'message': 'Invalid attempt'})
return jsonify({'counts': {'count': matching['count'], 'total': total['count']}})
def api_explorer_collection_set(tag_sets_id):
'''
Return a list of all the (public only or public and private, depending on user role) collections in a tag set. Not cached because this can change, and load time isn't terrible.
:param tag_sets_id: the tag set to query for public collections
:return: dict of info and list of collections in
'''
info = []
if is_user_logged_in() and user_has_auth_role(ROLE_MEDIA_EDIT) == True:
info = _tag_set_with_private_collections(tag_sets_id)
else:
info = _tag_set_with_public_collections(tag_sets_id)
#_add_user_favorite_flag_to_collections(info['collections'])
return jsonify(info)
def topic_sentence_count(topics_id):
if access_public_topic(topics_id):
response = topic_sentence_counts(TOOL_API_KEY,
topics_id,
snapshots_id=None,
timespans_id=None,
foci_id=None,
q=None)
elif is_user_logged_in():
response = topic_sentence_counts(user_mediacloud_key(), topics_id)
else:
return jsonify({'status': 'Error', 'message': 'Invalid attempt'})
return jsonify(response)
def api_explorer_collection_set(tag_sets_id):
"""
Return a list of all the (public only or public and private, depending on user role) collections in a tag set.
Not cached because this can change, and load time isn't terrible.
:param tag_sets_id: the tag set to query for public collections
:return: dict of info and list of collections in
"""
if is_user_logged_in() and user_has_auth_role(ROLE_MEDIA_EDIT) is True:
info = _tag_set_with_private_collections(tag_sets_id)
else:
info = _tag_set_with_public_collections(tag_sets_id)
# add_user_favorite_flag_to_collections(info['collections'])
return jsonify(info)
def story(topics_id, stories_id):
if is_user_logged_in():
local_mc = user_mediacloud_client()
story_topic_info = apicache.topic_story_list(user_mediacloud_key(),
topics_id,
stories_id=stories_id)
story_topic_info = story_topic_info['stories'][0]
'''
all_fb_count = []
more_fb_count = True
link_id = 0
while more_fb_count:
fb_page = local_mc.topicStoryListFacebookData(topics_id, limit=100, link_id=link_id)
all_fb_count = all_fb_count + fb_page['counts']
if 'next' in fb_page['link_ids']:
link_id = fb_page['link_ids']['next']
more_fb_count = True
else:
more_fb_count = False
for fb_item in all_fb_count:
if int(fb_item['stories_id']) == int(stories_id):
story_topic_info['facebook_collection_date'] = fb_item['facebook_api_collect_date']
'''
else:
return jsonify({'status': 'Error', 'message': 'Invalid attempt'})
try:
story_info = local_mc.story(
stories_id) # add in other fields from regular call
for k in story_info.keys():
story_topic_info[k] = story_info[k]
for tag in story_info['story_tags']:
if tag['tag_sets_id'] == tag_util.GEO_TAG_SET:
geonames_id = int(tag['tag'][9:])
try:
tag['geoname'] = _cached_geoname(geonames_id)
except Exception as e:
# query to CLIFF failed :-( handle it gracefully
logger.exception(e)
tag['geoname'] = {}
except MCException:
logger.warning(
"Story {} wasn't found in a regular story API call, but is it topic {}"
.format(stories_id, topics_id))
return jsonify(story_topic_info)
def story(topics_id, stories_id):
if is_user_logged_in():
local_mc = user_mediacloud_client()
story_topic_info = apicache.topic_story_list(user_mediacloud_key(), topics_id, stories_id=stories_id)
story_topic_info = story_topic_info['stories'][0]
'''
all_fb_count = []
more_fb_count = True
link_id = 0
while more_fb_count:
fb_page = local_mc.topicStoryListFacebookData(topics_id, limit=100, link_id=link_id)
all_fb_count = all_fb_count + fb_page['counts']
if 'next' in fb_page['link_ids']:
link_id = fb_page['link_ids']['next']
more_fb_count = True
else:
more_fb_count = False
for fb_item in all_fb_count:
if int(fb_item['stories_id']) == int(stories_id):
story_topic_info['facebook_collection_date'] = fb_item['facebook_api_collect_date']
'''
else:
return jsonify({'status': 'Error', 'message': 'Invalid attempt'})
try:
story_info = local_mc.story(stories_id) # add in other fields from regular call
for k in story_info.keys():
story_topic_info[k] = story_info[k]
for tag in story_info['story_tags']:
if tag['tag_sets_id'] == tag_util.GEO_TAG_SET:
geonames_id = int(tag['tag'][9:])
try:
tag['geoname'] = _cached_geoname(geonames_id)
except Exception as e:
# query to CLIFF failed :-( handle it gracefully
logger.exception(e)
tag['geoname'] = {}
except MCException:
logger.warning("Story {} wasn't found in a regular story API call, but is it topic {}".format(
stories_id, topics_id
))
return jsonify(story_topic_info)
def topic_tag_coverage(topics_id, tags_id):
'''
Useful for seeing how many stories in the topic are tagged with a specific tag
'''
if isinstance(tags_id, list): # doesn't repect duck-typing, but quick fix
tags_id_str = "({})".format(" ".join([str(tid) for tid in tags_id]))
else:
tags_id_str = str(tags_id)
# respect any query filter the user has set
query_with_tag = add_to_user_query("tags_id_stories:{}".format(tags_id_str))
# now get the counts
if access_public_topic(topics_id):
total = topic_story_count(TOOL_API_KEY, topics_id)
tagged = topic_story_count(TOOL_API_KEY, topics_id, q=query_with_tag) # force a count with just the query
elif is_user_logged_in():
total = topic_story_count(user_mediacloud_key(), topics_id)
tagged = topic_story_count(user_mediacloud_key(), topics_id, q=query_with_tag) # force a count with just the query
else:
return None
return {'counts': {'count': tagged['count'], 'total': total['count']}}
def get_topic_info_per_snapshot_timespan(topic_id):
if not is_user_logged_in():
local_mc = mc
else:
local_mc = user_admin_mediacloud_client()
snapshots = {
'list': local_mc.topicSnapshotList(topic_id),
}
most_recent_running_snapshot = {}
overall_timespan = {}
for snp in snapshots['list']:
if snp['searchable'] == 1 and snp['state'] == "completed":
most_recent_running_snapshot = snp
timespans = cached_topic_timespan_list(user_mediacloud_key(), topic_id,
most_recent_running_snapshot['snapshots_id'])
for ts in timespans:
if ts['period'] == "overall":
overall_timespan = ts
return {'snapshot': most_recent_running_snapshot, 'timespan': overall_timespan}
def topic_tag_coverage(topics_id, tags_id):
'''
Useful for seeing how many stories in the topic are tagged with a specific tag
'''
# respect any query filter the user has set
snapshots_id, timespans_id, foci_id, q = filters_from_args(request.args)
query_with_tag = add_to_user_query("tags_id_stories:{}".format(tags_id))
# now get the counts
if access_public_topic(topics_id):
total = topic_story_count(TOOL_API_KEY, topics_id)
tagged = topic_story_count(
TOOL_API_KEY, topics_id,
q=query_with_tag) # force a count with just the query
elif is_user_logged_in():
total = topic_story_count(user_mediacloud_key(), topics_id)
tagged = topic_story_count(
user_mediacloud_key(), topics_id,
q=query_with_tag) # force a count with just the query
else:
return None
return {'counts': {'count': tagged['count'], 'total': total['count']}}
def get_topic_info_per_snapshot_timespan(topic_id):
if not is_user_logged_in():
local_mc = mc
else:
local_mc = user_admin_mediacloud_client()
snapshots = {
'list': local_mc.topicSnapshotList(topic_id),
}
most_recent_running_snapshot = {}
overall_timespan = {}
for snp in snapshots['list']:
if snp['searchable'] == 1 and snp['state'] == "completed":
most_recent_running_snapshot = snp
timespans = cached_topic_timespan_list(
user_mediacloud_key(), topic_id,
most_recent_running_snapshot['snapshots_id'])
for ts in timespans:
if ts['period'] == "overall":
overall_timespan = ts
return {
'snapshot': most_recent_running_snapshot,
'timespan': overall_timespan
}
def access_public_topic(topics_id):
# check whether logged in here since it is a requirement for public access
if (not is_user_logged_in()) and (topic_is_public(topics_id)):
return True
return False
def _api_key():
api_key = user_mediacloud_key() \
if is_user_logged_in() else TOOL_API_KEY
return api_key
def api_key():
return user_mediacloud_key() if is_user_logged_in() else TOOL_API_KEY
def access_public_topic(topics_id):
# check whether logged in here since it is a requirement for public access
if (not is_user_logged_in()) and (topic_is_public(topics_id)):
return True
return False
def api_key():
return user_mediacloud_key() if is_user_logged_in() else TOOL_API_KEY
