def stage2():
film_name = request.args.get('filmName')
cost = request.args.get('cost')
theme = request.args.get('theme')
director = request.args.get('director')
actor = request.args.get('actor')
release_date = request.args.get('releaseDate')
if cost is None or theme is None or director is None or actor is None or release_date is None:
return rt.necessary_param_needed()
try:
cost = int(cost)
except:
return rt.param_type_error()
nn_res = neural_network_res(film_name=film_name,
director=director,
actor=actor,
genre=theme,
release_date=release_date,
is_3rd=False)
b_res = bayes_res(director=director,
actor=actor,
genre=theme,
release_date=release_date,
cost=cost)
dt_res = [0, 5]
box_office = vote(nn_res, b_res, dt_res)
return jsonify({
'code': '001',
'msg': 'success',
'data': {
'boxOfficeMin': box_office[0],
'boxOfficeMax': box_office[1]
}
})
def stage31():
film_name = request.args.get('filmName')
cost = request.args.get('cost')
theme = request.args.get('theme')
director = request.args.get('director')
actor = request.args.get('actor')
competition = request.args.get('competition')
topic = request.args.get('topic')
screen3 = request.args.get('screen3')
screen30 = request.args.get('screen30')
release_date = request.args.get('releaseDate')
if cost is None or theme is None or director is None or actor is None or release_date is None \
or topic is None or screen3 is None or competition is None:
return rt.necessary_param_needed()
if screen30 is None:
screen30 = 0
try:
cost = float(cost)
competition = int(competition)
topic = float(topic)
screen3 = int(screen3)
screen30 = int(screen30)
except:
return rt.param_type_error()
nn_res = neural_network_res(film_name=film_name,
director=director,
actor=actor,
genre=theme,
release_date=release_date,
topic=topic,
screen3d=screen3,
screen30d=screen30,
competition=competition,
is_3rd=True)
b_res = bayes_res(director=director,
actor=actor,
genre=theme,
release_date=release_date,
search=topic,
screen3days=screen3,
screen30days=screen30,
competition=competition,
stage=3)
dt_res = [0, 5]
box_office = vote(nn_res, b_res, dt_res)
return jsonify({
'code': '001',
'msg': 'success',
'data': {
'boxOfficeMin': box_office[0],
'boxOfficeMax': box_office[1],
'probability': str((nn_res[1] + b_res[1]) / 2)[:4]
}
})
def check_param(film):
if film['cost'] is None or film['theme'] is None or film['director'] is None or film['actor'] is None or \
film['releaseDate'] is None \
or film['topic'] is None or film['screen3'] is None or film['competition'] is None:
return rt.necessary_param_needed()
def query_director():
from predictBoxOffice import models
level = request.args.get('level')
box_office = request.args.get('boxOffice')
theme = request.args.get('theme')
cost = request.args.get('cost')
if level is None or box_office is None or theme is None:
return rt.necessary_param_needed()
try:
box_office = int(box_office)
level = int(level)
if not 0 <= box_office <= 8:
return rt.param_cross_border()
box_office = transform_box_office(box_office)
except:
return rt.param_type_error()
if cost is not None:
try:
cost = int(cost)
if not 1 <= cost <= 9:
return rt.param_cross_border()
cost = transform_cost(cost)
except:
return rt.param_type_error()
else:
cost = (-1, sys.maxsize)
movies = models.Movie.query.filter(
(box_office[0] <= models.Movie.box_office) & (models.Movie.box_office <= box_office[1])) \
.filter((cost[0] <= models.Movie.production_cost) & (models.Movie.production_cost <= cost[1])) \
.filter(models.Movie.movie_type.contains(theme)) \
.all()
directors = directors_from_movie(movies, level)
refer_movie = {}
for d in directors:
refer_movie[d.name] = list(
map(lambda x: x.name,
filter(lambda x: x.director.find(d.name) != -1, movies)))
directors = sorted(directors,
key=lambda x: abs(x.avg_box_office -
(box_office[1] - box_office[0])))
basic_rate = 0.5
box_office_rate = 0.2
theme_rate = 0.2
cost_rate = 0.1
match_rate = {}
is_internal = {}
directors_len = len(directors)
for i in range(directors_len):
if directors[i].is_internal:
is_internal[directors[i].name] = '1'
else:
is_internal[directors[i].name] = '0'
match_rate[directors[i].name] = basic_rate + (
(directors_len - i) / directors_len) * box_office_rate
types = directors[i].movie_type.split(',')
types_len = len(types)
for t in range(types_len):
if types[t] == theme:
match_rate[directors[i].name] += (
(types_len - t) / types_len) * theme_rate
break
if cost[0] != -1:
directors = sorted(directors,
key=lambda x: abs(x.avg_cost - (cost[1] - cost[0])))
for i in range(directors_len):
match_rate[directors[i].name] += (
(directors_len - 1 - i) / directors_len) * cost_rate
else:
for d in directors:
match_rate[d.name] += cost_rate
if len(match_rate) == 0:
return rt.no_response_data()
match_rate = sorted(match_rate.items(), key=lambda x: x[1], reverse=True)
result = []
for m in match_rate:
res = {
'name': m[0],
'nationality': is_internal[m[0]],
'matching': (str(m[1] * 100))[:4] + '%',
'referMovie': refer_movie[m[0]]
}
result.append(res)
return jsonify({'code': '001', 'msg': 'success', 'directorList': result})
def create_creator_test():
from predictBoxOffice import models
box_office = request.args.get('boxOffice')
cost = request.args.get('cost')
theme = request.args.get('theme')
if box_office is None:
return rt.necessary_param_needed()
try:
box_office = int(box_office)
if not 0 <= box_office <= 8:
return rt.param_cross_border()
box_office = transform_box_office(box_office)
except Exception:
return rt.param_type_error()
if cost is not None:
try:
cost = int(cost)
if not 1 <= cost <= 9:
return rt.param_cross_border()
cost = transform_cost(cost)
except:
return rt.param_type_error()
else:
cost = (-1, sys.maxsize)
movies = models.Movie.query.filter(
(box_office[0] <= models.Movie.box_office) & (models.Movie.box_office <= box_office[1])) \
.filter((cost[0] <= models.Movie.production_cost) & (models.Movie.production_cost <= cost[1])).all()
movie_type_dict = {}
directors, actors = director_actor(movies)
for i in range(len(movies)):
types = movies[i].movie_type.split(',')
for t in types:
movie_type_dict[t] = movie_type_dict.get(t, 0) + 1
mtd = sorted(movie_type_dict.items(), key=lambda x: x[1], reverse=True)[:6]
if not len(mtd):
return rt.no_response_data()
director_level = directors_actors_level(directors, mtd)
actor_level = directors_actors_level(actors, mtd, is_director=False)
if theme is not None:
if theme not in list(map(lambda x: x[0], mtd)):
return rt.no_response_data()
else:
res = {
'theme': theme,
'directorLevels': director_level[theme],
'actorLevels': actor_level[theme]
}
return jsonify({'code': '001', 'msg': 'success', 'schemes': res})
result = []
for i in range(len(mtd)):
res = {
'theme': mtd[i][0],
'directorLevels': director_level[mtd[i][0]],
'actorLevels': actor_level[mtd[i][0]]
}
result.append(res)
return jsonify({'code': '001', 'msg': 'success', 'schemes': result})