def run():
utils.log("version %s started" % addon.VERSION)
addon.set_global("extendedinfo_running", "true")
args = sys.argv[2][1:]
infos = []
params = {"handle": plugin.handle}
if args.startswith("---"):
delimiter = "&"
args = args[3:]
else:
delimiter = "&&"
for arg in args.split(delimiter):
param = arg.replace('"', '').replace("'", " ")
if param.startswith('info='):
infos.append(param[5:])
else:
try:
params[param.split("=")[0].lower()] = "=".join(
param.split("=")[1:]).strip().decode('utf-8')
except Exception:
pass
for info in infos:
listitems = process.start_info_actions(info, params)
if listitems:
listitems.set_plugin_list(plugin.handle)
break
else:
plugin.run()
addon.clear_global("extendedinfo_running")
utils.log('finished')
def get_locations(self, lat, lon, radius, locationtype):
params = {"key": GOOGLE_PLACES_KEY,
"radius": min(30000, radius),
"location": "%s,%s" % (lat, lon),
"types": locationtype}
base_url = BASE_URL + 'nearbysearch/json?'
results = Utils.get_JSON_response(base_url + urllib.urlencode(params))
places = ItemList()
if "meta" in results and results['meta']['code'] == 400:
utils.log("LIMIT EXCEEDED")
return "", []
if "results" not in results:
return "", []
for place in results['results']:
try:
params = {"maxwidth": 400,
"photoreference": place['photos'][0]['photo_reference'],
"key": GOOGLE_PLACES_KEY}
photo = BASE_URL + 'photo?' + urllib.urlencode(params)
except:
photo = ""
description = place['vicinity'] if "vicinity" in place else place.get('formatted_address', "")
item = VideoItem(label=place['name'],
label2=" / ".join(place['types']))
item.set_artwork({"thumb": photo,
"icon": place['icon']})
item.set_info("rating", place['rating'] * 2.0 if "rating" in place else "")
item.set_properties({'description': description,
"lat": place['geometry']['location']['lat'],
"lon": place['geometry']['location']['lng']})
places.append(item)
return places
def run():
utils.log("version %s started" % addon.VERSION)
addon.set_global("extendedinfo_running", "true")
args = sys.argv[2][1:]
infos = []
params = {"handle": plugin.handle}
if args.startswith("---"):
delimiter = "&"
args = args[3:]
else:
delimiter = "&&"
for arg in args.split(delimiter):
param = arg.replace('"', '').replace("'", " ")
if param.startswith('info='):
infos.append(param[5:])
else:
try:
params[param.split("=")[0].lower()] = "=".join(param.split("=")[1:]).strip().decode('utf-8')
except Exception:
pass
for info in infos:
listitems = process.start_info_actions(info, params)
if listitems:
listitems.set_plugin_list(plugin.handle)
break
else:
plugin.run()
addon.clear_global("extendedinfo_running")
utils.log('finished')
def get_movie_info(imdb_id):
try:
url = 'i=%s' % (imdb_id)
results = utils.get_JSON_response(BASE_URL + url, 20, "OMDB")
return dict((k, v) for (k, v) in results.iteritems() if v != "N/A")
except Exception:
utils.log("Exception: Error when fetching Omdb data from net")
return {}
def play(youtube_id):
# xbmc.executebuiltin("Dialog.Close(all,true)")
# wm.play_youtube_video(youtube_id)
url, _ = utils.youtube_info_by_id(youtube_id)
utils.log(url)
# utils.notify("test", "test")
xbmcplugin.setResolvedUrl(handle=plugin.handle,
succeeded=True,
listitem=xbmcgui.ListItem(path=url))
def play(youtube_id):
# xbmc.executebuiltin("Dialog.Close(all,true)")
# wm.play_youtube_video(youtube_id)
url, _ = utils.youtube_info_by_id(youtube_id)
utils.log(url)
# utils.notify("test", "test")
xbmcplugin.setResolvedUrl(handle=plugin.handle,
succeeded=True,
listitem=xbmcgui.ListItem(path=url))
def decorator(cls, *args, **kwargs):
self.show_busy()
result = None
try:
result = func(cls, *args, **kwargs)
except Exception:
utils.log(traceback.format_exc())
utils.notify("Error", "please contact add-on author")
finally:
self.hide_busy()
return result
def decorator(cls, *args, **kwargs):
self.show_busy()
result = None
try:
result = func(cls, *args, **kwargs)
except Exception:
utils.log(traceback.format_exc())
utils.notify("Error", "please contact add-on author")
finally:
self.hide_busy()
return result
def get_JSON_response(url="", cache_days=0.5):
filename = hashlib.md5(url).hexdigest()
path = utils.translate_path(os.path.join(addon.DATA_PATH, "%s.txt" % filename))
cache_seconds = int(cache_days * 86400.0)
utils.log(url)
if xbmcvfs.exists(path) and ((time.time() - os.path.getmtime(path)) < cache_seconds):
results = utils.read_from_file(path)
else:
response = get_string_from_url(url)
results = json.loads(response)
utils.save_to_file(results, filename, addon.DATA_PATH)
return results
def __init__(self):
utils.log("version %s started" % addon.VERSION)
addon.set_global("extendedinfo_running", "true")
self._parse_argv()
for info in self.infos:
listitems = process.start_info_actions(info, self.params)
if listitems:
listitems.set_plugin_list(plugin.handle)
break
else:
plugin.run()
addon.clear_global("extendedinfo_running")
def get_string_from_url(url):
for i in range(0, 3):
try:
request = urllib2.Request(url)
request.add_header('User-agent', 'XBMC/14.2 ( [email protected] )')
response = urllib2.urlopen(request, timeout=3)
return response.read()
except:
xbmc.sleep(500)
utils.notify("Error", "Could not download data. Internet connection OK?")
utils.log("get_string_from_url: could not get data from %s" % url)
return ""
def __init__(self):
utils.log("version %s started" % addon.VERSION)
addon.set_global("extendedinfo_running", "true")
self._parse_argv()
for info in self.infos:
listitems = process.start_info_actions(info, self.params)
if listitems:
listitems.set_plugin_list(plugin.handle)
break
else:
plugin.run()
addon.clear_global("extendedinfo_running")
def get_fav_path(fav):
"""
get builtin for fav according to type
*fav: dict from JSON API representing a favourite
"""
if fav["type"] == "media":
return "PlayMedia(%s)" % (fav["path"])
elif fav["type"] == "script":
return "RunScript(%s)" % (fav["path"])
elif "window" in fav and "windowparameter" in fav:
return "ActivateWindow(%s,%s)" % (fav["window"], fav["windowparameter"])
else:
utils.log("error parsing favs")
def onInit(self, *args, **kwargs):
super(DialogBaseInfo, self).onInit()
# self.set_buttons()
self.info.to_windowprops(window_id=self.window_id)
for container_id, key in self.LISTS:
try:
self.getControl(container_id).reset()
items = [i.get_listitem() for i in self.lists[key]]
self.getControl(container_id).addItems(items)
except Exception:
utils.log("Notice: No container with id %i available" % container_id)
addon.set_global("ImageColor", self.info.get_property('ImageColor'))
addon.set_global("infobackground", self.info.get_art('fanart_small'))
self.setProperty("type", self.TYPE)
self.setProperty("tmdb_logged_in", "true" if self.logged_in else "")
def onInit(self, *args, **kwargs):
super(DialogBaseInfo, self).onInit()
# self.set_buttons()
self.info.to_windowprops(window_id=self.window_id)
for container_id, key in self.LISTS:
try:
self.getControl(container_id).reset()
items = [i.get_listitem() for i in self.lists[key]]
self.getControl(container_id).addItems(items)
except Exception:
utils.log("Notice: No container with id %i available" %
container_id)
addon.set_global("ImageColor", self.info.get_property('ImageColor'))
addon.set_global("infobackground", self.info.get_art('fanart_small'))
self.setProperty("type", self.TYPE)
self.setProperty("tmdb_logged_in", "true" if self.logged_in else "")
def __init__(self):
utils.log("version %s started" % addon.VERSION)
addon.set_global("extendedinfo_running", "true")
self._parse_argv()
for info in self.infos:
listitems = process.start_info_actions(info, self.params)
pass_list_to_skin(
name=info, data=listitems, prefix=self.params.get("prefix", ""), limit=self.params.get("limit", 20)
)
if not self.infos:
addon.set_global("infodialogs.active", "true")
from resources.lib.WindowManager import wm
wm.open_video_list()
addon.clear_global("infodialogs.active")
addon.clear_global("extendedinfo_running")
def __init__(self):
utils.log("version %s started" % addon.VERSION)
addon.set_global("extendedinfo_running", "true")
self._parse_argv()
for info in self.infos:
listitems = process.start_info_actions(info, self.params)
pass_list_to_skin(name=info,
data=listitems,
prefix=self.params.get("prefix", ""),
limit=self.params.get("limit", 20))
if not self.infos:
addon.set_global('infodialogs.active', "true")
from resources.lib.WindowManager import wm
wm.open_video_list()
addon.clear_global('infodialogs.active')
addon.clear_global("extendedinfo_running")
def get_places(self, lat, lon, query="", category_id=""):
params = {"limit": 26,
"ll": '%.8f,%.8f' % (lat, lon),
"query": query,
"categoryId": category_id}
results = self.get_data(method="venues/search",
params=params,
cache_days=7)
if results and 'meta' in results:
if results['meta']['code'] == 200:
return self.handle_places(results['response']['venues'])
elif results['meta']['code'] == 400:
utils.notify("Error", "LIMIT EXCEEDED")
else:
utils.notify("ERROR", "Could not get requested information")
else:
utils.log("ERROR")
return []
def get_places_by_section(self, lat, lon, placetype):
params = {"venuePhotos": 1,
"ll": '%.8f,%.8f' % (float(lat), float(lon)),
"section": placetype}
results = self.get_data(method="venues/explore",
params=params,
cache_days=7)
if not results or 'meta' not in results:
return []
if results['meta']['code'] == 200:
if results['response']['groups'][0]['items']:
return self.handle_places(results['response']['groups'][0]['items'])
else:
utils.notify("Error", "No results found near the selected area.")
elif results['meta']['code'] == 400:
utils.log("LIMIT EXCEEDED")
else:
utils.log("ERROR" + str(results['meta']['code']))
return []
def navigate(self, control_id):
if not self.nav_mode_active:
return None
utils.log("lat: %s lon: %s" % (self.lat, self.lon))
if not self.street_view:
stepsize = 60.0 / math.pow(2, self.zoom)
if self.action_id == xbmcgui.ACTION_MOVE_UP:
self.lat += stepsize
elif self.action_id == xbmcgui.ACTION_MOVE_DOWN:
self.lat -= stepsize
elif self.action_id == xbmcgui.ACTION_MOVE_LEFT:
self.lon -= 2.0 * stepsize
elif self.action_id == xbmcgui.ACTION_MOVE_RIGHT:
self.lon += 2.0 * stepsize
else:
stepsize = 0.0002
radiantdirection = math.radians(self.direction)
if self.action_id == xbmcgui.ACTION_MOVE_UP:
self.lat += math.cos(radiantdirection) * stepsize
self.lon += math.sin(radiantdirection) * stepsize
elif self.action_id == xbmcgui.ACTION_MOVE_DOWN:
self.lat -= math.cos(radiantdirection) * stepsize
self.lon -= math.sin(radiantdirection) * stepsize
elif self.action_id == xbmcgui.ACTION_MOVE_LEFT:
if self.direction <= 0:
self.direction = 360
self.direction -= 18
elif self.action_id == xbmcgui.ACTION_MOVE_RIGHT:
if self.direction >= 348:
self.direction = 0
self.direction += 18
if self.lat > 90.0:
self.lat -= 180.0
if self.lat < -90.0:
self.lat += 180.0
if self.lon > 180.0:
self.lon -= 360.0
if self.lon < -180.0:
self.lon += 180.0
self.location = "%s,%s" % (self.lat, self.lon)
def blur(input_img, radius=25):
if not input_img:
return {}
if not xbmcvfs.exists(IMAGE_PATH):
xbmcvfs.mkdir(IMAGE_PATH)
input_img = utils.translate_path(urllib.unquote(input_img.encode("utf-8")))
input_img = input_img.replace("image://", "").rstrip("/")
cachedthumb = xbmc.getCacheThumbName(input_img)
filename = "%s-radius_%i.png" % (cachedthumb, radius)
targetfile = os.path.join(IMAGE_PATH, filename)
vid_cache_file = os.path.join("special://profile/Thumbnails/Video", cachedthumb[0], cachedthumb)
cache_file = os.path.join("special://profile/Thumbnails", cachedthumb[0], cachedthumb[:-4] + ".jpg")
if xbmcvfs.exists(targetfile):
img = PIL.Image.open(targetfile)
return {"ImageFilter": targetfile,
"ImageColor": get_colors(img)}
try:
if xbmcvfs.exists(cache_file):
utils.log("image already in xbmc cache: " + cache_file)
img = PIL.Image.open(utils.translate_path(cache_file))
elif xbmcvfs.exists(vid_cache_file):
utils.log("image already in xbmc video cache: " + vid_cache_file)
img = PIL.Image.open(utils.translate_path(vid_cache_file))
else:
xbmcvfs.copy(input_img, targetfile)
img = PIL.Image.open(targetfile)
img.thumbnail((200, 200), PIL.Image.ANTIALIAS)
imgfilter = MyGaussianBlur(radius=radius)
img = img.convert('RGB').filter(imgfilter)
img.save(targetfile)
except Exception:
utils.log("Could not get image for %s" % input_img)
return {}
return {"ImageFilter": targetfile,
"ImageColor": get_colors(img)}
def blur(input_img, radius=25):
if not input_img:
return {}
if not xbmcvfs.exists(IMAGE_PATH):
xbmcvfs.mkdir(IMAGE_PATH)
input_img = utils.translate_path(urllib.unquote(input_img.encode("utf-8")))
input_img = input_img.replace("image://", "").rstrip("/")
cachedthumb = xbmc.getCacheThumbName(input_img)
filename = "%s-radius_%i.png" % (cachedthumb, radius)
targetfile = os.path.join(IMAGE_PATH, filename)
vid_cache_file = os.path.join("special://profile/Thumbnails/Video",
cachedthumb[0], cachedthumb)
cache_file = os.path.join("special://profile/Thumbnails", cachedthumb[0],
cachedthumb[:-4] + ".jpg")
if xbmcvfs.exists(targetfile):
img = PIL.Image.open(targetfile)
return {"ImageFilter": targetfile, "ImageColor": get_colors(img)}
try:
if xbmcvfs.exists(cache_file):
utils.log("image already in xbmc cache: " + cache_file)
img = PIL.Image.open(utils.translate_path(cache_file))
elif xbmcvfs.exists(vid_cache_file):
utils.log("image already in xbmc video cache: " + vid_cache_file)
img = PIL.Image.open(utils.translate_path(vid_cache_file))
else:
xbmcvfs.copy(input_img, targetfile)
img = PIL.Image.open(targetfile)
img.thumbnail((200, 200), PIL.Image.ANTIALIAS)
imgfilter = MyGaussianBlur(radius=radius)
img = img.convert('RGB').filter(imgfilter)
img.save(targetfile)
except Exception:
utils.log("Could not get image for %s" % input_img)
return {}
return {"ImageFilter": targetfile, "ImageColor": get_colors(img)}
def get_similar_artists(self, artist_id):
"""
get list of artists from db which are similar to artist with *artist_id
based on LastFM online data
"""
import LastFM
simi_artists = LastFM.get_similar_artists(artist_id)
if simi_artists is None:
utils.log('Last.fm didn\'t return proper response')
return None
if not self.artists:
self.artists = self.get_artists()
artists = ItemList(content_type="artists")
for simi_artist, kodi_artist in itertools.product(simi_artists, self.artists):
if kodi_artist['musicbrainzartistid'] and kodi_artist['musicbrainzartistid'] == simi_artist['mbid']:
artists.append(kodi_artist)
elif kodi_artist['artist'] == simi_artist['name']:
data = kodijson.get_json(method="AudioLibrary.GetArtistDetails",
params={"properties": ["genre", "description", "mood", "style", "born", "died", "formed", "disbanded", "yearsactive", "instrument", "fanart", "thumbnail"], "artistid": kodi_artist['artistid']})
item = data["result"]["artistdetails"]
artwork = {"thumb": item['thumbnail'],
"fanart": item['fanart']}
artists.append({"label": item['label'],
"artwork": artwork,
"title": item['label'],
"genre": " / ".join(item['genre']),
"artist_description": item['description'],
"userrating": item['userrating'],
"born": item['born'],
"died": item['died'],
"formed": item['formed'],
"disbanded": item['disbanded'],
"yearsactive": " / ".join(item['yearsactive']),
"style": " / ".join(item['style']),
"mood": " / ".join(item['mood']),
"instrument": " / ".join(item['instrument']),
"librarypath": 'musicdb://artists/%s/' % item['artistid']})
utils.log('%i of %i artists found in last.FM are in Kodi database' % (len(artists), len(simi_artists)))
return artists
def start_info_actions(info, params):
if "artistname" in params:
params["artistname"] = params.get("artistname", "").split(" feat. ")[0].strip()
params["artist_mbid"] = utils.fetch_musicbrainz_id(params["artistname"])
utils.log(info)
utils.pp(params)
if "prefix" in params and not params["prefix"].endswith('.'):
params["prefix"] = params["prefix"] + '.'
# Audio
if info == 'discography':
discography = AudioDB.get_artist_discography(params["artistname"])
if not discography:
discography = LastFM.get_artist_albums(params.get("artist_mbid"))
return discography
elif info == 'mostlovedtracks':
return AudioDB.get_most_loved_tracks(params["artistname"])
elif info == 'trackdetails':
return AudioDB.get_track_details(params.get("id", ""))
elif info == 'topartists':
return LastFM.get_top_artists()
# RottenTomatoesMovies
elif info == 'intheatermovies':
return RottenTomatoes.get_movies("movies/in_theaters")
elif info == 'boxofficemovies':
return RottenTomatoes.get_movies("movies/box_office")
elif info == 'openingmovies':
return RottenTomatoes.get_movies("movies/opening")
elif info == 'comingsoonmovies':
return RottenTomatoes.get_movies("movies/upcoming")
elif info == 'toprentalmovies':
return RottenTomatoes.get_movies("dvds/top_rentals")
elif info == 'currentdvdmovies':
return RottenTomatoes.get_movies("dvds/current_releases")
elif info == 'newdvdmovies':
return RottenTomatoes.get_movies("dvds/new_releases")
elif info == 'upcomingdvdmovies':
return RottenTomatoes.get_movies("dvds/upcoming")
# The MovieDB
elif info == 'incinemamovies':
return tmdb.get_tmdb_movies("now_playing")
elif info == 'upcomingmovies':
return tmdb.get_tmdb_movies("upcoming")
elif info == 'topratedmovies':
return tmdb.get_tmdb_movies("top_rated")
elif info == 'popularmovies':
return tmdb.get_tmdb_movies("popular")
elif info == 'ratedmovies':
return tmdb.get_rated_media_items("movies")
elif info == 'starredmovies':
return tmdb.get_fav_items("movies")
elif info == 'accountlists':
account_lists = tmdb.handle_misc(tmdb.get_account_lists())
for item in account_lists:
item["directory"] = True
return account_lists
elif info == 'listmovies':
return tmdb.get_movies_from_list(params["id"])
elif info == 'airingtodaytvshows':
return tmdb.get_tmdb_shows("airing_today")
elif info == 'onairtvshows':
return tmdb.get_tmdb_shows("on_the_air")
elif info == 'topratedtvshows':
return tmdb.get_tmdb_shows("top_rated")
elif info == 'populartvshows':
return tmdb.get_tmdb_shows("popular")
elif info == 'ratedtvshows':
return tmdb.get_rated_media_items("tv")
elif info == 'ratedepisodes':
return tmdb.get_rated_media_items("tv/episodes")
elif info == 'starredtvshows':
return tmdb.get_fav_items("tv")
elif info == 'similarmovies':
movie_id = params.get("id")
if not movie_id:
movie_id = tmdb.get_movie_tmdb_id(imdb_id=params.get("imdb_id"),
dbid=params.get("dbid"))
if movie_id:
return tmdb.get_similar_movies(movie_id)
elif info == 'similartvshows':
tvshow_id = None
dbid = params.get("dbid")
name = params.get("name")
tmdb_id = params.get("tmdb_id")
tvdb_id = params.get("tvdb_id")
imdb_id = params.get("imdb_id")
if tmdb_id:
tvshow_id = tmdb_id
elif dbid and int(dbid) > 0:
tvdb_id = local_db.get_imdb_id("tvshow", dbid)
if tvdb_id:
tvshow_id = tmdb.get_show_tmdb_id(tvdb_id)
elif tvdb_id:
tvshow_id = tmdb.get_show_tmdb_id(tvdb_id)
elif imdb_id:
tvshow_id = tmdb.get_show_tmdb_id(imdb_id, "imdb_id")
elif name:
tvshow_id = tmdb.search_media(media_name=name,
year="",
media_type="tv")
if tvshow_id:
return tmdb.get_similar_tvshows(tvshow_id)
elif info == 'studio':
if params.get("id"):
return tmdb.get_company_data(params["id"])
elif params.get("studio"):
company_data = tmdb.search_company(params["studio"])
if company_data:
return tmdb.get_company_data(company_data[0]["id"])
elif info == 'set':
if params.get("dbid"):
name = local_db.get_set_name(params["dbid"])
if name:
params["setid"] = tmdb.get_set_id(name)
if params.get("setid"):
set_data, _ = tmdb.get_set_movies(params["setid"])
return set_data
elif info == 'movielists':
movie_id = params.get("id")
if not movie_id:
movie_id = tmdb.get_movie_tmdb_id(imdb_id=params.get("imdb_id"),
dbid=params.get("dbid"))
if movie_id:
return tmdb.get_movie_lists(movie_id)
elif info == 'keywords':
movie_id = params.get("id")
if not movie_id:
movie_id = tmdb.get_movie_tmdb_id(imdb_id=params.get("imdb_id"),
dbid=params.get("dbid"))
if movie_id:
return tmdb.get_keywords(movie_id)
elif info == 'popularpeople':
return tmdb.get_popular_actors()
elif info == 'personmovies':
person = tmdb.get_person_info(person_label=params.get("person"),
skip_dialog=True)
if person and person.get("id"):
movies = tmdb.get_person_movies(person["id"])
for item in movies:
del item["credit_id"]
return utils.reduce_list(movies, key="department")
elif info == 'traktsimilarmovies':
if params.get("id") or params.get("dbid"):
if params.get("dbid"):
movie_id = local_db.get_imdb_id("movie", params["dbid"])
else:
movie_id = params["id"]
return Trakt.get_similar("movie", movie_id)
elif info == 'traktsimilartvshows':
if params.get("id") or params.get("dbid"):
if params.get("dbid"):
if params.get("type") == "episode":
tvshow_id = local_db.get_tvshow_id_by_episode(params["dbid"])
else:
tvshow_id = local_db.get_imdb_id(media_type="tvshow",
dbid=params["dbid"])
else:
tvshow_id = params["id"]
return Trakt.get_similar("show", tvshow_id)
elif info == 'airingepisodes':
return Trakt.get_episodes("shows")
elif info == 'premiereepisodes':
return Trakt.get_episodes("premieres")
elif info == 'trendingshows':
return Trakt.get_shows("trending")
elif info == 'popularshows':
return Trakt.get_shows("popular")
elif info == 'anticipatedshows':
return Trakt.get_shows("anticipated")
elif info == 'mostcollectedshows':
return Trakt.get_shows_from_time("collected")
elif info == 'mostplayedshows':
return Trakt.get_shows_from_time("played")
elif info == 'mostwatchedshows':
return Trakt.get_shows_from_time("watched")
elif info == 'trendingmovies':
return Trakt.get_movies("trending")
elif info == 'traktpopularmovies':
return Trakt.get_movies("popular")
elif info == 'mostplayedmovies':
return Trakt.get_movies_from_time("played")
elif info == 'mostwatchedmovies':
return Trakt.get_movies_from_time("watched")
elif info == 'mostcollectedmovies':
return Trakt.get_movies_from_time("collected")
elif info == 'mostanticipatedmovies':
return Trakt.get_movies("anticipated")
elif info == 'traktboxofficemovies':
return Trakt.get_movies("boxoffice")
elif info == 'similarartistsinlibrary':
return local_db.get_similar_artists(params.get("artist_mbid"))
elif info == 'trackinfo':
addon.clear_global('%sSummary' % params.get("prefix", ""))
if params["artistname"] and params["trackname"]:
track_info = LastFM.get_track_info(artist_name=params["artistname"],
track=params["trackname"])
addon.set_global('%sSummary' % params.get("prefix", ""), track_info["summary"])
elif info == 'topartistsnearevents':
artists = local_db.get_artists()
import BandsInTown
return BandsInTown.get_near_events(artists[0:49])
elif info == 'youtubesearchvideos':
addon.set_global('%sSearchValue' % params.get("prefix", ""), params.get("id", ""))
if params.get("id"):
listitems = YouTube.search(search_str=params.get("id", ""),
hd=params.get("hd"),
orderby=params.get("orderby", "relevance"))
return listitems.get("listitems", [])
elif info == 'youtubeplaylistvideos':
return YouTube.get_playlist_videos(params.get("id", ""))
elif info == 'youtubeusersearchvideos':
user_name = params.get("id")
if user_name:
playlists = YouTube.get_user_playlists(user_name)
return YouTube.get_playlist_videos(playlists["uploads"])
elif info == 'favourites':
if params.get("id"):
items = favs.get_favs_by_type(params["id"])
else:
items = favs.get_favs()
addon.set_global('favourite.count', str(len(items)))
if items:
addon.set_global('favourite.1.name', items[-1]["label"])
return items
elif info == 'similarlocalmovies' and "dbid" in params:
return local_db.get_similar_movies(params["dbid"])
elif info == 'iconpanel':
return favs.get_icon_panel(int(params["id"])), "IconPanel" + str(params["id"])
# ACTIONS
if params.get("handle"):
xbmcplugin.setResolvedUrl(handle=int(params.get("handle")),
succeeded=False,
listitem=xbmcgui.ListItem())
if info in ['playmovie', 'playepisode', 'playmusicvideo', 'playalbum', 'playsong']:
kodijson.play_media(media_type=info.replace("play", ""),
dbid=params.get("dbid"),
resume=params.get("resume", "true"))
elif info == "openinfodialog":
if xbmc.getCondVisibility("System.HasModalDialog"):
container_id = ""
else:
container_id = "Container(%s)" % utils.get_infolabel("System.CurrentControlId")
dbid = utils.get_infolabel("%sListItem.DBID" % container_id)
db_type = utils.get_infolabel("%sListItem.DBType" % container_id)
if db_type == "movie":
params = {"dbid": dbid,
"id": utils.get_infolabel("%sListItem.Property(id)" % container_id),
"name": utils.get_infolabel("%sListItem.Title" % container_id)}
start_info_actions("extendedinfo", params)
elif db_type == "tvshow":
params = {"dbid": dbid,
"tvdb_id": utils.get_infolabel("%sListItem.Property(tvdb_id)" % container_id),
"id": utils.get_infolabel("%sListItem.Property(id)" % container_id),
"name": utils.get_infolabel("%sListItem.Title" % container_id)}
start_info_actions("extendedtvinfo", params)
elif db_type == "season":
params = {"tvshow": utils.get_infolabel("%sListItem.TVShowTitle" % container_id),
"season": utils.get_infolabel("%sListItem.Season" % container_id)}
start_info_actions("seasoninfo", params)
elif db_type == "episode":
params = {"tvshow": utils.get_infolabel("%sListItem.TVShowTitle" % container_id),
"season": utils.get_infolabel("%sListItem.Season" % container_id),
"episode": utils.get_infolabel("%sListItem.Episode" % container_id)}
start_info_actions("extendedepisodeinfo", params)
elif db_type in ["actor", "director"]:
params = {"name": utils.get_infolabel("%sListItem.Label" % container_id)}
start_info_actions("extendedactorinfo", params)
else:
utils.notify("Error", "Could not find valid content type")
elif info == "ratedialog":
if xbmc.getCondVisibility("System.HasModalDialog"):
container_id = ""
else:
container_id = "Container(%s)" % utils.get_infolabel("System.CurrentControlId")
dbid = utils.get_infolabel("%sListItem.DBID" % container_id)
db_type = utils.get_infolabel("%sListItem.DBType" % container_id)
if db_type == "movie":
params = {"dbid": dbid,
"id": utils.get_infolabel("%sListItem.Property(id)" % container_id),
"type": "movie"}
start_info_actions("ratemedia", params)
elif db_type == "tvshow":
params = {"dbid": dbid,
"id": utils.get_infolabel("%sListItem.Property(id)" % container_id),
"type": "tv"}
start_info_actions("ratemedia", params)
if db_type == "episode":
params = {"tvshow": utils.get_infolabel("%sListItem.TVShowTitle" % container_id),
"season": utils.get_infolabel("%sListItem.Season" % container_id),
"type": "episode"}
start_info_actions("ratemedia", params)
elif info == 'youtubebrowser':
wm.open_youtube_list(search_str=params.get("id", ""))
elif info == 'moviedbbrowser':
if addon.get_global('infodialogs.active'):
return None
addon.set_global('infodialogs.active', "true")
search_str = params.get("id", "")
if not search_str and params.get("search"):
result = xbmcgui.Dialog().input(heading=addon.LANG(16017),
type=xbmcgui.INPUT_ALPHANUM)
if result and result > -1:
search_str = result
else:
return None
wm.open_video_list(search_str=search_str,
mode="search")
addon.clear_global('infodialogs.active')
elif info == 'extendedinfo':
if addon.get_global('infodialogs.active'):
return None
addon.set_global('infodialogs.active', "true")
wm.open_movie_info(movie_id=params.get("id"),
dbid=params.get("dbid"),
imdb_id=params.get("imdb_id"),
name=params.get("name"))
addon.clear_global('infodialogs.active')
elif info == 'extendedactorinfo':
if addon.get_global('infodialogs.active'):
return None
addon.set_global('infodialogs.active', "true")
wm.open_actor_info(actor_id=params.get("id"),
name=params.get("name"))
addon.clear_global('infodialogs.active')
elif info == 'extendedtvinfo':
if addon.get_global('infodialogs.active'):
return None
addon.set_global('infodialogs.active', "true")
wm.open_tvshow_info(tmdb_id=params.get("id"),
tvdb_id=params.get("tvdb_id"),
dbid=params.get("dbid"),
imdb_id=params.get("imdb_id"),
name=params.get("name"))
addon.clear_global('infodialogs.active')
elif info == 'seasoninfo':
if addon.get_global('infodialogs.active'):
return None
addon.set_global('infodialogs.active', "true")
wm.open_season_info(tvshow=params.get("tvshow"),
dbid=params.get("dbid"),
season=params.get("season"))
addon.clear_global('infodialogs.active')
elif info == 'extendedepisodeinfo':
if addon.get_global('infodialogs.active'):
return None
addon.set_global('infodialogs.active', "true")
wm.open_episode_info(tvshow=params.get("tvshow"),
tvshow_id=params.get("tvshow_id"),
dbid=params.get("dbid"),
episode=params.get("episode"),
season=params.get("season"))
addon.clear_global('infodialogs.active')
elif info == 'albuminfo':
if params.get("id"):
album_details = AudioDB.get_album_details(params.get("id"))
utils.dict_to_windowprops(album_details, params.get("prefix", ""))
elif info == 'artistdetails':
artist_details = AudioDB.get_artist_details(params["artistname"])
utils.dict_to_windowprops(artist_details, params.get("prefix", ""))
elif info == 'ratemedia':
media_type = params.get("type")
if not media_type:
return None
if params.get("id"):
tmdb_id = params["id"]
elif media_type == "movie":
tmdb_id = tmdb.get_movie_tmdb_id(imdb_id=params.get("imdb_id"),
dbid=params.get("dbid"),
name=params.get("name"))
elif media_type == "tv" and params.get("dbid"):
tvdb_id = local_db.get_imdb_id(media_type="tvshow",
dbid=params["dbid"])
tmdb_id = tmdb.get_show_tmdb_id(tvdb_id=tvdb_id)
else:
return False
rating = utils.input_userrating()
tmdb.set_rating(media_type=media_type,
media_id=tmdb_id,
rating=rating,
dbid=params.get("dbid"))
elif info == 'action':
for builtin in params.get("id", "").split("$$"):
xbmc.executebuiltin(builtin)
elif info == "youtubevideo":
xbmc.executebuiltin("Dialog.Close(all,true)")
wm.play_youtube_video(params.get("id", ""))
elif info == 'playtrailer':
wm.show_busy()
if params.get("id"):
movie_id = params["id"]
elif int(params.get("dbid", -1)) > 0:
movie_id = local_db.get_imdb_id(media_type="movie",
dbid=params["dbid"])
elif params.get("imdb_id"):
movie_id = tmdb.get_movie_tmdb_id(params["imdb_id"])
else:
movie_id = ""
if movie_id:
trailer = tmdb.get_trailer(movie_id)
wm.hide_busy()
time.sleep(0.1)
if trailer:
wm.play_youtube_video(trailer)
elif params.get("title"):
wm.open_youtube_list(search_str=params["title"])
else:
wm.hide_busy()
elif info == 'deletecache':
addon.clear_globals()
for rel_path in os.listdir(addon.DATA_PATH):
path = os.path.join(addon.DATA_PATH, rel_path)
try:
if os.path.isdir(path):
shutil.rmtree(path)
except Exception as e:
utils.log(e)
utils.notify("Cache deleted")
elif info == 'syncwatchlist':
pass
for key, value in items:
li = xbmcgui.ListItem(label=value, thumbnailImage="DefaultFolder.png")
url = 'plugin://script.extendedinfo?info=%s' % key
xbmcplugin.addDirectoryItem(handle=plugin.handle,
url=url,
listitem=li,
isFolder=True)
xbmcplugin.addSortMethod(plugin.handle, xbmcplugin.SORT_METHOD_LABEL)
xbmcplugin.endOfDirectory(plugin.handle)
@plugin.route('/')
def root():
items = [
(plugin.url_for(trakt),
xbmcgui.ListItem(label="Trakt", thumbnailImage=TRAKT_IMAGE), True),
(plugin.url_for(tmdb),
xbmcgui.ListItem(label="TheMovieDB",
thumbnailImage=MOVIEDB_IMAGE), True),
]
xbmcplugin.addSortMethod(plugin.handle, xbmcplugin.SORT_METHOD_LABEL)
xbmcplugin.addDirectoryItems(plugin.handle, items)
xbmcplugin.endOfDirectory(plugin.handle)
if (__name__ == "__main__"):
utils.log('running plugin.py...................................')
xbmc.log('Running plugin.py...................................', 2)
Main()
utils.log('finished')
("premiereepisodes", addon.LANG(32029))]
for key, value in items:
li = xbmcgui.ListItem(label=value,
thumbnailImage="DefaultFolder.png")
url = 'plugin://script.extendedinfo?info=%s' % key
xbmcplugin.addDirectoryItem(handle=plugin.handle,
url=url,
listitem=li,
isFolder=True)
xbmcplugin.addSortMethod(plugin.handle, xbmcplugin.SORT_METHOD_LABEL)
xbmcplugin.endOfDirectory(plugin.handle)
@plugin.route('/')
def root():
items = [
(plugin.url_for(trakt), xbmcgui.ListItem(label="Trakt",
thumbnailImage=TRAKT_IMAGE), True),
(plugin.url_for(rotten_tomatoes), xbmcgui.ListItem(label="Rotten Tomatoes",
thumbnailImage=RT_IMAGE), True),
(plugin.url_for(tmdb), xbmcgui.ListItem(label="TheMovieDB",
thumbnailImage=MOVIEDB_IMAGE), True),
]
xbmcplugin.addSortMethod(plugin.handle, xbmcplugin.SORT_METHOD_LABEL)
xbmcplugin.addDirectoryItems(plugin.handle, items)
xbmcplugin.endOfDirectory(plugin.handle)
if (__name__ == "__main__"):
Main()
utils.log('finished')
def prettify(self):
"""
log a formatted list of all items
"""
for item in self._items:
utils.log(item)
li = xbmcgui.ListItem(label=value)
li.setArt({
'thumb':
'special://home/addons/script.extendedinfo/resources/trakt.png'
})
url = 'plugin://script.extendedinfo?info=%s' % key
xbmcplugin.addDirectoryItem(handle=plugin.handle,
url=url,
listitem=li,
isFolder=True)
xbmcplugin.addSortMethod(plugin.handle, xbmcplugin.SORT_METHOD_LABEL)
xbmcplugin.endOfDirectory(plugin.handle)
@plugin.route('/')
def root():
for i in ['trakt', 'tmdb']:
item = INDEX_MENU[i]
li_item = xbmcgui.ListItem(item['name'])
li_item.setArt(DEFAULT_ART)
xbmcplugin.addDirectoryItem(plugin.handle,
plugin.url_for(eval(item['route'])),
li_item, item['folder'])
xbmcplugin.addSortMethod(plugin.handle, xbmcplugin.SORT_METHOD_LABEL)
xbmcplugin.endOfDirectory(plugin.handle)
if (__name__ == "__main__"):
Main()
utils.log('finished')
def get_similar_artists(self, artist_id):
"""
get list of artists from db which are similar to artist with *artist_id
based on LastFM online data
"""
import LastFM
simi_artists = LastFM.get_similar_artists(artist_id)
if simi_artists is None:
utils.log('Last.fm didn\'t return proper response')
return None
if not self.artists:
self.artists = self.get_artists()
artists = ItemList(content_type="artists")
for simi_artist, kodi_artist in itertools.product(
simi_artists, self.artists):
if kodi_artist['musicbrainzartistid'] and kodi_artist[
'musicbrainzartistid'] == simi_artist['mbid']:
artists.append(kodi_artist)
elif kodi_artist['artist'] == simi_artist['name']:
data = kodijson.get_json(
method="AudioLibrary.GetArtistDetails",
params={
"properties": [
"genre", "description", "mood", "style", "born",
"died", "formed", "disbanded", "yearsactive",
"instrument", "fanart", "thumbnail"
],
"artistid":
kodi_artist['artistid']
})
item = data["result"]["artistdetails"]
artwork = {
"thumb": item['thumbnail'],
"fanart": item['fanart']
}
artists.append({
"label":
item['label'],
"artwork":
artwork,
"title":
item['label'],
"genre":
" / ".join(item['genre']),
"artist_description":
item['description'],
"userrating":
item['userrating'],
"born":
item['born'],
"died":
item['died'],
"formed":
item['formed'],
"disbanded":
item['disbanded'],
"yearsactive":
" / ".join(item['yearsactive']),
"style":
" / ".join(item['style']),
"mood":
" / ".join(item['mood']),
"instrument":
" / ".join(item['instrument']),
"librarypath":
'musicdb://artists/%s/' % item['artistid']
})
utils.log('%i of %i artists found in last.FM are in Kodi database' %
(len(artists), len(simi_artists)))
return artists
def prettify(self):
"""
log a formatted list of all items
"""
for item in self._items:
utils.log(item)
for info in self.infos:
listitems = process.start_info_actions(info, self.params)
pass_list_to_skin(
name=info, data=listitems, prefix=self.params.get("prefix", ""), limit=self.params.get("limit", 20)
)
if not self.infos:
addon.set_global("infodialogs.active", "true")
from resources.lib.WindowManager import wm
wm.open_video_list()
addon.clear_global("infodialogs.active")
addon.clear_global("extendedinfo_running")
def _parse_argv(self):
self.infos = []
self.params = {"handle": None}
for arg in sys.argv[1:]:
param = arg.replace('"', "").replace("'", " ")
if param.startswith("info="):
self.infos.append(param[5:])
else:
try:
self.params[param.split("=")[0].lower()] = "=".join(param.split("=")[1:]).strip().decode("utf-8")
except Exception:
pass
if __name__ == "__main__":
Main()
utils.log("finished")
