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__())