def add_from_imdb(imdb_id, youtube_id):
"""Retrieves movie data from the inofficial IMDb REST API as well as the IMDB lib imdbpie."""
file_name = os.path.dirname(__file__) + "/imdb/" + imdb_id + ".json"
if not os.path.isdir(os.path.dirname(file_name)):
os.mkdir(os.path.dirname(file_name))
if os.path.isfile(file_name):
imdb_saved = open(file_name)
imdb_save = json.loads(imdb_saved.read())
else:
response = urllib.urlopen('http://imdb.wemakesites.net/api/' + imdb_id + '?api_key=' + Movie.__api_key)
json_response = response.read()
imdb_data = json.loads(json_response)
imdb_save = imdb_data['data']
imdb = Imdb()
imdb = Imdb(anonymize=True) # to proxy requests
movie = imdb.get_title_by_id(imdb_id)
if not movie.title:
movie.title = raw_input("Movie Title not defined. Please set: ")
imdb_save['rating'] = movie.rating
imdb_save['title'] = movie.title
if youtube_id:
imdb_save['youtube_id'] = youtube_id
imdb_file = open(file_name, 'w')
imdb_file.write(json.dumps(imdb_save))
imdb_file.close()
def IMDBSearch(request):
client = Imdb(locale='en_US')
imdb = ImdbFacade(client=client)
imdb2 = Imdb()
results2 = set([])
search_term = ''
if 'search' in request.GET and request.GET['search'] is not '':
search_term = request.GET['search']
results = imdb2.search_for_title(search_term)
else:
results = Media.objects.none()
## Attempting to get the more detailed information, It works, sorta, but it'a really slow.
# for r in results:
# results2.add(r.imdb_id)
# for r in results2:
# print(imdb2.get_title(r)
table = IMDBSearchTable(results)
RequestConfig(request).configure(table)
return render(request, 'pages/IMDBsearch.html',
{
'search_term': search_term,
'table': table,
}
)
def metadata(s):
imdb = Imdb()
imdb = Imdb(anonymize=True) # to proxy requests
names = imdb.search_for_title(s)
title = imdb.get_title_by_id(names[0][u'imdb_id'])
cast = cast_rating(title.cast_summary)
return title
def episodeBuilder(episode_id):
imdb = Imdb()
imdb = Imdb(anonymize=True)
episode = imdb.get_title_by_id(episode_id)
return episode.plot_outline, episode.title
def imdb_rating(movieTitle, year=None):
imdb = Imdb()
try:
results = imdb.search_for_title(movieTitle)
except:
print('WARNING: Could not find the title %s' % movieTitle)
return 0.00
if year is None:
bestHit = results[0]
else:
gotHit = False
for result in results:
movieYear = int(result.get('year'))
if movieYear - 2 <= year and movieYear + 2 >= year:
bestHit = result
gotHit = True
break
if not gotHit:
print('WARNING: Could not get match for %s' % movieTitle)
return 0.00
print('-=MATCH=- %s --from %s --=-- %s' % (movieTitle, year, bestHit))
idBestHit = bestHit.get('imdb_id')
rating = imdb.get_title_by_id(idBestHit).rating
movType = imdb.get_title_by_id(idBestHit).type
if movType.lower() != 'feature' and movType.lower() != 'documentary':
print('WARNING: This is not a feature-film or docu: %s' % movieTitle)
return 0.00
elif rating is None:
print('WARNING: Could not get rating from title %s' %
bestHit.get('title'))
return 0.00
return float(rating)
def get(self, request, *arg, **kwargs):
ia = Imdb()
#pass int argument between 1-100 to get a list
#of the top movies right now
numtop = 50
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)
def main():
print("! Getting a list of TV shows from eztv...")
showlist_page = lxml.html.fromstring(requests.get(EZTV_URL).content)
shows = [l.text for l in showlist_page.xpath('//a[@class="thread_link"]')]
print("")
imdb = Imdb()
episode_records = []
for show_name in shows[:10]:
print("* Processing `{}`...".format(show_name))
episodes = None
for show in imdb.search_for_title(show_name):
try:
episodes = imdb.get_episodes(show['imdb_id'])
break
except (RuntimeError, TypeError):
# RuntimeError: This is thrown when a show is not recognized a series
# TypeError: Bug where seasons is None.
continue
if episodes is None:
print(" ! Couldn't find an IMDB entry for `{}`. Ignoring.".format(
show_name))
continue
episode_records += [e.__dict__ for e in episodes]
df = pd.DataFrame(episode_records)
df.to_csv(DATA_PATH, index=False)
def setup():
"""
Sets up global wiki object for Wikipedia lookups.
"""
global wiki, imdb
wiki = WikiApi()
imdb = Imdb(anonymize=True)
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 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 test_get_title_by_id_excludes_episodes(self):
assert self.imdb.get_title_by_id('tt3181538') is not None
imdb = Imdb(exclude_episodes=True)
title = imdb.get_title_by_id('tt3181538')
assert title is None
def test(title):
imdb = Imdb()
try:
search = imdb.search_for_title(title)[0]
except IndexError:
return 'Movie not found.'
#results = imdb.search_for_title(title)[:5]
#for i in range(len(results)):
# movie = results[i]
# print('{}. {} ({})'.format(i+1, movie['title'], movie['year']))
#while True:
# prompt = raw_input('> ')
# if prompt in ['1','2','3','4','5']:
# break
# else:
# print('Invalid choice.')
#select = results[int(prompt)-1]
#movie = imdb.get_title_by_id(select['imdb_id'])
# checking out all dir(movies)
#for i in dir(movie):
# if i.startswith('_'):
# continue
#x = getattr(movie, i)
# print('{} - {}'.format(i, x))
movie = imdb.get_title_by_id(search['imdb_id'])
return '{} ({})\n{}\nIMDB: {}'.format(movie.title, movie.year,
movie.plot_outline, movie.rating)
def __init__(self):
super().__init__()
try:
from imdbpie import Imdb
except ImportError:
showInfo('Please install the imdbpie module.')
return
self.imdb = Imdb()
self.mainLayout = QGridLayout(self)
self.queryInput = QLineEdit()
self.searchResults = QListWidget()
self.createButton = QPushButton("Create")
self.createButton.setAutoDefault(False)
self.sidebar = QWidget()
self.sidebarLayout = QVBoxLayout(self.sidebar)
# All valid tokens for imdbpie Person objects.
self.departments = [
'director', 'writer', 'cast', 'producer', 'cinematographer',
'editor', 'casting_director', 'production_designer',
'art_director', 'set_decorator', 'costume_designer',
'make_up_department', 'assistant_director', 'art_department',
'sound_department', 'visual_effects', 'music_department',
'miscellaneous'
]
self.depBoxes = [QCheckBox(token) for token in self.departments]
for box in self.depBoxes:
self.sidebarLayout.addWidget(box)
self.queryInput.returnPressed.connect(self.search)
self.createButton.clicked.connect(self.createNotes)
self.mainLayout.addWidget(self.queryInput, 0, 0, 1, 1)
self.mainLayout.addWidget(self.searchResults, 1, 0, 1, 1)
self.mainLayout.addWidget(self.createButton, 2, 0, 1, 1)
self.mainLayout.addWidget(self.sidebar, 0, 1, 3, 1)
self.exec_()
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 download_imdb_reviews(rating_range,
directory_path,
imdb_id,
max_results=1000):
imdb = Imdb()
for review in imdb.get_title_reviews(imdb_id, max_results=max_results):
if review.rating in rating_range:
download_imdb_review(directory_path, review)
def __init__(self):
socket.setdefaulttimeout(30)
self.plex_url = os.environ.get('PLEX_URL')
self.plex_token = os.environ.get('PLEX_TOKEN')
self.dir = os.environ.get('POSTER_DIR')
if not os.path.exists(self.dir):
os.makedirs(self.dir)
self.imdb = Imdb()
def test_get_title_excludes_episodes(client):
episode_imdb_id = 'tt3181538'
assert client.get_title(episode_imdb_id) is not None
with pytest.raises(LookupError) as exc:
Imdb(exclude_episodes=True).get_title(episode_imdb_id)
exc.match(r'Title not found. Title was an episode.+')
def seasonBuilder(title):
# gets the information of the show in general
# Also gets the seasons and episdoes in a dict to use in the other file
# iniatilize imdb object
imdb = Imdb()
imdb = Imdb(anonymize=True)
title_json = imdb.search_for_title(title)
if title_json == []:
print('No Results Found')
else:
# get imdb id to get more information
title_id = title_json[0]['imdb_id']
result = imdb.get_title_by_id(title_id)
show_title = result.title
year = result.year
image_url = result.cover_url
description = result.plot_outline
temp = imdb.get_episodes(title_id)
# build season dict to send back to main file
seasons = {}
episodes = {}
season_counter = 1
for e in temp:
# new dict entry for the next season, the number season of the show is the entry key
if e.season > season_counter:
# the current season is done, time to start building the next episiode dict
seasons[season_counter] = episodes
episodes = {}
season_counter += 1
episodes[e.episode] = [e.title, e.release_date, e.imdb_id]
return show_title, year, image_url, description, seasons
def __init__(self, bot: Hifumi):
"""
Initialize the Utilities class
:param bot: the bot object
"""
self.bot = bot
self.imdb_api = Imdb()
self.tzs = all_timezones
self.tzw = TzWhere()
def review_extracter(movie):
"""input movie name, outputs txt file with reviews on the front page of imdb"""
### extracts content from movie page ###
imdb = Imdb()
url = imdb.search_for_title(movie)[0]
reviews = imdb.get_title_user_reviews(url["imdb_id"])
### creates list of all reviews present on the front page###
imdb = Imdb()
url = imdb.search_for_title(movie)[0]
reviews = imdb.get_title_user_reviews(url["imdb_id"])
### creates txt file for all reviews present on the front page###
review_list = []
for i in range(len(reviews["reviews"])):
line = reviews["reviews"][i]["reviewText"]
review_list.append(line)
###pickles list###
with open(f"{movie}_imdb.pickle", "wb") as f:
pickle.dump(review_list, f)
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 get_title_id(movie, year):
''' Get title_id from imdb API
'''
imdb = Imdb(anonymize=True)
list_of_matches = imdb.search_for_title(movie)
try:
possible_match = next(filter(lambda x: x['year'] == year, list_of_matches))
return possible_match['imdb_id']
except StopIteration:
print('No match for movie {}'.format(movie))
def getMovieInfo(title):
imdb = Imdb(anonymize=True)
movie_id = imdb.search_for_title(title)[0]['imdb_id']
movie = imdb.get_title_by_id(movie_id)
movieInfo = [
'Title: ' + movie.title, 'Rating: ' + str(movie.rating),
'Runtime: ' + str(int(movie.runtime) / 60),
'Release Date: ' + movie.release_date,
'Certification: ' + movie.certification
]
return movieInfo
def main():
imdb = Imdb()
movie = str(input('Movie Name: '))
movie_search = '+'.join(movie.split())
# print(imdb.search_for_name("Christian Bale"))
movie_dict = imdb.search_for_title(movie_search)
help_print_movie(movie_dict)
imdb_id = str(input('IMBD ID: '))
review_dict = imdb.get_title_user_reviews(imdb_id)
review_list = review_dict['reviews']
help_print_review(review_list)
def test_build_url_proxied(self):
imdb_fr = Imdb(locale='en_FR',
cache=False,
anonymize=True,
proxy_uri='http://someproxywebsite.co.uk?url={0}')
imdb_fr.timestamp = time.mktime(datetime.date.today().timetuple())
url = imdb_fr._build_url(path='/title/maindetails',
params={'tconst': 'tt1111111'})
expected_url = ('http://someproxywebsite.co.uk?url=' +
quote('https://app.imdb.com/title/maindetails'))
assert url.startswith(expected_url) is True
def __init__(self, app_dir, logger):
self.app_dir_data = app_dir.user_data_dir
self.cur_cache = {}
self.cache = {}
self.cache_file = os.path.join(app_dir.user_data_dir, CACHING_FILE)
if os.path.exists(self.cache_file):
with open(self.cache_file) as f:
self.cache = yaml.load(f)
if not self.cache:
self.cache = {}
self.in_cache = []
self.imdb = Imdb()
self.logger = logger
def identify_movies(movies):
""" identifying the movies from IMDB """
imdb = Imdb()
ids = []
for key, vals in movies.items():
for val in vals:
for info in imdb.search_for_title(val):
if key == info.get('year') and val == info.get(
'title').lower():
ids.append(info.get('imdb_id'))
return [imdb.get_title_by_id(id) for id in ids]
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
def retrieve_imdb_info(movies_df):
imdb = Imdb(anonymize=True)
# movies_df = movies_df.head()
start = time.time()
start_row = movies_df.loc[movies_df['imdbId'] == 2267968].iloc[0]
start_row_index = start_row.name
indices = movies_df.index[start_row_index + 1:]
# indices = indices[:2]
with open('imdb_movies.csv', 'a') as csv_file:
csv_writer = csv.writer(csv_file, delimiter=',')
for index in indices:
row = movies_df.iloc[index]
imdb_id = row['imdbId']
imdb_id = imdb_id_conversion_dict.get(imdb_id, imdb_id)
imdb_id_str = 'tt%07d' % imdb_id
# print imdb_id, imdb_id_str
imdb_title = imdb.get_title_by_id(imdb_id_str)
elapsed_time = int(round(time.time() - start, 0))
minutes = elapsed_time // 60
seconds = elapsed_time % 60
print '%s %d:%02d %s' % (index, minutes, seconds, imdb_title)
imdb_movie = ImdbMovie(imdb_id,
imdb_title.title,
imdb_title.type,
imdb_title.year,
imdb_title.tagline,
imdb_title.rating,
imdb_title.certification,
imdb_title.genres,
imdb_title.votes,
imdb_title.runtime,
imdb_title.release_date,
convert_person_list(imdb_title.directors_summary),
convert_person_list(imdb_title.creators),
convert_person_list(imdb_title.cast_summary),
convert_person_list(imdb_title.writers_summary),
)
csv_writer.writerow(imdb_movie)
def __init__(self, **kwargs):
'''Service task constructor'''
# Initialising thread parent class
threading.Thread.__init__(self)
try:
# Initialising class variables
self.component = self.__class__.__name__
self.logger = Utilities.GetLogger(self.component)
# Thread action variables
self.tStop = threading.Event()
self.threads = []
self.tid = None
self.running = False
## Adding local variables
self.service = None
self.onStart = True
self.not_searching= False
self.search_title = None
self.logger.debug(" + Creating IMDB client")
self.imdb = Imdb()
self.logger.debug(" + Creating similarity calculator")
self.similarity = Similarity()
# Generating instance of strategy
for key, value in kwargs.iteritems():
if "service" == key:
self.service = value
elif "onStart" == key:
self.onStart = bool(value)
elif "search_title" == key:
self.search_title = value
## Setting item started for reporting to device action
self.running = True
# Starting action thread
if self.onStart:
self.logger.debug(" + Process is starting immediately")
self.start()
## Adding monitor thread to the list of references
self.threads.append(self)
except Exception as inst:
Utilities.ParseException(inst, logger=self.logger)
