def __init__(self):
addEvent('movie.info', self.getInfo, priority = 3)
addEvent('movie.info_by_tmdb', self.getInfo)
# Configure TMDB settings
tmdb3.set_key(self.conf('api_key'))
tmdb3.set_cache('null')
def tmdb_info(self):
from tmdb3 import searchSeries, set_cache, set_key, set_locale, get_locale
set_key('587c13e576f991c0a653f783b290a065')
set_cache(filename='/tmp/tmdb3.cache')
set_locale('en', 'us')
_locale = get_locale()
try:
tmdb_results = searchSeries(self.title, first_air_date_year=self.year, locale=_locale)
for _series in tmdb_results:
if self.country:
if not self.country in _series.origin_countries:
continue
if self.year:
if not self.year == _series.first_air_date.year():
continue
if self.title == decode(_series.name):
raise GetOutOfLoop(_series)
raise SeriesNotFound("Series Not Found in TMDb: {}".format(self.title))
except GetOutOfLoop, e:
_series = e.message
alias = {'name': 'title',
'id': 'tmdb_id',
'origin_countries': 'country'}
for key in dir(_series):
if key[:1] == '_': continue
if key in alias: key2 = alias[key]
else: key2 = key
if not hasattr(self, key2):
continue
setattr(self, key2, decode(getattr(_series, key)))
def __init__(self):
addEvent('movie.info', self.getInfo, priority=3)
addEvent('movie.info_by_tmdb', self.getInfo)
# Configure TMDB settings
tmdb3.set_key(self.conf('api_key'))
tmdb3.set_cache('null')
def __init__(self):
addEvent("movie.info", self.getInfo, priority=3)
addEvent("movie.info_by_tmdb", self.getInfo)
# Configure TMDB settings
tmdb3.set_key(self.conf("api_key"))
tmdb3.set_cache("null")
def get_list_by_name(zapros):
set_key('c97c17e619252e35bad2e158d4211fcc')
set_locale('ru', 'ru')
set_cache(engine='file', filename='/home/swasher/kinobox/.tmdb3cache')
results = searchMovie(zapros)
answer=[]
i=0
for movie in results[0:10]:
mov=kino()
#print unicode(results[i])
searchResult = results[i]
mov.id=searchResult.id
mov.title=searchResult.title
mov.year=str(searchResult.releasedate)[0:4]
mov.overview=searchResult.overview
mov.url='http://www.themoviedb.org/movie/'+str(mov.id)
mov.origname=searchResult.originaltitle
try:
mov.altname=searchResult.alternate_titles[0].title
except:
mov.altname=''
try:
mov.poster=searchResult.poster.geturl(size='w154')
except:
mov.poster=''
answer.append(mov)
i+=1
return answer
def fetch_details(self, args):
logging.debug("Fetching with details %s " % args)
title = args["title"]
year = args["year"]
if title is None:
logging.critical("Need a title")
raise RuntimeError("Need a title")
# Keep our temporary cache in /tmp, but one per user
tmdb3.set_cache(filename='tmdb3.' + str(os.getuid()) + '.cache')
# tmdb.set_locale(....) Should be automatic from environment
res = tmdb3.searchMovie(title, year=year)
logging.debug(res)
if len(res) == 0:
logging.error("Could not find any matching movie")
raise LookupError("Could not find match for " + title)
# Assume first match is the best
res0 = res[0]
poster = None
fanart = None
poster = self._get_image_url(res0.poster)
# Want the biggest image by default for fanart
if res0.backdrop:
fanart = res0.backdrop.geturl()
logging.debug("poster=%s fanart=%s title=%s year=%s" %
(poster, fanart, title, year))
return {"poster": poster, "fanart": fanart}
def __init__(self, api_key: str, locale: Locale, fallback_locale: Locale = None):
super().__init__()
self.api_key: str = api_key
self.locale: Locale = locale
self.fallback_locale: Locale = fallback_locale
set_key(api_key)
set_cache('null')
def init_tmdb3(alternative_lang=None):
tmdb3.set_key('1f834eb425728133b9a2c1c0c82980eb')
tmdb3.set_cache('null')
lng = alternative_lang or config.plugins.tmbd.locale.value
try:
tmdb3.set_locale(lng, lng.upper())
except:
tmdb3.set_locale('en', 'GB')
return tmdb3
def __init__(self):
addEvent('movie.info', self.getInfo, priority = 1)
addEvent('movie.info_by_tmdb', self.getInfo)
addEvent('info.search', self.search, priority = 1)
addEvent('movie.search', self.search, priority = 1)
# Configure TMDB settings
tmdb3.set_key(self.conf('api_key'))
tmdb3.set_locale(self.conf('locale', None))
tmdb3.set_cache('null')
def setUp(self):
set_key(FAKE_API_KEY)
if self.cache_file:
set_cache(filename=self.cache_file)
else:
set_cache(engine='null')
for mock_key in self.mock_requests:
mock_json_file, mock_url = self.mock_data[mock_key]
body = get_json_result(join(LOCALDIR, 'data', mock_json_file))
HTTPretty.register_uri(HTTPretty.GET,
mock_url.format(base_url=self.base_url,
api=self.api_key),
body=body)
def get_all_shows():
tmdb3.set_key(api_key)
tmdb3.set_cache('null')
tmdb3.set_cache(filename='/full/path/to/cache') # the 'file' engine is assumed
tmdb3.set_cache(filename='tmdb3.cache') # relative paths are put in /tmp
tmdb3.set_cache(engine='file', filename='~/.tmdb3cache')
with open(names_file) as f:
content = f.readlines()
show_img_urls = []
for raw in content:
show_name = raw.replace("\n", "")
print show_name
(show, show_seasons, show_episodes) = get_show_data(show_name)
with open(shows_json, 'a') as show_file:
json.dump(show, show_file, sort_keys=True, indent=4, separators=(',', ': '))
show_file.writelines(",\n")
with open(seasons_json, 'a') as season_file:
for show_season in show_seasons:
json.dump(show_season, season_file, sort_keys=True, indent=4, separators=(',', ': '))
season_file.writelines(",\n")
with open(episodes_json, 'a') as episode_file:
for show_episode in show_episodes:
json.dump(show_episode, episode_file, sort_keys=True, indent=4, separators=(',', ': '))
episode_file.writelines(",\n")
show_seasons = None
show_episodes = None
show_img_urls.append((show['name'], show['remote_img_url'], show['img_filename']))
return show_img_urls
def __init__(self, title, title_modifier, trailer_modifier):
from tmdb3 import set_key
from tmdb3 import set_cache
from tmdb3 import searchMovie
from tmdb3 import Movie, Collection, Person, Series
set_cache('null')
set_key('a7b2a24af9fbe91fc6003d4d111b3b37')
self.search_results = searchMovie(
title
) #self.search_results is a list returned by the searchMovie function after passing in the title variable.
self.video_id = self.search_results[
title_modifier].id # to use any of the provided methods from tmdb3 we need to get the movie's ID.
self.title = Movie(
self.video_id).title # method to return movies title.
def __init__(self):
log.trace('__init__ method: Started')
super(CleanUp, self).__init__()
trakt_auth_group = DadVision.cmdoptions.parser.add_argument_group("Profiles", description=None)
trakt_auth_group.add_argument("-y", "--grumpy", dest="HostName",
action="append_const", const="grumpy",
help="Entries for Grumpy")
trakt_auth_group.add_argument("-t", "--tigger", dest="HostName",
action="append_const", const="tigger",
help="Entires for Tigger")
trakt_auth_group.add_argument("-g", "--goofy", dest="HostName",
action="append_const", const="goofy",
help="Entries for Goofy")
trakt_auth_group.add_argument("-e", "--eeyore", dest="HostName",
action="append_const", const="eeyore",
help="Entries for Eeore")
trakt_auth_group.add_argument("-p", "--pluto", dest="HostName",
action="append_const", const="pluto",
help="Entries for Pluto")
trakt_options_group = DadVision.cmdoptions.parser.add_argument_group("Options", description=None)
trakt_options_group.add_argument("-c", "--clear", dest="Clear", nargs='*',
action='store', default='None',
help='Clear/Delete all entries in requested area: shows, movies')
trakt_options_group.add_argument("-l", "--list", dest="list", nargs='*',
action='store', default='None',
help='Clear/Delete all entries in requested area: shows, movies')
tmdb3.set_key('587c13e576f991c0a653f783b290a065')
tmdb3.set_cache(filename='tmdb3.cache')
self.db = api.TVDB("959D8E76B796A1FB")
#self.tmdbinfo = TMDBInfo()
self._collectedShows = []
self._watchedShows = []
self._watchlistShows = []
self._trakt_sdtv = []
self._trakt_720P = []
self._trakt_list = []
self.errorLog = []
return
def init_tmdb3():
tmdb3.set_key(config['apikey'])
tmdb3.set_cache('null')
lng = config['locale']
if lng == 'en':
tmdb3.set_locale(lng, 'US')
elif lng == 'el':
tmdb3.set_locale(lng, 'GR')
elif lng == 'cs':
tmdb3.set_locale(lng, 'CZ')
elif lng == 'da':
tmdb3.set_locale(lng, 'DK')
elif lng == 'uk':
tmdb3.set_locale('en', 'GB')
elif lng == 'fy':
tmdb3.set_locale(lng, 'NL')
else:
tmdb3.set_locale(lng, lng.upper())
print('tmdbv3 locale', tmdb3.get_locale())
return tmdb3
def __init__(self, title, title_modifier, trailer_modifier):
Video.__init__(self, title, title_modifier, trailer_modifier)
# was having trouble with inhereting the imported tmbd3 module from class video. So reimported it.
from tmdb3 import set_key
from tmdb3 import set_cache
from tmdb3 import searchMovie
from tmdb3 import Movie, Collection, Person, Series
set_cache('null')
set_key('a7b2a24af9fbe91fc6003d4d111b3b37')
self.tagline = Movie(
self.video_id
).tagline # returns short 'tagline' description of movie.
self.storyline = Movie(
self.video_id).overview # returns longer description of movie.
self.runtime = Movie(self.video_id).runtime # total runtime in minutes
self.poster_image_url = Movie(self.video_id).poster.geturl(
) # returns url of .jpg of the movie poster
self.trailer_youtube_url = Movie(
self.video_id).youtube_trailers[trailer_modifier].geturl(
) # youtube trailer.
self.release_date = Movie(self.video_id).releasedate
def init_tmdb3(alternative_lang=None):
import tmdb3
tmdb3.set_key('1f834eb425728133b9a2c1c0c82980eb')
tmdb3.set_cache('null')
lng = alternative_lang or config.plugins.tmbd.locale.value
if lng == 'en':
tmdb3.set_locale(lng, 'US')
elif lng == 'el':
tmdb3.set_locale(lng, 'GR')
elif lng == 'cs':
tmdb3.set_locale(lng, 'CZ')
elif lng == 'da':
tmdb3.set_locale(lng, 'DK')
elif lng == 'uk':
tmdb3.set_locale('en', 'GB')
elif lng == 'fy':
tmdb3.set_locale(lng, 'NL')
else:
try:
tmdb3.set_locale(lng, lng.upper())
except:
tmdb3 = None
return tmdb3
def init_tmdb3(alternative_lang=None):
import tmdb3
tmdb3.set_key('1f834eb425728133b9a2c1c0c82980eb')
tmdb3.set_cache('null')
lng = alternative_lang or config.plugins.tmbd.locale.value
if lng == 'en':
tmdb3.set_locale(lng, 'US')
elif lng == 'el':
tmdb3.set_locale(lng, 'GR')
elif lng == 'cs':
tmdb3.set_locale(lng, 'CZ')
elif lng == 'da':
tmdb3.set_locale(lng, 'DK')
elif lng == 'uk':
tmdb3.set_locale('en', 'GB')
elif lng == 'fy':
tmdb3.set_locale(lng, 'NL')
else:
try:
tmdb3.set_locale(lng, lng.upper())
except:
tmdb3 = None
return tmdb3
def tmdb_info(self):
from tmdb3 import searchSeries, set_cache, set_key, set_locale, get_locale
set_key('587c13e576f991c0a653f783b290a065')
set_cache(filename='/tmp/tmdb3.cache')
set_locale('en', 'us')
_locale = get_locale()
try:
tmdb_results = searchSeries(self.title,
first_air_date_year=self.year,
locale=_locale)
for _series in tmdb_results:
if self.country:
if not self.country in _series.origin_countries:
continue
if self.year:
if not self.year == _series.first_air_date.year():
continue
if self.title == decode(_series.name):
raise GetOutOfLoop(_series)
raise SeriesNotFound("Series Not Found in TMDb: {}".format(
self.title))
except GetOutOfLoop, e:
_series = e.message
alias = {
'name': 'title',
'id': 'tmdb_id',
'origin_countries': 'country'
}
for key in dir(_series):
if key[:1] == '_': continue
if key in alias: key2 = alias[key]
else: key2 = key
if not hasattr(self, key2):
continue
setattr(self, key2, decode(getattr(_series, key)))
class TMDB(Movie):
tmdb3.set_key('587c13e576f991c0a653f783b290a065')
tmdb3.set_cache(filename='tmdb3.cache')
def __init__(self, **kwargs):
super(TMDB, self).__init__(**kwargs)
return
def tmdb(self):
if self.year:
_movie = '{} ({})'.format(self.title, self.year)
try:
self.review_entries(list(tmdb3.searchMovieWithYear(_movie)))
return
except MovieNotFound:
pass
self.review_entries(list(tmdb3.searchMovie(self.title)))
return self
def review_entries(self, tmdb_results):
"""
:param tmdb_results:
:param chkyear:
:return: :raise MovieNotFound:
"""
try:
for _movie in tmdb_results:
_title = decode(_movie.title)
if self.year:
if matching(" ".join([_title.lower(), str(_movie.releasedate.year)]),
" ".join([self.title.lower(), str(self.year)])):
self.title = _title
raise GetOutOfLoop(_movie)
if matching(_title.lower(), self.title.lower()):
self.title = _title
raise GetOutOfLoop(_movie)
else:
# Check Alternate Titles: list(AlternateTitle) alternate_titles
for _alternate_title in _movie.alternate_titles:
log.trace('Check Alternate Titles: {}'.format(_alternate_title))
_alternate_title = decode(_alternate_title)
if matching(_alternate_title, self.title):
_movie.alternate_titles.append(_title)
self.title = _alternate_title
self.alternate_title = _movie.alternate_titles
raise GetOutOfLoop(_movie)
log.warn("Movie Not Found in TMDb: {}".format(self.title))
raise MovieNotFound("Movie Not Found in TMDb: {}".format(self.title))
except GetOutOfLoop, e:
_movie = e.message
if _movie.releasedate:
if self.year:
if (-2 < (self.year - _movie.releasedate.year) < 2):
self.year = _movie.releasedate.year
else:
msg = "Movie name found, Years too far apart: {} - {}/{}".format(self.title,
self.year,
_movie.releasedate.year)
log.warning(msg)
raise MovieNotFound(msg)
else:
self.year = _movie.releasedate.year
log.trace("Movie Located in TMDB")
self.tmdb_id = _movie.id
self.imdb_id = _movie.imdb
self.slug = self.title
self.cast = _movie.cast
if hasattr(_movie, "alternate_titles"):
self.alternate_title = _movie.alternate_titles
return
def add_tmdb_movie(id):
set_key('c97c17e619252e35bad2e158d4211fcc')
set_locale('ru', 'ru')
set_cache(engine='file', filename='/home/swasher/kinobox/.tmdb3cache')
m = Movi()
try:
mov = Movie(id)
except:
pass
#обработать (не нашло фильм, или ппц ваще) sys.exc_info()[0].__dict__
m.title=mov.title
m.overview=mov.overview
m.origtitle=mov.originaltitle
m.tmdb_id=mov.id
m.year=str(mov.releasedate)[0:4]
m.seen=False
m.seendate=datetime.date.today()
m.myrating=0
m.stored=True
m.adddate=datetime.date.today()
m.tagline=mov.tagline
m.save()
try:
poster = urllib.urlretrieve(mov.poster.geturl(size='w92'))
m.poster.save('poster_'+'w92_'+str(id)+'.jpg', File(open(poster[0])))
except:
#отсутствует постер
#print sys.exc_info()[0].__dict__
#{'__module__': 'tmdb3.tmdb_exceptions', '__doc__': None}
#print 'cant retrieve'
# если не обрабатывать - просто получается пустое поле, его можно обработать дальше
poster = urllib.urlretrieve(mov.poster.geturl(size='w92'))
m.poster.save('poster_'+'w92_'+str(id)+'.jpg', File(open(poster[0])))
pass
try:
posterbig = urllib.urlretrieve(mov.poster.geturl(size='w500'))
m.posterbig.save('poster_'+'w500_'+str(id)+'.jpg', File(open(posterbig[0])))
except:
pass
#get counries
countries = mov.countries
l = ''
for country in countries:
if country.name=='United States of America':
l+='USA'+', '
else:
l+=country.name+', '
m.countries=l[:-2]
genres = mov.genres
genre_list=[]
for genre in genres:
genre_list.append(genre.name)
for genre in genre_list:
try:
# пытаемся найти жанр по названию
gen=Genre.objects.filter(genre=genre)[0]
except:
# Если не найден, возникает исключение, и мы создаем новый жанр.
# Исключение возникает из-за попытки взять нулевой элемент пустого тупла
g=Genre(genre=genre)
g.save()
gen=Genre.objects.filter(genre=genre)[0]
m.genres.add(gen)
m.save()
cast=mov.cast
for actor in cast:
try:
pers=Person.objects.filter(name=actor.name)[0]
except:
#если актера actor.name нет в базе, то вызывется исключение, актер добавляется, и обзывется как pers
p = Person(name=actor.name, tmdb_id=actor.id)
p.save()
pers=Person.objects.filter(name=actor.name)[0]
#если актера до сих пор небыло, то добавляем фото
#todo в дальнейшем это убрать - сделать даунлоад фото, когда актер star-рится
try:
photo = urllib.urlretrieve(actor.profile.geturl(size='w45'))
p.photo.save('photo_'+'w45_'+str(actor.id)+'.jpg', File(open(photo[0])))
except:
#отсутствует постер
#print sys.exc_info()[0].__dict__
#{'__module__': 'tmdb3.tmdb_exceptions', '__doc__': None}
#print 'cant retrieve'
# если не обрабатывать - просто получается пустое поле, его можно обработать дальше
pass
# В это месте у нас есть объекты фильма 'm' и актера 'pers'
d = Duty(person=pers, movi=m, department='', character=actor.character, job='', order=actor.order)
d.save()
def init_tmdb():
tmdb3.set_key(settings.TMDB_KEY)
tmdb3.set_cache(filename=settings.TMDB_CACHE_PATH)
tmdb3.set_locale(*settings.LOCALES[settings.LANGUAGE_CODE])
return tmdb3
def init_tmdb():
"""Initialize TMDb api"""
tmdb3.set_key(config.cfg['API_KEY'])
tmdb3.set_cache(engine='file', filename=config.cfg['CACHEPATH']+'/.tmdb3cache')
tmdb3.set_locale(config.cfg['LANG'], config.cfg['COUNTRY'])
from tmdb3 import set_key
import json
import requests
import os
API = '259f7fc6b26292afaf6ec1dabe6fdd6a'
set_key(API)
from tmdb3 import set_cache
set_cache('null')
set_cache(filename='/full/path/to/cache') # the 'file' engine is assumed
set_cache(filename='tmdb3.cache') # relative paths are put in /tmp
set_cache(engine='file', filename='~/.tmdb3cache')
from tmdb3 import get_locale, set_locale
set_locale()
print(get_locale())
#locale has bet set to english and United States...yes
print
print
'''import urllib2 #import Request#, urlopen headers = {"Accept": "application/json"}
request = urllib2.Request("https://api.themoviedb.org/3/search/movie?api_key="+API+"&query=Foxx")
responsebody = urllib2.urlopen(request).read()
print responsebody
print
print'''
import tmdb3
search = 'Hanks'
a = tmdb3.searchPerson(search)
try:
import tmdb3
except ImportError:
raise plugin.DependencyError(issued_by='api_tmdb', missing='tmdb3',
message='TMDB requires https://github.com/wagnerrp/pytmdb3')
log = logging.getLogger('api_tmdb')
Base = db_schema.versioned_base('api_tmdb', 0)
# This is a FlexGet API key
tmdb3.tmdb_api.set_key('bdfc018dbdb7c243dc7cb1454ff74b95')
tmdb3.locales.set_locale("en", "us", True)
# There is a bug in tmdb3 library, where it uses the system encoding for query parameters, tmdb expects utf-8 #2392
tmdb3.locales.syslocale.encoding = 'utf-8'
tmdb3.set_cache('null')
@db_schema.upgrade('api_tmdb')
def upgrade(ver, session):
if ver is None:
log.info('Adding columns to tmdb cache table, marking current cache as expired.')
table_add_column('tmdb_movies', 'runtime', Integer, session)
table_add_column('tmdb_movies', 'tagline', Unicode, session)
table_add_column('tmdb_movies', 'budget', Integer, session)
table_add_column('tmdb_movies', 'revenue', Integer, session)
table_add_column('tmdb_movies', 'homepage', String, session)
table_add_column('tmdb_movies', 'trailer', String, session)
# Mark all cached movies as expired, so new fields get populated next lookup
movie_table = table_schema('tmdb_movies', session)
session.execute(movie_table.update(values={'updated': datetime(1970, 1, 1)}))
from tmdb3 import set_cache
from tmdb3 import Movie
import collections
import psycopg2
import csv
import tmdbsimple as tmdb
import distance
path="D:\hiwimov\meta_Movies_&_TV.txt"
path1='D:\hiwimov/tempo.txt'
import unicodedata
conn = psycopg2.connect(database="miner", user="******", password="******", host="192.168.32.161", port="5432")
cursor = conn.cursor()
temp = 1.0
set_key('**********')
tmdb.API_KEY = '*********'
set_cache('null')
with open(path,'r') as file:
for i in file:
asin_matches = re.findall("(?<=\"asin\"\: \")[0-9A-Za-z\'\s()-\:\;\.]{1,}",i)
im_url=re.findall('http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+', i)
title_matches = re.findall("(?<=\"title\"\: \")[0-9A-Za-z\'\s()\-\:\;\.]{1,}",i)
for title_amazon in title_matches:
for id_amazon in asin_matches:
for url_amazon in im_url:
search = tmdb.Search()
response = search.movie(query=title_amazon)
for s in search.results:
title_match=s['title']
uni_ignore=unicodedata.normalize('NFKD', title_match).encode('ascii','ignore')
try:
import tmdb3
except ImportError:
raise plugin.DependencyError(issued_by='api_tmdb', missing='tmdb3',
message='TMDB requires https://github.com/wagnerrp/pytmdb3')
log = logging.getLogger('api_tmdb')
Base = db_schema.versioned_base('api_tmdb', 0)
# This is a FlexGet API key
tmdb3.tmdb_api.set_key('bdfc018dbdb7c243dc7cb1454ff74b95')
tmdb3.locales.set_locale("en", "us", True)
# There is a bug in tmdb3 library, where it uses the system encoding for query parameters, tmdb expects utf-8 #2392
tmdb3.locales.syslocale.encoding = 'utf-8'
tmdb3.set_cache('null')
@db_schema.upgrade('api_tmdb')
def upgrade(ver, session):
if ver is None:
log.info('Adding columns to tmdb cache table, marking current cache as expired.')
table_add_column('tmdb_movies', 'runtime', Integer, session)
table_add_column('tmdb_movies', 'tagline', Unicode, session)
table_add_column('tmdb_movies', 'budget', Integer, session)
table_add_column('tmdb_movies', 'revenue', Integer, session)
table_add_column('tmdb_movies', 'homepage', String, session)
table_add_column('tmdb_movies', 'trailer', String, session)
# Mark all cached movies as expired, so new fields get populated next lookup
movie_table = table_schema('tmdb_movies', session)
session.execute(movie_table.update(values={'updated': datetime(1970, 1, 1)}))
import SocketServer
from handler import HCIRequestHandler
from tmdb3 import set_key
from tmdb3 import set_cache
Handler = HCIRequestHandler
server = SocketServer.TCPServer(('0.0.0.0', 8080), Handler)
set_key('43b0a2c458adc3c7d5968151b9599958')
set_cache('null') #TODO consider adding cache mechanism
server.serve_forever()
def __init__(self):
log.trace('__init__ method: Started')
super(CleanUp, self).__init__()
trakt_auth_group = DadVision.cmdoptions.parser.add_argument_group(
"Profiles", description=None)
trakt_auth_group.add_argument("-y",
"--grumpy",
dest="HostName",
action="append_const",
const="grumpy",
help="Entries for Grumpy")
trakt_auth_group.add_argument("-t",
"--tigger",
dest="HostName",
action="append_const",
const="tigger",
help="Entires for Tigger")
trakt_auth_group.add_argument("-g",
"--goofy",
dest="HostName",
action="append_const",
const="goofy",
help="Entries for Goofy")
trakt_auth_group.add_argument("-e",
"--eeyore",
dest="HostName",
action="append_const",
const="eeyore",
help="Entries for Eeore")
trakt_auth_group.add_argument("-p",
"--pluto",
dest="HostName",
action="append_const",
const="pluto",
help="Entries for Pluto")
trakt_options_group = DadVision.cmdoptions.parser.add_argument_group(
"Options", description=None)
trakt_options_group.add_argument(
"-c",
"--clear",
dest="Clear",
nargs='*',
action='store',
default='None',
help='Clear/Delete all entries in requested area: shows, movies')
trakt_options_group.add_argument(
"-l",
"--list",
dest="list",
nargs='*',
action='store',
default='None',
help='Clear/Delete all entries in requested area: shows, movies')
tmdb3.set_key('587c13e576f991c0a653f783b290a065')
tmdb3.set_cache(filename='tmdb3.cache')
self.db = api.TVDB("959D8E76B796A1FB")
#self.tmdbinfo = TMDBInfo()
self._collectedShows = []
self._watchedShows = []
self._watchlistShows = []
self._trakt_sdtv = []
self._trakt_720P = []
self._trakt_list = []
self.errorLog = []
return
import media
from tmdb3 import set_key
from tmdb3 import set_cache
from tmdb3 import Movie as Movie_db
import os
import fresh_tomatoes
set_key('XXX') #Insert API key for TMDB3 website
set_cache('null')
list_of_movies = []
for i in range(11, 23):
#Taking 12 movies from Movie_db and storing the data in list_of movies
curr_movie = Movie_db(i)
title = (curr_movie.title)
story_line = (curr_movie.overview)
poster = (curr_movie.poster.geturl())
trailer = (curr_movie.youtube_trailers[0].geturl())
movie_instance = media.Movie(title, story_line, poster, trailer)
list_of_movies.append(
movie_instance) #adding instances of Movie() class to list_of_movies
os.chdir(r"C:\Users\venkata.pushpak\Documents\Udacity\FSD\Project 1")
fresh_tomatoes.open_movies_page(list_of_movies)
def __init__(self, api_key, movie_id):
tmbd.set_key(api_key)
tmbd.set_cache('null')
tmbd.set_locale('en', 'US')
self.movie = tmbd.Movie(movie_id)
m.genres = newGenre
for p in d.cast[:10]:
newPerson = pmovie.person(m.cast)
newPerson.id = p.id
newPerson.name = p.name
m.cast = newPerson
return m
# Main
args = parseArguments()
db = psql.movieDB(dbFilename)
set_cache(engine='file', filename='/tmp/tmdb.cache')
set_key('f5a1e6218573b468f59d654ebe6269f9')
mFlask = Flask(__name__)
@mFlask.route('/')
def rootEndpoint():
return 'Pvice root endpoint\n'
@mFlask.route('/search/<pattern>')
def searchEndpoint(pattern):
return 'Search endpoint'
@mFlask.route('/movieSearch/<movie>')
def movieSearchEndpoint(movie):
search = searchMovie(movie)
import media
# Visit https://github.com/wagnerrp/pytmdb3 for more info
from tmdb3 import set_key
from tmdb3 import set_cache
from tmdb3 import set_locale
from tmdb3 import List
# Set personal key to API access
set_key('0ba74440350bf374cee4a9b89f7249a8')
# Caches data to limit excessive usage against API server
set_cache('null')
set_cache(filename='/full/path/to/cache')
set_cache(filename='tmdb3.cfrom random import randintache')
set_cache(engine='file', filename='~/.tmdb3cache')
# Set language and country configuration for API data
set_locale('en', 'us')
now_playing = []
coming_soon = []
modern_classics = []
classics = []
for x in range(0, len(List(35555).members)):
media_title = List(35555).members[x].title.replace(' ', '_')
media_title = media.Media(
List(35555).members[x].title,
