def getGenres(type):
if type == 'movie':
g = tmdb.Genres()
response = g.movie_list()
return response.items()
elif type == 'tv':
g = tmdb.Genres()
response = g.tv_list()
return response.items()
def insert_genres():
genres = tmdb.Genres().tv_list()["genres"]
genres += tmdb.Genres().movie_list()["genres"]
genres = {x['id']: x for x in genres}.values()
i = 0
for i, genre in enumerate(genres):
statement = "INSERT INTO genres (id, name) VALUES (%(id)s, %(name)s) ON CONFLICT DO NOTHING;"
execute_dml_statement(statement, genre)
progress_bar(i, len(genres), prefix='Inserting genres:')
clear_progress_bar('Inserted ' + str(i) + ' genres')
def _get_genres():
genres = tmdb.Genres().movie_list()["genres"]
id_name = list(map(lambda x: (x["id"], x["name"]), genres))
name_id = list(map(lambda x: reversed(x), id_name))
return dict(id_name + name_id)
def load_movies(path):
genre_id = 27
genres = tmdb.Genres(id=genre_id)
films = genres.movies()
total_pages = films['total_pages']
results = films['results']
print len(results)
df = pd.DataFrame(results)
for n_page in range(2, total_pages + 1):
response = genres.movies(page=n_page)
df = df.append(response['results'], ignore_index=True)
if n_page % 10 == 0:
time.sleep(1)
print n_page
if n_page % 20 == 0:
df.to_pickle(path)
df.drop([
'video', 'poster_path', 'popularity', 'overview', 'original_title',
'backdrop_path', 'adult', 'genre_ids'
],
axis=1,
inplace=True)
print df.head(), df.shape
df.to_pickle(path)
def get_genre(genre_id, name='', page=1):
tmdb.API_KEY = TMDB_KEY
genre = tmdb.Genres(genre_id)
genre_movies = genre.movies(page=page, include_all_movies=True)
movies = []
name = ' '.join(name.split('%20'))
for movie in genre_movies['results']:
year = ''
try:
if movie['release_date']:
year = f'({movie["release_date"][:4]})'
except Exception:
pass
movies.append({
'title': movie['title'],
'year': year,
'poster_path': movie['poster_path'],
'id': movie['id']
})
movies_data = {
'genre': {
'name': name,
'id': genre_id
},
'movies': movies,
'total_pages': genre_movies['total_pages']
}
return movies_data
def get_movie_genres(request):
genre = tmdb.Genres()
# Check if there is a CacheList entry where name='genres' here
# Soon we will also check if list is old and needs to be updated
if CachedList.objects.filter(name='genres'):
# print('genres exists',CachedList.objects.filter(name='genres'))
cl = CachedList.objects.filter(name='genres')[0]
response_data_str = cl.list_data
# print('response_data_str',response_data_str)
response_data = json.loads(response_data_str)
return JsonResponse(response_data)
else:
response_data = genre.movie_list()
# Basic implementation - create an entry into the CacheList model
response_data_str = json.dumps(response_data)
cl = CachedList(
name='genres',
list_data=response_data_str,
date_updated=timezone.now()
)
cl.save()
return JsonResponse(response_data)
def search_genre(page, data):
movieList = []
genre = tmdb.Genres(id=GenreList[data])
movies = genre.movies(page=page + 1)
for s in movies["results"]:
movieList.append(s)
return movieList
def main():
new_offset = None
today = now.day
hour = now.hour
while True:
movieMBot.get_updates(new_offset)
last_update = movieMBot.get_last_update()
last_update_id = last_update['update_id']
last_chat_text = last_update['message']['text']
last_chat_id = last_update['message']['chat']['id']
last_chat_name = last_update['message']['chat']['first_name']
if last_chat_text.lower(
) in greetings and today == now.day and 6 <= hour < 12:
movieMBot.send_message(last_chat_id,
'Доброе утро, {}'.format(last_chat_name))
today += 1 # can greet once
elif last_chat_text.lower(
) in greetings and today == now.day and 12 <= hour < 17:
movieMBot.send_message(last_chat_id,
'Добрый день, {}'.format(last_chat_name))
today += 1 # can greet once
elif last_chat_text.lower(
) in greetings and today == now.day and 17 <= hour < 23:
movieMBot.send_message(last_chat_id,
'Добрый вечер, {}'.format(last_chat_name))
today += 1 # can greet once
if last_chat_text.lower() == '/популярное':
popularList = ''
for i in range(len(get_request_(popular))):
film = tmdb.Movies().popular()['results'][i]
popularList += (i + 1).__str__() + ') ' + film[
'title'] + ' – rating: ' + film['vote_average'].__str__(
) + '\n'
movieMBot.send_message(last_chat_id, popularList)
if last_chat_text.lower() == '/жанры':
genre = tmdb.Genres().movie_list()['genres']
genLen = len(genre)
genreList = ''
for i in range(genLen):
genreList += genre[i]['name'] + '\t(id: ' + genre[i][
'id'].__str__() + ')' + '\n'
movieMBot.send_message(last_chat_id, genreList)
if last_chat_text.lower() == '/фильм':
movie = tmdb.Movies(100)
responce = movie.info()
print(tmdb.Movies().lists().__str__())
# movieMBot.send_message(last_chat_id, '\"' + movie.title + '\",' + ' here you go, {}'.format(last_chat_name))
new_offset = last_update_id + 1
def get_genre_based_recommendations(self, max_recommendations):
"""
Returns movie recommendations solely based on personality-genre associations.
Returns the recommendations as well as the list of genres for this user.
"""
genres = get_genres_for_user(self, max_distance=2, max_genres=4)
genre_ids = [
g['id'] for g in tmdb.Genres().movie_list()['genres']
if g['name'] in genres
]
recommendations = []
args = {
'page': 1,
'vote_count_gte': 20,
'vote_average_gte': 7,
'sort_by': 'vote_average.desc'
}
# If at least one rule can be applied, predict movies of the associated genres with a high rating.
# Otherwise, just predict movies of all genres with high ratings.
if len(genres) > 0:
args['with_genres'] = genre_ids
recs = tmdb.Discover().movie(**args)
recommendations += recs['results']
rated_movie_ids = [
r.movie.tmdb_id for r in Rating.objects.filter(rated_by=self)
]
# Filter out movies that the user has already seen
recommendations = [
r for r in recommendations if r['id'] not in rated_movie_ids
]
while len(recommendations) < max_recommendations and recs[
'page'] < recs['total_pages']:
args['page'] += 1
recs = tmdb.Discover().movie(**args)
recommendations += recs['results']
# Filter out movies that the user has already seen
recommendations = [
r for r in recommendations if r['id'] not in rated_movie_ids
]
if len(recommendations) > max_recommendations:
recommendations = recommendations[:max_recommendations]
# Save recommended Movies in DB
for rec in recommendations:
movie = Movie.objects.filter(tmdb_id=rec['id'])
if not movie.exists():
Movie(tmdb_id=rec['id'], title=rec['title']).save()
return recommendations, genres
def search_TvGenre(page, data):
tvList = []
genre = tmdb.Genres(id=GenreList[data])
tv = genre.tv(page=page + 1)
for s in tv["results"]:
tvList.append(s)
return tvList
def api_get_genre():
genres = tmdb.Genres()
response = genres.movie_list()
matcher = NodeMatcher(graph)
for g in response["genres"]:
gen = matcher.match("genre").where("_.id=" + str(g["id"])).first()
if (gen is None):
gen = Node("genre", id=g["id"], name=g["name"], page=0)
graph.create(gen)
def test():
genres = tmdb.Genres()
genres.movie_list()
data = []
for genre in genres.genres:
data.insert(genre['id'], genre['name'])
return render_template('test.html', data=data)
def saveTmdbGenres():
"""
Download genres from TMDB and save it into binary file
"""
listGenres = tmdb.Genres().movie_list()["genres"]
genres = { _format(g["name"]):i for i, g in enumerate(listGenres) }
np.save(Config.GENRES_FILE, np.asarray([genres]))
def run(self):
# Exponential waits on API calls, in case of limit reached.
while True:
waitTime = 10
try:
total_pages = tmdb.Genres(
self.genre_id).movies().get('total_pages')
waitTime = 10
break
except Exception:
print 'Waiting for refreshing API requests'
time.sleep(waitTime)
waitTime *= 2
for i in range(current_pages.get(self.genre_id), total_pages):
exit = False
while True:
try:
results = tmdb.Genres(
self.genre_id).movies(page=i).get('results')
waitTime = 10
break
except Exception:
time.sleep(waitTime)
waitTime *= 2
for movie in results:
if sizes.get(self.genre_id) >= MAX_COUNT:
exit = True
break
thread = threading.Thread(target=search_thread,
args=[movie, self.genre_id])
thread.start()
thread.join()
time.sleep(0.01)
if exit:
current_pages[self.genre_id] = i + 2
return
def get_genres(genre_ids, tmdb_key):
genres = []
with open(tmdb_key) as f:
api_key = [line.strip() for line in list(f)]
tmdb.API_KEY = api_key
tmdb_genres = tmdb.Genres().movie_list()
data = tmdb_genres['genres']
for genre_id in genre_ids:
for i in data:
if genre_id == i['id']:
genres.append(i['name'])
return genres
def add_genres(apps, schema_editor):
"""
Inserts available genres from TMDB into the database.
"""
MovieGenre = apps.get_model('app', 'MovieGenre')
tmdb.API_KEY = config.TMDB_API_KEY
genres = tmdb.Genres().movie_list()
for genre in genres['genres']:
movie_genre = MovieGenre(id=genre['id'], name=genre['name'])
movie_genre.save()
def get_genres(self, content_type):
"""Gets all available TMDB genres and genre IDs.
Args:
content_type: String containing "movie" or "tv".
"""
try:
# Obtain a movie's genres
if content_type.lower() == "movie":
return cache.handler(
"movie genres cache",
function=tmdb.Genres().movie_list,
cache_duration=GET_GENRES_CACHE_TIMEOUT,
)
# Obtain a TV show's genres
if content_type.lower() == "tv":
return cache.handler(
"movie genres cache",
function=tmdb.Genres().tv_list,
cache_duration=GET_GENRES_CACHE_TIMEOUT,
)
# Content Type was invalid
log.handler(
"Invalid content_type " + str(content_type) +
" in get_genres().",
log.WARNING,
self.__logger,
)
return {}
except:
log.handler(
"Failed to obtain genres!",
log.ERROR,
self.__logger,
)
return {}
def getGenre():
genres = tmdb.Genres()
genres_list = genres.movie_list()
fieldnames = genres_list.get('genres')[0].keys()
with open('data/d_genres.csv', 'w') as csv_file:
writer = csv.DictWriter(csv_file, fieldnames=fieldnames)
writer.writeheader()
print(genres_list)
for genre in genres_list.get('genres'):
writer.writerow(genre)
def __init__(self, credentials_filepath):
"""
:param credentials_filepath: Path to JSON file containing entries for keys "api_key", "username" and "password",
which are required for connecting to TMDb and obtaining a list of rated movies from a TMDb account.
"""
with open(credentials_filepath) as credentials_file:
self.credentials = json.load(credentials_file)
self.authenticate()
genres_list = tmdb.Genres().list()
self.genres = {}
for entry in genres_list["genres"]:
self.genres[entry["id"]] = entry["name"]
print("Done.")
class MovieForm(FlaskForm):
#choices=[]
#for genre in genres.genres:
# choices.insert(genre['id'], genre['name'])
genres = tmdb.Genres()
genres.movie_list()
#genres = SelectField("Sjangrar", validators=[required()], choices=genres.genres)
budget = IntegerField("Budsjett [i USD, 0-380 000 000]", validators=[required()])
popularity = FloatField("Popularitet [0.0-300.0]", validators=[required()])
runtime = IntegerField("Filmlengde [i minutt]", validators=[required()])
release_date = StringField("Gitt ut dato [mm/dd/yy]", validators=[required()])
original_language = StringField("Orginalt språk [en]", validators=[required()])
submit = SubmitField('Submit')
def index():
with open('api.key', 'r') as keyfile:
apikey = keyfile.readline()
tmdb.API_KEY = apikey
genres = tmdb.Genres()
response = genres.list()
genredict = response['genres']
mygenres = {}
for dicts in genredict:
for i in range(1):
mygenres[dicts['name']] = dicts['id']
return render_template('index.html', mygenres=mygenres)
def list_by_genre(number_movies, id_genre):
movies_informations = []
movie = {}
genre = tmdb.Genres(id_genre)
movies = genre.movies(page=2)
result = movies["results"]
for i in range(number_movies):
movie = {}
movie["id_movie"] = result[i]["id"]
movie["name"] = result[i]["title"]
movie["overview"] = result[i]["overview"]
movie["date"] = result[i]["release_date"]
movie["poster"] = "https://image.tmdb.org/t/p/w500" + result[i]["poster_path"]
movie["vote"] = str(result[i]["vote_average"])
movies_informations.append(movie)
return movies_informations
def add_genres(self):
genres = tmdb.Genres()
all = genres.movie_list()
all_gen = []
if len(all) > 0:
all_gen = all['genres']
id_list = []
name_list = []
if len(all_gen) > 0:
for x in all_gen:
id_list.append(x['id'])
name_list.append(x['name'].lower())
for x in range(0, len(id_list)):
self.GENRES[id_list[x]] = name_list[x]
class MovieForm(FlaskForm):
genreChoices = list(tmdb.Genres().movie_list()['genres'])
formattedGenres = []
formattedYears = []
# format the genre choices to a list of tuples in order to have SelectField accept it
for g in genreChoices:
formattedGenres.append((tuple((g['id'], g['name']))))
# format the year choices to a list of tuples in order to have SelectField accept it
for i in reversed(range(1970, 2021)):
formattedYears.append((tuple((i, str(i)))))
genre = SelectField('Genres', choices=formattedGenres, coerce=int)
firstYear = SelectField('from', choices=formattedYears, coerce=int)
lastYear = SelectField('to', choices= formattedYears, coerce=int)
includePG = BooleanField('include movies PG and under?', default='checked')
submit = SubmitField('Search!')
def run(self, dispatcher, tracker, domain):
#genre from user text
genre_name = tracker.get_slot('genre')
if genre_name == '':
response = "Sorry, found no genre name in that sentence. Try with different wording."
dispatcher.utter_message(response)
return [SlotSet('genre', genre_name)]
genre = tmdb.Genres()
response = genre.movie_list()
movie_id = 0
movie_genre = ''
for x in range(0, len(genre.genres)):
if genre.genres[x]['name'].lower() == genre_name:
movie_id = genre.genres[x]['id']
movie_genre = genre.genres[x]['name']
discover = tmdb.Discover()
response = discover.movie(page=1,
sort_by='popularity.desc',
include_adult=False,
include_video=False,
with_genres=movie_id)
if len(discover.results) > 0:
response = """Most popular {} movies:
{}, {},
{}, {},
{}, {},
{}, {},
{}, {}.""".format(movie_genre, discover.results[0]['title'],
discover.results[0]['release_date'],
discover.results[1]['title'],
discover.results[1]['release_date'],
discover.results[2]['title'],
discover.results[2]['release_date'],
discover.results[3]['title'],
discover.results[3]['release_date'],
discover.results[4]['title'],
discover.results[4]['release_date'])
else:
response = "Searched for genre " + genre_name + " movies but found no information. Check spelling and try again."
dispatcher.utter_message(response)
return [SlotSet('genre', genre_name)]
def filterMovies(self, page, id, gender, name):
if (page):
response = tmdb.Movies()
response = response.now_playing(page=page)
return response
if (id):
movieInfo = tmdb.Movies(id).info()
return movieInfo
if (gender):
genres = tmdb.Genres()
response = genres.movie_list()
return response
if (name):
response = tmdb.Search().movie(query=name)
return response
return None
def add_genres(self):
""""Adding genres and their id to help dictionary"""
genres = tmdb.Genres()
all = genres.movie_list() #get all genres list
all_gen = []
if len(all) > 0: # select only genres
all_gen = all['genres']
id_list = []
name_list = []
if len(all_gen) > 0:
for x in all_gen:
id_list.append(x['id'])
name_list.append(x['name'].lower())
for x in range(0, len(id_list)):
self.GENRES[id_list[x]] = name_list[x]
def serach_movies_by_genres(self, genres):
self.add_genres()
ID = self.search_id_genres(genres)
if ID != 0:
search = tmdb.Genres(ID)
response = search.movies()
all_title = []
all_id = []
result = {}
if len(response['results']) > 0:
for x in response['results']:
all_title.append(x['original_title'])
all_id.append(x['id'])
if len(all_title) > 0 and len(all_id) > 0:
for x in range(0, len(all_title)):
result[all_id[x]] = all_title[x]
return result
def filter_by_genre(self, pages=5):
if len(self.current_movies
) == 0: # if this was our first request to filter on
movies = []
for i in range(1, pages):
movies.append(
tm.Genres(self.kw_genres[self.keywords['genre']], page=i)
['results']) # get 5 pages with most vote counts
flatten = [item for sublist in movies for item in sublist]
self.current_movies = flatten
else:
# filter out by genre and update our selection, will probably be generalized later
selection = []
for movie in self.current_movies: # go through all movies
if self.kw_genres[self.keywords['genre']] in movie[
'genre_ids']: # check if the genre id that we want is in the current movie
selection.append(movie)
self.current_movies = selection # update our selections
def createGenres():
"""
Should be called only once!!!
Creates all genres for movies using the TMDb API
Args:
None
Returns:
None
"""
genres = tmdb.Genres().list()
genre_count = 0
for genre in genres['genres']:
if len(Genre.objects.filter(identifier=int(genre['id']))) == 0:
g = Genre(identifier=int(genre['id']), name=genre['name'])
g.save()
genre_count += 1
logging.debug('Genres added to database: ' + genre_count.__str__())
