Ruud
12 years ago
17 changed files with 2829 additions and 853 deletions
@ -1,740 +0,0 @@ |
|||
#!/usr/bin/env python |
|||
#-*- coding:utf-8 -*- |
|||
#author:doganaydin /// forked from dbr/Ben |
|||
#project:themoviedb |
|||
#repository:http://github.com/doganaydin/themoviedb |
|||
#license: LGPLv2 http://www.gnu.org/licenses/lgpl.html |
|||
|
|||
"""An interface to the themoviedb.org API""" |
|||
|
|||
__author__ = "doganaydin" |
|||
__version__ = "0.5" |
|||
|
|||
|
|||
config = {} |
|||
|
|||
def configure(api_key): |
|||
config['apikey'] = api_key |
|||
config['urls'] = {} |
|||
config['urls']['movie.search'] = "http://api.themoviedb.org/2.1/Movie.search/en/xml/%(apikey)s/%%s" % (config) |
|||
config['urls']['movie.getInfo'] = "http://api.themoviedb.org/2.1/Movie.getInfo/en/xml/%(apikey)s/%%s" % (config) |
|||
config['urls']['media.getInfo'] = "http://api.themoviedb.org/2.1/Media.getInfo/en/xml/%(apikey)s/%%s/%%s" % (config) |
|||
config['urls']['imdb.lookUp'] = "http://api.themoviedb.org/2.1/Movie.imdbLookup/en/xml/%(apikey)s/%%s" % (config) |
|||
config['urls']['movie.browse'] = "http://api.themoviedb.org/2.1/Movie.browse/en-US/xml/%(apikey)s?%%s" % (config) |
|||
|
|||
import os, struct, urllib, urllib2, xml.etree.cElementTree as ElementTree |
|||
|
|||
class TmdBaseError(Exception): |
|||
pass |
|||
|
|||
class TmdNoResults(TmdBaseError): |
|||
pass |
|||
|
|||
class TmdHttpError(TmdBaseError): |
|||
pass |
|||
|
|||
class TmdXmlError(TmdBaseError): |
|||
pass |
|||
|
|||
class TmdConfigError(TmdBaseError): |
|||
pass |
|||
|
|||
def opensubtitleHashFile(name): |
|||
"""Hashes a file using OpenSubtitle's method. |
|||
> In natural language it calculates: size + 64bit chksum of the first and |
|||
> last 64k (even if they overlap because the file is smaller than 128k). |
|||
A slightly more Pythonic version of the Python solution on.. |
|||
http://trac.opensubtitles.org/projects/opensubtitles/wiki/HashSourceCodes |
|||
""" |
|||
longlongformat = 'q' |
|||
bytesize = struct.calcsize(longlongformat) |
|||
|
|||
f = open(name, "rb") |
|||
|
|||
filesize = os.path.getsize(name) |
|||
fhash = filesize |
|||
|
|||
if filesize < 65536 * 2: |
|||
raise ValueError("File size must be larger than %s bytes (is %s)" % (65536 * 2, filesize)) |
|||
|
|||
for x in range(65536 / bytesize): |
|||
buf = f.read(bytesize) |
|||
(l_value,) = struct.unpack(longlongformat, buf) |
|||
fhash += l_value |
|||
fhash = fhash & 0xFFFFFFFFFFFFFFFF # to remain as 64bit number |
|||
|
|||
f.seek(max(0, filesize - 65536), 0) |
|||
for x in range(65536 / bytesize): |
|||
buf = f.read(bytesize) |
|||
(l_value,) = struct.unpack(longlongformat, buf) |
|||
fhash += l_value |
|||
fhash = fhash & 0xFFFFFFFFFFFFFFFF |
|||
|
|||
f.close() |
|||
return "%016x" % fhash |
|||
|
|||
class XmlHandler: |
|||
"""Deals with retrieval of XML files from API""" |
|||
def __init__(self, url): |
|||
self.url = url |
|||
|
|||
def _grabUrl(self, url): |
|||
try: |
|||
urlhandle = urllib2.urlopen(url) |
|||
except IOError, errormsg: |
|||
raise TmdHttpError(errormsg) |
|||
if urlhandle.code >= 400: |
|||
raise TmdHttpError("HTTP status code was %d" % urlhandle.code) |
|||
return urlhandle.read() |
|||
|
|||
def getEt(self): |
|||
xml = self._grabUrl(self.url) |
|||
try: |
|||
et = ElementTree.fromstring(xml) |
|||
except SyntaxError, errormsg: |
|||
raise TmdXmlError(errormsg) |
|||
return et |
|||
|
|||
class SearchResults(list): |
|||
"""Stores a list of Movie's that matched the search""" |
|||
def __repr__(self): |
|||
return "<Search results: %s>" % (list.__repr__(self)) |
|||
|
|||
class MovieResult(dict): |
|||
"""A dict containing the information about a specific search result""" |
|||
def __repr__(self): |
|||
return "<MovieResult: %s (%s)>" % (self.get("name"), self.get("released")) |
|||
|
|||
def info(self): |
|||
"""Performs a MovieDb.getMovieInfo search on the current id, returns |
|||
a Movie object |
|||
""" |
|||
cur_id = self['id'] |
|||
info = MovieDb().getMovieInfo(cur_id) |
|||
return info |
|||
|
|||
class Movie(dict): |
|||
"""A dict containing the information about the film""" |
|||
def __repr__(self): |
|||
return "<MovieResult: %s (%s)>" % (self.get("name"), self.get("released")) |
|||
|
|||
class Categories(dict): |
|||
"""Stores category information""" |
|||
def set(self, category_et): |
|||
"""Takes an elementtree Element ('category') and stores the url, |
|||
using the type and name as the dict key. |
|||
For example: |
|||
<category type="genre" url="http://themoviedb.org/encyclopedia/category/80" name="Crime"/> |
|||
..becomes: |
|||
categories['genre']['Crime'] = 'http://themoviedb.org/encyclopedia/category/80' |
|||
""" |
|||
_type = category_et.get("type") |
|||
name = category_et.get("name") |
|||
url = category_et.get("url") |
|||
self.setdefault(_type, {})[name] = url |
|||
self[_type][name] = url |
|||
|
|||
class Studios(dict): |
|||
"""Stores category information""" |
|||
def set(self, studio_et): |
|||
"""Takes an elementtree Element ('studio') and stores the url, |
|||
using the name as the dict key. |
|||
For example: |
|||
<studio url="http://www.themoviedb.org/encyclopedia/company/20" name="Miramax Films"/> |
|||
..becomes: |
|||
studios['name'] = 'http://www.themoviedb.org/encyclopedia/company/20' |
|||
""" |
|||
name = studio_et.get("name") |
|||
url = studio_et.get("url") |
|||
self[name] = url |
|||
|
|||
class Countries(dict): |
|||
"""Stores country information""" |
|||
def set(self, country_et): |
|||
"""Takes an elementtree Element ('country') and stores the url, |
|||
using the name and code as the dict key. |
|||
For example: |
|||
<country url="http://www.themoviedb.org/encyclopedia/country/223" name="United States of America" code="US"/> |
|||
..becomes: |
|||
countries['code']['name'] = 'http://www.themoviedb.org/encyclopedia/country/223' |
|||
""" |
|||
code = country_et.get("code") |
|||
name = country_et.get("name") |
|||
url = country_et.get("url") |
|||
self.setdefault(code, {})[name] = url |
|||
|
|||
class Image(dict): |
|||
"""Stores image information for a single poster/backdrop (includes |
|||
multiple sizes) |
|||
""" |
|||
def __init__(self, _id, _type, size, url): |
|||
self['id'] = _id |
|||
self['type'] = _type |
|||
|
|||
def largest(self): |
|||
for csize in ["original", "mid", "cover", "thumb"]: |
|||
if csize in self: |
|||
return csize |
|||
|
|||
def __repr__(self): |
|||
return "<Image (%s for ID %s)>" % (self['type'], self['id']) |
|||
|
|||
class ImagesList(list): |
|||
"""Stores a list of Images, and functions to filter "only posters" etc""" |
|||
def set(self, image_et): |
|||
"""Takes an elementtree Element ('image') and stores the url, |
|||
along with the type, id and size. |
|||
Is a list containing each image as a dictionary (which includes the |
|||
various sizes) |
|||
For example: |
|||
<image type="poster" size="original" url="http://images.themoviedb.org/posters/4181/67926_sin-city-02-color_122_207lo.jpg" id="4181"/> |
|||
..becomes: |
|||
images[0] = {'id':4181', 'type': 'poster', 'original': 'http://images.themov...'} |
|||
""" |
|||
_type = image_et.get("type") |
|||
_id = image_et.get("id") |
|||
size = image_et.get("size") |
|||
url = image_et.get("url") |
|||
cur = self.find_by('id', _id) |
|||
if len(cur) == 0: |
|||
nimg = Image(_id = _id, _type = _type, size = size, url = url) |
|||
self.append(nimg) |
|||
elif len(cur) == 1: |
|||
cur[0][size] = url |
|||
else: |
|||
raise ValueError("Found more than one poster with id %s, this should never happen" % (_id)) |
|||
|
|||
def find_by(self, key, value): |
|||
ret = [] |
|||
for cur in self: |
|||
if cur[key] == value: |
|||
ret.append(cur) |
|||
return ret |
|||
|
|||
@property |
|||
def posters(self): |
|||
return self.find_by('type', 'poster') |
|||
|
|||
@property |
|||
def backdrops(self): |
|||
return self.find_by('type', 'backdrop') |
|||
|
|||
class CrewRoleList(dict): |
|||
"""Stores a list of roles, such as director, actor etc |
|||
>>> import tmdb |
|||
>>> tmdb.getMovieInfo(550)['cast'].keys()[:5] |
|||
['casting', 'producer', 'author', 'sound editor', 'actor'] |
|||
""" |
|||
pass |
|||
|
|||
class CrewList(list): |
|||
"""Stores list of crew in specific role |
|||
>>> import tmdb |
|||
>>> tmdb.getMovieInfo(550)['cast']['author'] |
|||
[<author (id 7468): Chuck Palahniuk>, <author (id 7469): Jim Uhls>] |
|||
""" |
|||
pass |
|||
|
|||
class Person(dict): |
|||
"""Stores information about a specific member of cast""" |
|||
def __init__(self, job, _id, name, character, url): |
|||
self['job'] = job |
|||
self['id'] = _id |
|||
self['name'] = name |
|||
self['character'] = character |
|||
self['url'] = url |
|||
|
|||
def __repr__(self): |
|||
if self['character'] is None or self['character'] == "": |
|||
return "<%(job)s (id %(id)s): %(name)s>" % self |
|||
else: |
|||
return "<%(job)s (id %(id)s): %(name)s (as %(character)s)>" % self |
|||
|
|||
class MovieDb: |
|||
"""Main interface to www.themoviedb.com |
|||
The search() method searches for the film by title. |
|||
The getMovieInfo() method retrieves information about a specific movie using themoviedb id. |
|||
""" |
|||
def _parseSearchResults(self, movie_element): |
|||
cur_movie = MovieResult() |
|||
cur_images = ImagesList() |
|||
for item in movie_element.getchildren(): |
|||
if item.tag.lower() == "images": |
|||
for subitem in item.getchildren(): |
|||
cur_images.set(subitem) |
|||
else: |
|||
cur_movie[item.tag] = item.text |
|||
cur_movie['images'] = cur_images |
|||
return cur_movie |
|||
|
|||
def _parseMovie(self, movie_element): |
|||
cur_movie = Movie() |
|||
cur_categories = Categories() |
|||
cur_studios = Studios() |
|||
cur_countries = Countries() |
|||
cur_images = ImagesList() |
|||
cur_cast = CrewRoleList() |
|||
for item in movie_element.getchildren(): |
|||
if item.tag.lower() == "categories": |
|||
for subitem in item.getchildren(): |
|||
cur_categories.set(subitem) |
|||
elif item.tag.lower() == "studios": |
|||
for subitem in item.getchildren(): |
|||
cur_studios.set(subitem) |
|||
elif item.tag.lower() == "countries": |
|||
for subitem in item.getchildren(): |
|||
cur_countries.set(subitem) |
|||
elif item.tag.lower() == "images": |
|||
for subitem in item.getchildren(): |
|||
cur_images.set(subitem) |
|||
elif item.tag.lower() == "cast": |
|||
for subitem in item.getchildren(): |
|||
job = subitem.get("job").lower() |
|||
p = Person( |
|||
job = job, |
|||
_id = subitem.get("id"), |
|||
name = subitem.get("name"), |
|||
character = subitem.get("character"), |
|||
url = subitem.get("url"), |
|||
) |
|||
cur_cast.setdefault(job, CrewList()).append(p) |
|||
else: |
|||
cur_movie[item.tag] = item.text |
|||
|
|||
cur_movie['categories'] = cur_categories |
|||
cur_movie['studios'] = cur_studios |
|||
cur_movie['countries'] = cur_countries |
|||
cur_movie['images'] = cur_images |
|||
cur_movie['cast'] = cur_cast |
|||
return cur_movie |
|||
|
|||
def search(self, title): |
|||
"""Searches for a film by its title. |
|||
Returns SearchResults (a list) containing all matches (Movie instances) |
|||
""" |
|||
title = urllib.quote(title.encode("utf-8")) |
|||
url = config['urls']['movie.search'] % (title) |
|||
etree = XmlHandler(url).getEt() |
|||
search_results = SearchResults() |
|||
for cur_result in etree.find("movies").findall("movie"): |
|||
cur_movie = self._parseSearchResults(cur_result) |
|||
search_results.append(cur_movie) |
|||
return search_results |
|||
|
|||
def getMovieInfo(self, id): |
|||
"""Returns movie info by it's TheMovieDb ID. |
|||
Returns a Movie instance |
|||
""" |
|||
url = config['urls']['movie.getInfo'] % (id) |
|||
etree = XmlHandler(url).getEt() |
|||
moviesTree = etree.find("movies").findall("movie") |
|||
|
|||
if len(moviesTree) == 0: |
|||
raise TmdNoResults("No results for id %s" % id) |
|||
return self._parseMovie(moviesTree[0]) |
|||
|
|||
def mediaGetInfo(self, hash, size): |
|||
"""Used to retrieve specific information about a movie but instead of |
|||
passing a TMDb ID, you pass a file hash and filesize in bytes |
|||
""" |
|||
url = config['urls']['media.getInfo'] % (hash, size) |
|||
etree = XmlHandler(url).getEt() |
|||
moviesTree = etree.find("movies").findall("movie") |
|||
if len(moviesTree) == 0: |
|||
raise TmdNoResults("No results for hash %s" % hash) |
|||
return [self._parseMovie(x) for x in moviesTree] |
|||
|
|||
def imdbLookup(self, id = 0, title = False): |
|||
if not config.get('apikey'): |
|||
raise TmdConfigError("API Key not set") |
|||
if id > 0: |
|||
url = config['urls']['imdb.lookUp'] % (id) |
|||
else: |
|||
_imdb_id = self.search(title)[0]["imdb_id"] |
|||
url = config['urls']['imdb.lookUp'] % (_imdb_id) |
|||
etree = XmlHandler(url).getEt() |
|||
lookup_results = SearchResults() |
|||
for cur_lookup in etree.find("movies").findall("movie"): |
|||
cur_movie = self._parseSearchResults(cur_lookup) |
|||
lookup_results.append(cur_movie) |
|||
return lookup_results |
|||
|
|||
class Browse: |
|||
|
|||
def __init__(self, params = {}): |
|||
""" |
|||
tmdb.Browse(params) |
|||
default params = {"order_by":"release","order":"desc"} |
|||
params = {"query":"some query","release_max":"1991",...} |
|||
all posible parameters = http://api.themoviedb.org/2.1/methods/Movie.browse |
|||
""" |
|||
if "order_by" not in params: |
|||
params.update({"order_by":"release"}) |
|||
if "order" not in params: |
|||
params.update({"order":"desc"}) |
|||
|
|||
self.params = urllib.urlencode(params) |
|||
self.movie = self.look(self.params) |
|||
|
|||
def look(self, look_for): |
|||
url = config['urls']['movie.browse'] % (look_for) |
|||
etree = XmlHandler(url).getEt() |
|||
look_results = SearchResults() |
|||
for cur_lookup in etree.find("movies").findall("movie"): |
|||
cur_movie = self._parseSearchResults(cur_lookup) |
|||
look_results.append(cur_movie) |
|||
return look_results |
|||
|
|||
def _parseSearchResults(self, movie_element): |
|||
cur_movie = MovieResult() |
|||
cur_images = ImagesList() |
|||
for item in movie_element.getchildren(): |
|||
if item.tag.lower() == "images": |
|||
for subitem in item.getchildren(): |
|||
cur_images.set(subitem) |
|||
else: |
|||
cur_movie[item.tag] = item.text |
|||
cur_movie['images'] = cur_images |
|||
return cur_movie |
|||
|
|||
def getTotal(self): |
|||
return len(self.movie) |
|||
|
|||
def getRating(self, i): |
|||
return self.movie[i]["rating"] |
|||
|
|||
def getVotes(self, i): |
|||
return self.movie[i]["votes"] |
|||
|
|||
def getName(self, i): |
|||
return self.movie[i]["name"] |
|||
|
|||
def getLanguage(self, i): |
|||
return self.movie[i]["language"] |
|||
|
|||
def getCertification(self, i): |
|||
return self.movie[i]["certification"] |
|||
|
|||
def getUrl(self, i): |
|||
return self.movie[i]["url"] |
|||
|
|||
def getOverview(self, i): |
|||
return self.movie[i]["overview"] |
|||
|
|||
def getPopularity(self, i): |
|||
return self.movie[i]["popularity"] |
|||
|
|||
def getOriginalName(self, i): |
|||
return self.movie[i]["original_name"] |
|||
|
|||
def getLastModified(self, i): |
|||
return self.movie[i]["last_modified_at"] |
|||
|
|||
def getImdbId(self, i): |
|||
return self.movie[i]["imdb_id"] |
|||
|
|||
def getReleased(self, i): |
|||
return self.movie[i]["released"] |
|||
|
|||
def getScore(self, i): |
|||
return self.movie[i]["score"] |
|||
|
|||
def getAdult(self, i): |
|||
return self.movie[i]["adult"] |
|||
|
|||
def getVersion(self, i): |
|||
return self.movie[i]["version"] |
|||
|
|||
def getTranslated(self, i): |
|||
return self.movie[i]["translated"] |
|||
|
|||
def getType(self, i): |
|||
return self.movie[i]["type"] |
|||
|
|||
def getId(self, i): |
|||
return self.movie[i]["id"] |
|||
|
|||
def getAlternativeName(self, i): |
|||
return self.movie[i]["alternative_name"] |
|||
|
|||
def getPoster(self, i, size): |
|||
if size == "thumb" or size == "t": |
|||
return self.movie[i]["images"][0]["thumb"] |
|||
elif size == "cover" or size == "c": |
|||
return self.movie[i]["images"][0]["cover"] |
|||
else: |
|||
return self.movie[i]["images"][0]["mid"] |
|||
|
|||
def getBackdrop(self, i, size): |
|||
if size == "poster" or size == "p": |
|||
return self.movie[i]["images"][1]["poster"] |
|||
else: |
|||
return self.movie[i]["images"][1]["thumb"] |
|||
|
|||
|
|||
|
|||
# Shortcuts for tmdb search method |
|||
# using: |
|||
# movie = tmdb.tmdb("Sin City") |
|||
# print movie.getRating -> 7.0 |
|||
class tmdb: |
|||
|
|||
def __init__(self, name): |
|||
"""Convenience wrapper for MovieDb.search - so you can do.. |
|||
>>> import tmdb |
|||
>>> movie = tmdb.tmdb("Fight Club") |
|||
>>> ranking = movie.getRanking() or votes = movie.getVotes() |
|||
<Search results: [<MovieResult: Fight Club (1999-09-16)>]> |
|||
""" |
|||
mdb = MovieDb() |
|||
self.movie = mdb.search(name) |
|||
|
|||
def getTotal(self): |
|||
return len(self.movie) |
|||
|
|||
def getRating(self, i): |
|||
return self.movie[i]["rating"] |
|||
|
|||
def getVotes(self, i): |
|||
return self.movie[i]["votes"] |
|||
|
|||
def getName(self, i): |
|||
return self.movie[i]["name"] |
|||
|
|||
def getLanguage(self, i): |
|||
return self.movie[i]["language"] |
|||
|
|||
def getCertification(self, i): |
|||
return self.movie[i]["certification"] |
|||
|
|||
def getUrl(self, i): |
|||
return self.movie[i]["url"] |
|||
|
|||
def getOverview(self, i): |
|||
return self.movie[i]["overview"] |
|||
|
|||
def getPopularity(self, i): |
|||
return self.movie[i]["popularity"] |
|||
|
|||
def getOriginalName(self, i): |
|||
return self.movie[i]["original_name"] |
|||
|
|||
def getLastModified(self, i): |
|||
return self.movie[i]["last_modified_at"] |
|||
|
|||
def getImdbId(self, i): |
|||
return self.movie[i]["imdb_id"] |
|||
|
|||
def getReleased(self, i): |
|||
return self.movie[i]["released"] |
|||
|
|||
def getScore(self, i): |
|||
return self.movie[i]["score"] |
|||
|
|||
def getAdult(self, i): |
|||
return self.movie[i]["adult"] |
|||
|
|||
def getVersion(self, i): |
|||
return self.movie[i]["version"] |
|||
|
|||
def getTranslated(self, i): |
|||
return self.movie[i]["translated"] |
|||
|
|||
def getType(self, i): |
|||
return self.movie[i]["type"] |
|||
|
|||
def getId(self, i): |
|||
return self.movie[i]["id"] |
|||
|
|||
def getAlternativeName(self, i): |
|||
return self.movie[i]["alternative_name"] |
|||
|
|||
def getPoster(self, i, size): |
|||
if size == "thumb" or size == "t": |
|||
return self.movie[i]["images"][0]["thumb"] |
|||
elif size == "cover" or size == "c": |
|||
return self.movie[i]["images"][0]["cover"] |
|||
else: |
|||
return self.movie[i]["images"][0]["mid"] |
|||
|
|||
def getBackdrop(self, i, size): |
|||
if size == "poster" or size == "p": |
|||
return self.movie[i]["images"][1]["poster"] |
|||
else: |
|||
return self.movie[i]["images"][1]["thumb"] |
|||
|
|||
# Shortcuts for imdb lookup method |
|||
# using: |
|||
# movie = tmdb.imdb("Sin City") |
|||
# print movie.getRating -> 7.0 |
|||
class imdb: |
|||
|
|||
def __init__(self, id = 0, title = False): |
|||
# get first movie if result=0 |
|||
"""Convenience wrapper for MovieDb.search - so you can do.. |
|||
>>> import tmdb |
|||
>>> movie = tmdb.imdb(title="Fight Club") # or movie = tmdb.imdb(id=imdb_id) |
|||
>>> ranking = movie.getRanking() or votes = movie.getVotes() |
|||
<Search results: [<MovieResult: Fight Club (1999-09-16)>]> |
|||
""" |
|||
self.id = id |
|||
self.title = title |
|||
self.mdb = MovieDb() |
|||
self.movie = self.mdb.imdbLookup(self.id, self.title) |
|||
|
|||
def getTotal(self): |
|||
return len(self.movie) |
|||
|
|||
def getRuntime(self, i): |
|||
return self.movie[i]["runtime"] |
|||
|
|||
def getCategories(self): |
|||
from xml.dom.minidom import parse |
|||
adres = config['urls']['imdb.lookUp'] % self.getImdbId() |
|||
d = parse(urllib2.urlopen(adres)) |
|||
s = d.getElementsByTagName("categories") |
|||
ds = [] |
|||
for i in range(len(s[0].childNodes)): |
|||
if i % 2 > 0: |
|||
ds.append(s[0].childNodes[i].getAttribute("name")) |
|||
return ds |
|||
|
|||
def getRating(self, i): |
|||
return self.movie[i]["rating"] |
|||
|
|||
def getVotes(self, i): |
|||
return self.movie[i]["votes"] |
|||
|
|||
def getName(self, i): |
|||
return self.movie[i]["name"] |
|||
|
|||
def getLanguage(self, i): |
|||
return self.movie[i]["language"] |
|||
|
|||
def getCertification(self, i): |
|||
return self.movie[i]["certification"] |
|||
|
|||
def getUrl(self, i): |
|||
return self.movie[i]["url"] |
|||
|
|||
def getOverview(self, i): |
|||
return self.movie[i]["overview"] |
|||
|
|||
def getPopularity(self, i): |
|||
return self.movie[i]["popularity"] |
|||
|
|||
def getOriginalName(self, i): |
|||
return self.movie[i]["original_name"] |
|||
|
|||
def getLastModified(self, i): |
|||
return self.movie[i]["last_modified_at"] |
|||
|
|||
def getImdbId(self, i): |
|||
return self.movie[i]["imdb_id"] |
|||
|
|||
def getReleased(self, i): |
|||
return self.movie[i]["released"] |
|||
|
|||
def getAdult(self, i): |
|||
return self.movie[i]["adult"] |
|||
|
|||
def getVersion(self, i): |
|||
return self.movie[i]["version"] |
|||
|
|||
def getTranslated(self, i): |
|||
return self.movie[i]["translated"] |
|||
|
|||
def getType(self, i): |
|||
return self.movie[i]["type"] |
|||
|
|||
def getId(self, i): |
|||
return self.movie[i]["id"] |
|||
|
|||
def getAlternativeName(self, i): |
|||
return self.movie[i]["alternative_name"] |
|||
|
|||
def getPoster(self, i, size): |
|||
poster = [] |
|||
if size == "thumb" or size == "t": |
|||
_size = "thumb" |
|||
elif size == "cover" or size == "c": |
|||
_size = "cover" |
|||
else: |
|||
_size = "mid" |
|||
for a in self.movie[i]["images"]: |
|||
if a["type"] == "poster": |
|||
poster.append(a[_size]) |
|||
return poster |
|||
del poster |
|||
|
|||
def getBackdrop(self, i, size): |
|||
backdrop = [] |
|||
if size == "thumb" or size == "t": |
|||
_size = "thumb" |
|||
elif size == "cover" or size == "c": |
|||
_size = "cover" |
|||
else: |
|||
_size = "mid" |
|||
for a in self.movie[i]["images"]: |
|||
if a["type"] == "backdrop": |
|||
backdrop.append(a[_size]) |
|||
return backdrop |
|||
del backdrop |
|||
|
|||
def imdbLookup(id = 0, title = False): |
|||
"""Convenience wrapper for Imdb.Lookup - so you can do.. |
|||
>>> import tmdb |
|||
>>> tmdb.imdbLookup("Fight Club") |
|||
<Search results: [<MovieResult: Fight Club (1999-09-16)>]> |
|||
""" |
|||
mdb = MovieDb() |
|||
return mdb.imdbLookup(id, title) |
|||
|
|||
def search(name): |
|||
"""Convenience wrapper for MovieDb.search - so you can do.. |
|||
>>> import tmdb |
|||
>>> tmdb.search("Fight Club") |
|||
<Search results: [<MovieResult: Fight Club (1999-09-16)>]> |
|||
""" |
|||
mdb = MovieDb() |
|||
return mdb.search(name) |
|||
|
|||
def getMovieInfo(id): |
|||
"""Convenience wrapper for MovieDb.search - so you can do.. |
|||
>>> import tmdb |
|||
>>> tmdb.getMovieInfo(187) |
|||
<MovieResult: Sin City (2005-04-01)> |
|||
""" |
|||
mdb = MovieDb() |
|||
return mdb.getMovieInfo(id) |
|||
|
|||
def mediaGetInfo(hash, size): |
|||
"""Convenience wrapper for MovieDb.mediaGetInfo - so you can do.. |
|||
|
|||
>>> import tmdb |
|||
>>> tmdb.mediaGetInfo('907172e7fe51ba57', size = 742086656)[0] |
|||
<MovieResult: Sin City (2005-04-01)> |
|||
""" |
|||
mdb = MovieDb() |
|||
return mdb.mediaGetInfo(hash, size) |
|||
|
|||
def searchByHashingFile(filename): |
|||
"""Searches for the specified file using the OpenSubtitle hashing method |
|||
""" |
|||
return mediaGetInfo(opensubtitleHashFile(filename), os.path.size(filename)) |
|||
|
|||
def main(): |
|||
results = search("Fight Club") |
|||
searchResult = results[0] |
|||
movie = getMovieInfo(searchResult['id']) |
|||
print movie['name'] |
|||
|
|||
print "Producers:" |
|||
for prodr in movie['cast']['producer']: |
|||
print " " * 4, prodr['name'] |
|||
print movie['images'] |
|||
for genreName in movie['categories']['genre']: |
|||
print "%s (%s)" % (genreName, movie['categories']['genre'][genreName]) |
|||
|
|||
if __name__ == '__main__': |
|||
main() |
|||
@ -0,0 +1,11 @@ |
|||
#!/usr/bin/env python |
|||
|
|||
from tmdb_api import Configuration, searchMovie, searchMovieWithYear, \ |
|||
searchPerson, searchStudio, searchList, searchCollection, \ |
|||
Person, Movie, Collection, Genre, List, __version__ |
|||
from request import set_key, set_cache |
|||
from locales import get_locale, set_locale |
|||
from tmdb_auth import get_session, set_session |
|||
from cache_engine import CacheEngine |
|||
from tmdb_exceptions import * |
|||
|
|||
@ -0,0 +1,121 @@ |
|||
#!/usr/bin/env python |
|||
# -*- coding: utf-8 -*- |
|||
#----------------------- |
|||
# Name: cache.py |
|||
# Python Library |
|||
# Author: Raymond Wagner |
|||
# Purpose: Caching framework to store TMDb API results |
|||
#----------------------- |
|||
|
|||
from tmdb_exceptions import * |
|||
from cache_engine import Engines |
|||
|
|||
import cache_null |
|||
import cache_file |
|||
|
|||
class Cache( object ): |
|||
""" |
|||
This class implements a persistent cache, backed in a file specified in |
|||
the object creation. The file is protected for safe, concurrent access |
|||
by multiple instances using flock. |
|||
This cache uses JSON for speed and storage efficiency, so only simple |
|||
data types are supported. |
|||
Data is stored in a simple format {key:(expiretimestamp, data)} |
|||
""" |
|||
def __init__(self, engine=None, *args, **kwargs): |
|||
self._engine = None |
|||
self._data = {} |
|||
self._age = 0 |
|||
self.configure(engine, *args, **kwargs) |
|||
|
|||
def _import(self, data=None): |
|||
if data is None: |
|||
data = self._engine.get(self._age) |
|||
for obj in sorted(data, key=lambda x: x.creation): |
|||
if not obj.expired: |
|||
self._data[obj.key] = obj |
|||
self._age = max(self._age, obj.creation) |
|||
|
|||
def _expire(self): |
|||
for k,v in self._data.items(): |
|||
if v.expired: |
|||
del self._data[k] |
|||
|
|||
def configure(self, engine, *args, **kwargs): |
|||
if engine is None: |
|||
engine = 'file' |
|||
elif engine not in Engines: |
|||
raise TMDBCacheError("Invalid cache engine specified: "+engine) |
|||
self._engine = Engines[engine](self) |
|||
self._engine.configure(*args, **kwargs) |
|||
|
|||
def put(self, key, data, lifetime=60*60*12): |
|||
# pull existing data, so cache will be fresh when written back out |
|||
if self._engine is None: |
|||
raise TMDBCacheError("No cache engine configured") |
|||
self._expire() |
|||
self._import(self._engine.put(key, data, lifetime)) |
|||
|
|||
def get(self, key): |
|||
if self._engine is None: |
|||
raise TMDBCacheError("No cache engine configured") |
|||
self._expire() |
|||
if key not in self._data: |
|||
self._import() |
|||
try: |
|||
return self._data[key].data |
|||
except: |
|||
return None |
|||
|
|||
def cached(self, callback): |
|||
""" |
|||
Returns a decorator that uses a callback to specify the key to use |
|||
for caching the responses from the decorated function. |
|||
""" |
|||
return self.Cached(self, callback) |
|||
|
|||
class Cached( object ): |
|||
def __init__(self, cache, callback, func=None, inst=None): |
|||
self.cache = cache |
|||
self.callback = callback |
|||
self.func = func |
|||
self.inst = inst |
|||
|
|||
if func: |
|||
self.__module__ = func.__module__ |
|||
self.__name__ = func.__name__ |
|||
self.__doc__ = func.__doc__ |
|||
|
|||
def __call__(self, *args, **kwargs): |
|||
if self.func is None: # decorator is waiting to be given a function |
|||
if len(kwargs) or (len(args) != 1): |
|||
raise TMDBCacheError('Cache.Cached decorator must be called '+\ |
|||
'a single callable argument before it '+\ |
|||
'be used.') |
|||
elif args[0] is None: |
|||
raise TMDBCacheError('Cache.Cached decorator called before '+\ |
|||
'being given a function to wrap.') |
|||
elif not callable(args[0]): |
|||
raise TMDBCacheError('Cache.Cached must be provided a '+\ |
|||
'callable object.') |
|||
return self.__class__(self.cache, self.callback, args[0]) |
|||
elif self.inst.lifetime == 0: |
|||
return self.func(*args, **kwargs) |
|||
else: |
|||
key = self.callback() |
|||
data = self.cache.get(key) |
|||
if data is None: |
|||
data = self.func(*args, **kwargs) |
|||
if hasattr(self.inst, 'lifetime'): |
|||
self.cache.put(key, data, self.inst.lifetime) |
|||
else: |
|||
self.cache.put(key, data) |
|||
return data |
|||
|
|||
def __get__(self, inst, owner): |
|||
if inst is None: |
|||
return self |
|||
func = self.func.__get__(inst, owner) |
|||
callback = self.callback.__get__(inst, owner) |
|||
return self.__class__(self.cache, callback, func, inst) |
|||
|
|||
@ -0,0 +1,72 @@ |
|||
#!/usr/bin/env python |
|||
# -*- coding: utf-8 -*- |
|||
#----------------------- |
|||
# Name: cache_engine.py |
|||
# Python Library |
|||
# Author: Raymond Wagner |
|||
# Purpose: Base cache engine class for collecting registered engines |
|||
#----------------------- |
|||
|
|||
import time |
|||
from weakref import ref |
|||
|
|||
class Engines( object ): |
|||
def __init__(self): |
|||
self._engines = {} |
|||
def register(self, engine): |
|||
self._engines[engine.__name__] = engine |
|||
self._engines[engine.name] = engine |
|||
def __getitem__(self, key): |
|||
return self._engines[key] |
|||
def __contains__(self, key): |
|||
return self._engines.__contains__(key) |
|||
Engines = Engines() |
|||
|
|||
class CacheEngineType( type ): |
|||
""" |
|||
Cache Engine Metaclass that registers new engines against the cache |
|||
for named selection and use. |
|||
""" |
|||
def __init__(mcs, name, bases, attrs): |
|||
super(CacheEngineType, mcs).__init__(name, bases, attrs) |
|||
if name != 'CacheEngine': |
|||
# skip base class |
|||
Engines.register(mcs) |
|||
|
|||
class CacheEngine( object ): |
|||
__metaclass__ = CacheEngineType |
|||
|
|||
name = 'unspecified' |
|||
def __init__(self, parent): |
|||
self.parent = ref(parent) |
|||
def configure(self): |
|||
raise RuntimeError |
|||
def get(self, date): |
|||
raise RuntimeError |
|||
def put(self, key, value, lifetime): |
|||
raise RuntimeError |
|||
def expire(self, key): |
|||
raise RuntimeError |
|||
|
|||
class CacheObject( object ): |
|||
""" |
|||
Cache object class, containing one stored record. |
|||
""" |
|||
|
|||
def __init__(self, key, data, lifetime=0, creation=None): |
|||
self.key = key |
|||
self.data = data |
|||
self.lifetime = lifetime |
|||
self.creation = creation if creation is not None else time.time() |
|||
|
|||
def __len__(self): |
|||
return len(self.data) |
|||
|
|||
@property |
|||
def expired(self): |
|||
return (self.remaining == 0) |
|||
|
|||
@property |
|||
def remaining(self): |
|||
return max((self.creation + self.lifetime) - time.time(), 0) |
|||
|
|||
@ -0,0 +1,391 @@ |
|||
#!/usr/bin/env python |
|||
# -*- coding: utf-8 -*- |
|||
#----------------------- |
|||
# Name: cache_file.py |
|||
# Python Library |
|||
# Author: Raymond Wagner |
|||
# Purpose: Persistant file-backed cache using /tmp/ to share data |
|||
# using flock or msvcrt.locking to allow safe concurrent |
|||
# access. |
|||
#----------------------- |
|||
|
|||
import struct |
|||
import errno |
|||
import json |
|||
import os |
|||
import io |
|||
|
|||
from cStringIO import StringIO |
|||
|
|||
from tmdb_exceptions import * |
|||
from cache_engine import CacheEngine, CacheObject |
|||
|
|||
#################### |
|||
# Cache File Format |
|||
#------------------ |
|||
# cache version (2) unsigned short |
|||
# slot count (2) unsigned short |
|||
# slot 0: timestamp (8) double |
|||
# slot 0: lifetime (4) unsigned int |
|||
# slot 0: seek point (4) unsigned int |
|||
# slot 1: timestamp |
|||
# slot 1: lifetime index slots are IDd by their query date and |
|||
# slot 1: seek point are filled incrementally forwards. lifetime |
|||
# .... is how long after query date before the item |
|||
# .... expires, and seek point is the location of the |
|||
# slot N-2: timestamp start of data for that entry. 256 empty slots |
|||
# slot N-2: lifetime are pre-allocated, allowing fast updates. |
|||
# slot N-2: seek point when all slots are filled, the cache file is |
|||
# slot N-1: timestamp rewritten from scrach to add more slots. |
|||
# slot N-1: lifetime |
|||
# slot N-1: seek point |
|||
# block 1 (?) ASCII |
|||
# block 2 |
|||
# .... blocks are just simple ASCII text, generated |
|||
# .... as independent objects by the JSON encoder |
|||
# block N-2 |
|||
# block N-1 |
|||
# |
|||
#################### |
|||
|
|||
|
|||
def _donothing(*args, **kwargs): |
|||
pass |
|||
|
|||
try: |
|||
import fcntl |
|||
class Flock( object ): |
|||
""" |
|||
Context manager to flock file for the duration the object exists. |
|||
Referenced file will be automatically unflocked as the interpreter |
|||
exits the context. |
|||
Supports an optional callback to process the error and optionally |
|||
suppress it. |
|||
""" |
|||
LOCK_EX = fcntl.LOCK_EX |
|||
LOCK_SH = fcntl.LOCK_SH |
|||
|
|||
def __init__(self, fileobj, operation, callback=None): |
|||
self.fileobj = fileobj |
|||
self.operation = operation |
|||
self.callback = callback |
|||
def __enter__(self): |
|||
fcntl.flock(self.fileobj, self.operation) |
|||
def __exit__(self, exc_type, exc_value, exc_tb): |
|||
suppress = False |
|||
if callable(self.callback): |
|||
suppress = self.callback(exc_type, exc_value, exc_tb) |
|||
fcntl.flock(self.fileobj, fcntl.LOCK_UN) |
|||
return suppress |
|||
|
|||
def parse_filename(filename): |
|||
if '$' in filename: |
|||
# replace any environmental variables |
|||
filename = os.path.expandvars(filename) |
|||
if filename.startswith('~'): |
|||
# check for home directory |
|||
return os.path.expanduser(filename) |
|||
elif filename.startswith('/'): |
|||
# check for absolute path |
|||
return filename |
|||
# return path with temp directory prepended |
|||
return '/tmp/' + filename |
|||
|
|||
except ImportError: |
|||
import msvcrt |
|||
class Flock( object ): |
|||
LOCK_EX = msvcrt.LK_LOCK |
|||
LOCK_SH = msvcrt.LK_LOCK |
|||
|
|||
def __init__(self, fileobj, operation, callback=None): |
|||
self.fileobj = fileobj |
|||
self.operation = operation |
|||
self.callback = callback |
|||
def __enter__(self): |
|||
self.size = os.path.getsize(self.fileobj.name) |
|||
msvcrt.locking(self.fileobj.fileno(), self.operation, self.size) |
|||
def __exit__(self, exc_type, exc_value, exc_tb): |
|||
suppress = False |
|||
if callable(self.callback): |
|||
suppress = self.callback(exc_type, exc_value, exc_tb) |
|||
msvcrt.locking(self.fileobj.fileno(), msvcrt.LK_UNLCK, self.size) |
|||
return suppress |
|||
|
|||
def parse_filename(filename): |
|||
if '%' in filename: |
|||
# replace any environmental variables |
|||
filename = os.path.expandvars(filename) |
|||
if filename.startswith('~'): |
|||
# check for home directory |
|||
return os.path.expanduser(filename) |
|||
elif (ord(filename[0]) in (range(65,91)+range(99,123))) \ |
|||
and (filename[1:3] == ':\\'): |
|||
# check for absolute drive path (e.g. C:\...) |
|||
return filename |
|||
elif (filename.count('\\') >= 3) and (filename.startswith('\\\\')): |
|||
# check for absolute UNC path (e.g. \\server\...) |
|||
return filename |
|||
# return path with temp directory prepended |
|||
return os.path.expandvars(os.path.join('%TEMP%',filename)) |
|||
|
|||
|
|||
class FileCacheObject( CacheObject ): |
|||
_struct = struct.Struct('dII') # double and two ints |
|||
# timestamp, lifetime, position |
|||
|
|||
@classmethod |
|||
def fromFile(cls, fd): |
|||
dat = cls._struct.unpack(fd.read(cls._struct.size)) |
|||
obj = cls(None, None, dat[1], dat[0]) |
|||
obj.position = dat[2] |
|||
return obj |
|||
|
|||
def __init__(self, *args, **kwargs): |
|||
self._key = None |
|||
self._data = None |
|||
self._size = None |
|||
self._buff = StringIO() |
|||
super(FileCacheObject, self).__init__(*args, **kwargs) |
|||
|
|||
@property |
|||
def size(self): |
|||
if self._size is None: |
|||
self._buff.seek(0,2) |
|||
size = self._buff.tell() |
|||
if size == 0: |
|||
if (self._key is None) or (self._data is None): |
|||
raise RuntimeError |
|||
json.dump([self.key, self.data], self._buff) |
|||
self._size = self._buff.tell() |
|||
self._size = size |
|||
return self._size |
|||
@size.setter |
|||
def size(self, value): self._size = value |
|||
|
|||
@property |
|||
def key(self): |
|||
if self._key is None: |
|||
try: |
|||
self._key, self._data = json.loads(self._buff.getvalue()) |
|||
except: |
|||
pass |
|||
return self._key |
|||
@key.setter |
|||
def key(self, value): self._key = value |
|||
|
|||
@property |
|||
def data(self): |
|||
if self._data is None: |
|||
self._key, self._data = json.loads(self._buff.getvalue()) |
|||
return self._data |
|||
@data.setter |
|||
def data(self, value): self._data = value |
|||
|
|||
def load(self, fd): |
|||
fd.seek(self.position) |
|||
self._buff.seek(0) |
|||
self._buff.write(fd.read(self.size)) |
|||
|
|||
def dumpslot(self, fd): |
|||
pos = fd.tell() |
|||
fd.write(self._struct.pack(self.creation, self.lifetime, self.position)) |
|||
|
|||
def dumpdata(self, fd): |
|||
self.size |
|||
fd.seek(self.position) |
|||
fd.write(self._buff.getvalue()) |
|||
|
|||
|
|||
class FileEngine( CacheEngine ): |
|||
"""Simple file-backed engine.""" |
|||
name = 'file' |
|||
_struct = struct.Struct('HH') # two shorts for version and count |
|||
_version = 2 |
|||
|
|||
def __init__(self, parent): |
|||
super(FileEngine, self).__init__(parent) |
|||
self.configure(None) |
|||
|
|||
def configure(self, filename, preallocate=256): |
|||
self.preallocate = preallocate |
|||
self.cachefile = filename |
|||
self.size = 0 |
|||
self.free = 0 |
|||
self.age = 0 |
|||
|
|||
def _init_cache(self): |
|||
# only run this once |
|||
self._init_cache = _donothing |
|||
|
|||
if self.cachefile is None: |
|||
raise TMDBCacheError("No cache filename given.") |
|||
|
|||
self.cachefile = parse_filename(self.cachefile) |
|||
|
|||
try: |
|||
# attempt to read existing cache at filename |
|||
# handle any errors that occur |
|||
self._open('r+b') |
|||
# seems to have read fine, make sure we have write access |
|||
if not os.access(self.cachefile, os.W_OK): |
|||
raise TMDBCacheWriteError(self.cachefile) |
|||
|
|||
except IOError as e: |
|||
if e.errno == errno.ENOENT: |
|||
# file does not exist, create a new one |
|||
try: |
|||
self._open('w+b') |
|||
self._write([]) |
|||
except IOError as e: |
|||
if e.errno == errno.ENOENT: |
|||
# directory does not exist |
|||
raise TMDBCacheDirectoryError(self.cachefile) |
|||
elif e.errno == errno.EACCES: |
|||
# user does not have rights to create new file |
|||
raise TMDBCacheWriteError(self.cachefile) |
|||
else: |
|||
# let the unhandled error continue through |
|||
raise |
|||
elif e.errno == errno.EACCESS: |
|||
# file exists, but we do not have permission to access it |
|||
raise TMDBCacheReadError(self.cachefile) |
|||
else: |
|||
# let the unhandled error continue through |
|||
raise |
|||
|
|||
def get(self, date): |
|||
self._init_cache() |
|||
self._open('r+b') |
|||
|
|||
with Flock(self.cachefd, Flock.LOCK_SH): # lock for shared access |
|||
# return any new objects in the cache |
|||
return self._read(date) |
|||
|
|||
def put(self, key, value, lifetime): |
|||
self._init_cache() |
|||
self._open('r+b') |
|||
|
|||
with Flock(self.cachefd, Flock.LOCK_EX): # lock for exclusive access |
|||
newobjs = self._read(self.age) |
|||
newobjs.append(FileCacheObject(key, value, lifetime)) |
|||
|
|||
# this will cause a new file object to be opened with the proper |
|||
# access mode, however the Flock should keep the old object open |
|||
# and properly locked |
|||
self._open('r+b') |
|||
self._write(newobjs) |
|||
return newobjs |
|||
|
|||
def _open(self, mode='r+b'): |
|||
# enforce binary operation |
|||
try: |
|||
if self.cachefd.mode == mode: |
|||
# already opened in requested mode, nothing to do |
|||
self.cachefd.seek(0) |
|||
return |
|||
except: pass # catch issue of no cachefile yet opened |
|||
self.cachefd = io.open(self.cachefile, mode) |
|||
|
|||
def _read(self, date): |
|||
try: |
|||
self.cachefd.seek(0) |
|||
version, count = self._struct.unpack(\ |
|||
self.cachefd.read(self._struct.size)) |
|||
if version != self._version: |
|||
# old version, break out and well rewrite when finished |
|||
raise Exception |
|||
|
|||
self.size = count |
|||
cache = [] |
|||
while count: |
|||
# loop through storage definitions |
|||
obj = FileCacheObject.fromFile(self.cachefd) |
|||
cache.append(obj) |
|||
count -= 1 |
|||
|
|||
except: |
|||
# failed to read information, so just discard it and return empty |
|||
self.size = 0 |
|||
self.free = 0 |
|||
return [] |
|||
|
|||
# get end of file |
|||
self.cachefd.seek(0,2) |
|||
position = self.cachefd.tell() |
|||
newobjs = [] |
|||
emptycount = 0 |
|||
|
|||
# walk backward through all, collecting new content and populating size |
|||
while len(cache): |
|||
obj = cache.pop() |
|||
if obj.creation == 0: |
|||
# unused slot, skip |
|||
emptycount += 1 |
|||
elif obj.expired: |
|||
# object has passed expiration date, no sense processing |
|||
continue |
|||
elif obj.creation > date: |
|||
# used slot with new data, process |
|||
obj.size, position = position - obj.position, obj.position |
|||
newobjs.append(obj) |
|||
# update age |
|||
self.age = max(self.age, obj.creation) |
|||
elif len(newobjs): |
|||
# end of new data, break |
|||
break |
|||
|
|||
# walk forward and load new content |
|||
for obj in newobjs: |
|||
obj.load(self.cachefd) |
|||
|
|||
self.free = emptycount |
|||
return newobjs |
|||
|
|||
def _write(self, data): |
|||
if self.free and (self.size != self.free): |
|||
# we only care about the last data point, since the rest are |
|||
# already stored in the file |
|||
data = data[-1] |
|||
|
|||
# determine write position of data in cache |
|||
self.cachefd.seek(0,2) |
|||
end = self.cachefd.tell() |
|||
data.position = end |
|||
|
|||
# write incremental update to free slot |
|||
self.cachefd.seek(4 + 16*(self.size-self.free)) |
|||
data.dumpslot(self.cachefd) |
|||
data.dumpdata(self.cachefd) |
|||
|
|||
else: |
|||
# rewrite cache file from scratch |
|||
# pull data from parent cache |
|||
data.extend(self.parent()._data.values()) |
|||
data.sort(key=lambda x: x.creation) |
|||
# write header |
|||
size = len(data) + self.preallocate |
|||
self.cachefd.seek(0) |
|||
self.cachefd.truncate() |
|||
self.cachefd.write(self._struct.pack(self._version, size)) |
|||
# write storage slot definitions |
|||
prev = None |
|||
for d in data: |
|||
if prev == None: |
|||
d.position = 4 + 16*size |
|||
else: |
|||
d.position = prev.position + prev.size |
|||
d.dumpslot(self.cachefd) |
|||
prev = d |
|||
# fill in allocated slots |
|||
for i in range(2**8): |
|||
self.cachefd.write(FileCacheObject._struct.pack(0, 0, 0)) |
|||
# write stored data |
|||
for d in data: |
|||
d.dumpdata(self.cachefd) |
|||
|
|||
self.cachefd.flush() |
|||
|
|||
def expire(self, key): |
|||
pass |
|||
|
|||
|
|||
@ -0,0 +1,19 @@ |
|||
#!/usr/bin/env python |
|||
# -*- coding: utf-8 -*- |
|||
#----------------------- |
|||
# Name: cache_null.py |
|||
# Python Library |
|||
# Author: Raymond Wagner |
|||
# Purpose: Null caching engine for debugging purposes |
|||
#----------------------- |
|||
|
|||
from cache_engine import CacheEngine |
|||
|
|||
class NullEngine( CacheEngine ): |
|||
"""Non-caching engine for debugging.""" |
|||
name = 'null' |
|||
def configure(self): pass |
|||
def get(self, date): return [] |
|||
def put(self, key, value, lifetime): return [] |
|||
def expire(self, key): pass |
|||
|
|||
@ -0,0 +1,634 @@ |
|||
#!/usr/bin/env python |
|||
# -*- coding: utf-8 -*- |
|||
#----------------------- |
|||
# Name: locales.py Stores locale information for filtering results |
|||
# Python Library |
|||
# Author: Raymond Wagner |
|||
#----------------------- |
|||
|
|||
from tmdb_exceptions import * |
|||
import locale |
|||
|
|||
syslocale = None |
|||
|
|||
class LocaleBase( object ): |
|||
__slots__ = ['__immutable'] |
|||
_stored = {} |
|||
fallthrough = False |
|||
|
|||
def __init__(self, *keys): |
|||
for key in keys: |
|||
self._stored[key.lower()] = self |
|||
self.__immutable = True |
|||
|
|||
def __setattr__(self, key, value): |
|||
if getattr(self, '__immutable', False): |
|||
raise NotImplementedError(self.__class__.__name__ + |
|||
' does not support modification.') |
|||
super(LocaleBase, self).__setattr__(key, value) |
|||
|
|||
def __delattr__(self, key): |
|||
if getattr(self, '__immutable', False): |
|||
raise NotImplementedError(self.__class__.__name__ + |
|||
' does not support modification.') |
|||
super(LocaleBase, self).__delattr__(key) |
|||
|
|||
def __lt__(self, other): |
|||
return (id(self) != id(other)) and (str(self) > str(other)) |
|||
def __gt__(self, other): |
|||
return (id(self) != id(other)) and (str(self) < str(other)) |
|||
def __eq__(self, other): |
|||
return (id(self) == id(other)) or (str(self) == str(other)) |
|||
|
|||
@classmethod |
|||
def getstored(cls, key): |
|||
if key is None: |
|||
return None |
|||
try: |
|||
return cls._stored[key.lower()] |
|||
except: |
|||
raise TMDBLocaleError("'{0}' is not a known valid {1} code."\ |
|||
.format(key, cls.__name__)) |
|||
|
|||
class Language( LocaleBase ): |
|||
__slots__ = ['ISO639_1', 'ISO639_2', 'ISO639_2B', 'englishname', |
|||
'nativename'] |
|||
_stored = {} |
|||
|
|||
def __init__(self, iso1, iso2, ename): |
|||
self.ISO639_1 = iso1 |
|||
self.ISO639_2 = iso2 |
|||
# self.ISO639_2B = iso2b |
|||
self.englishname = ename |
|||
# self.nativename = nname |
|||
super(Language, self).__init__(iso1, iso2) |
|||
|
|||
def __str__(self): |
|||
return self.ISO639_1 |
|||
|
|||
def __repr__(self): |
|||
return u"<Language '{0.englishname}' ({0.ISO639_1})>".format(self) |
|||
|
|||
class Country( LocaleBase ): |
|||
__slots__ = ['alpha2', 'name'] |
|||
_stored = {} |
|||
|
|||
def __init__(self, alpha2, name): |
|||
self.alpha2 = alpha2 |
|||
self.name = name |
|||
super(Country, self).__init__(alpha2) |
|||
|
|||
def __str__(self): |
|||
return self.alpha2 |
|||
|
|||
def __repr__(self): |
|||
return u"<Country '{0.name}' ({0.alpha2})>".format(self) |
|||
|
|||
class Locale( LocaleBase ): |
|||
__slots__ = ['language', 'country', 'encoding'] |
|||
|
|||
def __init__(self, language, country, encoding): |
|||
self.language = Language.getstored(language) |
|||
self.country = Country.getstored(country) |
|||
self.encoding = encoding if encoding else 'latin-1' |
|||
|
|||
def __str__(self): |
|||
return u"{0}_{1}".format(self.language, self.country) |
|||
|
|||
def __repr__(self): |
|||
return u"<Locale {0.language}_{0.country}>".format(self) |
|||
|
|||
def encode(self, dat): |
|||
"""Encode using system default encoding for network/file output.""" |
|||
try: |
|||
return dat.encode(self.encoding) |
|||
except AttributeError: |
|||
# not a string type, pass along |
|||
return dat |
|||
except UnicodeDecodeError: |
|||
# just return unmodified and hope for the best |
|||
return dat |
|||
|
|||
def decode(self, dat): |
|||
"""Decode to system default encoding for internal use.""" |
|||
try: |
|||
return dat.decode(self.encoding) |
|||
except AttributeError: |
|||
# not a string type, pass along |
|||
return dat |
|||
except UnicodeEncodeError: |
|||
# just return unmodified and hope for the best |
|||
return dat |
|||
|
|||
def set_locale(language=None, country=None, fallthrough=False): |
|||
global syslocale |
|||
LocaleBase.fallthrough = fallthrough |
|||
|
|||
sysloc, sysenc = locale.getdefaultlocale() |
|||
|
|||
if (not language) or (not country): |
|||
dat = None |
|||
if syslocale is not None: |
|||
dat = (str(syslocale.language), str(syslocale.country)) |
|||
else: |
|||
if (sysloc is None) or ('_' not in sysloc): |
|||
dat = ('en', 'US') |
|||
else: |
|||
dat = sysloc.split('_') |
|||
if language is None: |
|||
language = dat[0] |
|||
if country is None: |
|||
country = dat[1] |
|||
|
|||
syslocale = Locale(language, country, sysenc) |
|||
|
|||
def get_locale(language=-1, country=-1): |
|||
"""Output locale using provided attributes, or return system locale.""" |
|||
global syslocale |
|||
# pull existing stored values |
|||
if syslocale is None: |
|||
loc = Locale(None, None, locale.getdefaultlocale()[1]) |
|||
else: |
|||
loc = syslocale |
|||
|
|||
# both options are default, return stored values |
|||
if language == country == -1: |
|||
return loc |
|||
|
|||
# supplement default option with stored values |
|||
if language == -1: |
|||
language = loc.language |
|||
elif country == -1: |
|||
country = loc.country |
|||
return Locale(language, country, loc.encoding) |
|||
|
|||
######## AUTOGENERATED LANGUAGE AND COUNTRY DATA BELOW HERE ######### |
|||
|
|||
Language("ab", "abk", u"Abkhazian") |
|||
Language("aa", "aar", u"Afar") |
|||
Language("af", "afr", u"Afrikaans") |
|||
Language("ak", "aka", u"Akan") |
|||
Language("sq", "alb/sqi", u"Albanian") |
|||
Language("am", "amh", u"Amharic") |
|||
Language("ar", "ara", u"Arabic") |
|||
Language("an", "arg", u"Aragonese") |
|||
Language("hy", "arm/hye", u"Armenian") |
|||
Language("as", "asm", u"Assamese") |
|||
Language("av", "ava", u"Avaric") |
|||
Language("ae", "ave", u"Avestan") |
|||
Language("ay", "aym", u"Aymara") |
|||
Language("az", "aze", u"Azerbaijani") |
|||
Language("bm", "bam", u"Bambara") |
|||
Language("ba", "bak", u"Bashkir") |
|||
Language("eu", "baq/eus", u"Basque") |
|||
Language("be", "bel", u"Belarusian") |
|||
Language("bn", "ben", u"Bengali") |
|||
Language("bh", "bih", u"Bihari languages") |
|||
Language("bi", "bis", u"Bislama") |
|||
Language("nb", "nob", u"Bokmål, Norwegian") |
|||
Language("bs", "bos", u"Bosnian") |
|||
Language("br", "bre", u"Breton") |
|||
Language("bg", "bul", u"Bulgarian") |
|||
Language("my", "bur/mya", u"Burmese") |
|||
Language("es", "spa", u"Castilian") |
|||
Language("ca", "cat", u"Catalan") |
|||
Language("km", "khm", u"Central Khmer") |
|||
Language("ch", "cha", u"Chamorro") |
|||
Language("ce", "che", u"Chechen") |
|||
Language("ny", "nya", u"Chewa") |
|||
Language("ny", "nya", u"Chichewa") |
|||
Language("zh", "chi/zho", u"Chinese") |
|||
Language("za", "zha", u"Chuang") |
|||
Language("cu", "chu", u"Church Slavic") |
|||
Language("cu", "chu", u"Church Slavonic") |
|||
Language("cv", "chv", u"Chuvash") |
|||
Language("kw", "cor", u"Cornish") |
|||
Language("co", "cos", u"Corsican") |
|||
Language("cr", "cre", u"Cree") |
|||
Language("hr", "hrv", u"Croatian") |
|||
Language("cs", "cze/ces", u"Czech") |
|||
Language("da", "dan", u"Danish") |
|||
Language("dv", "div", u"Dhivehi") |
|||
Language("dv", "div", u"Divehi") |
|||
Language("nl", "dut/nld", u"Dutch") |
|||
Language("dz", "dzo", u"Dzongkha") |
|||
Language("en", "eng", u"English") |
|||
Language("eo", "epo", u"Esperanto") |
|||
Language("et", "est", u"Estonian") |
|||
Language("ee", "ewe", u"Ewe") |
|||
Language("fo", "fao", u"Faroese") |
|||
Language("fj", "fij", u"Fijian") |
|||
Language("fi", "fin", u"Finnish") |
|||
Language("nl", "dut/nld", u"Flemish") |
|||
Language("fr", "fre/fra", u"French") |
|||
Language("ff", "ful", u"Fulah") |
|||
Language("gd", "gla", u"Gaelic") |
|||
Language("gl", "glg", u"Galician") |
|||
Language("lg", "lug", u"Ganda") |
|||
Language("ka", "geo/kat", u"Georgian") |
|||
Language("de", "ger/deu", u"German") |
|||
Language("ki", "kik", u"Gikuyu") |
|||
Language("el", "gre/ell", u"Greek, Modern (1453-)") |
|||
Language("kl", "kal", u"Greenlandic") |
|||
Language("gn", "grn", u"Guarani") |
|||
Language("gu", "guj", u"Gujarati") |
|||
Language("ht", "hat", u"Haitian") |
|||
Language("ht", "hat", u"Haitian Creole") |
|||
Language("ha", "hau", u"Hausa") |
|||
Language("he", "heb", u"Hebrew") |
|||
Language("hz", "her", u"Herero") |
|||
Language("hi", "hin", u"Hindi") |
|||
Language("ho", "hmo", u"Hiri Motu") |
|||
Language("hu", "hun", u"Hungarian") |
|||
Language("is", "ice/isl", u"Icelandic") |
|||
Language("io", "ido", u"Ido") |
|||
Language("ig", "ibo", u"Igbo") |
|||
Language("id", "ind", u"Indonesian") |
|||
Language("ia", "ina", u"Interlingua (International Auxiliary Language Association)") |
|||
Language("ie", "ile", u"Interlingue") |
|||
Language("iu", "iku", u"Inuktitut") |
|||
Language("ik", "ipk", u"Inupiaq") |
|||
Language("ga", "gle", u"Irish") |
|||
Language("it", "ita", u"Italian") |
|||
Language("ja", "jpn", u"Japanese") |
|||
Language("jv", "jav", u"Javanese") |
|||
Language("kl", "kal", u"Kalaallisut") |
|||
Language("kn", "kan", u"Kannada") |
|||
Language("kr", "kau", u"Kanuri") |
|||
Language("ks", "kas", u"Kashmiri") |
|||
Language("kk", "kaz", u"Kazakh") |
|||
Language("ki", "kik", u"Kikuyu") |
|||
Language("rw", "kin", u"Kinyarwanda") |
|||
Language("ky", "kir", u"Kirghiz") |
|||
Language("kv", "kom", u"Komi") |
|||
Language("kg", "kon", u"Kongo") |
|||
Language("ko", "kor", u"Korean") |
|||
Language("kj", "kua", u"Kuanyama") |
|||
Language("ku", "kur", u"Kurdish") |
|||
Language("kj", "kua", u"Kwanyama") |
|||
Language("ky", "kir", u"Kyrgyz") |
|||
Language("lo", "lao", u"Lao") |
|||
Language("la", "lat", u"Latin") |
|||
Language("lv", "lav", u"Latvian") |
|||
Language("lb", "ltz", u"Letzeburgesch") |
|||
Language("li", "lim", u"Limburgan") |
|||
Language("li", "lim", u"Limburger") |
|||
Language("li", "lim", u"Limburgish") |
|||
Language("ln", "lin", u"Lingala") |
|||
Language("lt", "lit", u"Lithuanian") |
|||
Language("lu", "lub", u"Luba-Katanga") |
|||
Language("lb", "ltz", u"Luxembourgish") |
|||
Language("mk", "mac/mkd", u"Macedonian") |
|||
Language("mg", "mlg", u"Malagasy") |
|||
Language("ms", "may/msa", u"Malay") |
|||
Language("ml", "mal", u"Malayalam") |
|||
Language("dv", "div", u"Maldivian") |
|||
Language("mt", "mlt", u"Maltese") |
|||
Language("gv", "glv", u"Manx") |
|||
Language("mi", "mao/mri", u"Maori") |
|||
Language("mr", "mar", u"Marathi") |
|||
Language("mh", "mah", u"Marshallese") |
|||
Language("ro", "rum/ron", u"Moldavian") |
|||
Language("ro", "rum/ron", u"Moldovan") |
|||
Language("mn", "mon", u"Mongolian") |
|||
Language("na", "nau", u"Nauru") |
|||
Language("nv", "nav", u"Navaho") |
|||
Language("nv", "nav", u"Navajo") |
|||
Language("nd", "nde", u"Ndebele, North") |
|||
Language("nr", "nbl", u"Ndebele, South") |
|||
Language("ng", "ndo", u"Ndonga") |
|||
Language("ne", "nep", u"Nepali") |
|||
Language("nd", "nde", u"North Ndebele") |
|||
Language("se", "sme", u"Northern Sami") |
|||
Language("no", "nor", u"Norwegian") |
|||
Language("nb", "nob", u"Norwegian Bokmål") |
|||
Language("nn", "nno", u"Norwegian Nynorsk") |
|||
Language("ii", "iii", u"Nuosu") |
|||
Language("ny", "nya", u"Nyanja") |
|||
Language("nn", "nno", u"Nynorsk, Norwegian") |
|||
Language("ie", "ile", u"Occidental") |
|||
Language("oc", "oci", u"Occitan (post 1500)") |
|||
Language("oj", "oji", u"Ojibwa") |
|||
Language("cu", "chu", u"Old Bulgarian") |
|||
Language("cu", "chu", u"Old Church Slavonic") |
|||
Language("cu", "chu", u"Old Slavonic") |
|||
Language("or", "ori", u"Oriya") |
|||
Language("om", "orm", u"Oromo") |
|||
Language("os", "oss", u"Ossetian") |
|||
Language("os", "oss", u"Ossetic") |
|||
Language("pi", "pli", u"Pali") |
|||
Language("pa", "pan", u"Panjabi") |
|||
Language("ps", "pus", u"Pashto") |
|||
Language("fa", "per/fas", u"Persian") |
|||
Language("pl", "pol", u"Polish") |
|||
Language("pt", "por", u"Portuguese") |
|||
Language("pa", "pan", u"Punjabi") |
|||
Language("ps", "pus", u"Pushto") |
|||
Language("qu", "que", u"Quechua") |
|||
Language("ro", "rum/ron", u"Romanian") |
|||
Language("rm", "roh", u"Romansh") |
|||
Language("rn", "run", u"Rundi") |
|||
Language("ru", "rus", u"Russian") |
|||
Language("sm", "smo", u"Samoan") |
|||
Language("sg", "sag", u"Sango") |
|||
Language("sa", "san", u"Sanskrit") |
|||
Language("sc", "srd", u"Sardinian") |
|||
Language("gd", "gla", u"Scottish Gaelic") |
|||
Language("sr", "srp", u"Serbian") |
|||
Language("sn", "sna", u"Shona") |
|||
Language("ii", "iii", u"Sichuan Yi") |
|||
Language("sd", "snd", u"Sindhi") |
|||
Language("si", "sin", u"Sinhala") |
|||
Language("si", "sin", u"Sinhalese") |
|||
Language("sk", "slo/slk", u"Slovak") |
|||
Language("sl", "slv", u"Slovenian") |
|||
Language("so", "som", u"Somali") |
|||
Language("st", "sot", u"Sotho, Southern") |
|||
Language("nr", "nbl", u"South Ndebele") |
|||
Language("es", "spa", u"Spanish") |
|||
Language("su", "sun", u"Sundanese") |
|||
Language("sw", "swa", u"Swahili") |
|||
Language("ss", "ssw", u"Swati") |
|||
Language("sv", "swe", u"Swedish") |
|||
Language("tl", "tgl", u"Tagalog") |
|||
Language("ty", "tah", u"Tahitian") |
|||
Language("tg", "tgk", u"Tajik") |
|||
Language("ta", "tam", u"Tamil") |
|||
Language("tt", "tat", u"Tatar") |
|||
Language("te", "tel", u"Telugu") |
|||
Language("th", "tha", u"Thai") |
|||
Language("bo", "tib/bod", u"Tibetan") |
|||
Language("ti", "tir", u"Tigrinya") |
|||
Language("to", "ton", u"Tonga (Tonga Islands)") |
|||
Language("ts", "tso", u"Tsonga") |
|||
Language("tn", "tsn", u"Tswana") |
|||
Language("tr", "tur", u"Turkish") |
|||
Language("tk", "tuk", u"Turkmen") |
|||
Language("tw", "twi", u"Twi") |
|||
Language("ug", "uig", u"Uighur") |
|||
Language("uk", "ukr", u"Ukrainian") |
|||
Language("ur", "urd", u"Urdu") |
|||
Language("ug", "uig", u"Uyghur") |
|||
Language("uz", "uzb", u"Uzbek") |
|||
Language("ca", "cat", u"Valencian") |
|||
Language("ve", "ven", u"Venda") |
|||
Language("vi", "vie", u"Vietnamese") |
|||
Language("vo", "vol", u"Volapük") |
|||
Language("wa", "wln", u"Walloon") |
|||
Language("cy", "wel/cym", u"Welsh") |
|||
Language("fy", "fry", u"Western Frisian") |
|||
Language("wo", "wol", u"Wolof") |
|||
Language("xh", "xho", u"Xhosa") |
|||
Language("yi", "yid", u"Yiddish") |
|||
Language("yo", "yor", u"Yoruba") |
|||
Language("za", "zha", u"Zhuang") |
|||
Language("zu", "zul", u"Zulu") |
|||
Country("AF", u"AFGHANISTAN") |
|||
Country("AX", u"ÅLAND ISLANDS") |
|||
Country("AL", u"ALBANIA") |
|||
Country("DZ", u"ALGERIA") |
|||
Country("AS", u"AMERICAN SAMOA") |
|||
Country("AD", u"ANDORRA") |
|||
Country("AO", u"ANGOLA") |
|||
Country("AI", u"ANGUILLA") |
|||
Country("AQ", u"ANTARCTICA") |
|||
Country("AG", u"ANTIGUA AND BARBUDA") |
|||
Country("AR", u"ARGENTINA") |
|||
Country("AM", u"ARMENIA") |
|||
Country("AW", u"ARUBA") |
|||
Country("AU", u"AUSTRALIA") |
|||
Country("AT", u"AUSTRIA") |
|||
Country("AZ", u"AZERBAIJAN") |
|||
Country("BS", u"BAHAMAS") |
|||
Country("BH", u"BAHRAIN") |
|||
Country("BD", u"BANGLADESH") |
|||
Country("BB", u"BARBADOS") |
|||
Country("BY", u"BELARUS") |
|||
Country("BE", u"BELGIUM") |
|||
Country("BZ", u"BELIZE") |
|||
Country("BJ", u"BENIN") |
|||
Country("BM", u"BERMUDA") |
|||
Country("BT", u"BHUTAN") |
|||
Country("BO", u"BOLIVIA, PLURINATIONAL STATE OF") |
|||
Country("BQ", u"BONAIRE, SINT EUSTATIUS AND SABA") |
|||
Country("BA", u"BOSNIA AND HERZEGOVINA") |
|||
Country("BW", u"BOTSWANA") |
|||
Country("BV", u"BOUVET ISLAND") |
|||
Country("BR", u"BRAZIL") |
|||
Country("IO", u"BRITISH INDIAN OCEAN TERRITORY") |
|||
Country("BN", u"BRUNEI DARUSSALAM") |
|||
Country("BG", u"BULGARIA") |
|||
Country("BF", u"BURKINA FASO") |
|||
Country("BI", u"BURUNDI") |
|||
Country("KH", u"CAMBODIA") |
|||
Country("CM", u"CAMEROON") |
|||
Country("CA", u"CANADA") |
|||
Country("CV", u"CAPE VERDE") |
|||
Country("KY", u"CAYMAN ISLANDS") |
|||
Country("CF", u"CENTRAL AFRICAN REPUBLIC") |
|||
Country("TD", u"CHAD") |
|||
Country("CL", u"CHILE") |
|||
Country("CN", u"CHINA") |
|||
Country("CX", u"CHRISTMAS ISLAND") |
|||
Country("CC", u"COCOS (KEELING) ISLANDS") |
|||
Country("CO", u"COLOMBIA") |
|||
Country("KM", u"COMOROS") |
|||
Country("CG", u"CONGO") |
|||
Country("CD", u"CONGO, THE DEMOCRATIC REPUBLIC OF THE") |
|||
Country("CK", u"COOK ISLANDS") |
|||
Country("CR", u"COSTA RICA") |
|||
Country("CI", u"CÔTE D'IVOIRE") |
|||
Country("HR", u"CROATIA") |
|||
Country("CU", u"CUBA") |
|||
Country("CW", u"CURAÇAO") |
|||
Country("CY", u"CYPRUS") |
|||
Country("CZ", u"CZECH REPUBLIC") |
|||
Country("DK", u"DENMARK") |
|||
Country("DJ", u"DJIBOUTI") |
|||
Country("DM", u"DOMINICA") |
|||
Country("DO", u"DOMINICAN REPUBLIC") |
|||
Country("EC", u"ECUADOR") |
|||
Country("EG", u"EGYPT") |
|||
Country("SV", u"EL SALVADOR") |
|||
Country("GQ", u"EQUATORIAL GUINEA") |
|||
Country("ER", u"ERITREA") |
|||
Country("EE", u"ESTONIA") |
|||
Country("ET", u"ETHIOPIA") |
|||
Country("FK", u"FALKLAND ISLANDS (MALVINAS)") |
|||
Country("FO", u"FAROE ISLANDS") |
|||
Country("FJ", u"FIJI") |
|||
Country("FI", u"FINLAND") |
|||
Country("FR", u"FRANCE") |
|||
Country("GF", u"FRENCH GUIANA") |
|||
Country("PF", u"FRENCH POLYNESIA") |
|||
Country("TF", u"FRENCH SOUTHERN TERRITORIES") |
|||
Country("GA", u"GABON") |
|||
Country("GM", u"GAMBIA") |
|||
Country("GE", u"GEORGIA") |
|||
Country("DE", u"GERMANY") |
|||
Country("GH", u"GHANA") |
|||
Country("GI", u"GIBRALTAR") |
|||
Country("GR", u"GREECE") |
|||
Country("GL", u"GREENLAND") |
|||
Country("GD", u"GRENADA") |
|||
Country("GP", u"GUADELOUPE") |
|||
Country("GU", u"GUAM") |
|||
Country("GT", u"GUATEMALA") |
|||
Country("GG", u"GUERNSEY") |
|||
Country("GN", u"GUINEA") |
|||
Country("GW", u"GUINEA-BISSAU") |
|||
Country("GY", u"GUYANA") |
|||
Country("HT", u"HAITI") |
|||
Country("HM", u"HEARD ISLAND AND MCDONALD ISLANDS") |
|||
Country("VA", u"HOLY SEE (VATICAN CITY STATE)") |
|||
Country("HN", u"HONDURAS") |
|||
Country("HK", u"HONG KONG") |
|||
Country("HU", u"HUNGARY") |
|||
Country("IS", u"ICELAND") |
|||
Country("IN", u"INDIA") |
|||
Country("ID", u"INDONESIA") |
|||
Country("IR", u"IRAN, ISLAMIC REPUBLIC OF") |
|||
Country("IQ", u"IRAQ") |
|||
Country("IE", u"IRELAND") |
|||
Country("IM", u"ISLE OF MAN") |
|||
Country("IL", u"ISRAEL") |
|||
Country("IT", u"ITALY") |
|||
Country("JM", u"JAMAICA") |
|||
Country("JP", u"JAPAN") |
|||
Country("JE", u"JERSEY") |
|||
Country("JO", u"JORDAN") |
|||
Country("KZ", u"KAZAKHSTAN") |
|||
Country("KE", u"KENYA") |
|||
Country("KI", u"KIRIBATI") |
|||
Country("KP", u"KOREA, DEMOCRATIC PEOPLE'S REPUBLIC OF") |
|||
Country("KR", u"KOREA, REPUBLIC OF") |
|||
Country("KW", u"KUWAIT") |
|||
Country("KG", u"KYRGYZSTAN") |
|||
Country("LA", u"LAO PEOPLE'S DEMOCRATIC REPUBLIC") |
|||
Country("LV", u"LATVIA") |
|||
Country("LB", u"LEBANON") |
|||
Country("LS", u"LESOTHO") |
|||
Country("LR", u"LIBERIA") |
|||
Country("LY", u"LIBYA") |
|||
Country("LI", u"LIECHTENSTEIN") |
|||
Country("LT", u"LITHUANIA") |
|||
Country("LU", u"LUXEMBOURG") |
|||
Country("MO", u"MACAO") |
|||
Country("MK", u"MACEDONIA, THE FORMER YUGOSLAV REPUBLIC OF") |
|||
Country("MG", u"MADAGASCAR") |
|||
Country("MW", u"MALAWI") |
|||
Country("MY", u"MALAYSIA") |
|||
Country("MV", u"MALDIVES") |
|||
Country("ML", u"MALI") |
|||
Country("MT", u"MALTA") |
|||
Country("MH", u"MARSHALL ISLANDS") |
|||
Country("MQ", u"MARTINIQUE") |
|||
Country("MR", u"MAURITANIA") |
|||
Country("MU", u"MAURITIUS") |
|||
Country("YT", u"MAYOTTE") |
|||
Country("MX", u"MEXICO") |
|||
Country("FM", u"MICRONESIA, FEDERATED STATES OF") |
|||
Country("MD", u"MOLDOVA, REPUBLIC OF") |
|||
Country("MC", u"MONACO") |
|||
Country("MN", u"MONGOLIA") |
|||
Country("ME", u"MONTENEGRO") |
|||
Country("MS", u"MONTSERRAT") |
|||
Country("MA", u"MOROCCO") |
|||
Country("MZ", u"MOZAMBIQUE") |
|||
Country("MM", u"MYANMAR") |
|||
Country("NA", u"NAMIBIA") |
|||
Country("NR", u"NAURU") |
|||
Country("NP", u"NEPAL") |
|||
Country("NL", u"NETHERLANDS") |
|||
Country("NC", u"NEW CALEDONIA") |
|||
Country("NZ", u"NEW ZEALAND") |
|||
Country("NI", u"NICARAGUA") |
|||
Country("NE", u"NIGER") |
|||
Country("NG", u"NIGERIA") |
|||
Country("NU", u"NIUE") |
|||
Country("NF", u"NORFOLK ISLAND") |
|||
Country("MP", u"NORTHERN MARIANA ISLANDS") |
|||
Country("NO", u"NORWAY") |
|||
Country("OM", u"OMAN") |
|||
Country("PK", u"PAKISTAN") |
|||
Country("PW", u"PALAU") |
|||
Country("PS", u"PALESTINIAN TERRITORY, OCCUPIED") |
|||
Country("PA", u"PANAMA") |
|||
Country("PG", u"PAPUA NEW GUINEA") |
|||
Country("PY", u"PARAGUAY") |
|||
Country("PE", u"PERU") |
|||
Country("PH", u"PHILIPPINES") |
|||
Country("PN", u"PITCAIRN") |
|||
Country("PL", u"POLAND") |
|||
Country("PT", u"PORTUGAL") |
|||
Country("PR", u"PUERTO RICO") |
|||
Country("QA", u"QATAR") |
|||
Country("RE", u"RÉUNION") |
|||
Country("RO", u"ROMANIA") |
|||
Country("RU", u"RUSSIAN FEDERATION") |
|||
Country("RW", u"RWANDA") |
|||
Country("BL", u"SAINT BARTHÉLEMY") |
|||
Country("SH", u"SAINT HELENA, ASCENSION AND TRISTAN DA CUNHA") |
|||
Country("KN", u"SAINT KITTS AND NEVIS") |
|||
Country("LC", u"SAINT LUCIA") |
|||
Country("MF", u"SAINT MARTIN (FRENCH PART)") |
|||
Country("PM", u"SAINT PIERRE AND MIQUELON") |
|||
Country("VC", u"SAINT VINCENT AND THE GRENADINES") |
|||
Country("WS", u"SAMOA") |
|||
Country("SM", u"SAN MARINO") |
|||
Country("ST", u"SAO TOME AND PRINCIPE") |
|||
Country("SA", u"SAUDI ARABIA") |
|||
Country("SN", u"SENEGAL") |
|||
Country("RS", u"SERBIA") |
|||
Country("SC", u"SEYCHELLES") |
|||
Country("SL", u"SIERRA LEONE") |
|||
Country("SG", u"SINGAPORE") |
|||
Country("SX", u"SINT MAARTEN (DUTCH PART)") |
|||
Country("SK", u"SLOVAKIA") |
|||
Country("SI", u"SLOVENIA") |
|||
Country("SB", u"SOLOMON ISLANDS") |
|||
Country("SO", u"SOMALIA") |
|||
Country("ZA", u"SOUTH AFRICA") |
|||
Country("GS", u"SOUTH GEORGIA AND THE SOUTH SANDWICH ISLANDS") |
|||
Country("SS", u"SOUTH SUDAN") |
|||
Country("ES", u"SPAIN") |
|||
Country("LK", u"SRI LANKA") |
|||
Country("SD", u"SUDAN") |
|||
Country("SR", u"SURINAME") |
|||
Country("SJ", u"SVALBARD AND JAN MAYEN") |
|||
Country("SZ", u"SWAZILAND") |
|||
Country("SE", u"SWEDEN") |
|||
Country("CH", u"SWITZERLAND") |
|||
Country("SY", u"SYRIAN ARAB REPUBLIC") |
|||
Country("TW", u"TAIWAN, PROVINCE OF CHINA") |
|||
Country("TJ", u"TAJIKISTAN") |
|||
Country("TZ", u"TANZANIA, UNITED REPUBLIC OF") |
|||
Country("TH", u"THAILAND") |
|||
Country("TL", u"TIMOR-LESTE") |
|||
Country("TG", u"TOGO") |
|||
Country("TK", u"TOKELAU") |
|||
Country("TO", u"TONGA") |
|||
Country("TT", u"TRINIDAD AND TOBAGO") |
|||
Country("TN", u"TUNISIA") |
|||
Country("TR", u"TURKEY") |
|||
Country("TM", u"TURKMENISTAN") |
|||
Country("TC", u"TURKS AND CAICOS ISLANDS") |
|||
Country("TV", u"TUVALU") |
|||
Country("UG", u"UGANDA") |
|||
Country("UA", u"UKRAINE") |
|||
Country("AE", u"UNITED ARAB EMIRATES") |
|||
Country("GB", u"UNITED KINGDOM") |
|||
Country("US", u"UNITED STATES") |
|||
Country("UM", u"UNITED STATES MINOR OUTLYING ISLANDS") |
|||
Country("UY", u"URUGUAY") |
|||
Country("UZ", u"UZBEKISTAN") |
|||
Country("VU", u"VANUATU") |
|||
Country("VE", u"VENEZUELA, BOLIVARIAN REPUBLIC OF") |
|||
Country("VN", u"VIET NAM") |
|||
Country("VG", u"VIRGIN ISLANDS, BRITISH") |
|||
Country("VI", u"VIRGIN ISLANDS, U.S.") |
|||
Country("WF", u"WALLIS AND FUTUNA") |
|||
Country("EH", u"WESTERN SAHARA") |
|||
Country("YE", u"YEMEN") |
|||
Country("ZM", u"ZAMBIA") |
|||
Country("ZW", u"ZIMBABWE") |
|||
@ -0,0 +1,109 @@ |
|||
#!/usr/bin/env python |
|||
# -*- coding: utf-8 -*- |
|||
#----------------------- |
|||
# Name: pager.py List-like structure designed for handling paged results |
|||
# Python Library |
|||
# Author: Raymond Wagner |
|||
#----------------------- |
|||
|
|||
from collections import Sequence, Iterator |
|||
|
|||
class PagedIterator( Iterator ): |
|||
def __init__(self, parent): |
|||
self._parent = parent |
|||
self._index = -1 |
|||
self._len = len(parent) |
|||
|
|||
def __iter__(self): |
|||
return self |
|||
|
|||
def next(self): |
|||
self._index += 1 |
|||
if self._index == self._len: |
|||
raise StopIteration |
|||
return self._parent[self._index] |
|||
|
|||
class UnpagedData( object ): |
|||
def copy(self): |
|||
return self.__class__() |
|||
|
|||
def __mul__(self, other): |
|||
return (self.copy() for a in range(other)) |
|||
|
|||
def __rmul__(self, other): |
|||
return (self.copy() for a in range(other)) |
|||
|
|||
class PagedList( Sequence ): |
|||
""" |
|||
List-like object, with support for automatically grabbing additional |
|||
pages from a data source. |
|||
""" |
|||
_iter_class = None |
|||
|
|||
def __iter__(self): |
|||
if self._iter_class is None: |
|||
self._iter_class = type(self.__class__.__name__ + 'Iterator', |
|||
(PagedIterator,), {}) |
|||
return self._iter_class(self) |
|||
|
|||
def __len__(self): |
|||
try: |
|||
return self._len |
|||
except: |
|||
return len(self._data) |
|||
|
|||
def __init__(self, iterable, pagesize=20): |
|||
self._data = list(iterable) |
|||
self._pagesize = pagesize |
|||
|
|||
def __getitem__(self, index): |
|||
if isinstance(index, slice): |
|||
return [self[x] for x in xrange(*index.indices(len(self)))] |
|||
if index >= len(self): |
|||
raise IndexError("list index outside range") |
|||
if (index >= len(self._data)) \ |
|||
or isinstance(self._data[index], UnpagedData): |
|||
self._populatepage(index/self._pagesize + 1) |
|||
return self._data[index] |
|||
|
|||
def __setitem__(self, index, value): |
|||
raise NotImplementedError |
|||
|
|||
def __delitem__(self, index): |
|||
raise NotImplementedError |
|||
|
|||
def __contains__(self, item): |
|||
raise NotImplementedError |
|||
|
|||
def _populatepage(self, page): |
|||
pagestart = (page-1) * self._pagesize |
|||
if len(self._data) < pagestart: |
|||
self._data.extend(UnpagedData()*(pagestart-len(self._data))) |
|||
if len(self._data) == pagestart: |
|||
self._data.extend(self._getpage(page)) |
|||
else: |
|||
for data in self._getpage(page): |
|||
self._data[pagestart] = data |
|||
pagestart += 1 |
|||
|
|||
def _getpage(self, page): |
|||
raise NotImplementedError("PagedList._getpage() must be provided "+\ |
|||
"by subclass") |
|||
|
|||
class PagedRequest( PagedList ): |
|||
""" |
|||
Derived PageList that provides a list-like object with automatic paging |
|||
intended for use with search requests. |
|||
""" |
|||
def __init__(self, request, handler=None): |
|||
self._request = request |
|||
if handler: self._handler = handler |
|||
super(PagedRequest, self).__init__(self._getpage(1), 20) |
|||
|
|||
def _getpage(self, page): |
|||
req = self._request.new(page=page) |
|||
res = req.readJSON() |
|||
self._len = res['total_results'] |
|||
for item in res['results']: |
|||
yield self._handler(item) |
|||
|
|||
@ -0,0 +1,157 @@ |
|||
#!/usr/bin/env python |
|||
# -*- coding: utf-8 -*- |
|||
#----------------------- |
|||
# Name: tmdb_request.py |
|||
# Python Library |
|||
# Author: Raymond Wagner |
|||
# Purpose: Wrapped urllib2.Request class pre-configured for accessing the |
|||
# TMDb v3 API |
|||
#----------------------- |
|||
|
|||
from tmdb_exceptions import * |
|||
from locales import get_locale |
|||
from cache import Cache |
|||
|
|||
from urllib import urlencode |
|||
import urllib2 |
|||
import json |
|||
|
|||
DEBUG = False |
|||
cache = Cache(filename='pytmdb3.cache') |
|||
|
|||
#DEBUG = True |
|||
#cache = Cache(engine='null') |
|||
|
|||
def set_key(key): |
|||
""" |
|||
Specify the API key to use retrieving data from themoviedb.org. This |
|||
key must be set before any calls will function. |
|||
""" |
|||
if len(key) != 32: |
|||
raise TMDBKeyInvalid("Specified API key must be 128-bit hex") |
|||
try: |
|||
int(key, 16) |
|||
except: |
|||
raise TMDBKeyInvalid("Specified API key must be 128-bit hex") |
|||
Request._api_key = key |
|||
|
|||
def set_cache(engine=None, *args, **kwargs): |
|||
"""Specify caching engine and properties.""" |
|||
cache.configure(engine, *args, **kwargs) |
|||
|
|||
class Request( urllib2.Request ): |
|||
_api_key = None |
|||
_base_url = "http://api.themoviedb.org/3/" |
|||
|
|||
@property |
|||
def api_key(self): |
|||
if self._api_key is None: |
|||
raise TMDBKeyMissing("API key must be specified before "+\ |
|||
"requests can be made") |
|||
return self._api_key |
|||
|
|||
def __init__(self, url, **kwargs): |
|||
"""Return a request object, using specified API path and arguments.""" |
|||
kwargs['api_key'] = self.api_key |
|||
self._url = url.lstrip('/') |
|||
self._kwargs = dict([(kwa,kwv) for kwa,kwv in kwargs.items() |
|||
if kwv is not None]) |
|||
|
|||
locale = get_locale() |
|||
kwargs = {} |
|||
for k,v in self._kwargs.items(): |
|||
kwargs[k] = locale.encode(v) |
|||
url = '{0}{1}?{2}'.format(self._base_url, self._url, urlencode(kwargs)) |
|||
|
|||
urllib2.Request.__init__(self, url) |
|||
self.add_header('Accept', 'application/json') |
|||
self.lifetime = 3600 # 1hr |
|||
|
|||
def new(self, **kwargs): |
|||
"""Create a new instance of the request, with tweaked arguments.""" |
|||
args = dict(self._kwargs) |
|||
for k,v in kwargs.items(): |
|||
if v is None: |
|||
if k in args: |
|||
del args[k] |
|||
else: |
|||
args[k] = v |
|||
obj = self.__class__(self._url, **args) |
|||
obj.lifetime = self.lifetime |
|||
return obj |
|||
|
|||
def add_data(self, data): |
|||
"""Provide data to be sent with POST.""" |
|||
urllib2.Request.add_data(self, urlencode(data)) |
|||
|
|||
def open(self): |
|||
"""Open a file object to the specified URL.""" |
|||
try: |
|||
if DEBUG: |
|||
print 'loading '+self.get_full_url() |
|||
if self.has_data(): |
|||
print ' '+self.get_data() |
|||
return urllib2.urlopen(self) |
|||
except urllib2.HTTPError, e: |
|||
raise TMDBHTTPError(e) |
|||
|
|||
def read(self): |
|||
"""Return result from specified URL as a string.""" |
|||
return self.open().read() |
|||
|
|||
@cache.cached(urllib2.Request.get_full_url) |
|||
def readJSON(self): |
|||
"""Parse result from specified URL as JSON data.""" |
|||
url = self.get_full_url() |
|||
try: |
|||
# catch HTTP error from open() |
|||
data = json.load(self.open()) |
|||
except TMDBHTTPError, e: |
|||
try: |
|||
# try to load whatever was returned |
|||
data = json.loads(e.response) |
|||
except: |
|||
# cannot parse json, just raise existing error |
|||
raise e |
|||
else: |
|||
# response parsed, try to raise error from TMDB |
|||
handle_status(data, url) |
|||
# no error from TMDB, just raise existing error |
|||
raise e |
|||
handle_status(data, url) |
|||
#if DEBUG: |
|||
# import pprint |
|||
# pprint.PrettyPrinter().pprint(data) |
|||
return data |
|||
|
|||
status_handlers = { |
|||
1: None, |
|||
2: TMDBRequestInvalid('Invalid service - This service does not exist.'), |
|||
3: TMDBRequestError('Authentication Failed - You do not have '+\ |
|||
'permissions to access this service.'), |
|||
4: TMDBRequestInvalid("Invalid format - This service doesn't exist "+\ |
|||
'in that format.'), |
|||
5: TMDBRequestInvalid('Invalid parameters - Your request parameters '+\ |
|||
'are incorrect.'), |
|||
6: TMDBRequestInvalid('Invalid id - The pre-requisite id is invalid '+\ |
|||
'or not found.'), |
|||
7: TMDBKeyInvalid('Invalid API key - You must be granted a valid key.'), |
|||
8: TMDBRequestError('Duplicate entry - The data you tried to submit '+\ |
|||
'already exists.'), |
|||
9: TMDBOffline('This service is tempirarily offline. Try again later.'), |
|||
10: TMDBKeyRevoked('Suspended API key - Access to your account has been '+\ |
|||
'suspended, contact TMDB.'), |
|||
11: TMDBError('Internal error - Something went wrong. Contact TMDb.'), |
|||
12: None, |
|||
13: None, |
|||
14: TMDBRequestError('Authentication Failed.'), |
|||
15: TMDBError('Failed'), |
|||
16: TMDBError('Device Denied'), |
|||
17: TMDBError('Session Denied')} |
|||
|
|||
def handle_status(data, query): |
|||
status = status_handlers[data.get('status_code', 1)] |
|||
if status is not None: |
|||
status.tmdberrno = data['status_code'] |
|||
status.query = query |
|||
raise status |
|||
@ -0,0 +1,689 @@ |
|||
#!/usr/bin/env python |
|||
# -*- coding: utf-8 -*- |
|||
#----------------------- |
|||
# Name: tmdb_api.py Simple-to-use Python interface to TMDB's API v3 |
|||
# Python Library |
|||
# Author: Raymond Wagner |
|||
# Purpose: This Python library is intended to provide a series of classes |
|||
# and methods for search and retrieval of text metadata and image |
|||
# URLs from TMDB. |
|||
# Preliminary API specifications can be found at |
|||
# http://help.themoviedb.org/kb/api/about-3 |
|||
# License: Creative Commons GNU GPL v2 |
|||
# (http://creativecommons.org/licenses/GPL/2.0/) |
|||
#----------------------- |
|||
|
|||
__title__ = "tmdb_api - Simple-to-use Python interface to TMDB's API v3 "+\ |
|||
"(www.themoviedb.org)" |
|||
__author__ = "Raymond Wagner" |
|||
__purpose__ = """ |
|||
This Python library is intended to provide a series of classes and methods |
|||
for search and retrieval of text metadata and image URLs from TMDB. |
|||
Preliminary API specifications can be found at |
|||
http://help.themoviedb.org/kb/api/about-3""" |
|||
|
|||
__version__="v0.6.17" |
|||
# 0.1.0 Initial development |
|||
# 0.2.0 Add caching mechanism for API queries |
|||
# 0.2.1 Temporary work around for broken search paging |
|||
# 0.3.0 Rework backend machinery for managing OO interface to results |
|||
# 0.3.1 Add collection support |
|||
# 0.3.2 Remove MythTV key from results.py |
|||
# 0.3.3 Add functional language support |
|||
# 0.3.4 Re-enable search paging |
|||
# 0.3.5 Add methods for grabbing current, popular, and top rated movies |
|||
# 0.3.6 Rework paging mechanism |
|||
# 0.3.7 Generalize caching mechanism, and allow controllability |
|||
# 0.4.0 Add full locale support (language and country) and optional fall through |
|||
# 0.4.1 Add custom classmethod for dealing with IMDB movie IDs |
|||
# 0.4.2 Improve cache file selection for Windows systems |
|||
# 0.4.3 Add a few missed Person properties |
|||
# 0.4.4 Add support for additional Studio information |
|||
# 0.4.5 Add locale fallthrough for images and alternate titles |
|||
# 0.4.6 Add slice support for search results |
|||
# 0.5.0 Rework cache framework and improve file cache performance |
|||
# 0.6.0 Add user authentication support |
|||
# 0.6.1 Add adult filtering for people searches |
|||
# 0.6.2 Add similar movie search for Movie objects |
|||
# 0.6.3 Add Studio search |
|||
# 0.6.4 Add Genre list and associated Movie search |
|||
# 0.6.5 Prevent data from being blanked out by subsequent queries |
|||
# 0.6.6 Turn date processing errors into mutable warnings |
|||
# 0.6.7 Add support for searching by year |
|||
# 0.6.8 Add support for collection images |
|||
# 0.6.9 Correct Movie image language filtering |
|||
# 0.6.10 Add upcoming movie classmethod |
|||
# 0.6.11 Fix URL for top rated Movie query |
|||
# 0.6.12 Add support for Movie watchlist query and editing |
|||
# 0.6.13 Fix URL for rating Movies |
|||
# 0.6.14 Add support for Lists |
|||
# 0.6.15 Add ability to search Collections |
|||
# 0.6.16 Make absent primary images return None (previously u'') |
|||
# 0.6.17 Add userrating/votes to Image, add overview to Collection, remove |
|||
# releasedate sorting from Collection Movies |
|||
|
|||
from request import set_key, Request |
|||
from util import Datapoint, Datalist, Datadict, Element, NameRepr, SearchRepr |
|||
from pager import PagedRequest |
|||
from locales import get_locale, set_locale |
|||
from tmdb_auth import get_session, set_session |
|||
from tmdb_exceptions import * |
|||
|
|||
import datetime |
|||
|
|||
DEBUG = False |
|||
|
|||
def process_date(datestr): |
|||
try: |
|||
return datetime.date(*[int(x) for x in datestr.split('-')]) |
|||
except (TypeError, ValueError): |
|||
import sys |
|||
import warnings |
|||
import traceback |
|||
_,_,tb = sys.exc_info() |
|||
f,l,_,_ = traceback.extract_tb(tb)[-1] |
|||
warnings.warn_explicit(('"{0}" is not a supported date format. ' |
|||
'Please fix upstream data at http://www.themoviedb.org.')\ |
|||
.format(datestr), Warning, f, l) |
|||
return None |
|||
|
|||
class Configuration( Element ): |
|||
images = Datapoint('images') |
|||
def _populate(self): |
|||
return Request('configuration') |
|||
Configuration = Configuration() |
|||
|
|||
class Account( NameRepr, Element ): |
|||
def _populate(self): |
|||
return Request('account', session_id=self._session.sessionid) |
|||
|
|||
id = Datapoint('id') |
|||
adult = Datapoint('include_adult') |
|||
country = Datapoint('iso_3166_1') |
|||
language = Datapoint('iso_639_1') |
|||
name = Datapoint('name') |
|||
username = Datapoint('username') |
|||
|
|||
@property |
|||
def locale(self): |
|||
return get_locale(self.language, self.country) |
|||
|
|||
def searchMovie(query, locale=None, adult=False, year=None): |
|||
kwargs = {'query':query, 'include_adult':adult} |
|||
if year is not None: |
|||
try: |
|||
kwargs['year'] = year.year |
|||
except AttributeError: |
|||
kwargs['year'] = year |
|||
return MovieSearchResult(Request('search/movie', **kwargs), locale=locale) |
|||
|
|||
def searchMovieWithYear(query, locale=None, adult=False): |
|||
year = None |
|||
if (len(query) > 6) and (query[-1] == ')') and (query[-6] == '('): |
|||
# simple syntax check, no need for regular expression |
|||
try: |
|||
year = int(query[-5:-1]) |
|||
except ValueError: |
|||
pass |
|||
else: |
|||
if 1885 < year < 2050: |
|||
# strip out year from search |
|||
query = query[:-7] |
|||
else: |
|||
# sanity check on resolved year failed, pass through |
|||
year = None |
|||
return searchMovie(query, locale, adult, year) |
|||
|
|||
class MovieSearchResult( SearchRepr, PagedRequest ): |
|||
"""Stores a list of search matches.""" |
|||
_name = None |
|||
def __init__(self, request, locale=None): |
|||
if locale is None: |
|||
locale = get_locale() |
|||
super(MovieSearchResult, self).__init__( |
|||
request.new(language=locale.language), |
|||
lambda x: Movie(raw=x, locale=locale)) |
|||
|
|||
def searchPerson(query, adult=False): |
|||
return PeopleSearchResult(Request('search/person', query=query, |
|||
include_adult=adult)) |
|||
|
|||
class PeopleSearchResult( SearchRepr, PagedRequest ): |
|||
"""Stores a list of search matches.""" |
|||
_name = None |
|||
def __init__(self, request): |
|||
super(PeopleSearchResult, self).__init__(request, |
|||
lambda x: Person(raw=x)) |
|||
|
|||
def searchStudio(query): |
|||
return StudioSearchResult(Request('search/company', query=query)) |
|||
|
|||
class StudioSearchResult( SearchRepr, PagedRequest ): |
|||
"""Stores a list of search matches.""" |
|||
_name = None |
|||
def __init__(self, request): |
|||
super(StudioSearchResult, self).__init__(request, |
|||
lambda x: Studio(raw=x)) |
|||
|
|||
def searchList(query, adult=False): |
|||
ListSearchResult(Request('search/list', query=query, include_adult=adult)) |
|||
|
|||
class ListSearchResult( SearchRepr, PagedRequest ): |
|||
"""Stores a list of search matches.""" |
|||
_name = None |
|||
def __init__(self, request): |
|||
super(ListSearchResult, self).__init__(request, |
|||
lambda x: List(raw=x)) |
|||
|
|||
def searchCollection(query, locale=None): |
|||
return CollectionSearchResult(Request('search/collection', query=query), |
|||
locale=locale) |
|||
|
|||
class CollectionSearchResult( SearchRepr, PagedRequest ): |
|||
"""Stores a list of search matches.""" |
|||
_name=None |
|||
def __init__(self, request, locale=None): |
|||
if locale is None: |
|||
locale = get_locale() |
|||
super(CollectionSearchResult, self).__init__( |
|||
request.new(language=locale.language), |
|||
lambda x: Collection(raw=x, locale=locale)) |
|||
|
|||
class Image( Element ): |
|||
filename = Datapoint('file_path', initarg=1, |
|||
handler=lambda x: x.lstrip('/')) |
|||
aspectratio = Datapoint('aspect_ratio') |
|||
height = Datapoint('height') |
|||
width = Datapoint('width') |
|||
language = Datapoint('iso_639_1') |
|||
userrating = Datapoint('vote_average') |
|||
votes = Datapoint('vote_count') |
|||
|
|||
def sizes(self): |
|||
return ['original'] |
|||
|
|||
def geturl(self, size='original'): |
|||
if size not in self.sizes(): |
|||
raise TMDBImageSizeError |
|||
url = Configuration.images['base_url'].rstrip('/') |
|||
return url+'/{0}/{1}'.format(size, self.filename) |
|||
|
|||
# sort preferring locale's language, but keep remaining ordering consistent |
|||
def __lt__(self, other): |
|||
return (self.language == self._locale.language) \ |
|||
and (self.language != other.language) |
|||
def __gt__(self, other): |
|||
return (self.language != other.language) \ |
|||
and (other.language == self._locale.language) |
|||
# direct match for comparison |
|||
def __eq__(self, other): |
|||
return self.filename == other.filename |
|||
# special handling for boolean to see if exists |
|||
def __nonzero__(self): |
|||
if len(self.filename) == 0: |
|||
return False |
|||
return True |
|||
|
|||
def __repr__(self): |
|||
# BASE62 encoded filename, no need to worry about unicode |
|||
return u"<{0.__class__.__name__} '{0.filename}'>".format(self) |
|||
|
|||
class Backdrop( Image ): |
|||
def sizes(self): |
|||
return Configuration.images['backdrop_sizes'] |
|||
class Poster( Image ): |
|||
def sizes(self): |
|||
return Configuration.images['poster_sizes'] |
|||
class Profile( Image ): |
|||
def sizes(self): |
|||
return Configuration.images['profile_sizes'] |
|||
class Logo( Image ): |
|||
def sizes(self): |
|||
return Configuration.images['logo_sizes'] |
|||
|
|||
class AlternateTitle( Element ): |
|||
country = Datapoint('iso_3166_1') |
|||
title = Datapoint('title') |
|||
|
|||
# sort preferring locale's country, but keep remaining ordering consistent |
|||
def __lt__(self, other): |
|||
return (self.country == self._locale.country) \ |
|||
and (self.country != other.country) |
|||
def __gt__(self, other): |
|||
return (self.country != other.country) \ |
|||
and (other.country == self._locale.country) |
|||
def __eq__(self, other): |
|||
return self.country == other.country |
|||
|
|||
def __repr__(self): |
|||
return u"<{0.__class__.__name__} '{0.title}' ({0.country})>"\ |
|||
.format(self).encode('utf-8') |
|||
|
|||
class Person( Element ): |
|||
id = Datapoint('id', initarg=1) |
|||
name = Datapoint('name') |
|||
biography = Datapoint('biography') |
|||
dayofbirth = Datapoint('birthday', default=None, handler=process_date) |
|||
dayofdeath = Datapoint('deathday', default=None, handler=process_date) |
|||
homepage = Datapoint('homepage') |
|||
birthplace = Datapoint('place_of_birth') |
|||
profile = Datapoint('profile_path', handler=Profile, \ |
|||
raw=False, default=None) |
|||
adult = Datapoint('adult') |
|||
aliases = Datalist('also_known_as') |
|||
|
|||
def __repr__(self): |
|||
return u"<{0.__class__.__name__} '{0.name}'>"\ |
|||
.format(self).encode('utf-8') |
|||
|
|||
def _populate(self): |
|||
return Request('person/{0}'.format(self.id)) |
|||
def _populate_credits(self): |
|||
return Request('person/{0}/credits'.format(self.id), \ |
|||
language=self._locale.language) |
|||
def _populate_images(self): |
|||
return Request('person/{0}/images'.format(self.id)) |
|||
|
|||
roles = Datalist('cast', handler=lambda x: ReverseCast(raw=x), \ |
|||
poller=_populate_credits) |
|||
crew = Datalist('crew', handler=lambda x: ReverseCrew(raw=x), \ |
|||
poller=_populate_credits) |
|||
profiles = Datalist('profiles', handler=Profile, poller=_populate_images) |
|||
|
|||
class Cast( Person ): |
|||
character = Datapoint('character') |
|||
order = Datapoint('order') |
|||
|
|||
def __repr__(self): |
|||
return u"<{0.__class__.__name__} '{0.name}' as '{0.character}'>"\ |
|||
.format(self).encode('utf-8') |
|||
|
|||
class Crew( Person ): |
|||
job = Datapoint('job') |
|||
department = Datapoint('department') |
|||
|
|||
def __repr__(self): |
|||
return u"<{0.__class__.__name__} '{0.name}','{0.job}'>"\ |
|||
.format(self).encode('utf-8') |
|||
|
|||
class Keyword( Element ): |
|||
id = Datapoint('id') |
|||
name = Datapoint('name') |
|||
|
|||
def __repr__(self): |
|||
return u"<{0.__class__.__name__} {0.name}>".format(self).encode('utf-8') |
|||
|
|||
class Release( Element ): |
|||
certification = Datapoint('certification') |
|||
country = Datapoint('iso_3166_1') |
|||
releasedate = Datapoint('release_date', handler=process_date) |
|||
def __repr__(self): |
|||
return u"<{0.__class__.__name__} {0.country}, {0.releasedate}>"\ |
|||
.format(self).encode('utf-8') |
|||
|
|||
class Trailer( Element ): |
|||
name = Datapoint('name') |
|||
size = Datapoint('size') |
|||
source = Datapoint('source') |
|||
|
|||
class YoutubeTrailer( Trailer ): |
|||
def geturl(self): |
|||
return "http://www.youtube.com/watch?v={0}".format(self.source) |
|||
|
|||
def __repr__(self): |
|||
# modified BASE64 encoding, no need to worry about unicode |
|||
return u"<{0.__class__.__name__} '{0.name}'>".format(self) |
|||
|
|||
class AppleTrailer( Element ): |
|||
name = Datapoint('name') |
|||
sources = Datadict('sources', handler=Trailer, attr='size') |
|||
|
|||
def sizes(self): |
|||
return self.sources.keys() |
|||
|
|||
def geturl(self, size=None): |
|||
if size is None: |
|||
# sort assuming ###p format for now, take largest resolution |
|||
size = str(sorted([int(size[:-1]) for size in self.sources])[-1])+'p' |
|||
return self.sources[size].source |
|||
|
|||
def __repr__(self): |
|||
return u"<{0.__class__.__name__} '{0.name}'>".format(self) |
|||
|
|||
class Translation( Element ): |
|||
name = Datapoint('name') |
|||
language = Datapoint('iso_639_1') |
|||
englishname = Datapoint('english_name') |
|||
|
|||
def __repr__(self): |
|||
return u"<{0.__class__.__name__} '{0.name}' ({0.language})>"\ |
|||
.format(self).encode('utf-8') |
|||
|
|||
class Genre( NameRepr, Element ): |
|||
id = Datapoint('id') |
|||
name = Datapoint('name') |
|||
|
|||
def _populate_movies(self): |
|||
return Request('genre/{0}/movies'.format(self.id), \ |
|||
language=self._locale.language) |
|||
|
|||
@property |
|||
def movies(self): |
|||
if 'movies' not in self._data: |
|||
search = MovieSearchResult(self._populate_movies(), \ |
|||
locale=self._locale) |
|||
search._name = "{0.name} Movies".format(self) |
|||
self._data['movies'] = search |
|||
return self._data['movies'] |
|||
|
|||
@classmethod |
|||
def getAll(cls, locale=None): |
|||
class GenreList( Element ): |
|||
genres = Datalist('genres', handler=Genre) |
|||
def _populate(self): |
|||
return Request('genre/list', language=self._locale.language) |
|||
return GenreList(locale=locale).genres |
|||
|
|||
|
|||
class Studio( NameRepr, Element ): |
|||
id = Datapoint('id', initarg=1) |
|||
name = Datapoint('name') |
|||
description = Datapoint('description') |
|||
headquarters = Datapoint('headquarters') |
|||
logo = Datapoint('logo_path', handler=Logo, \ |
|||
raw=False, default=None) |
|||
# FIXME: manage not-yet-defined handlers in a way that will propogate |
|||
# locale information properly |
|||
parent = Datapoint('parent_company', \ |
|||
handler=lambda x: Studio(raw=x)) |
|||
|
|||
def _populate(self): |
|||
return Request('company/{0}'.format(self.id)) |
|||
def _populate_movies(self): |
|||
return Request('company/{0}/movies'.format(self.id), \ |
|||
language=self._locale.language) |
|||
|
|||
# FIXME: add a cleaner way of adding types with no additional processing |
|||
@property |
|||
def movies(self): |
|||
if 'movies' not in self._data: |
|||
search = MovieSearchResult(self._populate_movies(), \ |
|||
locale=self._locale) |
|||
search._name = "{0.name} Movies".format(self) |
|||
self._data['movies'] = search |
|||
return self._data['movies'] |
|||
|
|||
class Country( NameRepr, Element ): |
|||
code = Datapoint('iso_3166_1') |
|||
name = Datapoint('name') |
|||
|
|||
class Language( NameRepr, Element ): |
|||
code = Datapoint('iso_639_1') |
|||
name = Datapoint('name') |
|||
|
|||
class Movie( Element ): |
|||
@classmethod |
|||
def latest(cls): |
|||
req = Request('latest/movie') |
|||
req.lifetime = 600 |
|||
return cls(raw=req.readJSON()) |
|||
|
|||
@classmethod |
|||
def nowplaying(cls, locale=None): |
|||
res = MovieSearchResult(Request('movie/now-playing'), locale=locale) |
|||
res._name = 'Now Playing' |
|||
return res |
|||
|
|||
@classmethod |
|||
def mostpopular(cls, locale=None): |
|||
res = MovieSearchResult(Request('movie/popular'), locale=locale) |
|||
res._name = 'Popular' |
|||
return res |
|||
|
|||
@classmethod |
|||
def toprated(cls, locale=None): |
|||
res = MovieSearchResult(Request('movie/top_rated'), locale=locale) |
|||
res._name = 'Top Rated' |
|||
return res |
|||
|
|||
@classmethod |
|||
def upcoming(cls, locale=None): |
|||
res = MovieSearchResult(Request('movie/upcoming'), locale=locale) |
|||
res._name = 'Upcoming' |
|||
return res |
|||
|
|||
@classmethod |
|||
def favorites(cls, session=None): |
|||
if session is None: |
|||
session = get_session() |
|||
account = Account(session=session) |
|||
res = MovieSearchResult( |
|||
Request('account/{0}/favorite_movies'.format(account.id), |
|||
session_id=session.sessionid)) |
|||
res._name = "Favorites" |
|||
return res |
|||
|
|||
@classmethod |
|||
def ratedmovies(cls, session=None): |
|||
if session is None: |
|||
session = get_session() |
|||
account = Account(session=session) |
|||
res = MovieSearchResult( |
|||
Request('account/{0}/rated_movies'.format(account.id), |
|||
session_id=session.sessionid)) |
|||
res._name = "Movies You Rated" |
|||
return res |
|||
|
|||
@classmethod |
|||
def watchlist(cls, session=None): |
|||
if session is None: |
|||
session = get_session() |
|||
account = Account(session=session) |
|||
res = MovieSearchResult( |
|||
Request('account/{0}/movie_watchlist'.format(account.id), |
|||
session_id=session.sessionid)) |
|||
res._name = "Movies You're Watching" |
|||
return res |
|||
|
|||
@classmethod |
|||
def fromIMDB(cls, imdbid, locale=None): |
|||
try: |
|||
# assume string |
|||
if not imdbid.startswith('tt'): |
|||
imdbid = "tt{0:0>7}".format(imdbid) |
|||
except AttributeError: |
|||
# assume integer |
|||
imdbid = "tt{0:0>7}".format(imdbid) |
|||
if locale is None: |
|||
locale = get_locale() |
|||
movie = cls(imdbid, locale=locale) |
|||
movie._populate() |
|||
return movie |
|||
|
|||
id = Datapoint('id', initarg=1) |
|||
title = Datapoint('title') |
|||
originaltitle = Datapoint('original_title') |
|||
tagline = Datapoint('tagline') |
|||
overview = Datapoint('overview') |
|||
runtime = Datapoint('runtime') |
|||
budget = Datapoint('budget') |
|||
revenue = Datapoint('revenue') |
|||
releasedate = Datapoint('release_date', handler=process_date) |
|||
homepage = Datapoint('homepage') |
|||
imdb = Datapoint('imdb_id') |
|||
|
|||
backdrop = Datapoint('backdrop_path', handler=Backdrop, \ |
|||
raw=False, default=None) |
|||
poster = Datapoint('poster_path', handler=Poster, \ |
|||
raw=False, default=None) |
|||
|
|||
popularity = Datapoint('popularity') |
|||
userrating = Datapoint('vote_average') |
|||
votes = Datapoint('vote_count') |
|||
|
|||
adult = Datapoint('adult') |
|||
collection = Datapoint('belongs_to_collection', handler=lambda x: \ |
|||
Collection(raw=x)) |
|||
genres = Datalist('genres', handler=Genre) |
|||
studios = Datalist('production_companies', handler=Studio) |
|||
countries = Datalist('production_countries', handler=Country) |
|||
languages = Datalist('spoken_languages', handler=Language) |
|||
|
|||
def _populate(self): |
|||
return Request('movie/{0}'.format(self.id), \ |
|||
language=self._locale.language) |
|||
def _populate_titles(self): |
|||
kwargs = {} |
|||
if not self._locale.fallthrough: |
|||
kwargs['country'] = self._locale.country |
|||
return Request('movie/{0}/alternative_titles'.format(self.id), **kwargs) |
|||
def _populate_cast(self): |
|||
return Request('movie/{0}/casts'.format(self.id)) |
|||
def _populate_images(self): |
|||
kwargs = {} |
|||
if not self._locale.fallthrough: |
|||
kwargs['language'] = self._locale.language |
|||
return Request('movie/{0}/images'.format(self.id), **kwargs) |
|||
def _populate_keywords(self): |
|||
return Request('movie/{0}/keywords'.format(self.id)) |
|||
def _populate_releases(self): |
|||
return Request('movie/{0}/releases'.format(self.id)) |
|||
def _populate_trailers(self): |
|||
return Request('movie/{0}/trailers'.format(self.id), \ |
|||
language=self._locale.language) |
|||
def _populate_translations(self): |
|||
return Request('movie/{0}/translations'.format(self.id)) |
|||
|
|||
alternate_titles = Datalist('titles', handler=AlternateTitle, \ |
|||
poller=_populate_titles, sort=True) |
|||
cast = Datalist('cast', handler=Cast, \ |
|||
poller=_populate_cast, sort='order') |
|||
crew = Datalist('crew', handler=Crew, poller=_populate_cast) |
|||
backdrops = Datalist('backdrops', handler=Backdrop, \ |
|||
poller=_populate_images, sort=True) |
|||
posters = Datalist('posters', handler=Poster, \ |
|||
poller=_populate_images, sort=True) |
|||
keywords = Datalist('keywords', handler=Keyword, \ |
|||
poller=_populate_keywords) |
|||
releases = Datadict('countries', handler=Release, \ |
|||
poller=_populate_releases, attr='country') |
|||
youtube_trailers = Datalist('youtube', handler=YoutubeTrailer, \ |
|||
poller=_populate_trailers) |
|||
apple_trailers = Datalist('quicktime', handler=AppleTrailer, \ |
|||
poller=_populate_trailers) |
|||
translations = Datalist('translations', handler=Translation, \ |
|||
poller=_populate_translations) |
|||
|
|||
def setFavorite(self, value): |
|||
req = Request('account/{0}/favorite'.format(\ |
|||
Account(session=self._session).id), |
|||
session_id=self._session.sessionid) |
|||
req.add_data({'movie_id':self.id, 'favorite':str(bool(value)).lower()}) |
|||
req.lifetime = 0 |
|||
req.readJSON() |
|||
|
|||
def setRating(self, value): |
|||
if not (0 <= value <= 10): |
|||
raise TMDBError("Ratings must be between '0' and '10'.") |
|||
req = Request('movie/{0}/rating'.format(self.id), \ |
|||
session_id=self._session.sessionid) |
|||
req.lifetime = 0 |
|||
req.add_data({'value':value}) |
|||
req.readJSON() |
|||
|
|||
def setWatchlist(self, value): |
|||
req = Request('account/{0}/movie_watchlist'.format(\ |
|||
Account(session=self._session).id), |
|||
session_id=self._session.sessionid) |
|||
req.lifetime = 0 |
|||
req.add_data({'movie_id':self.id, |
|||
'movie_watchlist':str(bool(value)).lower()}) |
|||
req.readJSON() |
|||
|
|||
def getSimilar(self): |
|||
return self.similar |
|||
|
|||
@property |
|||
def similar(self): |
|||
res = MovieSearchResult(Request('movie/{0}/similar_movies'\ |
|||
.format(self.id)), |
|||
locale=self._locale) |
|||
res._name = 'Similar to {0}'.format(self._printable_name()) |
|||
return res |
|||
|
|||
@property |
|||
def lists(self): |
|||
res = ListSearchResult(Request('movie/{0}/lists'.format(self.id))) |
|||
res._name = "Lists containing {0}".format(self._printable_name()) |
|||
return res |
|||
|
|||
def _printable_name(self): |
|||
if self.title is not None: |
|||
s = u"'{0}'".format(self.title) |
|||
elif self.originaltitle is not None: |
|||
s = u"'{0}'".format(self.originaltitle) |
|||
else: |
|||
s = u"'No Title'" |
|||
if self.releasedate: |
|||
s = u"{0} ({1})".format(s, self.releasedate.year) |
|||
return s |
|||
|
|||
def __repr__(self): |
|||
return u"<{0} {1}>".format(self.__class__.__name__,\ |
|||
self._printable_name()).encode('utf-8') |
|||
|
|||
class ReverseCast( Movie ): |
|||
character = Datapoint('character') |
|||
|
|||
def __repr__(self): |
|||
return u"<{0.__class__.__name__} '{0.character}' on {1}>"\ |
|||
.format(self, self._printable_name()).encode('utf-8') |
|||
|
|||
class ReverseCrew( Movie ): |
|||
department = Datapoint('department') |
|||
job = Datapoint('job') |
|||
|
|||
def __repr__(self): |
|||
return u"<{0.__class__.__name__} '{0.job}' for {1}>"\ |
|||
.format(self, self._printable_name()).encode('utf-8') |
|||
|
|||
class Collection( NameRepr, Element ): |
|||
id = Datapoint('id', initarg=1) |
|||
name = Datapoint('name') |
|||
backdrop = Datapoint('backdrop_path', handler=Backdrop, \ |
|||
raw=False, default=None) |
|||
poster = Datapoint('poster_path', handler=Poster, \ |
|||
raw=False, default=None) |
|||
members = Datalist('parts', handler=Movie) |
|||
overview = Datapoint('overview') |
|||
|
|||
def _populate(self): |
|||
return Request('collection/{0}'.format(self.id), \ |
|||
language=self._locale.language) |
|||
def _populate_images(self): |
|||
kwargs = {} |
|||
if not self._locale.fallthrough: |
|||
kwargs['language'] = self._locale.language |
|||
return Request('collection/{0}/images'.format(self.id), **kwargs) |
|||
|
|||
backdrops = Datalist('backdrops', handler=Backdrop, \ |
|||
poller=_populate_images, sort=True) |
|||
posters = Datalist('posters', handler=Poster, \ |
|||
poller=_populate_images, sort=True) |
|||
|
|||
class List( NameRepr, Element ): |
|||
id = Datapoint('id', initarg=1) |
|||
name = Datapoint('name') |
|||
author = Datapoint('created_by') |
|||
description = Datapoint('description') |
|||
favorites = Datapoint('favorite_count') |
|||
language = Datapoint('iso_639_1') |
|||
count = Datapoint('item_count') |
|||
poster = Datapoint('poster_path', handler=Poster, \ |
|||
raw=False, default=None) |
|||
|
|||
members = Datalist('items', handler=Movie) |
|||
|
|||
def _populate(self): |
|||
return Request('list/{0}'.format(self.id)) |
|||
|
|||
@ -0,0 +1,131 @@ |
|||
#!/usr/bin/env python |
|||
# -*- coding: utf-8 -*- |
|||
#----------------------- |
|||
# Name: tmdb_auth.py |
|||
# Python Library |
|||
# Author: Raymond Wagner |
|||
# Purpose: Provide authentication and session services for |
|||
# calls against the TMDB v3 API |
|||
#----------------------- |
|||
|
|||
from datetime import datetime as _pydatetime, \ |
|||
tzinfo as _pytzinfo |
|||
import re |
|||
class datetime( _pydatetime ): |
|||
"""Customized datetime class with ISO format parsing.""" |
|||
_reiso = re.compile('(?P<year>[0-9]{4})' |
|||
'-(?P<month>[0-9]{1,2})' |
|||
'-(?P<day>[0-9]{1,2})' |
|||
'.' |
|||
'(?P<hour>[0-9]{2})' |
|||
':(?P<min>[0-9]{2})' |
|||
'(:(?P<sec>[0-9]{2}))?' |
|||
'(?P<tz>Z|' |
|||
'(?P<tzdirec>[-+])' |
|||
'(?P<tzhour>[0-9]{1,2})' |
|||
'(:)?' |
|||
'(?P<tzmin>[0-9]{2})?' |
|||
')?') |
|||
|
|||
class _tzinfo( _pytzinfo): |
|||
def __init__(self, direc='+', hr=0, min=0): |
|||
if direc == '-': |
|||
hr = -1*int(hr) |
|||
self._offset = timedelta(hours=int(hr), minutes=int(min)) |
|||
def utcoffset(self, dt): return self._offset |
|||
def tzname(self, dt): return '' |
|||
def dst(self, dt): return timedelta(0) |
|||
|
|||
@classmethod |
|||
def fromIso(cls, isotime, sep='T'): |
|||
match = cls._reiso.match(isotime) |
|||
if match is None: |
|||
raise TypeError("time data '%s' does not match ISO 8601 format" \ |
|||
% isotime) |
|||
|
|||
dt = [int(a) for a in match.groups()[:5]] |
|||
if match.group('sec') is not None: |
|||
dt.append(int(match.group('sec'))) |
|||
else: |
|||
dt.append(0) |
|||
if match.group('tz'): |
|||
if match.group('tz') == 'Z': |
|||
tz = cls._tzinfo() |
|||
elif match.group('tzmin'): |
|||
tz = cls._tzinfo(*match.group('tzdirec','tzhour','tzmin')) |
|||
else: |
|||
tz = cls._tzinfo(*match.group('tzdirec','tzhour')) |
|||
dt.append(0) |
|||
dt.append(tz) |
|||
return cls(*dt) |
|||
|
|||
from request import Request |
|||
from tmdb_exceptions import * |
|||
|
|||
syssession = None |
|||
|
|||
def set_session(sessionid): |
|||
global syssession |
|||
syssession = Session(sessionid) |
|||
|
|||
def get_session(sessionid=None): |
|||
global syssession |
|||
if sessionid: |
|||
return Session(sessionid) |
|||
elif syssession is not None: |
|||
return syssession |
|||
else: |
|||
return Session.new() |
|||
|
|||
class Session( object ): |
|||
|
|||
@classmethod |
|||
def new(cls): |
|||
return cls(None) |
|||
|
|||
def __init__(self, sessionid): |
|||
self.sessionid = sessionid |
|||
|
|||
@property |
|||
def sessionid(self): |
|||
if self._sessionid is None: |
|||
if self._authtoken is None: |
|||
raise TMDBError("No Auth Token to produce Session for") |
|||
# TODO: check authtokenexpiration against current time |
|||
req = Request('authentication/session/new', \ |
|||
request_token=self._authtoken) |
|||
req.lifetime = 0 |
|||
dat = req.readJSON() |
|||
if not dat['success']: |
|||
raise TMDBError("Session generation failed") |
|||
self._sessionid = dat['session_id'] |
|||
return self._sessionid |
|||
|
|||
@sessionid.setter |
|||
def sessionid(self, value): |
|||
self._sessionid = value |
|||
self._authtoken = None |
|||
self._authtokenexpiration = None |
|||
if value is None: |
|||
self.authenticated = False |
|||
else: |
|||
self.authenticated = True |
|||
|
|||
@property |
|||
def authtoken(self): |
|||
if self.authenticated: |
|||
raise TMDBError("Session is already authenticated") |
|||
if self._authtoken is None: |
|||
req = Request('authentication/token/new') |
|||
req.lifetime = 0 |
|||
dat = req.readJSON() |
|||
if not dat['success']: |
|||
raise TMDBError("Auth Token request failed") |
|||
self._authtoken = dat['request_token'] |
|||
self._authtokenexpiration = datetime.fromIso(dat['expires_at']) |
|||
return self._authtoken |
|||
|
|||
@property |
|||
def callbackurl(self): |
|||
return "http://www.themoviedb.org/authenticate/"+self._authtoken |
|||
|
|||
@ -0,0 +1,89 @@ |
|||
#!/usr/bin/env python |
|||
# -*- coding: utf-8 -*- |
|||
#----------------------- |
|||
# Name: tmdb_exceptions.py Common exceptions used in tmdbv3 API library |
|||
# Python Library |
|||
# Author: Raymond Wagner |
|||
#----------------------- |
|||
|
|||
class TMDBError( Exception ): |
|||
Error = 0 |
|||
KeyError = 10 |
|||
KeyMissing = 20 |
|||
KeyInvalid = 30 |
|||
KeyRevoked = 40 |
|||
RequestError = 50 |
|||
RequestInvalid = 51 |
|||
PagingIssue = 60 |
|||
CacheError = 70 |
|||
CacheReadError = 71 |
|||
CacheWriteError = 72 |
|||
CacheDirectoryError = 73 |
|||
ImageSizeError = 80 |
|||
HTTPError = 90 |
|||
Offline = 100 |
|||
LocaleError = 110 |
|||
|
|||
def __init__(self, msg=None, errno=0): |
|||
self.errno = errno |
|||
if errno == 0: |
|||
self.errno = getattr(self, 'TMDB'+self.__class__.__name__, errno) |
|||
self.args = (msg,) |
|||
|
|||
class TMDBKeyError( TMDBError ): |
|||
pass |
|||
|
|||
class TMDBKeyMissing( TMDBKeyError ): |
|||
pass |
|||
|
|||
class TMDBKeyInvalid( TMDBKeyError ): |
|||
pass |
|||
|
|||
class TMDBKeyRevoked( TMDBKeyInvalid ): |
|||
pass |
|||
|
|||
class TMDBRequestError( TMDBError ): |
|||
pass |
|||
|
|||
class TMDBRequestInvalid( TMDBRequestError ): |
|||
pass |
|||
|
|||
class TMDBPagingIssue( TMDBRequestError ): |
|||
pass |
|||
|
|||
class TMDBCacheError( TMDBRequestError ): |
|||
pass |
|||
|
|||
class TMDBCacheReadError( TMDBCacheError ): |
|||
def __init__(self, filename): |
|||
super(TMDBCacheReadError, self).__init__( |
|||
"User does not have permission to access cache file: {0}.".format(filename)) |
|||
self.filename = filename |
|||
|
|||
class TMDBCacheWriteError( TMDBCacheError ): |
|||
def __init__(self, filename): |
|||
super(TMDBCacheWriteError, self).__init__( |
|||
"User does not have permission to write cache file: {0}.".format(filename)) |
|||
self.filename = filename |
|||
|
|||
class TMDBCacheDirectoryError( TMDBCacheError ): |
|||
def __init__(self, filename): |
|||
super(TMDBCacheDirectoryError, self).__init__( |
|||
"Directory containing cache file does not exist: {0}.".format(filename)) |
|||
self.filename = filename |
|||
|
|||
class TMDBImageSizeError( TMDBError ): |
|||
pass |
|||
|
|||
class TMDBHTTPError( TMDBError ): |
|||
def __init__(self, err): |
|||
self.httperrno = err.code |
|||
self.response = err.fp.read() |
|||
super(TMDBHTTPError, self).__init__(str(err)) |
|||
|
|||
class TMDBOffline( TMDBError ): |
|||
pass |
|||
|
|||
class TMDBLocaleError( TMDBError ): |
|||
pass |
|||
|
|||
@ -0,0 +1,366 @@ |
|||
#!/usr/bin/env python |
|||
# -*- coding: utf-8 -*- |
|||
#----------------------- |
|||
# Name: util.py Assorted utilities used in tmdb_api |
|||
# Python Library |
|||
# Author: Raymond Wagner |
|||
#----------------------- |
|||
|
|||
from copy import copy |
|||
from locales import get_locale |
|||
from tmdb_auth import get_session |
|||
|
|||
class NameRepr( object ): |
|||
"""Mixin for __repr__ methods using 'name' attribute.""" |
|||
def __repr__(self): |
|||
return u"<{0.__class__.__name__} '{0.name}'>"\ |
|||
.format(self).encode('utf-8') |
|||
|
|||
class SearchRepr( object ): |
|||
""" |
|||
Mixin for __repr__ methods for classes with '_name' and |
|||
'_request' attributes. |
|||
""" |
|||
def __repr__(self): |
|||
name = self._name if self._name else self._request._kwargs['query'] |
|||
return u"<Search Results: {0}>".format(name).encode('utf-8') |
|||
|
|||
class Poller( object ): |
|||
""" |
|||
Wrapper for an optional callable to populate an Element derived class |
|||
with raw data, or data from a Request. |
|||
""" |
|||
def __init__(self, func, lookup, inst=None): |
|||
self.func = func |
|||
self.lookup = lookup |
|||
self.inst = inst |
|||
if func: |
|||
# with function, this allows polling data from the API |
|||
self.__doc__ = func.__doc__ |
|||
self.__name__ = func.__name__ |
|||
self.__module__ = func.__module__ |
|||
else: |
|||
# without function, this is just a dummy poller used for applying |
|||
# raw data to a new Element class with the lookup table |
|||
self.__name__ = '_populate' |
|||
|
|||
def __get__(self, inst, owner): |
|||
# normal decorator stuff |
|||
# return self for a class |
|||
# return instantiated copy of self for an object |
|||
if inst is None: |
|||
return self |
|||
func = None |
|||
if self.func: |
|||
func = self.func.__get__(inst, owner) |
|||
return self.__class__(func, self.lookup, inst) |
|||
|
|||
def __call__(self): |
|||
# retrieve data from callable function, and apply |
|||
if not callable(self.func): |
|||
raise RuntimeError('Poller object called without a source function') |
|||
req = self.func() |
|||
if (('language' in req._kwargs) or ('country' in req._kwargs)) \ |
|||
and self.inst._locale.fallthrough: |
|||
# request specifies a locale filter, and fallthrough is enabled |
|||
# run a first pass with specified filter |
|||
if not self.apply(req.readJSON(), False): |
|||
return |
|||
# if first pass results in missed data, run a second pass to |
|||
# fill in the gaps |
|||
self.apply(req.new(language=None, country=None).readJSON()) |
|||
# re-apply the filtered first pass data over top the second |
|||
# unfiltered set. this is to work around the issue that the |
|||
# properties have no way of knowing when they should or |
|||
# should not overwrite existing data. the cache engine will |
|||
# take care of the duplicate query |
|||
self.apply(req.readJSON()) |
|||
|
|||
def apply(self, data, set_nones=True): |
|||
# apply data directly, bypassing callable function |
|||
unfilled = False |
|||
for k,v in self.lookup.items(): |
|||
if (k in data) and \ |
|||
((data[k] is not None) if callable(self.func) else True): |
|||
# argument received data, populate it |
|||
setattr(self.inst, v, data[k]) |
|||
elif v in self.inst._data: |
|||
# argument did not receive data, but Element already contains |
|||
# some value, so skip this |
|||
continue |
|||
elif set_nones: |
|||
# argument did not receive data, so fill it with None |
|||
# to indicate such and prevent a repeat scan |
|||
setattr(self.inst, v, None) |
|||
else: |
|||
# argument does not need data, so ignore it allowing it to |
|||
# trigger a later poll. this is intended for use when |
|||
# initializing a class with raw data, or when performing a |
|||
# first pass through when performing locale fall through |
|||
unfilled = True |
|||
return unfilled |
|||
|
|||
class Data( object ): |
|||
""" |
|||
Basic response definition class |
|||
This maps to a single key in a JSON dictionary received from the API |
|||
""" |
|||
def __init__(self, field, initarg=None, handler=None, poller=None, |
|||
raw=True, default=u'', lang=False): |
|||
""" |
|||
This defines how the dictionary value is to be processed by the poller |
|||
field -- defines the dictionary key that filters what data this uses |
|||
initarg -- (optional) specifies that this field must be supplied |
|||
when creating a new instance of the Element class this |
|||
definition is mapped to. Takes an integer for the order |
|||
it should be used in the input arguments |
|||
handler -- (optional) callable used to process the received value |
|||
before being stored in the Element object. |
|||
poller -- (optional) callable to be used if data is requested and |
|||
this value has not yet been defined. the callable should |
|||
return a dictionary of data from a JSON query. many |
|||
definitions may share a single poller, which will be |
|||
and the data used to populate all referenced definitions |
|||
based off their defined field |
|||
raw -- (optional) if the specified handler is an Element class, |
|||
the data will be passed into it using the 'raw' keyword |
|||
attribute. setting this to false will force the data to |
|||
instead be passed in as the first argument |
|||
""" |
|||
self.field = field |
|||
self.initarg = initarg |
|||
self.poller = poller |
|||
self.raw = raw |
|||
self.default = default |
|||
self.sethandler(handler) |
|||
|
|||
def __get__(self, inst, owner): |
|||
if inst is None: |
|||
return self |
|||
if self.field not in inst._data: |
|||
if self.poller is None: |
|||
return None |
|||
self.poller.__get__(inst, owner)() |
|||
return inst._data[self.field] |
|||
|
|||
def __set__(self, inst, value): |
|||
if (value is not None) and (value != ''): |
|||
value = self.handler(value) |
|||
else: |
|||
value = self.default |
|||
if isinstance(value, Element): |
|||
value._locale = inst._locale |
|||
value._session = inst._session |
|||
inst._data[self.field] = value |
|||
|
|||
def sethandler(self, handler): |
|||
# ensure handler is always callable, even for passthrough data |
|||
if handler is None: |
|||
self.handler = lambda x: x |
|||
elif isinstance(handler, ElementType) and self.raw: |
|||
self.handler = lambda x: handler(raw=x) |
|||
else: |
|||
self.handler = lambda x: handler(x) |
|||
|
|||
class Datapoint( Data ): |
|||
pass |
|||
|
|||
class Datalist( Data ): |
|||
""" |
|||
Response definition class for list data |
|||
This maps to a key in a JSON dictionary storing a list of data |
|||
""" |
|||
def __init__(self, field, handler=None, poller=None, sort=None, raw=True): |
|||
""" |
|||
This defines how the dictionary value is to be processed by the poller |
|||
field -- defines the dictionary key that filters what data this uses |
|||
handler -- (optional) callable used to process the received value |
|||
before being stored in the Element object. |
|||
poller -- (optional) callable to be used if data is requested and |
|||
this value has not yet been defined. the callable should |
|||
return a dictionary of data from a JSON query. many |
|||
definitions may share a single poller, which will be |
|||
and the data used to populate all referenced definitions |
|||
based off their defined field |
|||
sort -- (optional) name of attribute in resultant data to be used |
|||
to sort the list after processing. this effectively |
|||
a handler be defined to process the data into something |
|||
that has attributes |
|||
raw -- (optional) if the specified handler is an Element class, |
|||
the data will be passed into it using the 'raw' keyword |
|||
attribute. setting this to false will force the data to |
|||
instead be passed in as the first argument |
|||
""" |
|||
super(Datalist, self).__init__(field, None, handler, poller, raw) |
|||
self.sort = sort |
|||
def __set__(self, inst, value): |
|||
data = [] |
|||
if value: |
|||
for val in value: |
|||
val = self.handler(val) |
|||
if isinstance(val, Element): |
|||
val._locale = inst._locale |
|||
val._session = inst._session |
|||
data.append(val) |
|||
if self.sort: |
|||
if self.sort is True: |
|||
data.sort() |
|||
else: |
|||
data.sort(key=lambda x: getattr(x, self.sort)) |
|||
inst._data[self.field] = data |
|||
|
|||
class Datadict( Data ): |
|||
""" |
|||
Response definition class for dictionary data |
|||
This maps to a key in a JSON dictionary storing a dictionary of data |
|||
""" |
|||
def __init__(self, field, handler=None, poller=None, raw=True, |
|||
key=None, attr=None): |
|||
""" |
|||
This defines how the dictionary value is to be processed by the poller |
|||
field -- defines the dictionary key that filters what data this uses |
|||
handler -- (optional) callable used to process the received value |
|||
before being stored in the Element object. |
|||
poller -- (optional) callable to be used if data is requested and |
|||
this value has not yet been defined. the callable should |
|||
return a dictionary of data from a JSON query. many |
|||
definitions may share a single poller, which will be |
|||
and the data used to populate all referenced definitions |
|||
based off their defined field |
|||
key -- (optional) name of key in resultant data to be used as |
|||
the key in the stored dictionary. if this is not the |
|||
field name from the source data is used instead |
|||
attr -- (optional) name of attribute in resultant data to be used |
|||
as the key in the stored dictionary. if this is not |
|||
the field name from the source data is used instead |
|||
raw -- (optional) if the specified handler is an Element class, |
|||
the data will be passed into it using the 'raw' keyword |
|||
attribute. setting this to false will force the data to |
|||
instead be passed in as the first argument |
|||
""" |
|||
if key and attr: |
|||
raise TypeError("`key` and `attr` cannot both be defined") |
|||
super(Datadict, self).__init__(field, None, handler, poller, raw) |
|||
if key: |
|||
self.getkey = lambda x: x[key] |
|||
elif attr: |
|||
self.getkey = lambda x: getattr(x, attr) |
|||
else: |
|||
raise TypeError("Datadict requires `key` or `attr` be defined "+\ |
|||
"for populating the dictionary") |
|||
def __set__(self, inst, value): |
|||
data = {} |
|||
if value: |
|||
for val in value: |
|||
val = self.handler(val) |
|||
if isinstance(val, Element): |
|||
val._locale = inst._locale |
|||
val._session = inst._session |
|||
data[self.getkey(val)] = val |
|||
inst._data[self.field] = data |
|||
|
|||
class ElementType( type ): |
|||
""" |
|||
MetaClass used to pre-process Element-derived classes and set up the |
|||
Data definitions |
|||
""" |
|||
def __new__(mcs, name, bases, attrs): |
|||
# any Data or Poller object defined in parent classes must be cloned |
|||
# and processed in this class to function properly |
|||
# scan through available bases for all such definitions and insert |
|||
# a copy into this class's attributes |
|||
# run in reverse order so higher priority values overwrite lower ones |
|||
data = {} |
|||
pollers = {'_populate':None} |
|||
|
|||
for base in reversed(bases): |
|||
if isinstance(base, mcs): |
|||
for k, attr in base.__dict__.items(): |
|||
if isinstance(attr, Data): |
|||
# extract copies of each defined Data element from |
|||
# parent classes |
|||
attr = copy(attr) |
|||
attr.poller = attr.poller.func |
|||
data[k] = attr |
|||
elif isinstance(attr, Poller): |
|||
# extract copies of each defined Poller function |
|||
# from parent classes |
|||
pollers[k] = attr.func |
|||
for k,attr in attrs.items(): |
|||
if isinstance(attr, Data): |
|||
data[k] = attr |
|||
if '_populate' in attrs: |
|||
pollers['_populate'] = attrs['_populate'] |
|||
|
|||
# process all defined Data attribues, testing for use as an initial |
|||
# argument, and building a list of what Pollers are used to populate |
|||
# which Data points |
|||
pollermap = dict([(k,[]) for k in pollers]) |
|||
initargs = [] |
|||
for k,v in data.items(): |
|||
v.name = k |
|||
if v.initarg: |
|||
initargs.append(v) |
|||
if v.poller: |
|||
pn = v.poller.__name__ |
|||
if pn not in pollermap: |
|||
pollermap[pn] = [] |
|||
if pn not in pollers: |
|||
pollers[pn] = v.poller |
|||
pollermap[pn].append(v) |
|||
else: |
|||
pollermap['_populate'].append(v) |
|||
|
|||
# wrap each used poller function with a Poller class, and push into |
|||
# the new class attributes |
|||
for k,v in pollermap.items(): |
|||
if len(v) == 0: |
|||
continue |
|||
lookup = dict([(attr.field, attr.name) for attr in v]) |
|||
poller = Poller(pollers[k], lookup) |
|||
attrs[k] = poller |
|||
# backfill wrapped Poller into each mapped Data object, and ensure |
|||
# the data elements are defined for this new class |
|||
for attr in v: |
|||
attr.poller = poller |
|||
attrs[attr.name] = attr |
|||
|
|||
# build sorted list of arguments used for intialization |
|||
attrs['_InitArgs'] = tuple([a.name for a in \ |
|||
sorted(initargs, key=lambda x: x.initarg)]) |
|||
return type.__new__(mcs, name, bases, attrs) |
|||
|
|||
def __call__(cls, *args, **kwargs): |
|||
obj = cls.__new__(cls) |
|||
if ('locale' in kwargs) and (kwargs['locale'] is not None): |
|||
obj._locale = kwargs['locale'] |
|||
else: |
|||
obj._locale = get_locale() |
|||
|
|||
if 'session' in kwargs: |
|||
obj._session = kwargs['session'] |
|||
else: |
|||
obj._session = get_session() |
|||
|
|||
obj._data = {} |
|||
if 'raw' in kwargs: |
|||
# if 'raw' keyword is supplied, create populate object manually |
|||
if len(args) != 0: |
|||
raise TypeError('__init__() takes exactly 2 arguments (1 given)') |
|||
obj._populate.apply(kwargs['raw'], False) |
|||
else: |
|||
# if not, the number of input arguments must exactly match that |
|||
# defined by the Data definitions |
|||
if len(args) != len(cls._InitArgs): |
|||
raise TypeError('__init__() takes exactly {0} arguments ({1} given)'\ |
|||
.format(len(cls._InitArgs)+1, len(args)+1)) |
|||
for a,v in zip(cls._InitArgs, args): |
|||
setattr(obj, a, v) |
|||
|
|||
obj.__init__() |
|||
return obj |
|||
|
|||
class Element( object ): |
|||
__metaclass__ = ElementType |
|||
_lang = 'en' |
|||
|
|||
Loading…
Reference in new issue