def GetMeta(t, y):
tmdb.API_KEY = 'b888b64c9155c26ade5659ea4dd60e64'
search = tmdb.Search()
search.movie(query=t)
for s in search.results:
year = s['release_date'].split('-', 2)
if year[0] == y:
d = s
state = True
break
else:
state = False
imdb = Imdb()
results = imdb.search_for_title(t)
if state is True:
for i in results:
if i['type'] == 'feature' and i['year'] == y:
result = i
g = imdb.get_title_genres(result['imdb_id'])
d['genre_ids'] = g['genres']
break
else:
d['genre_ids'] = ''
return d
else:
d = {}
return d
def detail(request, movie_id):
if not request.user.is_authenticated():
return render(request, 'movies/base.html')
else:
user = request.user
imdb = Imdb()
titledetails = imdb.get_title(movie_id)
dlist = []
detlist = []
try:
dlist.append(titledetails['base']['image']['url'])
except:
# insert a null image
dlist.append(' ')
detlist.append(titledetails['base']['title'])
title = titledetails['base']['title']
detlist.append(titledetails['base']['year'])
try:
min = int(titledetails['base']['runningTimeInMinutes'])
hrs = int(min / 60)
minutes = min - 60 * hrs
time = str(hrs) + 'hr ' + str(minutes) + 'min'
detlist.append(time)
except:
detlist.append('-')
detlist.append(imdb.get_title_genres(movie_id)['genres'])
try:
detlist.append(titledetails['plot']['summaries'][0]['text'])
except:
detlist.append('-')
try:
#print('hello')
castandcrew = imdb.get_title_credits(movie_id)
castlist = []
detdict = {}
detdict['director'] = castandcrew['credits']['director'][0]['name']
detdict['producer'] = castandcrew['credits']['producer'][0]['name']
writers = []
for i in castandcrew['credits']['writer']:
writers.append(i['name'])
writerset = set(writers)
detdict['writers'] = list(writerset)
detlist.append(detdict)
for i in range(0, 6):
castdict = {}
castdict[castandcrew['credits']['cast'][i][
'name']] = castandcrew['credits']['cast'][i]['characters']
castlist.append(castdict)
detlist.append(castlist)
except:
detlist.append('-')
dlist.append(detlist)
return render(request, 'movies/moviedetails.html', {
'dlist': dlist,
'title': title
})
def _fetch_metadata(self):
searchtitle = self._title
if searchtitle.endswith(", The"):
searchtitle = "The {}".format(searchtitle[:-5])
elif searchtitle.endswith(", A"):
searchtitle = "A {}".format(searchtitle[:-3])
imdb = Imdb()
if "id" not in self._md:
print(" * Searching IMDB")
results = imdb.search_for_title(searchtitle)
movie_results = [r for r in results if r["type"] == "feature" and r["year"] is not None]
while len(movie_results) == 0:
searchtitle = input("No results for \"%s\" Enter alternate/correct movie title >> " % searchtitle)
results = imdb.search_for_title(searchtitle)
movie_results = [r for r in results if r["type"] == "feature" and r["year"] is not None]
exact_matches = [r for r in movie_results if r["title"].lower() == searchtitle.lower()]
if len(exact_matches) > 0:
movie_results = exact_matches
if len(movie_results) > 1:
choices=[("%s (%s)" % (r["title"], r["year"]), idx) for idx, r in enumerate(movie_results)]
choices.append(("Not found", -1))
answer = inquirer.prompt([
inquirer.List("index",
message="Multiple results found:",
choices=choices
)
])
if answer["index"] == -1:
self._md["id"] = input("Enter IMDB id: ")
movie_results = []
else:
movie_results = [movie_results[answer["index"]]]
if len(movie_results) > 0:
mpr = movie_results[0]
self._md["id"] = mpr["imdb_id"]
print(" * Fetching data for {} ({})".format(mpr["title"], mpr["year"]))
else:
print(" * Fetching data for %s" % self._md["id"])
imdb_movie = imdb.get_title(self._md["id"])
self._md["title"] = imdb_movie["base"]["title"]
self._md["year"] = imdb_movie["base"]["year"]
if "outline" in imdb_movie["plot"]:
self._md["plot"] = imdb_movie["plot"]["outline"]["text"]
else:
self._md["plot"] = imdb_movie["plot"]["summaries"][0]["text"]
self._md["genres"] = imdb.get_title_genres(self._md["id"])["genres"]
self._write_nfo()
def AddMovieToDB(imdbId):
ia = Imdb()
data = ia.get_title(imdbId)
title = data['base']['title']
imageUrl = data['base']['image']['url']
genres = ia.get_title_genres(imdbId)['genres']
year = data['base']['year']
movie = Movie(imdbId = imdbId, year = year, poster = imageUrl, genre = genres, title = title)
movie.save()
return
class MovieList:
def __init__(self):
tmdbsimple.API_KEY = settings.TMDB_API_KEY
self.filename = "movies.db"
self.full_path = db_full_path(self.filename)
if self.filename not in db_cons or not db_cons[self.filename]:
movie.Session.configure(
bind=create_engine(f"sqlite:///{self.full_path}",
echo=True,
connect_args={"check_same_thread": False},
json_serializer=lambda obj: json.dumps(
obj, ensure_ascii=False)))
self.session: Session = movie.Session()
movie.Base.metadata.create_all(self.session.bind, checkfirst=True)
db_locks[self.filename] = threading.Lock()
db_cons[self.filename] = self.session
else:
self.session: Session = db_cons[self.filename]
self.imdb = Imdb(exclude_episodes=True)
def __iter__(self):
for item in self.query.all():
yield item
def __getitem__(self, pk):
return self.query.get(pk)
def __contains__(self, pk):
try:
self.__getitem__(pk)
return True
except KeyError:
return False
@staticmethod
def search_tmdb(query=None,
tmdb_id=None,
year=None,
language=None,
adult=False):
if tmdb_id:
results = [movies.Movies(id=tmdb_id)]
elif query:
tmdb_kwargs = dict(query=query,
year=year,
language=language,
adult=adult)
tmdb_kwargs = {
key: value
for key, value in tmdb_kwargs.items() if value
}
results = search.Search().movie(**tmdb_kwargs)['results']
else:
raise Exception('Query or tmdb id is required!')
return results
@staticmethod
def popular_tmdb(language=None):
tmdb_kwargs = dict(language=language) if language else dict()
return movies.Movies().popular(**tmdb_kwargs)['results']
def search_imdb(self, query: str = ''):
return self.imdb.search_for_title(title=query)
def popular_imdb(self):
return self.imdb.get_popular_movies()['ranks']
def add_from_tmdb(self,
tmdb_id: str,
language: str = settings.INDEXER_DEFAULT_LANGUAGE):
logger.debug(f'Adding movie from tmdb with id: {tmdb_id}')
existing = self.session.query(
movie.IndexerData).filter_by(pk=tmdb_id).first()
if existing:
logger.debug(f'Movie already existed as {existing.movie.name}')
return existing.movie
tmdb_object = tmdbsimple.movies.Movies(id=tmdb_id).info()
return self.add_from_imdb(tmdb_object['imdb_id'],
language,
tmdb_primary=True)
def add_from_imdb(self,
imdb_id: str,
language: str = settings.INDEXER_DEFAULT_LANGUAGE,
tmdb_primary=False):
if not tmdb_primary:
logger.debug(f'Adding movie from imdb id: {imdb_id}')
existing = self.session.query(
movie.IndexerData).filter_by(pk=imdb_id).first()
if existing:
logger.debug(f'Movie already existed as {existing.movie.name}')
return existing.movie
imdb_object = self.imdb.get_title(imdb_id)
tmdb_id = tmdbsimple.find.Find(id=imdb_id).info(
external_source='imdb_id')['movie_results'][0]['id']
tmdb_object = tmdbsimple.movies.Movies(id=tmdb_id).info()
if tmdb_primary:
instance = movie.Movie(
tmdb_object['title'],
year=tmdb_object['release_date'].split('-')[0])
if imdb_object['base']['title'] and not instance.name:
instance.name = imdb_object['base']['title']
else:
instance = movie.Movie(imdb_object['base']['title'],
year=imdb_object['base']['year']
or tmdb_object)
if tmdb_object['release_date'] and not instance.year:
instance.year = tmdb_object['release_date'].split('-')[0]
if tmdb_object['title'] and not instance.name:
instance.name = tmdb_object['title']
if tmdb_object['release_date']:
instance.date = datetime.datetime.strptime(
tmdb_object['release_date'], '%Y-%m-%d').date()
instance.language = tmdb_object['original_language'] or language
tmdb_data = movie.IndexerData(site='tmdb',
data=tmdb_object,
pk=tmdb_id)
imdb_data = movie.IndexerData(site='imdb',
data=imdb_object,
pk=imdb_id)
imdb_genres = self.imdb.get_title_genres(imdb_id)['genres']
def add_imdb_genres():
for genre in imdb_genres:
logger.debug(f'Adding imdb genre {genre}')
imdb_data.genres.append(movie.Genres(pk=genre))
instance.indexer_data.append(imdb_data)
def add_tmdb_genres():
for genre in tmdb_object['genres']:
if genre['name'] not in imdb_genres:
logger.debug(f'Adding tmdb genre {genre["name"]}')
tmdb_data.genres.append(movie.Genres(pk=genre['name']))
instance.indexer_data.append(tmdb_data)
if tmdb_primary:
add_tmdb_genres()
add_imdb_genres()
else:
add_imdb_genres()
add_tmdb_genres()
self.commit(instance)
logger.debug(f'Returning instance for {instance.name}')
return instance
def commit(self, instance=None):
logger.debug('Committing')
if instance:
self.session.add(instance)
self.session.flush()
self.session.commit()
def delete(self, pk):
instance = self.query.get(pk)
if instance:
self.session.delete(instance)
@property
def query(self):
return self.session.query(movie.Movie)
def by_slug(self, slug):
return self.query.filter_by(slug=slug).first()
def search_providers(self, movie_object: movie.Movie):
# We should only need to support backlog for movies manually
# Movies should be returned in the existing RSS searches if we have movies in our list
strings = movie_object.search_strings()
for provider in settings.providerList:
if provider.can_backlog and provider.backlog_enabled and provider.supports_movies:
results = provider.search(strings)
for result in results:
movie.Result(result=result,
provider=provider,
movie=movie_object)
self.commit(movie_object)
# TODO: Check if we need to break out here and stop hitting providers if we found a good result
def snatch_movie(self, result: movie.Result):
pass
def search_thread(self):
pass
count = 0
genre_dict = {}
seasons_dict = {}
imdb = Imdb()
for series in list_1:
count += 1
print(count)
if series:
try:
title = re.sub(r"\B([A-Z])", r" \1", series)
k = imdb.search_for_title(title)
b = k[0]['imdb_id']
year = k[0]['year']
try:
genre = imdb.get_title_genres(b)['genres']
genre_dict[series] = genre
except LookupError:
print('LookupError for {}', series)
genre_dict[series] = 'unknown'
try:
eps = len(imdb.get_title_episodes(b)['seasons'])
seasons_dict[series] = eps
except LookupError:
print('LookupError for {}', series)
seasons_dict[series] = 1
except LookupError:
print('LookupError for {}', series)
except TimeoutError:
print('TimeoutError for {}', series)
new_path = os.path.join(base, f_name + f[-4:])
if os.path.exists(new_path):
print("File already exists: {0} : {1}".format(f, new_path))
continue
os.rename(os.path.join(root, f), new_path)
if len(os.listdir(root)) < 1:
try:
os.rmdir(root)
except:
pass
# ---------------------------------------------
# Create a shortcut to the file based on genre
# ---------------------------------------------
desktop = winshell.desktop()
genres = ia.get_title_genres(res[n]['imdb_id'])
library = "Z:\Ripped\Movies"
for genre in genres:
genre_dir = os.path.join(library, "Genres", genre)
if not os.path.exists(genre_dir):
os.mkdir(genre_dir)
s_path = os.path.join(genre_dir, f_name + ".lnk")
if os.path.exists(s_path):
os.remove(s_path)
target = new_path
wDir = base
icon = new_path
shell = Dispatch('WScript.Shell')
shortcut = shell.CreateShortCut(s_path)
def start_process(filenames, mode):
"""
This is the main funtion of the script
where it does its main processing.\n
filenames is the list of files to be processed\n
mode = 1,2,3 or 4\n
1 means mp4 to tagged mp4\n
2 means mp4 with sub to subbed and tagged mp4\n
3 means mkv to tagged mp4\n
4 means mkv with sub to subbed and tagged mp4
"""
for filename in filenames:
try:
title = filename[:-4]
stream_md = collect_stream_metadata(filename)
streams_to_process = []
dvdsub_exists=False
for stream in stream_md['streams']:
if not stream['codec_name'] in sub_codec_blacklist:
streams_to_process.append(stream['index'])
else:
dvdsub_exists=True
print('\nSearching IMDb for "{}"'.format(title))
imdb = Imdb()
movie_results = []
results = imdb.search_for_title(title)
for result in results:
if result['type'] == "feature":
movie_results.append(result)
if not movie_results:
while not movie_results:
title = input('\nNo results for "' + title +
'" Enter alternate/correct movie title >> ')
results = imdb.search_for_title(title)
for result in results:
if result['type'] == "feature":
movie_results.append(result)
# The most prominent result is the first one
# mpr - Most Prominent Result
mpr = movie_results[0]
print('\nFetching data for {} ({})'.format(mpr['title'],
mpr['year']))
# imdb_movie is a dict of info about the movie
imdb_movie = imdb.get_title(mpr['imdb_id'])
imdb_movie_title = imdb_movie['base']['title']
imdb_movie_year = imdb_movie['base']['year']
imdb_movie_id = mpr['imdb_id']
imdb_movie_rating = imdb_movie['ratings']['rating']
if not 'outline' in imdb_movie['plot']:
imdb_movie_plot_outline = (imdb_movie['plot']['summaries'][0]
['text'])
print("\nPlot outline does not exist. Fetching plot summary "
"instead.\n\n")
else:
imdb_movie_plot_outline = imdb_movie['plot']['outline']['text']
# Composing a string to have the rating and the plot of the
# movie which will go into the 'comment' metadata of the
# mp4 file.
imdb_rating_and_plot = str('IMDb rating ['
+ str(float(imdb_movie_rating))
+ '/10] - '
+ imdb_movie_plot_outline)
imdb_movie_genres = imdb.get_title_genres(imdb_movie_id)['genres']
# Composing the 'genre' string of the movie.
# I use ';' as a delimeter to searate the multiple genre values
genre = ';'.join(imdb_movie_genres)
newfilename = (imdb_movie_title
+ ' ('
+ str(imdb_movie_year)
+ ').mp4')
# We don't want the characters not allowed in a filename
newfilename = (newfilename
.replace(':', ' -')
.replace('/', ' ')
.replace('?', ''))
command = ""
stream_map = []
for f in streams_to_process:
stream_map.append("-map 0:{}".format(f))
stream_map_str = ' '.join(stream_map)
if mode == 1:
# it is required to rename it as its already an mp4 file that
# wasn't proccessed by ffmpeg
os.rename(filename, newfilename)
if mode == 2 or mode == 4:
command = ('ffmpeg -i "'
+ filename
+ '" -sub_charenc UTF-8 -i "'
+ filename[:-4]
+ '.srt" '
+ stream_map_str
+ ' -map 1 -c copy -c:s mov_text '
'"' + newfilename + '"')
subprocess.run(shlex.split(command))
if mode == 3:
command = ('ffmpeg -i '
+ '"' + filename + '" '
+ stream_map_str
+ ' -c copy -c:s mov_text '
'"' + newfilename + '"')
subprocess.run(shlex.split(command))
if dvdsub_exists:
print("\nRemoved DVD Subtitles due to uncompatibility with "
"mp4 file format")
# The poster is fetched from tmdb only if there is no file
# named " filename + '.jpg' " in the working directory
# this way user can provide their own poster image to be used
poster_filename = filename[:-4] + '.jpg'
if not os.path.isfile(poster_filename):
print('\nFetching the movie poster...')
tmdb_find = tmdb.Find(imdb_movie_id)
tmdb_find.info(external_source = 'imdb_id')
path = tmdb_find.movie_results[0]['poster_path']
complete_path = r'https://image.tmdb.org/t/p/w780' + path
uo = urllib.request.urlopen(complete_path)
with open(poster_filename, "wb") as poster_file:
poster_file.write(uo.read())
poster_file.close()
video = MP4(newfilename)
with open(poster_filename, "rb") as f:
video["covr"] = [MP4Cover(
f.read(),
imageformat=MP4Cover.FORMAT_JPEG)]
video['\xa9day'] = str(imdb_movie_year)
video['\xa9nam'] = imdb_movie_title
video['\xa9cmt'] = imdb_rating_and_plot
video['\xa9gen'] = genre
print('\nAdding poster and tagging file...')
try:
video.save()
# I have encounterd this error in pevious version
# of script, now I handle it by removing the metadata
# of the file. That seems to solve the probelem
except OverflowError:
remove_meta_command = ('ffmpeg -i "' + newfilename
+ '" -codec copy -map_metadata -1 "'
+ newfilename[:-4] + 'new.mp4"')
subprocess.run(shlex.split(remove_meta_command))
video_new = MP4(newfilename[:-4] + 'new.mp4')
with open(poster_filename, "rb") as f:
video_new["covr"] = [MP4Cover(
f.read(),
imageformat=MP4Cover.FORMAT_JPEG)]
video_new['\xa9day'] = str(imdb_movie_year)
video_new['\xa9nam'] = imdb_movie_title
video_new['\xa9cmt'] = imdb_rating_and_plot
video_new['\xa9gen'] = genre
print('\nAdding poster and tagging file...')
try:
video_new.save()
if not os.path.exists('auto fixed files'):
os.makedirs('auto fixed files')
os.rename(newfilename[:-4]
+ 'new.mp4', 'auto fixed files\\'
+ newfilename[:-4] + '.mp4')
os.remove(newfilename)
except OverflowError:
errored_files.append(filename
+ (' - Could not save even after'
'striping metadata'))
continue
os.remove(poster_filename)
print('\n' + filename
+ (' was proccesed successfuly!\n\n===================='
'======================================'))
except Exception as e:
print('\nSome error occured while processing '
+ filename
+ '\n\n====================================================')
errored_files.append(filename + ' - ' + str(e))
PrintException()
tempData['rating'] = movie["ratings"]['rating']
except:
print("Couldn't get ratings")
try:
if tempData['duration'] == "":
tempData['duration'] = movie['base']["runningTimeInMinutes"]
except:
print("Couldn't get duration")
try:
if tempData["release_date"] == "":
tempData["release_date"] = movie["base"]['year']
except:
print("Couldn't get release date")
try:
if tempData["genres"] == []:
tempData["genres"] = imdb.get_title_genres(
tempData["imdb_id"])["genres"]
except:
print("Couldn't get geners")
tempData["progress"] = 0
#Add main video file
if tempData["main_id"] == "" or uDP:
tempData["main_id"] = getPointer(
glob.glob(os.path.join(path, '*.mp4'))[0])
#Add trailer file, download if doesn't exist
if tempData["trailer_id"] == "" or uDP:
if (len(glob.glob(os.path.join(path, '*.trailer'))) == 0):
print("No trailer found. Downloading.")
url = imdb.get_title_videos(
def get_imdb_best_title(torrent_info, comparator):
try:
from operator import itemgetter
from imdbpie import Imdb
imdb = Imdb()
updated_imdb = []
imdb_selected = []
item_selected = {}
year_found = None
torrent_title = torrent_info['torrent_title']
## Using torrent title until year,
## only if torrent title has a year
title_has_year = re.match(r'.*([1-3][0-9]{3})', torrent_title)
if title_has_year is not None:
year_found = title_has_year.group(1)
## Adding torrent title year
torrent_info.update({'year':year_found})
splitted = str(torrent_title.split(year_found)[0])
else:
splitted = str(torrent_title)
## Remove non-required specific characters
if not splitted.isalpha():
splitted = splitted.translate(None, "([_#@&*|~`%^<>").strip()
torrent_info['torrent_title'] = splitted
## Getting IMDB information
imdb_data = imdb.search_for_title(splitted)
self.logger.debug("+ Getting IMDB [%s] items"%(str(len(imdb_data))))
## Pre-selecting only IMDB titles that
## look very similar to torrent title
ignored_items = 0
for imdb_item in imdb_data:
score = comparator.score(splitted, imdb_item['title'])
year_matches = year_found == imdb_item['year']
item_type = 'feature' == imdb_item['type']
## Adding only very similar titles
if score > 0.98:
imdb_item.update({'score':score})
imdb_item.update({'year_matches':year_matches})
updated_imdb.append(imdb_item)
else:
ignored_items += 1
self.logger.debug(" Ignored [%s] vs [%s] = %f"%
(splitted, imdb_item['title'], score))
self.logger.debug("+ Ignored [%s] item(s)"%(str(ignored_items)))
## Sorting IMDB retrieved items by similarity score
sorted_imdb = sorted(updated_imdb, key=itemgetter('score'), reverse=True)
## Checking if torrent year matches, otherwise
## provide only feature type IMDB items
better_item_not_found = False
for imdb_item in sorted_imdb:
item_added = False
new_item = {}
if imdb_item['year_matches']:
better_item_not_found = True
item_added = True
elif not better_item_not_found and 'feature' == imdb_item['type']:
item_added = True
## Retrieving additional IMDB information
## and adding item
if item_added:
imdb_id = imdb_item['imdb_id']
title_info = imdb.get_title(imdb_id)
title_genres = imdb.get_title_genres(imdb_id)
if title_genres is not None and 'genres' in title_genres:
genres_label = str(', '.join(title_genres['genres']))
imdb_item.update({'genres': genres_label})
imdb_image_url = ''
if 'image' in title_info['base'].keys():
imdb_image_url = title_info['base']['image']['url']
else:
self.logger.debug("- Image URL not found")
self.logger.debug("- Looking in similarities for images...")
for similarity_item in title_info['similarities']:
itemKeys = similarity_item.keys()
if 'image' in itemKeys:
imageKey = similarity_item['image'].keys()
if 'url' in imageKey:
imdb_image_url = similarity_item['image']['url']
self.logger.debug(" Using image from similarities")
break
imdb_raiting = ''
if 'rating' in title_info['ratings'].keys():
imdb_raiting = str(title_info['ratings']['rating'])
else:
self.logger.debug("- Raiting not found")
imdb_plot = ''
if 'outline' in title_info['plot'].keys():
imdb_plot = title_info['plot']['outline']['text']
else:
self.logger.debug("- Plot not found")
imdb_title_url = title_info['base']['id']
imdb_item.update({'raiting': imdb_raiting})
imdb_item.update({'plot': imdb_plot})
imdb_item.update({'image_url': imdb_image_url})
imdb_item.update({'title_url': 'http://www.imdb.com/'+imdb_title_url})
imdb_selected.append(imdb_item)
item_selected.update({'imdb_info':imdb_selected})
item_selected.update({'torrent_info':torrent_info})
except Exception as inst:
Utilities.ParseException(inst, logger=self.logger)
finally:
return item_selected
