class TMDBMovie(TMDBContainer, Base):
__tablename__ = 'tmdb_movies'
id = Column(Integer, primary_key=True, autoincrement=False, nullable=False)
updated = Column(DateTime, default=datetime.now, nullable=False)
popularity = Column(Integer)
translated = Column(Boolean)
adult = Column(Boolean)
language = Column(String)
original_name = Column(Unicode)
name = Column(Unicode)
alternative_name = Column(Unicode)
movie_type = Column(String)
imdb_id = Column(String)
url = Column(String)
votes = Column(Integer)
rating = Column(Float)
certification = Column(String)
overview = Column(Unicode)
runtime = Column(Integer)
tagline = Column(Unicode)
budget = Column(Integer)
revenue = Column(Integer)
homepage = Column(String)
trailer = Column(String)
_released = Column('released', DateTime)
released = text_date_synonym('_released')
year = year_property('released')
posters = relation('TMDBPoster',
backref='movie',
cascade='all, delete, delete-orphan')
genres = relation('TMDBGenre', secondary=genres_table, backref='movies')
class TMDBMovie(TMDBContainer, Base):
__tablename__ = 'tmdb_movies'
id = Column(Integer, primary_key=True, autoincrement=False, nullable=False)
updated = Column(DateTime, default=datetime.now, nullable=False)
popularity = Column(Integer)
translated = Column(Boolean)
adult = Column(Boolean)
language = Column(String)
original_name = Column(Unicode)
name = Column(Unicode)
alternative_name = Column(Unicode)
movie_type = Column(String)
imdb_id = Column(String)
url = Column(String)
votes = Column(Integer)
rating = Column(Float)
certification = Column(String)
overview = Column(Unicode)
runtime = Column(Integer)
tagline = Column(Unicode)
budget = Column(Integer)
revenue = Column(Integer)
homepage = Column(String)
trailer = Column(String)
_released = Column('released', DateTime)
released = text_date_synonym('_released')
year = year_property('released')
posters = relation('TMDBPoster', backref='movie', cascade='all, delete, delete-orphan')
genres = relation('TMDBGenre', secondary=genres_table, backref='movies')
def update_from_object(self, update_object):
try:
TMDBContainer.update_from_object(self, update_object)
self.translated = len(update_object.translations) > 0
if len(update_object.languages) > 0:
self.language = update_object.languages[0].code # .code or .name ?
self.original_name = update_object.originaltitle
self.name = update_object.title
try:
if len(update_object.alternate_titles) > 0:
# maybe we could choose alternate title from movie country only
self.alternative_name = update_object.alternate_titles[0].title
except UnicodeEncodeError:
# Bug in tmdb3 library, see #2437. Just don't set alternate_name when it fails
pass
self.imdb_id = update_object.imdb
self.url = update_object.homepage
self.rating = update_object.userrating
if len(update_object.youtube_trailers) > 0:
self.trailer = update_object.youtube_trailers[0].source # unicode: ooNSm6Uug3g
elif len(update_object.apple_trailers) > 0:
self.trailer = update_object.apple_trailers[0].source
self.released = update_object.releasedate
except tmdb3.TMDBError as e:
raise LookupError('Error updating data from tmdb: %s' % e)
class BlurayMovie(Base):
__tablename__ = 'bluray_movies'
id = Column(Integer, primary_key=True, autoincrement=False, nullable=False)
name = Column(Unicode)
url = Column(Unicode)
release_date = Column(Date)
year = year_property('release_date')
runtime = Column(Integer)
overview = Column(Unicode)
country = Column(Unicode)
studio = Column(Unicode)
rating = Column(Float)
bluray_rating = Column(Integer)
certification = Column(Unicode)
_genres = relation('BlurayGenre', secondary=genres_table, backref='movies')
genres = association_proxy('_genres', 'name')
updated = Column(DateTime, default=datetime.now, nullable=False)
def __init__(self, title, year):
if year:
title_year = '{} ({})'.format(title, year)
else:
title_year = title
params = {
'search': 'bluraymovies',
'country': 'ALL',
'keyword': title,
'_': str(int(time.time() * 1000))
}
country_params = {'_': params['_']}
try:
search_results = bluray_request('quicksearch/search.php',
**params)['items']
countries = bluray_request('countries.json.php', **
country_params) or {}
if not search_results:
raise LookupError(
'No search results found for {} on blu-ray.com'.format(
title_year))
search_results = sorted(
search_results,
key=lambda k: extract_release_date(k.get('reldate')))
except requests.RequestException as e:
raise LookupError(
'Error searching for {} on blu-ray.com: {}'.format(
title_year, e))
# Simply take the first result unless year does not match
for result in search_results:
if year and str(year) != result['year']:
continue
self.id = int(result['url'].split('/')[-2])
self.name = result['title']
flag = result['flag']
country_code = flag.split('/')[-1].split(
'.')[0].lower() # eg. http://some/url/UK.png -> uk
# find country based on flag url, default United States
country = 'United States'
for c in countries['countries']:
if c['c'].lower() == country_code:
country = c['n']
self.country = country
self.release_date = extract_release_date(result.get('reldate'))
self.bluray_rating = int(
result['rating']) if result['rating'] else None
# Used for parsing some more data, sadly with soup
self.url = result['url']
movie_info_response = requests.get(self.url).content
movie_info = get_soup(movie_info_response)
# runtime and rating, should be the last span tag with class subheading
bluray_info = movie_info.find('div', attrs={'class': 'bluray'})
bluray_info = bluray_info.find_all('span',
attrs={'class': 'subheading'
})[-1].text.split('|')
self.studio = bluray_info[0].strip()
for info in bluray_info[1:]:
if 'min' in info:
self.runtime = int(info.replace('min', '').strip())
elif 'Rated' in info:
self.certification = info.replace('Rated', '').strip()
# rating
rating_tag = movie_info.find('div', id='ratingscore')
self.rating = float(
rating_tag.text.strip()) if rating_tag else None
# Third onecol_content contains some information we want
onecol_content = movie_info.find_all(
'div', attrs={'class': 'onecol_content'})[2]
# overview, genres etc
contents = onecol_content.find('div').find('div')
overview_tag = contents.find('p')
self.overview = overview_tag.text.strip() if overview_tag else None
# genres
genres_table = contents.find('table')
if not genres_table:
break
genres_content = genres_table.find_all('tr')
if not genres_content:
break
genres = set()
for genre in genres_content:
genres.add(genre.find('td').text.strip())
self._genres = [BlurayGenre(name=genre) for genre in genres]
break
else:
raise LookupError(
'No search results found for {} on blu-ray.com'.format(
title_year))
class TMDBMovie(Base):
__tablename__ = 'tmdb_movies'
id = Column(Integer, primary_key=True, autoincrement=False, nullable=False)
imdb_id = Column(Unicode)
url = Column(Unicode)
name = Column(Unicode)
original_name = Column(Unicode)
alternative_name = Column(Unicode)
released = Column(Date)
year = year_property('released')
runtime = Column(Integer)
language = Column(Unicode)
overview = Column(Unicode)
tagline = Column(Unicode)
rating = Column(Float)
votes = Column(Integer)
popularity = Column(Float)
adult = Column(Boolean)
budget = Column(Integer)
revenue = Column(Integer)
homepage = Column(Unicode)
lookup_language = Column(String)
_posters = relation('TMDBPoster',
backref='movie',
cascade='all, delete, delete-orphan')
_backdrops = relation('TMDBBackdrop',
backref='movie',
cascade='all, delete, delete-orphan')
_genres = relation('TMDBGenre', secondary=genres_table, backref='movies')
genres = association_proxy('_genres', 'name')
updated = Column(DateTime, default=datetime.now, nullable=False)
def __init__(self, id, language):
"""
Looks up movie on tmdb and creates a new database model for it.
These instances should only be added to a session via `session.merge`.
"""
self.id = id
try:
movie = tmdb_request('movie/{}'.format(self.id),
append_to_response='alternative_titles',
language=language)
except requests.RequestException as e:
raise LookupError('Error updating data from tmdb: %s' % e)
self.imdb_id = movie['imdb_id']
self.name = movie['title']
self.original_name = movie['original_title']
if movie.get('release_date'):
self.released = dateutil_parse(movie['release_date']).date()
self.runtime = movie['runtime']
self.language = movie['original_language']
self.overview = movie['overview']
self.tagline = movie['tagline']
self.rating = movie['vote_average']
self.votes = movie['vote_count']
self.popularity = movie['popularity']
self.adult = movie['adult']
self.budget = movie['budget']
self.revenue = movie['revenue']
self.homepage = movie['homepage']
self.lookup_language = language
try:
self.alternative_name = movie['alternative_titles']['titles'][0][
'title']
except (KeyError, IndexError):
# No alternate titles
self.alternative_name = None
self._genres = [TMDBGenre(**g) for g in movie['genres']]
self.updated = datetime.now()
def get_images(self):
log.debug('images for movie %s not found in DB, fetching from TMDB',
self.name)
try:
images = tmdb_request('movie/{}/images'.format(self.id))
except requests.RequestException as e:
raise LookupError('Error updating data from tmdb: %s' % e)
self._posters = [
TMDBPoster(movie_id=self.id, **p) for p in images['posters']
]
self._backdrops = [
TMDBBackdrop(movie_id=self.id, **b) for b in images['backdrops']
]
@property
def posters(self):
if not self._posters:
self.get_images()
return self._posters
@property
def backdrops(self):
if not self._backdrops:
self.get_images()
return self._backdrops
def to_dict(self):
return {
'id': self.id,
'imdb_id': self.imdb_id,
'name': self.name,
'original_name': self.original_name,
'alternative_name': self.alternative_name,
'year': self.year,
'runtime': self.runtime,
'language': self.language,
'overview': self.overview,
'tagline': self.tagline,
'rating': self.rating,
'votes': self.votes,
'popularity': self.popularity,
'adult': self.adult,
'budget': self.budget,
'revenue': self.revenue,
'homepage': self.homepage,
'genres': [g for g in self.genres],
'updated': self.updated,
'lookup_language': self.lookup_language
}
class TMDBMovie(Base):
__tablename__ = 'tmdb_movies'
id = Column(Integer, primary_key=True, autoincrement=False, nullable=False)
imdb_id = Column(Unicode)
url = Column(Unicode)
name = Column(Unicode)
original_name = Column(Unicode)
alternative_name = Column(Unicode)
_released = Column('released', DateTime)
released = text_date_synonym('_released')
year = year_property('released')
certification = Column(Unicode)
runtime = Column(Integer)
language = Column(Unicode)
overview = Column(Unicode)
tagline = Column(Unicode)
rating = Column(Float)
votes = Column(Integer)
popularity = Column(Integer)
adult = Column(Boolean)
budget = Column(Integer)
revenue = Column(Integer)
homepage = Column(Unicode)
posters = relation('TMDBPoster',
backref='movie',
cascade='all, delete, delete-orphan')
_genres = relation('TMDBGenre', secondary=genres_table, backref='movies')
genres = association_proxy('_genres', 'name')
updated = Column(DateTime, default=datetime.now, nullable=False)
def __init__(self, id):
"""
Looks up movie on tmdb and creates a new database model for it.
These instances should only be added to a session via `session.merge`.
"""
self.id = id
try:
movie = tmdb_request(
'movie/{}'.format(self.id),
append_to_response='alternative_titles,images')
except requests.RequestException as e:
raise LookupError('Error updating data from tmdb: %s' % e)
self.imdb_id = movie['imdb_id']
self.name = movie['title']
self.original_name = movie['original_title']
self.released = movie['release_date']
self.runtime = movie['runtime']
self.language = movie['original_language']
self.overview = movie['overview']
self.tagline = movie['tagline']
self.rating = movie['vote_average']
self.votes = movie['vote_count']
self.popularity = movie['popularity']
self.adult = movie['adult']
self.budget = movie['budget']
self.revenue = movie['revenue']
self.homepage = movie['homepage']
self.alternative_name = None
try:
self.alternative_name = movie['alternative_titles']['titles'][0][
'title']
except (KeyError, IndexError):
pass # No alternate titles
self._genres = [TMDBGenre(**g) for g in movie['genres']]
# Just grab the top 5 posters
self.posters = [
TMDBPoster(**p) for p in movie['images']['posters'][:5]
]
self.updated = datetime.now()
