def title_text_search():
query = request.args.get('query')
not_listed = request.args.get('more') if request.args.get('more') else None
titles = None
if not not_listed:
titles = Title.find_by_title(query)
if titles:
response = []
for title in titles:
response.append({
"uid":
title.uid,
"title":
title.title,
"released":
title.released,
"title_type":
title.title_type,
"children_known":
title.children_known if title.children_known else False
})
return {"known": True, "results": response, "query": query}
response = API.retrieve('/search/multi', {'query': query})
titles = parse_search_results(response, "titles")
return {"known": False, "results": titles}
def add_titles(self, titles_info):
try:
from titles import Title
except ImportError:
from coactors.titles import Title
query = """MERGE (a:Actor {uid: $uid})
ON CREATE SET a += {name: $name}
SET a += {children_known: True}
WITH a
CALL {
WITH a
UNWIND $batch as row
MERGE (_:Title {uid: row.uid})
ON CREATE SET _ += {title: row.title, released: row.released, title_type: row.title_type}
MERGE (a)-[:ACTED_IN]->(_)
RETURN _
}"""
params = {"name": self.name, "uid": self.uid}
batch = []
for i in range(0,len(titles_info)):
batch.append( {"uid": titles_info[i]["uid"], "title":titles_info[i]["title"],
"released":titles_info[i]["released"],"title_type":titles_info[i]["title_type"]} )
params['batch'] = batch
return Title.match(graph ).raw_query(query, params)
def get_titles_data(titles_attr):
new_titles = []
for title in titles_attr:
uid = None
if type(title) == dict:
uid = title['uid']
title_type = title['title_type']
elif type(title) == Title and (title.children_known is None
or not title.children_known):
uid = title.uid[2:]
title_type = title.title_type
if uid:
if title_type == "movie":
response = API.retrieve(f'/{title_type}/{uid}',
{'append_to_response': "credits"})
else:
response = API.retrieve(
f'/{title_type}/{uid}',
{'append_to_response': "aggregate_credits"})
cast = Title.parse_cast(response, title_type)
new_titles.append(cast)
return new_titles
def find_title(uid):
title = Title.find_by_uid(uid)
if title:
cast = title.get_cast()
return title.serialize2(cast)
else:
return {}
def get_titles():
titles = Title.get_all()
title_list = []
for title in titles:
title_list.append(title.serialize())
from flask import jsonify
return jsonify(title_list)
def create_title():
uid = request.args.get('uid')
title_type = request.args.get('title_type')
if uid.isnumeric():
if title_type == "movie" or title_type == "tv":
prefix = title_type[0:2]
else:
return {}
elif uid[2:].isnumeric():
prefix = uid[0:2]
uid = uid[2:]
if prefix == "mo":
title_type = "movie"
elif prefix == "tv":
title_type = "tv"
else:
return {}
title = find_title(prefix + uid)
if title and 'children_known' in title:
return title
title_data = get_titles_data([{'uid': uid, "title_type": title_type}])
t = Title(title_data[0]['uid'], title_data[0]['title'],
title_data[0]['released'], title_data[0]['title_type'])
actors_added = t.add_cast(title_data[0]['cast'])
actors = get_actors_data(actors_added)
for actor in actors:
a = Actor(actor['uid'], actor['name'])
a.add_titles(actor['titles'])
return redirect(url_for('find_title', uid=title_data[0]['uid']))
def get_groups_titles(self, actor_uids):
try:
from titles import Title
except ImportError:
from coactors.titles import Title
actor_uids.append(self.uid)
return Title.match(graph ).raw_query("""MATCH(a:Actor)-[r1:ACTED_IN]->(_:Title)
WHERE a.uid IN $actor_uids
WITH count(r1) as rels, _
WHERE rels = $rels
WITH distinct _ """, {"actor_uids":actor_uids, "rels": len(actor_uids)})
def get_multi():
actors = Actor.get_all(limit=10)
actor_list = []
for actor in actors:
actor_list.append(actor.serialize())
titles = Title.get_all(limit=10)
title_list = []
for title in titles:
title_list.append(title.serialize())
return {'titles': title_list, "actors": actor_list}
def create_actor():
uid = request.args.get('uid')
uid = uid if uid.isnumeric() else uid[2:]
if not uid.isnumeric():
return {}
actor = find_actor("na" + uid)
if actor and 'children_known' in actor:
return actor
actor_data = get_actors_data([{'uid': uid}])
a = Actor(actor_data[0]['uid'], actor_data[0]['name'])
titles_added = a.add_titles(actor_data[0]['titles'])
casts = get_titles_data(titles_added)
for cast in casts:
t = Title(cast['uid'], cast['title'], cast['released'],
cast['title_type'])
t.add_cast(cast['cast'])
return redirect(url_for('find_actor', uid=actor_data[0]['uid']))
def parse_filmography(actor_data):
import json
try:
from titles import Title
except ImportError:
from coactors.titles import Title
actor_data = json.loads(actor_data)
titles = actor_data['combined_credits']['cast']
result = []
for title in titles:
title_type = title['media_type']
result.append( Title.parse_properties(title, title_type) )
return {"titles": result, "uid": "na" + str(actor_data['id']),
"name": actor_data['name']}
def parse_search_results(response, search_type):
import json
response = json.loads(response)
response = response['results']
result = []
if search_type == "titles":
for el in response:
if el['media_type'] == "tv" or el['media_type'] == "movie":
result.append(Title.parse_properties(el, None, False))
#people search
else:
for el in response:
if el['known_for_department'] == "Acting" or el[
'known_for_department'] == "acting":
result.append({'uid': str(el['id']), 'name': el['name']})
return result
def parse_cast(title_data, title_type):
import json
try:
from titles import Title
except ImportError:
from coactors.titles import Title
title_data = json.loads(title_data)
cast = title_data['credits'][
'cast'] if 'credits' in title_data else title_data[
'aggregate_credits']['cast']
properties = Title.parse_properties(title_data, title_type)
result = []
min_episodes = int(
title_data['number_of_episodes'] *
0.05) if 'number_of_episodes' in title_data else None
min_episodes = 0 if min_episodes and cast[0][
'total_episode_count'] < min_episodes else min_episodes
for actor in cast:
if 'total_episode_count' in actor and actor[
'total_episode_count'] < min_episodes:
continue
result.append({
"uid": "na" + str(actor['id']),
"name": actor['name']
})
return {
'cast': result,
'uid': properties['uid'],
'released': properties['released'],
"title_type": title_type,
'title': properties['title']
}
def get_titles(self):
try:
from titles import Title
except ImportError:
from coactors.titles import Title
return Title.match(graph ).raw_query("MATCH(a:Actor {uid: $uid})-[:ACTED_IN]->(_:Title) ", {"uid":self.uid})