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 post(self, request, *arg, **kwargs ):
content = request.data
ia = Imdb()
try:
#pass in imdb movie id to get movie details
data = content['movieId']
try:
movie = ia.get_title(data)
return HttpResponse(json.dumps(movie))
except ValueError:
return HttpResponse("Invalid IMDB id", status = 400)
except KeyError:
pass
try:
#pass int argument between 1-100 to get a list
#of the top movies right now
numtop = content['top']
top100 = ia.get_popular_movies()
tosend = []
index = 0
for m in top100['ranks']:
index = index + 1
if index > int(numtop):
break
m_dict = {}
imdbId = m['id'][7:16]
m_dict['imdbId'] = str(imdbId)
m_dict['title'] = str(m['title'])
m_dict['posterUrl'] = str(m['image']['url'])
m_dict['year'] = str(m['year'])
tosend.append(m_dict)
try:
return HttpResponse(json.dumps(tosend))
except ValueError:
return HttpResponse("ValueError, int between 1-100 plz", status = 400)
except KeyError:
pass
try:
#pass imdb id to get a list of similar titles
data = content['similar']
try:
similarTitles = ia.get_title_similarities(data)
return HttpResponse(json.dumps(similarTitles))
except ValueError:
return HttpResponse("Invalid IMDB id", status = 400)
except KeyError:
return HttpResponse('Request Not Understood.', status = 400)
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 IMDB(Miner):
def __init__(self):
self.handle = Imdb()
super(IMDB, self).__init__()
def top_list(self, number):
pop_movies = self.handle.top_250()
return pop_movies
def get_movie_id(self, index):
return "tt" + index # formatting to IMDB_ID
def get_movie_by_id(self, movie_id):
return self.handle.get_title_images(movie_id), self.handle.get_title(movie_id)
movie_genres = {}
actor_set = {}
with open('data.csv') as f:
for row in f.readlines()[1:]:
columns = row.split(',')
movie_id = columns[0].split('/')[4]
genres = columns[1][:-1].split('|')
movie_list.append(movie_id)
movie_genres[movie_id] = genres
imdb = Imdb()
movie_count = 0
for movie_id in movie_list:
try:
title = imdb.get_title(movie_id)
sql = (
'''INSERT INTO movie_movie VALUES (\'{}\',\'{}\',\'{}\',\'{}\',\'{}\',\'{}\',\'{}\',\'{}\',\'{}\')'''.format(
movie_id,
single_quote(str(title['base']['title'])),
title['base']['year'],
title['base']['runningTimeInMinutes'],
movie_genres[movie_id],
title['ratings']['rating'],
single_quote(title['base']['image']['url']),
single_quote(str(title['plot']['outline']['text'])),
single_quote(str(imdb.get_title_videos(movie_id)['videos'][0]['encodings'][0]['play']))
))
execute_sql(sql)
movie_count += 1
print("Insert movie: " + movie_id, movie_count)
soup = BeautifulSoup(page.text, 'html.parser')
movie_diary = soup.find_all(class_='headline-3 prettify')
movies = []
for x in movie_diary:
movies.append(x.find('a').text)
print('Finished getting movie list...')
imdb = Imdb()
poster = {}
if not os.path.isdir(USER):
print('Folder for ' + USER + ' created!')
os.mkdir(USER)
else:
print('Folder for ' + USER + ' exists!')
for movie in movies:
try:
if not os.path.isfile(USER + '/' + movie + '.jpg'):
print('Downloading image for: ' + movie)
urllib.request.urlretrieve(imdb.get_title(imdb.search_for_title(movie)[0]['imdb_id'])['base']['image']['url'], USER + '/' + movie + '.jpg')
else:
print('Using local image for: ' + movie)
except Exception as e:
print('ERROR: ' + movie + ' could not be processed!')
print(e)
def APIGetTitle(id): imdb = Imdb() dict = imdb.get_title(id) return dict
def parse_imdb_id_from_url(url):
import re
m = re.search('/(tt.*?)/', url)
imdb_id = m.group(1)
return imdb_id
if __name__ == '__main__':
from sys import argv
myargs = getopts(argv)
if '--url' in myargs:
imdb_id = parse_imdb_id_from_url(myargs['--url'])
# imdbpie https://github.com/richardasaurus/imdb-pie
from imdbpie import Imdb
import objdict
import json
imdb = Imdb()
film = imdb.get_title(imdb_id)
film = objdict.loads(json.dumps(film))
#print film.base
# duration is retuned in seconds
#print(film.base.title + ',' + film.directors_summary[0].name + ',' + str(film.base.year) + ',' + '0:' + str(int(film.runtime / 60)))
year_part = ' (' + str(film.base.year) + ')'
print('* [' + film.base.title + ']' + '(http://www.imdb.com/title/' + imdb_id +
'/)' + year_part)
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
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()
'duration': "",
"release_date": "",
"genres": [],
"main_id": "",
"trailer_id": "",
"tall": "",
"wide": "",
"progress": 0
}
if "" in tempData.values() or [] in tempData.values(
) or "progress" not in tempData.keys() or uDP:
try:
if tempData["imdb_id"] == "":
imdb_id = imdb.search_for_title(name)[0]["imdb_id"]
print(imdb_id)
movie = imdb.get_title(imdb_id)
if input(movie["base"]["title"] + " == " + name) == "n":
imdb_id = input("Enter id:")
movie = imdb.get_title(imdb_id)
tempData["imdb_id"] = imdb_id
else:
movie = imdb.get_title(tempData["imdb_id"])
except:
print("something Failed")
imdb_id = imdb.search_for_title(name)[0]["imdb_id"]
movie = imdb.get_title(imdb_id)
if input(movie["base"]["title"] + " == " + name) == "n":
imdb_id = input("Enter id:")
movie = imdb.get_title(imdb_id)
tempData["imdb_id"] = imdb_id
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
