def tmdb_get_movies(config_path, plex, data):
try:
tmdb_id = re.search('.*?(\\d+)', data)
tmdb_id = tmdb_id.group(1)
except AttributeError: # Bad URL Provided
return
t_movie = Movie()
tmdb = Collection()
tmdb.api_key = config_tools.TMDB(
config_path).apikey # Set TMDb api key for Collection
if tmdb.api_key == "None":
raise KeyError("Invalid TMDb API Key")
t_movie.api_key = tmdb.api_key # Copy same api key to Movie
t_col = tmdb.details(tmdb_id)
t_movs = []
for tmovie in t_col.parts:
t_movs.append(tmovie['id'])
# Create dictionary of movies and their guid
# GUIDs reference from which source Plex has pulled the metadata
p_m_map = {}
p_movies = plex.Library.all()
for m in p_movies:
guid = m.guid
if "themoviedb://" in guid:
guid = guid.split('themoviedb://')[1].split('?')[0]
elif "imdb://" in guid:
guid = guid.split('imdb://')[1].split('?')[0]
else:
guid = "None"
p_m_map[m] = guid
matched = []
missing = []
# We want to search for a match first to limit TMDb API calls
# Too many rapid calls can cause a momentary block
# If needed in future maybe add a delay after x calls to let the limit reset
for mid in t_movs: # For each TMBd ID in TMBd Collection
match = False
for m in p_m_map: # For each movie in Plex
if "tt" not in p_m_map[
m] != "None": # If the Plex movie's guid does not start with tt
if int(p_m_map[m]) == int(mid):
match = True
break
if not match:
imdb_id = t_movie.details(mid).entries['imdb_id']
for m in p_m_map:
if "tt" in p_m_map[m]:
if p_m_map[m] == imdb_id:
match = True
break
if match:
matched.append(m)
else:
missing.append(t_movie.details(mid).entries['imdb_id'])
return matched, missing
def tmdb_get_metadata(config_path, data, type):
# Instantiate TMDB objects
tmdb_id = int(data)
api_key = config_tools.TMDB(config_path).apikey
language = config_tools.TMDB(config_path).language
is_movie = config_tools.Plex(config_path).library_type == "movie"
if type in ["overview", "poster", "backdrop"]:
collection = Collection()
collection.api_key = api_key
collection.language = language
try:
if type == "overview":
meta = collection.details(tmdb_id).overview
elif type == "poster":
meta = collection.details(tmdb_id).poster_path
elif type == "backdrop":
meta = collection.details(tmdb_id).backdrop_path
except AttributeError:
media = Movie() if is_movie else TV()
media.api_key = api_key
media.language = language
try:
if type == "overview":
meta = media.details(tmdb_id).overview
elif type == "poster":
meta = media.details(tmdb_id).poster_path
elif type == "backdrop":
meta = media.details(tmdb_id).backdrop_path
except AttributeError:
raise ValueError(
"| TMDb Error: TMBd {} ID: {} not found".format(
"Movie/Collection" if is_movie else "Show", tmdb_id))
elif type in ["biography", "profile", "name"]:
person = Person()
person.api_key = api_key
person.language = language
try:
if type == "biography":
meta = person.details(tmdb_id).biography
elif type == "profile":
meta = person.details(tmdb_id).profile_path
elif type == "name":
meta = person.details(tmdb_id).name
except AttributeError:
raise ValueError(
"| TMDb Error: TMBd Actor ID: {} not found".format(tmdb_id))
else:
raise RuntimeError(
"type {} not yet supported in tmdb_get_metadata".format(type))
if meta is None:
raise ValueError("| TMDb Error: TMDB ID {} has no {}".format(
tmdb_id, type))
elif type in ["profile", "poster", "backdrop"]:
return "https://image.tmdb.org/t/p/original" + meta
else:
return meta
def __init__(self, movieId):
self.movie = movies.loc[(movies['movieId'] == movieId)].max()
self.title, self.year = sep_year_title(self.movie.title)
self.id = movieId
self.genres = self.movie.genres.split('|')
self.tmdb_id = links.loc[(links['movieId'] == self.id)].max().tmdbId
try:
movie = Movie()
details = movie.details(self.tmdb_id)
self.title = details.title
self.poster_url = 'http://image.tmdb.org/t/p/w500/' + details.poster_path
self.overview = details.overview
self.release_date = details.release_date
self.runtime = details.runtime
self.budget = details.budget
self.revenue = details.revenue
self.popularity = details.popularity
except:
self.poster_url = None
self.overview = 'Not Found'
self.release_date = None
self.runtime = 0
self.budget = 0
self.revenue = 0
self.popularity = 0
def fetch():
projectpath = request.form['projectFilepath']
id = request.args.get(projectpath)
print(id)
movie = Movie()
m = movie.details(343611)
url = "http://image.tmdb.org/t/p/w500/" + m.poster_path
response = requests.get(url)
img = Image.open(BytesIO(response.content))
img.save('static/movie.jpg')
return render_template("image.html")
def imdb_get_movies(config_path, plex, data):
title_ids = data[1]
print("| {} Movies found on IMDb".format(len(title_ids)))
tmdb = TMDb()
tmdb.api_key = config_tools.TMDB(config_path).apikey
movie = Movie()
imdb_map = {}
matched_imdb_movies = []
missing_imdb_movies = []
current_length = 0
current_count = 0
plex_tools.create_cache(config_path)
plex_movies = plex.Library.all()
for m in plex_movies:
current_count += 1
print_display = "| Processing: {}/{} {}".format(current_count, len(plex_movies), m.title)
print(adjust_space(current_length, print_display), end="\r")
current_length = len(print_display)
if 'plex://' in m.guid:
item = m
# Check cache for imdb_id
imdb_id = plex_tools.query_cache(config_path, item.guid, 'imdb_id')
if not imdb_id:
imdb_id, tmdb_id = plex_tools.alt_id_lookup(plex, item)
print(adjust_space(current_length, "| Cache | + | {} | {} | {} | {}".format(item.guid, imdb_id, tmdb_id, item.title)))
plex_tools.update_cache(config_path, item.guid, imdb_id=imdb_id, tmdb_id=tmdb_id)
elif 'themoviedb://' in m.guid:
if not tmdb.api_key == "None":
tmdb_id = m.guid.split('themoviedb://')[1].split('?')[0]
tmdbapi = movie.details(tmdb_id)
imdb_id = tmdbapi.imdb_id if hasattr(tmdbapi, 'imdb_id') else None
else:
imdb_id = None
elif 'imdb://' in m.guid:
imdb_id = m.guid.split('imdb://')[1].split('?')[0]
else:
imdb_id = None
if imdb_id and imdb_id in title_ids:
imdb_map[imdb_id] = m
else:
imdb_map[m.ratingKey] = m
print(adjust_space(current_length, "| Processed {} Movies".format(len(plex_movies))))
for imdb_id in title_ids:
movie = imdb_map.pop(imdb_id, None)
if movie:
matched_imdb_movies.append(plex.Server.fetchItem(movie.ratingKey))
else:
missing_imdb_movies.append(imdb_id)
return matched_imdb_movies, missing_imdb_movies
def get_details(self):
"""
get movie details from TMDB
"""
movieId = self.movieId
movie = Movie()
print(movie)
m = movie.details(movieId)
poster = m.poster_path
image_base = 'http://image.tmdb.org/t/p/w185'
image_url = image_base + poster
return m.overview, image_url, m.title, m.popularity, m.release_date
def search(self, submission):
movie = Movie()
title = submission
if len(title) > 0:
try:
search = movie.search(title)
except Exception as e:
return
if len(search) > 0:
first = search[0]
try:
movie = movie.details(first.id)
except Exception as e:
return
self.post(movie)
def import_movie_genre(start, end):
mg_list = []
movie = Movie()
for i in range(start, end):
try:
genre_list = movie.details(i).genres
for g in genre_list:
movie_id = i
genre_id = g['id']
mg = DbMovieGenre(movie_id=movie_id, genre_id=genre_id)
mg_list.append(mg)
print(movie_id, genre_id, g['name'])
except TMDbException: # if this id is not exist
pass
return mg_list
def imdb_get_movies(config_path, plex, data):
tmdb = TMDb()
movie = Movie()
tmdb.api_key = config_tools.TMDB(config_path).apikey
imdb_url = data
if imdb_url[-1:] == " ":
imdb_url = imdb_url[:-1]
imdb_map = {}
library_language = plex.Library.language
try:
r = requests.get(imdb_url,
headers={'Accept-Language': library_language})
except requests.exceptions.MissingSchema:
return
tree = html.fromstring(r.content)
title_ids = tree.xpath("//div[contains(@class, 'lister-item-image')]"
"//a/img//@data-tconst")
if title_ids:
for m in plex.Library.all():
if 'themoviedb://' in m.guid:
if not tmdb.api_key == "None":
tmdb_id = m.guid.split('themoviedb://')[1].split('?')[0]
tmdbapi = movie.details(tmdb_id)
imdb_id = tmdbapi.imdb_id
else:
imdb_id = None
elif 'imdb://' in m.guid:
imdb_id = m.guid.split('imdb://')[1].split('?')[0]
else:
imdb_id = None
if imdb_id and imdb_id in title_ids:
imdb_map[imdb_id] = m
else:
imdb_map[m.ratingKey] = m
matched_imbd_movies = []
missing_imdb_movies = []
for imdb_id in title_ids:
movie = imdb_map.pop(imdb_id, None)
if movie:
matched_imbd_movies.append(
plex.Server.fetchItem(movie.ratingKey))
else:
missing_imdb_movies.append(imdb_id)
return matched_imbd_movies, missing_imdb_movies
def init():
movieName = input("\nMovie Name?")
tmdb = TMDb()
tmdb.api_key = "10163a322f4558e7cc6411377702d81d"
movie = Movie()
try:
search = movie.search(movieName)
if search is not None:
for e in search:
movieID = e.id
break
else:
movieID = None
m = movie.details(movieID)
initial_budget = m.budget
revenue = m.revenue
title = m.original_title
print("-Full name: " + title)
if (initial_budget is not 0):
print("-Intial Budget: " + (str(int(initial_budget))))
else:
print(
"NO INITIAL BUDGET REPORTED. DO NOT USE THIS ENTRY FOR TRAINING DATA."
)
if (revenue is not 0):
print("-Revenue: " + (str(int(revenue))))
else:
print(
"NO REVENUE REPORTED. DO NOT USE THIS ENTRY FOR TRAINING DATA."
)
exit()
except:
print("\nBad movie entry?")
return title, initial_budget, revenue
def import_movie(start, end):
movies = []
movie = Movie()
for i in range(start, end):
try:
m = movie.details(i)
tmdb_id = int(m.id)
imdb_id = m.imdb_id
title = m.title
original_title = m.original_title
collection = str(m.belongs_to_collection) # need to re-format
if collection != "None":
collection = eval(collection)
collection = collection['name']
language = m.original_language
release_date = m.release_date
if release_date == '': release_date = None
overview = m.overview
vote_average = m.vote_average
country_list = eval(str(
m.production_countries)) # need to re-format
country = ""
for c in country_list:
country = country + '[' + c['name'] + ']'
runtime = m.runtime
poster_path = m.poster_path
d = DbMovie(tmdb_id, imdb_id, title, original_title, collection,
language, release_date, overview, vote_average,
country, runtime, poster_path)
print(d.tmdb_id, d.imdb_id, d.title, d.original_title,
d.collection, d.language, d.release_date, d.vote_average,
d.vote_count, d.country, d.runtime, d.poster_path)
print(d.overview)
movies.append(d)
except TMDbException: # if this id is not exist
pass
return movies
def get_detalles(id, tipo=''):
try:
if id == '':
abort(404, "Post id {0} doesn't exist.".format(id))
if tipo == '':
abort(403)
detalles = ""
if tipo == "peliculas":
movie = Movie()
detalles = movie.details(id)
elif tipo == "series":
season = Season()
detalles = season.details(id)
elif tipo == "tv":
tv = TV()
detalles = tv.details(id)
return detalles
except Exception as e:
raise e
def imdb_get_movies(data):
imdb_url = data
# movieLibrary = plex.library.section("Movies")
library_language = plex.library.section("Movies").language
r = requests.get(imdb_url, headers={'Accept-Language': library_language})
tree = html.fromstring(r.content)
title_name = tree.xpath(
"//div[contains(@class, 'lister-item-content')]//h3[contains(@class, "
"'lister-item-header')]//a/text()")
title_years = tree.xpath(
"//div[contains(@class, 'lister-item-content')]//h3[contains(@class, "
"'lister-item-header')]//span[contains(@class, 'lister-item-year')]/text()"
)
title_ids = tree.xpath(
"//div[contains(@class, 'lister-item-image')]//a/img//@data-tconst")
tmdb = TMDb()
tmdb.api_key = config['tmdb']['apikey']
movie = Movie()
imdb_map = {}
matched_movies = []
for m in plex.library.section("Movies").all():
if 'themoviedb://' in m.guid:
if not tmdb.api_key == "None":
tmdb_id = m.guid.split('themoviedb://')[1].split('?')[0]
tmdbapi = movie.details(tmdb_id)
imdb_id = tmdbapi.imdb_id
else:
imdb_id = None
elif 'imdb://' in m.guid:
imdb_id = m.guid.split('imdb://')[1].split('?')[0]
else:
imdb_id = None
if imdb_id and imdb_id in title_ids:
imdb_map[imdb_id] = m
else:
imdb_map[m.ratingKey] = m
if imdb_id in title_ids:
matched_movies.append(m)
return matched_movies
def serialize_movie_details(id):
m = Movie()
k = m.details(int(id))
casts = []
if len(k.casts["cast"])>20:
k.casts["cast"] = k.casts["cast"][:20]
for i in k.casts["cast"]:
try:
casts.append({'name':i['name'], 'character': i['character'], 'image': 'https://image.tmdb.org/t/p/w500' + i['profile_path']})
except:
casts.append({'name':i['name'], 'character': i['character']})
director = ""
for i in k.casts["crew"]:
if i["job"] == "Director":
director += i['name']
genres_str = ""
for j in k.genres:
genres_str += j['name'] + ", "
genres_str = genres_str[:-2]
response = {'title':k.original_title, 'director': director, 'year': str(k.release_date)[:4], 'runtime': k.runtime,
'genres': genres_str, 'rating' : k.vote_average, 'backdrop' : 'https://image.tmdb.org/t/p/w500' + k.backdrop_path,
'poster':'https://image.tmdb.org/t/p/w500'+k.poster_path,'summary':k.overview, 'casts':casts}
similar = m.similar(int(id))
if len(similar)>10:
similar = similar[:10]
similar_movies = []
for i in similar:
if len(i['title'])>30:
i['title'] = i['title'][:30] + "..."
genres_str = ""
if len(i["genre_ids"])>3:
i["genre_ids"] = i["genre_ids"][:3]
for j in i["genre_ids"]:
genres_str += genres[str(j)] + ", "
genres_str = genres_str[:-2]
similar_movies.append({'title':i['title'], 'poster':'https://image.tmdb.org/t/p/w500'+i['poster_path'],
'genres':genres_str, 'id':i["id"], 'year': str(k.release_date)[:4]})
return [response,similar_movies]
def get_movie_details(tmdbId, df_MovieLens):
country, genres, budget, revenue, keywords, MLens_rating = '', '', np.NaN, np.NaN, '', np.NaN
if tmdbId:
movie_api = Movie()
movie_api.wait_on_rate_limit = True
movie_dict = movie_api.details(tmdbId).__dict__
country_list = movie_dict['entries']['production_countries']
if country_list:
country = movie_dict['entries']['production_countries'][0][
'iso_3166_1']
genres_list = movie_dict['entries']['genres']
genres = '/'.join([i['name'] for i in genres_list])
budget = movie_dict['entries']['budget']
revenue = movie_dict['entries']['revenue']
keywords_list = movie_dict['entries']['keywords']['keywords']
keywords = '/'.join([i['name'] for i in keywords_list])
MLens_rating_Series = df_MovieLens[df_MovieLens['tmdbId'] ==
tmdbId]['rating']
if len(MLens_rating_Series) == 1:
MLens_rating = float(MLens_rating_Series)
#time.sleep(0.5) # to ensure not to exceed the rate limit of API
return [country, genres, budget, revenue, keywords, MLens_rating, tmdbId]
def post_movie(api, cgi='27'):
# Choose Genre
cgi = random.choice(list(dict.keys()))
# Create recommendation
discover = Discover()
movie = discover.discover_movies({'with_genres': cgi, 'with_original_language': 'en', 'release_date.lte': '2020-02-02', \
'vote_average.gte': '7', 'vote_count.gte': '100', 'page': str(random.randint(1, 5))})
rec = random.choice(movie)
# Get IMDB ID
movieimd = Movie()
imd = movieimd.details(rec.id)
# Create hashtags
namehash = '#' + re.sub(r'\W+', '', rec.title)
genhash = '#' + re.sub(r'\W+', '', dict[str(rec.genre_ids[0])])
# Create post string
tweet = '𝗧𝗶𝘁𝗹𝗲: ' + rec.title + '\n𝗚𝗲𝗻𝗿𝗲: ' + dict[str(rec.genre_ids[0])] + '\n𝗬𝗲𝗮𝗿: ' + rec.release_date[0:4] + \
'\n𝗦𝗰𝗼𝗿𝗲: ' + str(int(rec.vote_average*10)) + "%" + '\n\nWas it worth the watch? ' + namehash + ' ' + genhash + \
'\nhttps://www.imdb.com/title/' + imd.imdb_id
return tweet
class Tmdbapi:
tmdb = TMDb()
tmdb.api_key = API_KEY
def __init__(self):
self.movie = Movie()
self.tv = TV()
# Movies
# Search for a movie and find the movie's data, its director and its cast
# Put all of that in a data holding object
# The data is NOT LINKED TO EACH OTHER
# This linking has to be done elsewhere by checking the database
# For example:
# the movie's director property will be None, the director's id will be None, the cast's id's will be None
# Their names need to be checked in the database first to make sure not to add them twice
# Convert tmdbv3 API data into our own MovieSearchResult
def tmdb_to_movie(self, moviedata) -> MovieSearchResult:
movie = database.Movie()
movie.tmdbId = moviedata.id
movie.title = moviedata.title
movie.description = moviedata.overview
movie_credits = self.movie.credits(moviedata.id).entries
movie.director = None
movie_details = self.movie.details(moviedata.id).entries
runtime = None
genre = None
if movie_details is not None:
if "runtime" in movie_details.keys():
runtime = movie_details["runtime"]
else:
runtime = 0
if "genres" in movie_details.keys():
genres = movie_details["genres"]
else:
genres = None
if genres is not None and len(genres) > 0:
genre = genres[0]["name"]
else:
genre = "Unknown"
movie.runtime = runtime
movie.genre = genre
if hasattr(moviedata,
'release_date') and len(moviedata.release_date) != 0:
movie.releaseYear = int(moviedata.release_date[0:4])
else:
movie.releaseYear = 0
movie.avgRating = moviedata.vote_average
# Director
director = None
director_name = None
crew = []
if "crew" in movie_credits.keys():
crew = movie_credits["crew"]
for person in crew:
if person["job"] == "Director":
director_name = person["name"]
break
if director_name is not None:
director = database.Contributor()
director.name = director_name
# Cast
cast = []
actors = []
if "cast" in movie_credits.keys():
actors = movie_credits["cast"]
for actor in actors[0:CAST_AMOUNT]:
cast_member = database.Contributor()
cast_member.name = actor["name"]
cast.append(cast_member)
output = MovieSearchResult()
output.movie = movie
output.director = director
output.cast = cast
return output
# Search for a movie by title and duration
def search_movie(self, query: str, duration: int) -> MovieSearchResult:
search = self.movie.search(query)
output = None
for movie_data in search:
movie = self.tmdb_to_movie(movie_data)
if output is None:
output = movie
#elif abs(movie.movie.runtime - duration) < abs(output.movie.runtime - duration):
#output = movie
return output
# Search multiple movies by title
def search_movies(self, query: str,
max_movies: int) -> [MovieSearchResult]:
search = self.movie.search(query)
output = []
for movie_data in search:
if len(output) >= max_movies:
break
movie = self.tmdb_to_movie(movie_data)
output.append(movie)
return output
# "Download" a movie thumbnail
def get_poster_movie(self, tmdb_id: int) -> str:
movie_result = self.movie.details(tmdb_id)
poster_path = movie_result.poster_path
if poster_path is None:
return None
return "https://image.tmdb.org/t/p/w500" + poster_path
# Get similar tmdb movies
def get_similar_tmdb_movies(self, tmdb_id: int) -> [MovieSearchResult]:
output = []
for moviedata in self.movie.similar(tmdb_id):
output.append(self.tmdb_to_movie(moviedata))
if len(output) == SIMILAR_AMOUNT:
break
return output
# TV shows
# Convert tmdbv3 API data into our own TvShowSearchResult
def tmdb_to_tvshow(self, tvshowdata) -> TvShowSearchResult:
tvshow = database.TvShow()
tvshow.title = tvshowdata.name
tvshow.tmdbId = tvshowdata.id
tvshow.description = tvshowdata.overview
tvshow.director = None
tvshow_details = self.tv.details(tvshowdata.id).entries
runtime = 0
genre = None
if tvshow_details is not None:
if "episode_run_time" in tvshow_details.keys():
runtimes = tvshow_details["episode_run_time"]
else:
runtimes = None
if runtimes is not None and len(runtimes) != 0:
runtime = runtimes[0]
if "genres" in tvshow_details.keys():
genres = tvshow_details["genres"]
else:
genres = None
if genres is not None and len(genres) > 0:
genre = genres[0]["name"]
else:
genre = "Unknown"
tvshow.runtime = runtime
tvshow.genre = genre
if hasattr(tvshowdata,
'first_air_date') and len(tvshowdata.first_air_date) != 0:
tvshow.releaseYear = int(tvshowdata.first_air_date[0:4])
else:
tvshow.releaseYear = 0
tvshow.avgRating = tvshowdata.vote_average
# Director
director = None
if "created_by" in tvshow_details.keys():
created_by = tvshow_details["created_by"]
else:
created_by = None
if created_by is not None and len(created_by) != 0:
director = database.Contributor()
director.name = created_by[0]["name"]
# Cast
cast = []
if "credits" in tvshow_details.keys():
if "cast" in tvshow_details["credits"].keys():
actors = tvshow_details["credits"]["cast"]
else:
actors = []
for actor in actors[0:CAST_AMOUNT]:
cast_member = database.Contributor()
cast_member.name = actor["name"]
cast.append(cast_member)
# Episodes
episodes = []
if "seasons" in tvshow_details.keys():
seasons_data = tvshow_details["seasons"]
for season_data in seasons_data:
season_nr = season_data["season_number"]
for episode_nr in range(1, season_data["episode_count"] + 1):
episode = database.Episode()
episode.tmdbId = None
episode.season = season_nr
episode.episode = episode_nr
episodes.append(episode)
output = TvShowSearchResult()
output.tvshow = tvshow
output.episodes = episodes
output.director = director
output.cast = cast
return output
# Search for a tv show via the API and turn the found data into a database supported object
def search_tvshow(self, query: str, duration: int) -> TvShowSearchResult:
search = self.tv.search(query)
output = None
for tvshow_data in search:
tvshow = self.tmdb_to_tvshow(tvshow_data)
if output is None:
output = tvshow
#elif abs(tvshow.tvshow.runtime - duration) < abs(output.tvshow.runtime - duration):
#output = tvshow
return output
# Search for a tv show via the API and turn the found data into a database supported object
def search_tvshows(self, query: str,
max_tvshows: int) -> [TvShowSearchResult]:
search = self.tv.search(query)
output = []
for tvshowdata in search:
if len(output) >= max_tvshows:
break
tvshow = self.tmdb_to_tvshow(tvshowdata)
output.append(tvshow)
return output
# "Download" a tv show thumbnail
def get_poster_tv(self, tmdb_id: int) -> str:
tv_result = self.tv.details(tmdb_id)
poster_path = tv_result.poster_path
if poster_path is None:
return None
return "https://image.tmdb.org/t/p/w500" + poster_path
# Get the similar items of a tv show
def get_similar_tmdb_tvshows(self, tmdb_id: int) -> [TvShowSearchResult]:
output = []
for tvshowdata in self.tv.similar(tmdb_id):
output.append(self.tmdb_to_tvshow(tvshowdata))
if len(output) == SIMILAR_AMOUNT:
break
return output
def getMovieNamePoster(movie_id):
id = int(movie_id)
movie = Movie()
s = movie.details(id)
return s.original_title, s.poster_path
def singleMovie(request, movie_id):
data = {}
id = int(movie_id)
# Fetching all the reviews of that movie.
reviews = ReviewMovie.objects.filter(movieid=id)
userReviews = []
if reviews != None:
temp = {}
for review in reviews:
userReviews.append({'review': review.review, 'date': review.date, 'userid': review.userid})
data['userReview'] = userReviews
else:
data['userReview'] = None
# Checking if the logged in user has reviewed it or not.
check = ReviewMovie.objects.filter(movieid=id).filter(userid=request.user.username)
if check.exists():
data['check'] = True
else:
data['check'] = False
# If user send review request this part is executed.
if request.method == 'POST':
username = request.user.username
text = request.POST['review']
# calling getSentiment function to get probability and sentiment of reviews.
prob, sen = getSentiment(text)
r = ReviewMovie(
userid = username,
movieid = movie_id,
review = request.POST['review'],
sentiment = sen,
probability= prob
)
#form.data['sentiment'], form.data['probability'] = sentiment.getsentiment(form.cleaned_data['review'])
# Saving the review and sending a confirmation message.
r.save()
messages.success(request, 'Your review has been saved successfully.')
return redirect(singleMovie, id)
# Setting movie details
movie = Movie()
s = movie.details(id)
# Arranging Movie data
cast = []
temp = s.casts.cast
length = min(len(temp),20)
for i in range(length):
if temp[i].known_for_department == "Acting":
cast.append({'original_name': temp[i].original_name, 'character': temp[i].character, 'photo': temp[i].profile_path})
crew = []
temp = s.casts.crew
length = min(len(temp),20)
for i in range(length):
crew.append({'department': temp[i].department, 'name': temp[i].original_name, 'photo': temp[i].profile_path})
del temp
data['title'] = s.original_title
data['description'] = s.overview
data['release_day'] = s.release_date
data['status'] = s.status
data['country'] = s.production_countries[0].name
data['runtime'] = s.runtime
data['budget'] = s.budget
data['revenue'] = s.revenue
if s.trailers.youtube == []:
data['trailer'] = 'None'
else:
data['trailer'] = s.trailers.youtube[0].source
data['adult'] = s.adult
data['poster'] = s.poster_path
data['votes'] = getRatingMovie(movieid=id)
data['negative'] = 100 - data['votes']
data['cast'] = cast
data['crew'] = crew
context = {}
context['data'] = data
return render(request, 'rhub/info.html', context)
def handle(self, *args, **options):
not_added = 0
added = 0
mov_id = 1
user_count = 1
from tmdbv3api import TMDb
tmdb = TMDb()
tmdb.api_key = '' # api_key
tmdb.language = 'en'
tmdb.debug = True
from tmdbv3api import Movie
mov = Movie()
#file1 = open('film/management/commands/Attributes_Imdb_test1', 'r')
#Lines = file1.readlines()
imdb_id_list = []
"""
f = open("recommendedfilm")
recommend = {}
for i in f:
l = i.split("\n")[0].split("\t")
recommend[l[0]] = eval(l[1])
"""
f = open("film/management/commands/watchedfilms")
watchedfilms = {}
for i in f:
l = i.split("\n")[0].split("\t")
watchedfilms[l[0]] = eval(l[1])
"""
for line in Lines:
k = line.split('\t')[0]
imdb_id_list.append(k)
"""
for user_id in watchedfilms.keys():
films = watchedfilms[user_id]
user_email = "*****@*****.**" % user_count
try:
auth_user = User.objects.create_user(username=user_id, email=user_email, password='******')
except:
my_user = User.objects.get(username=user_id)
user_profile = UserProfile.objects.create(user=my_user, spec_id=user_id)
printed = 'User ID %d is added' % user_count
print(printed)
user_count = user_count + 1
for film in films: # film[0] = imdb_id ve film[1] = user_score
imdb_id = film[0]
user_score = Decimal(film[1])
control_exist = Mov.objects.filter(imdb=imdb_id)
if control_exist:
my_movie = Mov.objects.get(imdb=imdb_id)
score = Score(user=my_user, movie=my_movie, score=user_score)
score.save()
user_profile.scores.add(score)
user_profile.save()
else:
k = mov.details(imdb_id)
try:
m = k.poster_path
img_path = "https://image.tmdb.org/t/p/w185%s" % m
big_img_path = "https://image.tmdb.org/t/p/w500%s" % m
except:
error_id = "imdb id = %s can not be added" % imdb_id
print(error_id)
not_added = not_added+1
continue
try:
p = k.vote_average
vote_average = Decimal(p)
vote_average = vote_average/2
vote_average = round(vote_average, 1)
except:
vote_average = Decimal(0.0)
genre_list = []
if k.original_title:
title = k.original_title
if k.overview:
overview = k.overview
for genre in k.genres:
genre_list.append(genre)
vid = mov.videos(imdb_id)
key = ""
if vid:
key = vid[0].key
yt_url = "https://www.youtube.com/embed/%s" % key
rls_date = k.release_date
rls_year = k.release_date.split('-')[0]
credits = mov.credits(imdb_id)
cast_list = []
for c in credits.cast:
cast_list.append(c)
if cast_list:
print(cast_list[0]['name'])
for c in cast_list:
t = c['profile_path']
c['profile_path'] = "https://image.tmdb.org/t/p/w342%s" % t
writer_list = []
director_list = []
for c in credits.crew:
if c['department'] == "Writing":
writer_list.append(c)
if c['department'] == "Directing" and c['job'] == "Director":
director_list.append(c)
for c in writer_list:
t = c['profile_path']
c['profile_path'] = "https://image.tmdb.org/t/p/w342%s" % t
for c in director_list:
t = c['profile_path']
c['profile_path'] = "https://image.tmdb.org/t/p/w342%s" % t
movie = Mov(year=rls_year, date=rls_date, imdb=imdb_id, title=title,
topic=overview,poster_url=img_path,poster_big_url=big_img_path,
video_url=yt_url, avg_score=vote_average)
try:
movie.save()
except:
print("There is invalid field somewhere in movie fields. So this can not be added")
not_added = not_added + 1
continue
adding_control = "movie_id %d is added" % mov_id
print(adding_control)
mov_id = mov_id + 1
for i in cast_list:
person_query = Person.objects.filter(id_unique = i['id'])
if not person_query:
person = Person(id_unique=i['id'], name=i['name'], portrait_url=i['profile_path'], type='Star')
person.save()
movie.starring.add(person)
movie.save()
else:
person = Person.objects.get(id_unique = i['id'])
movie.starring.add(person)
movie.save()
for i in writer_list:
person_query = Person.objects.filter(id_unique=i['id'])
if not person_query:
person = Person(id_unique=i['id'], name=i['name'], portrait_url=i['profile_path'], type='Writer')
person.save()
movie.writer.add(person)
movie.save()
else:
person = Person.objects.get(id_unique=i['id'])
movie.writer.add(person)
movie.save()
for i in director_list:
person_query = Person.objects.filter(id_unique=i['id'])
if not person_query:
person = Person(id_unique=i['id'], name=i['name'], portrait_url=i['profile_path'], type='Director')
person.save()
movie.director.add(person)
movie.save()
else:
person = Person.objects.get(id_unique=i['id'])
movie.director.add(person)
movie.save()
for i in genre_list:
existing_genre = Genre.objects.filter(name__exact=i['name'])
if not existing_genre:
genre = Genre(name=i['name'])
genre.save()
movie.genres.add(genre)
movie.save()
else:
genre = Genre.objects.get(name=i['name'])
movie.genres.add(genre)
movie.save()
score = Score(user=my_user, movie=movie, score=user_score)
score.save()
user_profile.scores.add(score)
user_profile.save()
"""
if user_count == 6:
break
"""
not_added_result = 'Eklenmeyen sayisi = %d' % not_added
print(not_added_result)
self.stdout.write(self.style.SUCCESS('Successfully added'))
def main():
movie = Movie()
n=idTerakhir()
while n > 353000: #353000 just a limit for iteration, may be changed to 1 for all movie id
m = movie.details(n)
try:
if m==[] or m is None or m==() or m=="":
print("Data film ini tidak ditemukan")
else:
id_movie=n
attr = getattr(m, "original_title", None)
if attr is not None:
judul=m.original_title
budget=m.budget
overview=m.overview
popularity=m.popularity
poster=m.poster_path
tglrelease=m.release_date
pendapatan=m.revenue
runtime=m.runtime
status = m.status
voteavrg = m.vote_average
votecount = m.vote_count
tagline = m.tagline
homepage = m.homepage
negaraproduksi = m.production_countries
bahasa=m.original_language
revenue=m.revenue
print("Mengambil Data Film "+judul)
for x in range(0,len(m.genres)):
insert_genre(m.genres[x]["id"],m.genres[x]["name"])
insert_film(id_movie,judul,overview,poster,homepage,popularity,revenue,runtime,tagline,voteavrg,votecount,m.genres[x]["id"],bahasa,1000000,1000000,1000000,1000000,"",budget)
xtanggal = m.release_date
if xtanggal!="":
a,b,c = xtanggal.split("-")
insert_waktu(a,b,c,xtanggal)
insert_film(id_movie,judul,overview,poster,homepage,popularity,revenue,runtime,tagline,voteavrg,votecount,1000000,bahasa,xtanggal,1000000,1000000,1000000,"",budget)
else:
print("Belum ada release data")
for z in range(0,len(m.production_companies)):
insert_companies(m.production_companies[z]["id"],m.production_companies[z]["name"],m.production_companies[z]["origin_country"],m.production_companies[z]["logo_path"])
insert_film(id_movie,judul,overview,poster,homepage,popularity,revenue,runtime,tagline,voteavrg,votecount,1000000,bahasa,1000000,1000000,1000000,m.production_companies[z]["id"],"",budget)
for y in range(0,len(m.production_countries)):
sqlprod = "insert ignore into sma_tbl_dimnegara(id_negara,nama_negara) values(%s,%s)"
args = (m.production_countries[y]["iso_3166_1"],m.production_countries[y]["name"])
cursor.execute(sqlprod, args)
mydb.commit()
insert_film(id_movie,judul,overview,poster,homepage,popularity,revenue,runtime,tagline,voteavrg,votecount,1000000,bahasa,1000000,m.production_countries[y]["iso_3166_1"],1000000,1000000,"",budget)
r = movie.reviews(n)
if r==[]:
print("Tidak ada data review")
else:
for h in range(0,len(r.results)):
dtreview = "Author: "+r.results[h]["author"]+"<br>"+r.results[h]["content"]
insert_film(id_movie,judul,overview,poster,homepage,popularity,revenue,runtime,tagline,voteavrg,votecount,1000000,bahasa,1000000,1000000,1000000,1000000,dtreview,budget)
c = movie.credits(n)
if c==[]:
print("Tidak ada data person")
else:
for dd in c.cast:
id_person =dd["id"]
nama =dd["name"]
job ="Cast"
with urllib.request.urlopen("https://api.themoviedb.org/3/person/"+str(id_person)+"?api_key=ee183266d8fc13c415cad996a43d03b1&language=en-US") as url:
c = json.loads(url.read().decode())
popularity =c["popularity"]
pob =c["place_of_birth"]
foto =c["profile_path"]
birthday =c["birthday"]
homepage =c["homepage"]
biography =c["biography"]
insert_person(id_person,nama,biography,popularity,pob,foto,job,birthday,homepage)
insert_film(id_movie,judul,overview,poster,homepage,popularity,revenue,runtime,tagline,voteavrg,votecount,1000000,bahasa,1000000,1000000,id_person,1000000,"",budget)
c = movie.credits(n)
if c==[]:
print("Tidak ada data person")
else:
for cc in c.crew:
id_person =cc["id"]
nama =cc["name"]
job ="Crew"
with urllib.request.urlopen("https://api.themoviedb.org/3/person/"+str(id_person)+"?api_key=ee183266d8fc13c415cad996a43d03b1&language=en-US") as url:
c = json.loads(url.read().decode())
popularity =c["popularity"]
pob =c["place_of_birth"]
foto =c["profile_path"]
birthday =c["birthday"]
homepage =c["homepage"]
biography =c["biography"]
insert_person(id_person,nama,biography,popularity,pob,foto,job,birthday,homepage)
insert_film(id_movie,judul,overview,poster,homepage,popularity,revenue,runtime,tagline,voteavrg,votecount,1000000,bahasa,1000000,1000000,id_person,1000000,"",budget)
class ShowAPIDB():
def __init__(self):
self.tmdb = TMDb()
self.tmdb.api_key = "e00b72174e4ae097af808f34a8f220fc"
self.tv = TV()
self.season = Season()
self.movie = Movie()
self.discover = Discover()
def buscarSerie(self, nombre):
resultado = self.tv.search(nombre)
series = []
for i in resultado:
serie = Tablas.Show()
serie.nombre = i.name
serie.idShow = i.id
serie.overview = i.overview
serie.poster = i.poster_path
serie.puntuacionIMDB = i.vote_average
serie.tipo = 1
series.append(serie)
return series
def buscarPelicula(self, nombre):
resultado = self.movie.search(nombre)
pelis = []
for i in resultado:
peli = Tablas.Show()
peli.tipo = 0
peli.nombre = i.title
peli.idShow = i.id
peli.overview = i.overview
peli.poster = i.poster_path
peli.puntuacionIMDB = i.vote_average
pelis.append(peli)
return pelis
def buscarPeliculaPorID(self, id):
resultado = self.movie.details(id)
peli = Tablas.Show()
peli.tipo = 0
peli.nombre = resultado.title
peli.idShow = resultado.id
peli.overview = resultado.overview
peli.poster = resultado.poster_path
peli.puntuacionIMDB = resultado.vote_average
return peli
def buscarSeriePorID(self, id):
i = self.tv.details(id)
serie = Tablas.Show()
serie.nombre = i.name
serie.idShow = i.id
serie.overview = i.overview
serie.poster = i.poster_path
serie.puntuacionIMDB = i.vote_average
serie.tipo = 1
return serie
def descubrir(self):
show = self.discover.discover_tv_shows({'sort_by': 'popularity.desc'})
series = []
for i in show:
serie = Tablas.Show()
serie.nombre = i.name
serie.idShow = i.id
serie.overview = i.overview
serie.poster = i.poster_path
serie.puntuacionIMDB = i.vote_average
serie.tipo = 1
series.append(serie)
return series
def tmdb_get_movies(config_path, plex, plex_map, data, method):
t_movs = []
t_movie = Movie()
t_movie.api_key = config_tools.TMDB(
config_path).apikey # Set TMDb api key for Movie
if t_movie.api_key == "None":
raise KeyError("Invalid TMDb API Key")
count = 0
if method == "tmdb_discover":
attrs = data.copy()
discover = Discover()
discover.api_key = t_movie.api_key
discover.discover_movies(attrs)
total_pages = int(os.environ["total_pages"])
total_results = int(os.environ["total_results"])
limit = int(attrs.pop('limit'))
amount = total_results if limit == 0 or total_results < limit else limit
print("| Processing {}: {} movies".format(method, amount))
for attr, value in attrs.items():
print("| {}: {}".format(attr, value))
for x in range(total_pages):
attrs["page"] = x + 1
tmdb_movies = discover.discover_movies(attrs)
for tmovie in tmdb_movies:
count += 1
t_movs.append(tmovie.id)
if count == amount:
break
if count == amount:
break
elif method in [
"tmdb_popular", "tmdb_top_rated", "tmdb_now_playing",
"tmdb_trending_daily", "tmdb_trending_weekly"
]:
trending = Trending()
trending.api_key = t_movie.api_key
for x in range(int(int(data) / 20) + 1):
if method == "tmdb_popular":
tmdb_movies = t_movie.popular(x + 1)
elif method == "tmdb_top_rated":
tmdb_movies = t_movie.top_rated(x + 1)
elif method == "tmdb_now_playing":
tmdb_movies = t_movie.now_playing(x + 1)
elif method == "tmdb_trending_daily":
tmdb_movies = trending.movie_day(x + 1)
elif method == "tmdb_trending_weekly":
tmdb_movies = trending.movie_week(x + 1)
for tmovie in tmdb_movies:
count += 1
t_movs.append(tmovie.id)
if count == data:
break
if count == data:
break
print("| Processing {}: {} Items".format(method, data))
else:
tmdb_id = int(data)
if method == "tmdb_list":
tmdb = List()
tmdb.api_key = t_movie.api_key
try:
t_col = tmdb.details(tmdb_id)
tmdb_name = str(t_col)
for tmovie in t_col:
if tmovie.media_type == "movie":
t_movs.append(tmovie.id)
except:
raise ValueError(
"| Config Error: TMDb List: {} not found".format(tmdb_id))
elif method == "tmdb_company":
tmdb = Company()
tmdb.api_key = t_movie.api_key
tmdb_name = str(tmdb.details(tmdb_id))
company_movies = tmdb.movies(tmdb_id)
for tmovie in company_movies:
t_movs.append(tmovie.id)
else:
tmdb = Collection()
tmdb.api_key = t_movie.api_key
t_col = tmdb.details(tmdb_id)
tmdb_name = str(t_col)
try:
for tmovie in t_col.parts:
t_movs.append(tmovie['id'])
except AttributeError:
try:
t_movie.details(tmdb_id).imdb_id
tmdb_name = str(t_movie.details(tmdb_id))
t_movs.append(tmdb_id)
except:
raise ValueError(
"| Config Error: TMDb ID: {} not found".format(
tmdb_id))
print("| Processing {}: ({}) {}".format(method, tmdb_id, tmdb_name))
matched = []
missing = []
for mid in t_movs:
mid = str(mid)
if mid in plex_map:
matched.append(plex.Server.fetchItem(plex_map[mid]))
else:
missing.append(mid)
return matched, missing
class TMDbTests(unittest.TestCase):
def setUp(self):
self.tmdb = TMDb()
self.tmdb.api_key = os.environ['TMDB_API_KEY']
self.tmdb.language = 'en'
self.tmdb.debug = True
self.tmdb.wait_on_rate_limit = True
self.movie = Movie()
self.discover = Discover()
self.tv = TV()
self.person = Person()
self.collection = Collection()
self.company = Company()
self.season = Season()
self.list = List()
def test_get_tv_keywords(self):
keywords = self.tv.keywords(1396)
self.assertGreater(len(keywords), 0)
def test_get_tv_reviews(self):
reviews = self.tv.reviews(1396)
self.assertGreater(len(reviews), 0)
def test_get_movie_repr(self):
search = self.movie.search("Mad Max")
for results in search:
print(results)
def test_get_tv_show_repr(self):
search_tv = self.tv.search('Breaking Bad')
for results in search_tv:
print(results)
def test_get_movie(self):
movie = self.movie.details(111)
self.assertIsNotNone(movie)
self.assertEqual(movie['title'], 'Scarface')
self.assertEqual(movie['id'], 111)
self.assertTrue('title' in movie)
self.assertTrue('overview' in movie)
self.assertTrue('id' in movie)
def test_get_movie_reviews(self):
search = self.movie.search("Mad Max")
self.assertTrue(len(search) > 0)
first = search[0]
reviews = self.movie.reviews(first.id)
self.assertTrue(len(reviews) > 0)
for review in reviews:
self.assertTrue('id' in review))
self.assertTrue('content' in review))
def test_get_movie_lists(self):
lists = self.movie.lists(111)
self.assertTrue(len(lists) > 0)
self.assertTrue(hasattr(lists[0], 'description'))
self.assertTrue(hasattr(lists[0], 'name'))
def test_get_movie_credits(self):
credits = self.movie.credits(111)
print(credits)
self.assertIsNotNone(credits)
def test_get_movie_images(self):
images = self.movie.images(111)
print(images)
self.assertIsNotNone(images)
def test_get_movie_videos(self):
videos = self.movie.videos(111)
self.assertTrue(len(videos) > 0)
self.assertTrue(hasattr(videos[0], 'id'))
def test_get_movie_recommendations(self):
recs = self.movie.recommendations(111)
self.assertTrue(len(recs) > 0)
self.assertTrue(hasattr(recs[0], 'id'))
def test_discover_movies(self):
discover = self.discover.discover_movies({
'primary_release_year': '2015',
'with_genres': '28',
'page': '1',
'vote_average.gte': '8'
})
class TMDbTests(unittest.TestCase):
def setUp(self):
self.tmdb = TMDb()
self.tmdb.api_key = os.environ["TMDB_API_KEY"]
self.tmdb.language = "en"
self.tmdb.debug = True
self.tmdb.wait_on_rate_limit = True
self.movie = Movie()
self.discover = Discover()
self.tv = TV()
self.person = Person()
self.collection = Collection()
self.company = Company()
self.season = Season()
self.list = List()
def test_get_tv_keywords(self):
keywords = self.tv.keywords(1396)
self.assertGreater(len(keywords), 0)
def test_get_tv_reviews(self):
reviews = self.tv.reviews(1396)
self.assertGreater(len(reviews), 0)
def test_get_movie_repr(self):
search = self.movie.search("Mad Max")
for results in search:
print(results)
def test_get_tv_show_repr(self):
search_tv = self.tv.search("Breaking Bad")
for results in search_tv:
print(results)
def test_get_movie(self):
movie = self.movie.details(111)
self.assertIsNotNone(movie)
self.assertEqual(movie.title, "Scarface")
self.assertEqual(movie.id, 111)
self.assertTrue(hasattr(movie, "title"))
self.assertTrue(hasattr(movie, "overview"))
self.assertTrue(hasattr(movie, "id"))
def test_get_movie_reviews(self):
search = self.movie.search("Mad Max")
self.assertTrue(len(search) > 0)
first = search[0]
reviews = self.movie.reviews(first.id)
self.assertTrue(len(reviews) > 0)
for review in reviews:
self.assertTrue(hasattr(review, "id"))
self.assertTrue(hasattr(review, "content"))
def test_get_movie_lists(self):
lists = self.movie.lists(111)
self.assertTrue(len(lists) > 0)
self.assertTrue(hasattr(lists[0], "description"))
self.assertTrue(hasattr(lists[0], "name"))
def test_get_movie_credits(self):
credits = self.movie.credits(111)
print(credits)
self.assertIsNotNone(credits)
def test_get_movie_images(self):
images = self.movie.images(111)
print(images)
self.assertIsNotNone(images)
def test_get_movie_videos(self):
videos = self.movie.videos(111)
self.assertTrue(len(videos) > 0)
self.assertTrue(hasattr(videos[0], "id"))
def test_get_movie_recommendations(self):
recs = self.movie.recommendations(111)
self.assertTrue(len(recs) > 0)
self.assertTrue(hasattr(recs[0], "id"))
def test_discover_movies(self):
discover = self.discover.discover_movies({
"primary_release_year": "2015",
"with_genres": "28",
"page": "1",
"vote_average.gte": "8",
})
self.assertTrue(len(discover) > 0)
self.assertTrue(hasattr(discover[0], "id"))
movie = discover[0]
has_genre = False
for genre_id in movie.genre_ids:
if genre_id == 28:
has_genre = True
self.assertTrue(has_genre)
def test_discover_tv_shows(self):
discover = self.discover.discover_tv_shows({
"with_genres": "16",
"vote_average.gte": "8",
"page": "1"
})
self.assertTrue(len(discover) > 0)
self.assertTrue(hasattr(discover[0], "id"))
movie = discover[0]
has_genre = False
for genre_id in movie.genre_ids:
if genre_id == 16:
has_genre = True
self.assertTrue(has_genre)
def test_get_latest_movie(self):
videos = self.movie.latest()
self.assertIsNotNone(videos)
self.assertTrue(hasattr(videos, "id"))
def test_now_playing(self):
now_playing = self.movie.now_playing()
self.assertTrue(len(now_playing) > 0)
self.assertTrue(hasattr(now_playing[0], "id"))
def test_top_rated(self):
top_rated = self.movie.top_rated()
self.assertTrue(len(top_rated) > 0)
self.assertTrue(hasattr(top_rated[0], "id"))
def test_upcoming(self):
upcoming = self.movie.upcoming()
self.assertTrue(len(upcoming) > 0)
self.assertTrue(hasattr(upcoming[0], "id"))
def test_popular(self):
popular = self.movie.popular()
self.assertTrue(len(popular) > 0)
self.assertTrue(hasattr(popular[0], "id"))
def test_search(self):
search = self.movie.search("Mad Max")
self.assertTrue(len(search) > 0)
self.assertTrue(hasattr(search[0], "id"))
def test_similar(self):
similar = self.movie.similar(111)
self.assertTrue(len(similar) > 0)
self.assertTrue(hasattr(similar[0], "id"))
def test_get_tv_show(self):
show = self.tv.details(12)
self.assertIsNotNone(show)
self.assertTrue(hasattr(show, "id"))
def test_on_the_air(self):
show = self.tv.on_the_air()
self.assertTrue(len(show) > 0)
def test_airing_today(self):
show = self.tv.on_the_air()
self.assertTrue(len(show) > 0)
def test_tv_videos(self):
show = self.tv.videos(1396)
self.assertTrue(len(show) > 0)
def test_tv_recommendations(self):
show = self.tv.recommendations(1396)
self.assertTrue(len(show) > 0)
def test_external_ids(self):
show = self.tv.external_ids(1776)
self.assertEqual(show["imdb_id"], "tt0488262")
def test_get_latest_tv_show(self):
latest_tv = self.tv.latest()
self.assertIsNotNone(latest_tv)
self.assertTrue(hasattr(latest_tv, "id"))
def test_search_tv(self):
search_tv = self.tv.search("Sunny")
self.assertTrue(len(search_tv) > 0)
self.assertTrue(hasattr(search_tv[0], "id"))
def test_popular_shows(self):
popular = self.tv.popular()
self.assertTrue(len(popular) > 0)
self.assertTrue(hasattr(popular[0], "id"))
def test_top_rated_shows(self):
top_rated = self.tv.top_rated()
self.assertTrue(len(top_rated) > 0)
self.assertTrue(hasattr(top_rated[0], "id"))
def test_get_person(self):
person = self.person.details(234)
self.assertIsNotNone(person)
self.assertTrue(hasattr(person, "id"))
def test_search_person(self):
search_person = self.person.search("Bryan")
self.assertTrue(len(search_person) > 0)
self.assertTrue(hasattr(search_person[0], "id"))
def test_collection_details(self):
c = Collection()
details = c.details(10)
self.assertEqual(details.name, "Star Wars Collection")
self.assertEqual(details.id, 10)
self.assertTrue(hasattr(details, "overview"))
self.assertTrue(hasattr(details, "poster_path"))
def test_collection_images(self):
c = Collection()
images = c.images(10)
self.assertTrue(hasattr(images, "backdrops"))
self.assertTrue(hasattr(images, "posters"))
def test_popular_people(self):
popular = self.person.popular()
self.assertTrue(len(popular) > 0)
first = popular[0]
self.assertTrue(hasattr(first, "name"))
self.assertTrue(hasattr(first, "known_for"))
def test_latest_person(self):
latest_person = self.person.latest()
self.assertIsNotNone(latest_person)
self.assertTrue(hasattr(latest_person, "name"))
self.assertTrue(hasattr(latest_person, "id"))
def test_person_images(self):
images = self.person.images(11)
self.assertIsNotNone(images)
self.assertTrue(hasattr(images, "profiles"))
self.assertTrue(hasattr(images, "id"))
def test_company_details(self):
c = self.company.details(1)
self.assertTrue(hasattr(c, "name"))
self.assertEqual(c.name, "Lucasfilm Ltd.")
def test_company_movies(self):
company = self.company.movies(1)
self.assertTrue(len(company) > 0)
first = company[0]
self.assertTrue(hasattr(first, "title"))
self.assertTrue(hasattr(first, "overview"))
def test_config(self):
config = Configuration()
info = config.info()
self.assertIsNotNone(info)
self.assertTrue(hasattr(info, "images"))
def test_genres(self):
genres = Genre()
movie_genres = genres.movie_list()
self.assertIsNotNone(movie_genres)
tv_genres = genres.tv_list()
self.assertIsNotNone(tv_genres)
def test_season(self):
s = self.season.details(1418, 1)
self.assertIsNotNone(s)
self.assertEqual(s.name, "Season 1")
self.assertEqual(s.id, 3738)
self.assertTrue(hasattr(s, "episodes"))
self.assertTrue(hasattr(s, "overview"))
self.assertTrue(hasattr(s, "id"))
def test_get_season_changes(self):
s = self.season.changes(1418)
self.assertIsNotNone(s)
def test_get_season_external_ids(self):
s = self.season.external_ids(1418, 1)
self.assertIsNotNone(s)
self.assertIsNotNone(s["tvdb_id"])
def test_get_season_videos(self):
s = self.season.videos(1418, 1)
def test_get_season_images(self):
s = self.season.images(1418, 1)
for l in s:
self.assertIsNotNone(l.width)
self.assertIsNotNone(l.height)
def test_get_season_credits(self):
s = self.season.credits(1418, 1)
for c in s:
self.assertIsNotNone(c.name)
self.assertIsNotNone(c.character)
def test_get_movie_by_external_id(self):
ex = self.movie.external(external_id="tt8155288",
external_source="imdb_id")
res = ex["movie_results"][0]
self.assertTrue(res["title"] == "Happy Death Day 2U")
def test_get_list(self):
list = self.list.details(list_id="112870")
self.assertTrue(len(list) > 10)
self.assertTrue(hasattr(list[0], "id"))
self.assertTrue(hasattr(list[0], "title"))
def test_get_certifications(self):
certifications = Certification()
movie_certifications = certifications.movie_list()
self.assertIsNotNone(movie_certifications)
tv_certifications = certifications.tv_list()
self.assertIsNotNone(tv_certifications)
revenue_list = []
runtime_list = []
spoken_languages_list = []
status_list = []
tagline_list = []
title_list = []
video_list = []
vote_average_list = []
vote_count_list = []
df1 = pandas.read_csv('movies.csv')
#adult = belongs_to_collection = budget = genres = homepage = id = imdb_id = original_language = original_title = overview = popularity = poster_path = production_companies = production_countries = release_date = revenue = runtime = spoken_languages = status = tagline = title = video = vote_average = vote_count = []
#for j in range(0,4):
# for i in range(j*37,j*37+37):
for i in range(0,20):
m = movie.details(df1[movieId][i])
if hasattr(m,'adult'):
adult_list.append(m.adult)
belongs_to_collection_list.append(m.belongs_to_collection)
budget_list.append(m.budget)
genres_list.append(m.genres)
homepage_list.append(m.homepage)
id_list.append(m.id)
imdb_id_list.append(m.imdb_id)
original_language_list.append(m.original_language)
original_title_list.append(m.original_title)
overview_list.append(m.overview)
popularity_list.append(m.popularity)
poster_path_list.append(m.poster_path)
production_companies_list.append(m.production_companies)
production_countries_list.append(m.production_countries)
def tmdb_get_movies(config_path, plex, data, is_list=False):
tmdb_id = int(data)
t_movs = []
t_movie = Movie()
t_movie.api_key = config_tools.TMDB(
config_path).apikey # Set TMDb api key for Movie
if t_movie.api_key == "None":
raise KeyError("Invalid TMDb API Key")
tmdb = List() if is_list else Collection()
tmdb.api_key = t_movie.api_key
t_col = tmdb.details(tmdb_id)
if is_list:
try:
for tmovie in t_col:
if tmovie.media_type == "movie":
t_movs.append(tmovie.id)
except:
raise ValueError(
"| Config Error: TMDb List: {} not found".format(tmdb_id))
else:
try:
for tmovie in t_col.parts:
t_movs.append(tmovie['id'])
except AttributeError:
try:
t_movie.details(tmdb_id).imdb_id
t_movs.append(tmdb_id)
except:
raise ValueError(
"| Config Error: TMDb ID: {} not found".format(tmdb_id))
# Create dictionary of movies and their guid
# GUIDs reference from which source Plex has pulled the metadata
p_m_map = {}
p_movies = plex.Library.all()
for m in p_movies:
guid = m.guid
if "themoviedb://" in guid:
guid = guid.split('themoviedb://')[1].split('?')[0]
elif "imdb://" in guid:
guid = guid.split('imdb://')[1].split('?')[0]
elif "plex://" in guid:
guid = guid.split('plex://')[1].split('?')[0]
else:
guid = "None"
p_m_map[m] = guid
matched = []
missing = []
plex_tools.create_cache(config_path)
# We want to search for a match first to limit TMDb API calls
# Too many rapid calls can cause a momentary block
# If needed in future maybe add a delay after x calls to let the limit reset
for mid in t_movs: # For each TMBd ID in TMBd Collection
match = False
for m in p_m_map: # For each movie in Plex
item = m
agent_type = urlparse(m.guid).scheme.split('.')[-1]
# Plex movie agent
if agent_type == 'plex':
# Check cache for tmdb_id
tmdb_id = plex_tools.query_cache(config_path, item.guid,
'tmdb_id')
imdb_id = plex_tools.query_cache(config_path, item.guid,
'imdb_id')
if not tmdb_id:
imdb_id, tmdb_id = plex_tools.alt_id_lookup(plex, item)
print("| Cache | + | {} | {} | {} | {}".format(
item.guid, imdb_id, tmdb_id, item.title))
plex_tools.update_cache(config_path,
item.guid,
imdb_id=imdb_id,
tmdb_id=tmdb_id)
if int(tmdb_id) == int(mid):
match = True
break
elif agent_type == 'themoviedb':
if int(p_m_map[m]) == int(mid):
match = True
break
elif agent_type == 'imdb':
imdb_id = t_movie.details(mid).imdb_id
for m in p_m_map:
if "tt" in p_m_map[m]:
if p_m_map[m] == imdb_id:
match = True
break
if match:
matched.append(m)
else:
# Duplicate TMDb call?
missing.append(t_movie.details(mid).imdb_id)
return matched, missing
def run_imdb_sync():
try:
plex = PlexServer(PLEX_URL, PLEX_TOKEN)
except:
print("Whoopsie! There's an error connecting to the Plex server at: {base_url}".format(base_url=PLEX_URL))
print("Please check that config.ini exists, and is correct.")
print("If the URL displayed is the correct URL for your server, then your token may be incorrect.")
print("\n")
input("Press Enter to exit")
sys.exit()
# Get list of movies from the Plex server
all_movies = []
for movie_lib in MOVIE_LIBRARIES:
try:
print("Retrieving a list of movies from the '{library}' library in Plex.".format(library=movie_lib))
print("\n")
movie_library = plex.library.section(movie_lib)
library_language = movie_library.language # IMDB will use language from last library in list
all_movies.extend(movie_library.all())
except:
print("The '{library}' library does not exist in Plex.".format(library=movie_lib))
print("Please check that config.ini exists, and is correct.")
print("\n")
input("Press Enter to exit")
sys.exit()
# Get the requested imdb list
print("Retrieving movies from selected IMDB list. Depending on the amount of pages selected this might take a few minutes.")
print("\n")
maxpages = int(PAGE_NUMBERS) + 1
title_name = []
title_years = []
title_ids = []
for i in range(1,maxpages):
url = IMDB_URL + '?page={}'.format(i)
r = requests.get(url, headers={'Accept-Language': library_language})
tree = html.fromstring(r.content)
title_name.extend(tree.xpath("//div[contains(@class, 'lister-item-content')]//h3[contains(@class, 'lister-item-header')]//a/text()"))
title_years.extend(tree.xpath("//div[contains(@class, 'lister-item-content')]//h3[contains(@class, 'lister-item-header')]//span[contains(@class, 'lister-item-year')]/text()"))
title_ids.extend(tree.xpath("//div[contains(@class, 'lister-item-image')]//a/img//@data-tconst"))
# Convert TMDB to IMDB ID and create a dictionary of {imdb_id: movie}
print("Matching IMDB IDs to Library. For large Libraries using TMDB agent this step can take a long time.")
print("\n")
reqcount = 0
tmdb = TMDb()
tmdb.api_key = parser.get('tmdb', 'apikey')
movie = Movie()
imdb_map = {}
for m in all_movies:
if 'themoviedb://' in m.guid:
if reqcount >= 10:
time.sleep(2.5)
reqcount = 0
if tmdb.api_key:
try:
tmdb_id = m.guid.split('themoviedb://')[1].split('?')[0]
tmdbapi = movie.details(tmdb_id)
imdb_id = tmdbapi.imdb_id
reqcount += 1
except AttributeError:
imdb_id = None
reqcount += 1
else:
imdb_id = None
elif 'imdb://' in m.guid:
imdb_id = m.guid.split('imdb://')[1].split('?')[0]
else:
imdb_id = None
if imdb_id and imdb_id in title_ids:
imdb_map[imdb_id] = m
else:
imdb_map[m.ratingKey] = m
# Add movies to the selected collection
print("Adding the collection '{}' to matched movies.".format(IMDB_COLLECTION_NAME))
print("\n")
in_library_idx = []
for i, imdb_id in enumerate(title_ids):
movie = imdb_map.pop(imdb_id, None)
if movie:
add_collection(movie.librarySectionID, movie.ratingKey)
in_library_idx.append(i)
# Get list of missing movies from selected list
missing_imdb_movies = [(idx, imdb) for idx, imdb in enumerate(zip(title_ids, title_name, title_years))
if idx not in in_library_idx]
return missing_imdb_movies, len(title_ids)
class TMDbTests(unittest.TestCase):
def setUp(self):
self.tmdb = TMDb()
self.tmdb.api_key = os.environ['TMDB_API_KEY']
self.tmdb.language = 'en'
self.tmdb.debug = True
self.tmdb.wait_on_rate_limit = True
self.movie = Movie()
self.discover = Discover()
self.tv = TV()
self.person = Person()
self.collection = Collection()
self.company = Company()
self.season = Season()
def test_get_movie(self):
movie = self.movie.details(111)
self.assertIsNotNone(movie)
self.assertEqual(movie.title, 'Scarface')
self.assertEqual(movie.id, 111)
self.assertTrue(hasattr(movie, 'title'))
self.assertTrue(hasattr(movie, 'overview'))
self.assertTrue(hasattr(movie, 'id'))
def test_get_movie_reviews(self):
search = self.movie.search("Mad Max")
self.assertTrue(len(search) > 0)
first = search[0]
reviews = self.movie.reviews(first.id)
self.assertTrue(len(reviews) > 0)
for review in reviews:
self.assertTrue(hasattr(review, 'id'))
self.assertTrue(hasattr(review, 'content'))
def test_get_movie_lists(self):
lists = self.movie.lists(111)
self.assertTrue(len(lists) > 0)
self.assertTrue(hasattr(lists[0], 'description'))
self.assertTrue(hasattr(lists[0], 'name'))
def test_get_movie_videos(self):
videos = self.movie.videos(111)
self.assertTrue(len(videos) > 0)
self.assertTrue(hasattr(videos[0], 'id'))
def test_get_movie_recommendations(self):
recs = self.movie.recommendations(111)
self.assertTrue(len(recs) > 0)
self.assertTrue(hasattr(recs[0], 'id'))
def test_discover_movies(self):
discover = self.discover.discover_movies({
'primary_release_year': '2015',
'with_genres': '28',
'page': '1',
'vote_average.gte': '8'
})
self.assertTrue(len(discover) > 0)
self.assertTrue(hasattr(discover[0], 'id'))
movie = discover[0]
has_genre = False
for genre_id in movie.genre_ids:
if genre_id == 28:
has_genre = True
self.assertTrue(has_genre)
def test_discover_tv_shows(self):
discover = self.discover.discover_tv_shows({
'with_genres': '16',
'vote_average.gte': '8',
'page': '1'
})
self.assertTrue(len(discover) > 0)
self.assertTrue(hasattr(discover[0], 'id'))
movie = discover[0]
has_genre = False
for genre_id in movie.genre_ids:
if genre_id == 16:
has_genre = True
self.assertTrue(has_genre)
def test_get_latest_movie(self):
videos = self.movie.latest()
self.assertIsNotNone(videos)
self.assertTrue(hasattr(videos, 'id'))
def test_now_playing(self):
now_playing = self.movie.now_playing()
self.assertTrue(len(now_playing) > 0)
self.assertTrue(hasattr(now_playing[0], 'id'))
def test_top_rated(self):
top_rated = self.movie.top_rated()
self.assertTrue(len(top_rated) > 0)
self.assertTrue(hasattr(top_rated[0], 'id'))
def test_upcoming(self):
upcoming = self.movie.upcoming()
self.assertTrue(len(upcoming) > 0)
self.assertTrue(hasattr(upcoming[0], 'id'))
def test_popular(self):
popular = self.movie.popular()
self.assertTrue(len(popular) > 0)
self.assertTrue(hasattr(popular[0], 'id'))
def test_search(self):
search = self.movie.search('Mad Max')
self.assertTrue(len(search) > 0)
self.assertTrue(hasattr(search[0], 'id'))
def test_similar(self):
similar = self.movie.similar(111)
self.assertTrue(len(similar) > 0)
self.assertTrue(hasattr(similar[0], 'id'))
def test_get_tv_show(self):
show = self.tv.details(12)
self.assertIsNotNone(show)
self.assertTrue(hasattr(show, 'id'))
def test_get_latest_tv_show(self):
latest_tv = self.tv.latest()
self.assertIsNotNone(latest_tv)
self.assertTrue(hasattr(latest_tv, 'id'))
def test_search_tv(self):
search_tv = self.tv.search('Sunny')
self.assertTrue(len(search_tv) > 0)
self.assertTrue(hasattr(search_tv[0], 'id'))
def test_popular_shows(self):
popular = self.tv.popular()
self.assertTrue(len(popular) > 0)
self.assertTrue(hasattr(popular[0], 'id'))
def test_top_rated_shows(self):
top_rated = self.tv.top_rated()
self.assertTrue(len(top_rated) > 0)
self.assertTrue(hasattr(top_rated[0], 'id'))
def test_get_person(self):
person = self.person.details(234)
self.assertIsNotNone(person)
self.assertTrue(hasattr(person, 'id'))
def test_search_person(self):
search_person = self.person.search('Bryan')
self.assertTrue(len(search_person) > 0)
self.assertTrue(hasattr(search_person[0], 'id'))
def test_collection_details(self):
c = Collection()
details = c.details(10)
self.assertEqual(details.name, 'Star Wars Collection')
self.assertEqual(details.id, 10)
self.assertTrue(hasattr(details, 'overview'))
self.assertTrue(hasattr(details, 'poster_path'))
def test_collection_images(self):
c = Collection()
images = c.images(10)
self.assertTrue(hasattr(images, 'backdrops'))
self.assertTrue(hasattr(images, 'posters'))
def test_popular_people(self):
popular = self.person.popular()
self.assertTrue(len(popular) > 0)
first = popular[0]
self.assertTrue(hasattr(first, 'name'))
self.assertTrue(hasattr(first, 'known_for'))
def test_latest_person(self):
latest_person = self.person.latest()
self.assertIsNotNone(latest_person)
self.assertTrue(hasattr(latest_person, 'name'))
self.assertTrue(hasattr(latest_person, 'id'))
def test_person_images(self):
images = self.person.images(11)
self.assertIsNotNone(images)
self.assertTrue(hasattr(images, 'profiles'))
self.assertTrue(hasattr(images, 'id'))
def test_company_details(self):
c = self.company.details(1)
self.assertTrue(hasattr(c, 'name'))
self.assertEqual(c.name, 'Lucasfilm')
def test_company_movies(self):
company = self.company.movies(1)
self.assertTrue(len(company) > 0)
first = company[0]
self.assertTrue(hasattr(first, 'title'))
self.assertTrue(hasattr(first, 'overview'))
def test_config(self):
config = Configuration()
info = config.info()
self.assertIsNotNone(info)
self.assertTrue(hasattr(info, 'images'))
def test_genres(self):
genres = Genre()
movie_genres = genres.movie_list()
self.assertIsNotNone(movie_genres)
tv_genres = genres.tv_list()
self.assertIsNotNone(tv_genres)
def test_season(self):
s = self.season.details(1418, 1)
self.assertIsNotNone(s)
self.assertEqual(s.name, 'Season 1')
self.assertEqual(s.id, 3738)
self.assertTrue(hasattr(s, 'episodes'))
self.assertTrue(hasattr(s, 'overview'))
self.assertTrue(hasattr(s, 'id'))
def test_get_season_changes(self):
s = self.season.changes(1418, 1)
self.assertIsNotNone(s)
def test_get_season_external_ids(self):
s = self.season.external_ids(1418, 1)
self.assertIsNotNone(s)
self.assertIsNotNone(s['tvdb_id'])
def test_get_season_videos(self):
s = self.season.videos(1418, 1)
def test_get_season_images(self):
s = self.season.images(1418, 1)
for l in s:
self.assertIsNotNone(l.width)
self.assertIsNotNone(l.height)
def test_get_season_credits(self):
s = self.season.credits(1418, 1)
for c in s:
self.assertIsNotNone(c.name)
self.assertIsNotNone(c.character)
def test_get_movie_by_external_id(self):
ex = self.movie.external(external_id="tt8155288", external_source="imdb_id")
res = ex['movie_results'][0]
self.assertTrue(res['title'] == "Happy Death Day 2U")
release_date = str(p.release_date)
popularity = str(p.popularity)
imagenes = str(p.poster_path)
lista_populares_titulos.append(titulos)
lista_populares_release_date.append(release_date)
lista_populares_popularity.append(popularity)
lista_populares_imagenes.append(imagenes)
w = (len(titulos))
#print(w)
#top 5 movies
#joker---------------------------
jok = movie.details(475557)
joker_title = jok.title
#joker_overview = jok.overview
joker_release_date = str(jok.release_date)
#joker_votos = str(jok.vote_count)
joker_popularity = str(jok.popularity)
joker_image = str(jok.poster_path)
#-----------------------------------------
#avengers
avengers = movie.search('Avengers: Endgame')
lista_avengers = []
for av in avengers:
avengers_titulo = av.title
avengers_release_date = str(av.release_date)
avengers_popularity = str(av.popularity)
from tmdbv3api import TMDb, Movie tmdb = TMDb() tmdb.api_key = "" movie = Movie() m = movie.details(111) print(m.title) print(m.overview) print(m.popularity)
