def nhlDirectory():
dt = procTimezone(5)
datex = int(dt.strftime('%Y%m%d'))
url = 'http://live.nhl.com/GameData/SeasonSchedule-20152016.json'
result = client.request(url)
items = json.loads(result)
items = sorted(items, key=lambda k: k['est'])
addDirectoryItem(control.lang(30751).encode('utf-8'), 'Scoreboard', 'nhlScoreboard', '0', '0')
addDirectoryItem(control.lang(30752).encode('utf-8'), 'Archived', 'nhlArchives', '0', '0')
addDirectoryItem(control.lang(30753).encode('utf-8'), '0', '0', '0', '0')
addDirectoryItem(control.lang(30754).encode('utf-8'), '0', '0', '0', '0')
for item in items:
try:
est = datetime.datetime.strptime(item['est'], '%Y%m%d %H:%M:%S')
date = int(est.strftime('%Y%m%d'))
if not date == datex: raise Exception()
est = procTimezone(5, est)
name = '%s at %s [COLOR gold](%s)[/COLOR] [COLOR red](%s)[/COLOR]' % (item['a'], item['h'], est.strftime('%H:%M'), est.strftime('%Y-%m-%d'))
url = str(item['id'])
addDirectoryItem(name, url, 'nhlStreams', '0', '0')
except:
pass
endDirectory()
def views(self):
try:
control.idle()
items = [ (control.lang(32001).encode('utf-8'), 'movies'), (control.lang(32002).encode('utf-8'), 'tvshows'), (control.lang(32054).encode('utf-8'), 'seasons'), (control.lang(32038).encode('utf-8'), 'episodes') ]
select = control.selectDialog([i[0] for i in items], control.lang(32049).encode('utf-8'))
if select == -1: return
content = items[select][1]
title = control.lang(32059).encode('utf-8')
url = '%s?action=addView&content=%s' % (sys.argv[0], content)
poster, banner, fanart = control.addonPoster(), control.addonBanner(), control.addonFanart()
item = control.item(label=title)
item.setInfo(type='Video', infoLabels = {'title': title})
item.setArt({'icon': poster, 'thumb': poster, 'poster': poster, 'banner': banner})
item.setProperty('Fanart_Image', fanart)
control.addItem(handle=int(sys.argv[1]), url=url, listitem=item, isFolder=False)
control.content(int(sys.argv[1]), content)
control.directory(int(sys.argv[1]), cacheToDisc=True)
from resources.lib.libraries import views
views.setView(content, {})
except:
return
def range(self, url):
control.idle()
yes = control.yesnoDialog(control.lang(32555).encode('utf-8'), '', '')
if not yes: return
if not control.condVisibility(
'Window.IsVisible(infodialog)') and not control.condVisibility(
'Player.HasVideo'):
control.infoDialog(control.lang(32552).encode('utf-8'),
time=10000000)
self.infoDialog = True
from resources.lib.indexers import tvshows
items = tvshows.tvshows().get(url, idx=False)
if items == None: items = []
for i in items:
try:
if xbmc.abortRequested == True: return sys.exit()
self.add(i['title'],
i['year'],
i['imdb'],
i['tvdb'],
range=True)
except:
pass
if self.infoDialog == True:
control.infoDialog(control.lang(32554).encode('utf-8'), time=1)
if self.library_setting == 'true' and not control.condVisibility(
'Library.IsScanningVideo'):
control.execute('UpdateLibrary(video)')
def get(self, name, year='0'):
try:
offset = '0'
if not control.setting('bookmarks') == 'true': raise Exception()
idFile = hashlib.md5()
for i in name: idFile.update(str(i))
for i in year: idFile.update(str(i))
idFile = str(idFile.hexdigest())
dbcon = database.connect(control.bookmarksFile)
dbcur = dbcon.cursor()
dbcur.execute("SELECT * FROM bookmark WHERE idFile = '%s'" % idFile)
match = dbcur.fetchone()
self.offset = str(match[1])
dbcon.commit()
if self.offset == '0': raise Exception()
minutes, seconds = divmod(float(self.offset), 60) ; hours, minutes = divmod(minutes, 60)
label = '%02d:%02d:%02d' % (hours, minutes, seconds)
label = (control.lang(32502) % label).encode('utf-8')
try: yes = control.dialog.contextmenu([label, control.lang(32501).encode('utf-8'), ])
except: yes = control.yesnoDialog(label, '', '', str(name), control.lang(32503).encode('utf-8'), control.lang(32501).encode('utf-8'))
if yes: self.offset = '0'
return self.offset
except:
return offset
def addDirectoryItem(self,
name,
query,
thumb,
icon,
context=None,
queue=False,
isAction=True,
isFolder=True):
try:
name = control.lang(name).encode('utf-8')
except:
pass
url = '%s?action=%s' % (sysaddon, query) if isAction == True else query
if "http" not in thumb:
thumb = os.path.join(artPath,
thumb) if not artPath == None else icon
cm = []
if queue == True:
cm.append((queueMenu, 'RunPlugin(%s?action=queueItem)' % sysaddon))
if not context == None:
cm.append((control.lang(context[0]).encode('utf-8'),
'RunPlugin(%s?action=%s)' % (sysaddon, context[1])))
item = control.item(label=name)
item.addContextMenuItems(cm)
item.setArt({'icon': icon, 'thumb': thumb})
if not addonFanart == None:
item.setProperty('Fanart_Image', addonFanart)
control.addItem(handle=syshandle,
url=url,
listitem=item,
isFolder=isFolder)
def clearCacheAll(self):
control.idle()
yes = control.yesnoDialog(control.lang(32056).encode('utf-8'), '', '')
if not yes: return
from ptw.libraries import cache
cache.cache_clear_all()
control.infoDialog(control.lang(32057).encode('utf-8'), sound=True, icon='INFO')
def add(self, name, title, year, imdb, tmdb, range=False):
if not control.condVisibility('Window.IsVisible(infodialog)') and not control.condVisibility('Player.HasVideo')\
and self.silentDialog is False:
control.infoDialog(control.lang(32552).encode('utf-8'),
time=10000000)
self.infoDialog = True
try:
if not self.dupe_setting == 'true': raise Exception()
id = [imdb, tmdb] if not tmdb == '0' else [imdb]
lib = control.jsonrpc(
'{"jsonrpc": "2.0", "method": "VideoLibrary.GetMovies", "params": {"filter":{"or": [{"field": "year", "operator": "is", "value": "%s"}, {"field": "year", "operator": "is", "value": "%s"}, {"field": "year", "operator": "is", "value": "%s"}]}, "properties" : ["imdbnumber", "originaltitle", "year"]}, "id": 1}'
% (year, str(int(year) + 1), str(int(year) - 1)))
lib = unicode(lib, 'utf-8', errors='ignore')
lib = json.loads(lib)['result']['movies']
lib = [
i for i in lib
if str(i['imdbnumber']) in id or (i['originaltitle'].encode(
'utf-8') == title and str(i['year']) == year)
][0]
except:
lib = []
files_added = 0
try:
if not lib == []: raise Exception()
if self.check_setting == 'true':
src = lib_tools.check_sources(title, year, imdb, None, None,
None, None, None)
if not src: raise Exception()
self.strmFile({
'name': name,
'title': title,
'year': year,
'imdb': imdb,
'tmdb': tmdb
})
files_added += 1
except:
pass
if range == True: return
if self.infoDialog == True:
control.infoDialog(control.lang(32554).encode('utf-8'), time=1)
if self.library_setting == 'true' and not control.condVisibility(
'Library.IsScanningVideo') and files_added > 0:
control.execute('UpdateLibrary(video)')
def getCategory():
getDirectory('0', phLink, '0', '0', '0', '0', '0', close=False)
addCategoryItem('NHL', 'nhlDirectory', 'hockey.jpg')
addCategoryItem(
control.lang(30701).encode('utf-8'), 'openSettings', 'settings.png')
addCategoryItem(
control.lang(30721).encode('utf-8'), 'downloader', 'downloader.png')
addCategoryItem(
control.lang(30702).encode('utf-8'), 'search', 'search.png')
if phTest in control.listDir(control.dataPath)[1]:
addCategoryItem('Testings', 'localDirectory', 'home.png')
endCategory()
def nhlResolve(url):
try:
try: url, selectGame, side = re.compile('(.+?)x0xe(.+?)x0xe(.+?)$').findall(url)[0]
except: selectGame, side = None, None
header = '|' + urllib.urlencode({'User-Agent': 'PS4 libhttp/1.76 (PlayStation 4)'})
base = re.compile('(.*/).+[.]m3u8').findall(url)
if not url.endswith('m3u8'):
return player().run(url + header, selectGame ,side)
result = client.request(url)
result = re.compile('BANDWIDTH=(\d*)\n(.+?[.]m3u8)').findall(result)
result = [(int(int(i[0]) / 1000), i[1]) for i in result]
result = sorted(result, reverse=True)
result = [(str(i[0]), base[0] + i[1]) for i in result]
q = [i[0] for i in result]
u = [i[1] for i in result]
select = control.selectDialog(q, control.lang(30756).encode('utf-8'))
if select == -1: return
url = u[select]
player().run(url + header, selectGame ,side)
except:
return
def accountCheck(self):
if traktCredentials == False and imdbCredentials == False:
control.idle()
control.infoDialog(control.lang(32042).encode('utf-8'),
sound=True,
icon='WARNING')
sys.exit()
def deleteFavourite(meta, content):
try:
meta = json.loads(meta)
if 'title' in meta: title = meta['title']
if 'tvshowtitle' in meta: title = meta['tvshowtitle']
try:
dbcon = database.connect(control.favouritesFile)
dbcur = dbcon.cursor()
try:
dbcur.execute("DELETE FROM %s WHERE id = '%s'" %
(content, meta['imdb']))
except:
pass
try:
dbcur.execute("DELETE FROM %s WHERE id = '%s'" %
(content, meta['tvdb']))
except:
pass
dbcon.commit()
except:
pass
control.refresh()
control.infoDialog(control.lang(30412).encode('utf-8'), heading=title)
except:
return
def silent(self, url):
control.idle()
if not control.condVisibility(
'Window.IsVisible(infodialog)') and not control.condVisibility(
'Player.HasVideo'):
control.infoDialog(control.lang(32608).encode('utf-8'),
time=10000000)
self.infoDialog = True
self.silentDialog = True
from resources.lib.indexers import tvshows
items = tvshows.tvshows().get(url, idx=False)
if items == None: items = []
for i in items:
try:
if xbmc.abortRequested == True: return sys.exit()
self.add(i['title'],
i['year'],
i['imdb'],
i['tvdb'],
range=True)
except:
pass
if self.infoDialog is True:
self.silentDialog = False
control.infoDialog("Trakt TV Show Sync Complete", time=1)
def infoCheck(self, version):
try:
control.infoDialog('',
control.lang(32074).encode('utf-8'),
time=5000,
sound=False)
return '1'
except:
return '1'
def getSearch():
addDirectoryItem('%s...' % control.lang(30702).encode('utf-8'), '0',
'searchDirectory', '0', '0', '0', '0', '0', {})
addDirectoryItem(
control.lang(30703).encode('utf-8'), '0', 'clearSearch', '0', '0', '0',
'0', '0', {})
try:
def search():
return
result = cache.get(search, 600000000, table='rel_srch')
for q in result:
try:
addDirectoryItem('%s...' % q, q, 'searchDirectory2', '0', '0',
'0', '0', '0', {})
except:
pass
except:
pass
control.directory(int(sys.argv[1]), cacheToDisc=True)
def addFavourite(meta, content, query):
try:
item = dict()
meta = json.loads(meta)
try:
id = meta['imdb']
except:
id = meta['tvdb']
if 'title' in meta: title = item['title'] = meta['title']
if 'originaltitle' in meta:
title = item['originaltitle'] = meta['originaltitle']
if 'tvshowtitle' in meta: title = item['title'] = meta['tvshowtitle']
if 'year' in meta: item['year'] = meta['year']
if 'poster' in meta: item['poster'] = meta['poster']
if 'fanart' in meta: item['fanart'] = meta['fanart']
if 'imdb' in meta: item['imdb'] = meta['imdb']
if 'tmdb' in meta: item['tmdb'] = meta['tmdb']
if 'tvdb' in meta: item['tvdb'] = meta['tvdb']
if 'tvrage' in meta: item['tvrage'] = meta['tvrage']
control.makeFile(control.dataPath)
dbcon = database.connect(control.favouritesFile)
dbcur = dbcon.cursor()
dbcur.execute("CREATE TABLE IF NOT EXISTS %s ("
"id TEXT, "
"items TEXT, "
"UNIQUE(id)"
");" % content)
dbcur.execute("DELETE FROM %s WHERE id = '%s'" % (content, id))
dbcur.execute("INSERT INTO %s Values (?, ?)" % content,
(id, repr(item)))
dbcon.commit()
if query == None: control.refresh()
control.infoDialog(control.lang(30411).encode('utf-8'), heading=title)
except:
return
def resolveUrl(name, url, audio, image, fanart, playable, content):
try:
if '.f4m' in url:
label = cleantitle(name)
ext = url.split('?')[0].split('&')[0].split('|')[0].rsplit(
'.')[-1].replace('/', '').lower()
if not ext == 'f4m': raise Exception()
from resources.lib.libraries.f4mproxy.F4mProxy import f4mProxyHelper
return f4mProxyHelper().playF4mLink(url, label, None, None, '',
image)
#legacy issue, will be removed later
if 'afdah.org' in url and not '</source>' in url:
url += '<source>afdah</source>'
if '</source>' in url:
source = re.compile('<source>(.+?)</source>').findall(url)[0]
url = re.compile('(.+?)<source>').findall(url)[0]
for i in ['_mv', '_tv', '_mv_tv']:
try:
call = __import__(
'resources.lib.sources.%s%s' % (source, i), globals(),
locals(), ['object'], -1).source()
except:
pass
from resources.lib import sources
d = sources.sources()
url = call.get_sources(url, d.hosthdfullDict, d.hostsdfullDict,
d.hostlocDict)
if type(url) == list and len(url) == 1:
url = url[0]['url']
elif type(url) == list:
url = sorted(url, key=lambda k: k['quality'])
for i in url:
i.update(
(k, '720p') for k, v in i.iteritems() if v == 'HD')
for i in url:
i.update(
(k, '480p') for k, v in i.iteritems() if v == 'SD')
q = [
'[B]%s[/B] | %s' %
(i['source'].upper(), i['quality'].upper()) for i in url
]
u = [i['url'] for i in url]
select = control.selectDialog(q)
if select == -1: return
url = u[select]
url = call.resolve(url)
from resources.lib import resolvers
host = (urlparse.urlparse(url).netloc).rsplit('.',
1)[0].rsplit('.')[-1]
url = resolvers.request(url)
if type(url) == list and len(url) == 1:
url = url[0]['url']
elif type(url) == list:
url = sorted(url, key=lambda k: k['quality'])
for i in url:
i.update((k, '720p') for k, v in i.iteritems() if v == 'HD')
for i in url:
i.update((k, '480p') for k, v in i.iteritems() if v == 'SD')
q = [
'[B]%s[/B] | %s' % (host.upper(), i['quality'].upper())
for i in url
]
u = [i['url'] for i in url]
select = control.selectDialog(q)
if select == -1: return
url = u[select]
if url == None: raise Exception()
except:
return control.infoDialog(control.lang(30705).encode('utf-8'))
pass
if playable == 'true':
item = control.item(path=url)
return control.resolve(int(sys.argv[1]), True, item)
else:
label = cleantitle(name)
item = control.item(path=url, iconImage=image, thumbnailImage=image)
item.setInfo(type='Video', infoLabels={'title': label})
control.playlist.clear()
control.player.play(url, item)
def searchDirectory(query=None):
if (query == None or query == ''):
keyboard = control.keyboard('', control.lang(30702).encode('utf-8'))
keyboard.doModal()
if not (keyboard.isConfirmed()): return
query = keyboard.getText()
if (query == None or query == ''): return
def search():
return [query]
result = cache.get(search, 600000000, table='rel_srch')
def search():
return [
x for y, x in enumerate((result + [query]))
if x not in (result + [query])[:y]
]
result = cache.get(search, 0, table='rel_srch')
global global_search
global_search = []
def worker(url):
global_search.append(str(client.request(url)))
servers = client.request(phLink)
servers = str(servers).replace('\n', '')
servers = re.findall('</name><link>(.+?)</link>', servers)
servers = [urlparse.urlparse(i).netloc for i in servers]
servers = [phSearch % i for i in servers if not 'mecca' in i]
threads = []
for server in servers:
threads.append(workers.Thread(worker, server))
[i.start() for i in threads]
[i.join() for i in threads]
urls = global_search
global_search = []
urls = [str(i).replace('\n', '') for i in urls]
urls = [re.findall('<link>(.+?)</link>', i)[:30] for i in urls]
urls = sum(urls, [])
threads = []
for url in urls:
threads.append(workers.Thread(worker, url))
[i.start() for i in threads]
[i.join() for i in threads]
links = global_search
global_search = []
for link in links:
try:
link = str(link).replace('\r', '').replace('\n', '').replace(
'\t', '').replace(' ', '')
try:
fanart = re.findall('<fanart>(.+?)</fanart>', link)[0]
except:
fanart = '0'
try:
vip = re.findall('<poster>(.+?)</poster>', link)[0]
except:
vip = ''
if vip == 'Team Phoenix': vip = ''
try:
content = re.findall('<meta>(.+?)</meta>', link)[0]
except:
content = '0'
try:
tvshow = re.findall('<tvshow>(.+?)</tvshow>', link)[0]
except:
tvshow = '0'
if content in ['seasons', 'episodes'] and tvshow == '0':
content = '0'
dirs = re.compile('<dir>(.+?)</dir>').findall(link)
for dir in dirs:
try:
data = {}
name = re.findall('<name>(.+?)</name>', dir)[0]
name = cleantitle(name)
if not query.lower() in name.lower(): raise Exception()
url = re.findall('<link>(.+?)</link>', dir)[0]
try:
image = re.findall('<thumbnail>(.+?)</thumbnail>',
dir)[0]
except:
image = '0'
try:
fanart2 = re.findall('<fanart>(.+?)</fanart>', dir)[0]
except:
fanart2 = fanart
if content == 'tvshows':
try:
title = cleantitle(name).encode('utf-8')
data = {'title': title, 'tvshowtitle': title}
except:
pass
if re.search('[a-zA-Z]', vip):
name += ' [COLOR orange]%s[/COLOR]' % vip
addDirectoryItem(name, url, 'ndmode', image, image,
fanart2, '0', content, data)
except:
pass
items = re.compile('<item>(.+?)</item>').findall(link)
for item in items:
try:
data = {}
name = re.findall('<title>(.+?)</title>', item)[0]
name = cleantitle(name)
if not query.lower() in name.lower(): raise Exception()
url = re.findall('<link>(.+?)</link>', item)[0]
try:
image = re.findall('<thumbnail>(.+?)</thumbnail>',
item)[0]
except:
image = '0'
try:
fanart2 = re.findall('<fanart>(.+?)</fanart>', item)[0]
except:
fanart2 = fanart
if content == 'movies':
try:
title = cleantitle(name).encode('utf-8')
data = {'title': title}
title, year = re.compile(
'(.+?)[(](\d{4})[)]').findall(name)[0]
title = cleantitle(title).encode('utf-8')
data = {'title': title, 'year': year}
except:
pass
if re.search('[a-zA-Z]', vip):
name += ' [COLOR orange]%s[/COLOR]' % vip
if 'sublink' in url:
addDirectoryItem(name,
url,
'subDirectory',
image,
image,
fanart2,
'0',
content,
data,
isFolder=True)
else:
addDirectoryItem(name,
url,
'resolveUrl',
image,
image,
fanart2,
'0',
content,
data,
isFolder=False)
except:
pass
except:
pass
control.directory(int(sys.argv[1]), cacheToDisc=True)
def subDirectory(name, url, audio, image, fanart, playable, tvshow, content):
match = re.compile('<sublink>(.+?)</sublink>').findall(url)
if len(match) == 0: return
try:
title = cleantitle(name).encode('utf-8')
data = {'title': title}
except:
pass
try:
if not content == 'movies': raise Exception()
title = cleantitle(name).encode('utf-8')
data = {'title': title}
title, year = re.compile('(.+?)[(](\d{4})[)]').findall(name)[0]
title = cleantitle(title).encode('utf-8')
data = {'title': title, 'year': year}
from metahandler import metahandlers
metaget = metahandlers.MetaData(preparezip=False)
#data = metaget.get_meta('movie', title, year=year)
data = cachemeta.get(metaget.get_meta, 24, 'movie', title, '', '',
year)
metaimage = data['cover_url']
if not metaimage == '': image = metaimage
metafanart = data['backdrop_url']
if not metafanart == '': fanart = metafanart
except:
pass
try:
if tvshow == '0' and not content == 'episodes': raise Exception()
try:
title = cleantitle(name).encode('utf-8')
data = {'title': title, 'tvshowtitle': tvshow}
except:
pass
try:
i = cleaneptitle(tvshow, title)
title, season, episode = i[0].encode('utf-8'), i[1], i[2]
data = {
'title': title,
'tvshowtitle': tvshow,
'season': season,
'episode': episode
}
except:
pass
from metahandler import metahandlers
metaget = metahandlers.MetaData(preparezip=False)
tvd = metaget.get_meta('tvshow', tvshow)
tvd = cachemeta.get(metaget.get_meta, 24, 'tvshow', tvshow, '', '', '')
data.update({
'year': tvd['year'],
'imdb_id': tvd['imdb_id'],
'tvdb_id': tvd['tvdb_id'],
'tvshowtitle': tvd['TVShowTitle'],
'genre': tvd['genre'],
'studio': tvd['studio'],
'status': tvd['status'],
'duration': tvd['duration'],
'rating': tvd['rating'],
'mpaa': tvd['mpaa'],
'plot': tvd['plot'],
'cast': tvd['cast']
})
metafanart = tvd['backdrop_url']
if not metafanart == '': image = fanart = metafanart
except:
pass
for i in range(0, len(match)):
url = match[i]
label = '%s %s %s' % (name, control.lang(30704).encode('utf-8'),
str(i + 1))
addDirectoryItem(label,
url,
'resolveUrl',
image,
image,
fanart,
'0',
content,
data,
isFolder=False)
control.directory(int(sys.argv[1]), cacheToDisc=True)
def manager(name, imdb, tvdb, content):
try:
post = {
"movies": [{
"ids": {
"imdb": imdb
}
}]
} if content == 'movie' else {
"shows": [{
"ids": {
"tvdb": tvdb
}
}]
}
items = [(control.lang(32516).encode('utf-8'), '/sync/collection')]
items += [(control.lang(32517).encode('utf-8'),
'/sync/collection/remove')]
items += [(control.lang(32518).encode('utf-8'), '/sync/watchlist')]
items += [(control.lang(32519).encode('utf-8'),
'/sync/watchlist/remove')]
items += [(control.lang(32520).encode('utf-8'),
'/users/me/lists/%s/items')]
result = getTraktAsJson('/users/me/lists')
lists = [(i['name'], i['ids']['slug']) for i in result]
lists = [lists[i // 2] for i in range(len(lists) * 2)]
for i in range(0, len(lists), 2):
lists[i] = ((control.lang(32521) % lists[i][0]).encode('utf-8'),
'/users/me/lists/%s/items' % lists[i][1])
for i in range(1, len(lists), 2):
lists[i] = ((control.lang(32522) % lists[i][0]).encode('utf-8'),
'/users/me/lists/%s/items/remove' % lists[i][1])
items += lists
select = control.selectDialog([i[0] for i in items],
control.lang(32515).encode('utf-8'))
if select == -1:
return
elif select == 4:
t = control.lang(32520).encode('utf-8')
k = control.keyboard('', t)
k.doModal()
new = k.getText() if k.isConfirmed() else None
if (new == None or new == ''): return
result = __getTrakt('/users/me/lists',
post={
"name": new,
"privacy": "private"
})[0]
try:
slug = utils.json_loads_as_str(result)['ids']['slug']
except:
return control.infoDialog(control.lang(32515).encode('utf-8'),
heading=str(name),
sound=True,
icon='ERROR')
result = __getTrakt(items[select][1] % slug, post=post)[0]
else:
result = __getTrakt(items[select][1], post=post)[0]
icon = control.infoLabel(
'ListItem.Icon') if not result == None else 'ERROR'
control.infoDialog(control.lang(32515).encode('utf-8'),
heading=str(name),
sound=True,
icon=icon)
except:
return
from ptw.libraries import control
from random import randint
import json
try:
rand = randint(1,len(rlist))-1
for p in ['title','year','imdb','tvdb','season','episode','tvshowtitle','premiered','select']:
if rtype == "show" and p == "tvshowtitle":
try: r += '&'+p+'='+urllib.quote_plus(rlist[rand]['title'])
except: pass
else:
try: r += '&'+p+'='+urllib.quote_plus(rlist[rand][p])
except: pass
try: r += '&meta='+urllib.quote_plus(json.dumps(rlist[rand]))
except: r += '&meta='+urllib.quote_plus("{}")
if rtype == "movie":
try: control.infoDialog(rlist[rand]['title'], control.lang(32536).encode('utf-8'), time=30000)
except: pass
elif rtype == "episode":
try: control.infoDialog(rlist[rand]['tvshowtitle']+" - Season "+rlist[rand]['season']+" - "+rlist[rand]['title'], control.lang(32536).encode('utf-8'), time=30000)
except: pass
control.execute('RunPlugin(%s)' % r)
except:
control.infoDialog(control.lang(32537).encode('utf-8'), time=8000)
elif action == 'movieToLibrary':
from resources.lib.libraries import libtools
libtools.libmovies().add(name, title, year, imdb, tmdb)
elif action == 'moviesToLibrary':
from resources.lib.libraries import libtools
libtools.libmovies().range(url)
def add(self, tvshowtitle, year, imdb, tvdb, range=False):
if not control.condVisibility('Window.IsVisible(infodialog)') and not control.condVisibility('Player.HasVideo')\
and self.silentDialog is False:
control.infoDialog(control.lang(32552).encode('utf-8'),
time=10000000)
self.infoDialog = True
from resources.lib.indexers import episodes
items = episodes.episodes().get(tvshowtitle,
year,
imdb,
tvdb,
idx=False)
try:
items = [{
'title': i['title'],
'year': i['year'],
'imdb': i['imdb'],
'tvdb': i['tvdb'],
'season': i['season'],
'episode': i['episode'],
'tvshowtitle': i['tvshowtitle'],
'premiered': i['premiered']
} for i in items]
except:
items = []
try:
if not self.dupe_setting == 'true': raise Exception()
if items == []: raise Exception()
id = [items[0]['imdb'], items[0]['tvdb']]
lib = control.jsonrpc(
'{"jsonrpc": "2.0", "method": "VideoLibrary.GetTVShows", "params": {"properties" : ["imdbnumber", "title", "year"]}, "id": 1}'
)
lib = unicode(lib, 'utf-8', errors='ignore')
lib = json.loads(lib)['result']['tvshows']
lib = [
i['title'].encode('utf-8') for i in lib
if str(i['imdbnumber']) in id or (
i['title'].encode('utf-8') == items[0]['tvshowtitle']
and str(i['year']) == items[0]['year'])
][0]
lib = control.jsonrpc(
'{"jsonrpc": "2.0", "method": "VideoLibrary.GetEpisodes", "params": {"filter":{"and": [{"field": "tvshow", "operator": "is", "value": "%s"}]}, "properties": ["season", "episode"]}, "id": 1}'
% lib)
lib = unicode(lib, 'utf-8', errors='ignore')
lib = json.loads(lib)['result']['episodes']
lib = [
'S%02dE%02d' % (int(i['season']), int(i['episode']))
for i in lib
]
items = [
i for i in items if not 'S%02dE%02d' %
(int(i['season']), int(i['episode'])) in lib
]
except:
pass
files_added = 0
for i in items:
try:
if xbmc.abortRequested == True: return sys.exit()
if self.check_setting == 'true':
if i['episode'] == '1':
self.block = True
src = lib_tools.check_sources(i['title'], i['year'],
i['imdb'], i['tvdb'],
i['season'],
i['episode'],
i['tvshowtitle'],
i['premiered'])
if src: self.block = False
if self.block == True: raise Exception()
premiered = i.get('premiered', '0')
if (premiered != '0'
and int(re.sub('[^0-9]', '', str(premiered))) > int(
self.date)) or (premiered == '0'
and not self.include_unknown):
continue
self.strmFile(i)
files_added += 1
except:
pass
if range == True: return
if self.infoDialog is True:
control.infoDialog(control.lang(32554).encode('utf-8'), time=1)
if self.library_setting == 'true' and not control.condVisibility(
'Library.IsScanningVideo') and files_added > 0:
control.execute('UpdateLibrary(video)')
from ptw.libraries import control
from ptw.libraries import trakt
from ptw.libraries import cache
sysaddon = sys.argv[0]
syshandle = int(sys.argv[1])
artPath = control.artPath() ; addonFanart = control.addonFanart()
imdbCredentials = False if control.setting('imdb.user') == '' else True
traktCredentials = trakt.getTraktCredentialsInfo()
traktIndicators = trakt.getTraktIndicatorsInfo()
queueMenu = control.lang(32065).encode('utf-8')
class navigator:
def root(self):
self.addDirectoryItem(32001, 'movieNavigator', 'movies.png', 'DefaultMovies.png')
self.addDirectoryItem(32002, 'tvNavigator', 'tvshows.png', 'DefaultTVShows.png')
if not control.setting('lists.widget') == '0':
self.addDirectoryItem(32003, 'mymovieNavigator', 'mymovies.png', 'DefaultVideoPlaylists.png')
self.addDirectoryItem(32004, 'mytvNavigator', 'mytvshows.png', 'DefaultVideoPlaylists.png')
if not control.setting('movie.widget') == '0':
self.addDirectoryItem(32005, 'movieWidget', 'latest-movies.png', 'DefaultRecentlyAddedMovies.png')
self.addDirectoryItem(32007, 'channels', 'calendar.png', 'DefaultMovies.png')
def addDirectoryItem(name,
url,
action,
image,
image2,
fanart,
audio,
content,
data,
tvshow='0',
totalItems=0,
isFolder=True):
if not str(image).lower().startswith('http'):
image = control.addonInfo('icon')
if not str(image2).lower().startswith('http'):
image2 = control.addonInfo('icon')
if not str(fanart).lower().startswith('http'):
fanart = control.addonInfo('fanart')
if content in ['movies', 'episodes']: playable = 'true'
else: playable = 'false'
sysaddon = sys.argv[0]
u = '%s?name=%s&url=%s&audio=%s&image=%s&fanart=%s&playable=%s&tvshow=%s&content=%s&action=%s' % (
sysaddon, urllib.quote_plus(name), urllib.quote_plus(url),
urllib.quote_plus(audio), urllib.quote_plus(image),
urllib.quote_plus(fanart), urllib.quote_plus(playable), str(tvshow),
str(content), str(action))
cm = []
if content in ['movies', 'tvshows']:
data.update({
'trailer':
'%s?action=trailer&name=%s' % (sysaddon, urllib.quote_plus(name))
})
cm.append((control.lang(30707).encode('utf-8'),
'RunPlugin(%s?action=trailer&name=%s)' %
(sysaddon, urllib.quote_plus(name))))
if not 'plot' in data:
data.update({'plot': control.lang(30706).encode('utf-8')})
if content == 'movies':
cm.append((control.lang(30708).encode('utf-8'), 'XBMC.Action(Info)'))
elif content in ['tvshows', 'seasons']:
cm.append((control.lang(30709).encode('utf-8'), 'XBMC.Action(Info)'))
elif content == 'episodes':
cm.append((control.lang(30710).encode('utf-8'), 'XBMC.Action(Info)'))
if content == 'movies' and not isFolder == True:
downloadFile = name
try:
downloadFile = '%s (%s)' % (data['title'], data['year'])
except:
pass
cm.append((control.lang(30722).encode('utf-8'),
'RunPlugin(%s?action=addDownload&name=%s&url=%s&image=%s)' %
(sysaddon, urllib.quote_plus(downloadFile),
urllib.quote_plus(url), urllib.quote_plus(image))))
elif content == 'episodes' and not isFolder == True:
downloadFile = name
try:
downloadFile = '%s S%02dE%02d' % (
data['tvshowtitle'], int(data['season']), int(data['episode']))
except:
pass
cm.append((control.lang(30722).encode('utf-8'),
'RunPlugin(%s?action=addDownload&name=%s&url=%s&image=%s)' %
(sysaddon, urllib.quote_plus(downloadFile),
urllib.quote_plus(url), urllib.quote_plus(image))))
if content == 'movies':
cm.append((control.lang(30711).encode('utf-8'),
'RunPlugin(%s?action=addView&content=movies)' % sysaddon))
elif content == 'tvshows':
cm.append((control.lang(30712).encode('utf-8'),
'RunPlugin(%s?action=addView&content=tvshows)' % sysaddon))
elif content == 'seasons':
cm.append((control.lang(30713).encode('utf-8'),
'RunPlugin(%s?action=addView&content=seasons)' % sysaddon))
elif content == 'episodes':
cm.append((control.lang(30714).encode('utf-8'),
'RunPlugin(%s?action=addView&content=episodes)' % sysaddon))
item = control.item(name,
iconImage='DefaultFolder.png',
thumbnailImage=image)
try:
item.setArt({
'poster': image2,
'tvshow.poster': image2,
'season.poster': image2,
'banner': image,
'tvshow.banner': image,
'season.banner': image
})
except:
pass
item.addContextMenuItems(cm, replaceItems=False)
item.setProperty('Fanart_Image', fanart)
if playable == 'true': item.setProperty('IsPlayable', 'true')
item.setInfo(type='Video', infoLabels=data)
control.addItem(handle=int(sys.argv[1]),
url=u,
listitem=item,
totalItems=totalItems,
isFolder=isFolder)
def download(name, image, url):
from ptw.libraries import control
if url == None:
return control.infoDialog(control.lang(30501).encode('utf-8'))
try:
headers = dict(urlparse.parse_qsl(url.rsplit('|', 1)[1]))
except:
headers = dict('')
url = url.split('|')[0]
content = re.compile('(.+?)\sS(\d*)E\d*$').findall(name)
transname = name.translate(None, '\/:*?"<>|').strip('.')
levels = ['../../../..', '../../..', '../..', '..']
if len(content) == 0:
dest = control.setting('movie_downloads')
control.log('DEST M: |%s|%s|' % (dest, len(dest)))
if len(dest) == 0:
control.infoDialog(control.lang(33002).encode('utf-8'))
control.openSettings('8.1')
exit()
dest = control.transPath(dest)
for level in levels:
try:
control.makeFile(os.path.abspath(os.path.join(dest, level)))
except:
pass
control.makeFile(dest)
dest = os.path.join(dest, transname)
control.makeFile(dest)
else:
dest = control.setting('tv_downloads')
control.log('DEST TV: |%s|' % dest)
if len(dest) == 0:
control.infoDialog(control.lang(33002).encode('utf-8'))
control.openSettings('8.2')
exit()
dest = control.transPath(dest)
for level in levels:
try:
control.makeFile(os.path.abspath(os.path.join(dest, level)))
except:
pass
control.makeFile(dest)
transtvshowtitle = content[0][0].translate(None,
'\/:*?"<>|').strip('.')
dest = os.path.join(dest, transtvshowtitle)
control.makeFile(dest)
dest = os.path.join(dest, 'Season %01d' % int(content[0][1]))
control.makeFile(dest)
ext = os.path.splitext(urlparse.urlparse(url).path)[1][1:]
if not ext in ['mp4', 'mkv', 'flv', 'avi', 'mpg']: ext = 'mp4'
dest = os.path.join(dest, transname + '.' + ext)
sysheaders = urllib.quote_plus(json.dumps(headers))
sysurl = urllib.quote_plus(url)
systitle = urllib.quote_plus(name)
sysimage = urllib.quote_plus(image)
sysdest = urllib.quote_plus(dest)
script = inspect.getfile(inspect.currentframe())
cmd = 'RunScript(%s, %s, %s, %s, %s, %s)' % (
script, sysurl, sysdest, systitle, sysimage, sysheaders)
xbmc.executebuiltin(cmd)
def nhlStreams(name, url):
try:
name = re.sub('\s\[COLOR.+?\].+?\[/COLOR\]', '', name).strip()
n1 = name + ' [COLOR gold]%s[/COLOR]' ; n2 = name + ' [COLOR red]%s[/COLOR]'
selectHomeGame = 'x0xe%sx0xehome' % str(url)
selectAwayGame = 'x0xe%sx0xeaway' % str(url)
url = re.compile('(\d{4})(\d{2})(\d{4})').findall(url)[0]
url = 'http://smb.cdnak.neulion.com/fs/nhl/mobile/feed_new/data/streams/%s/ipad/%s_%s.json' % (url[0], url[1], url[2])
result = client.request(url)
result = json.loads(result)
items = result['gameStreams']['ipad']
h = items['home'] ; a = items['away']
except:
pass
l1 = []; l2 = []
try: finish = result['finish']
except: finish = 'true'
try: image = re.compile('"image" *: *"(.+?)"').findall(json.dumps(h))[-1]
except: image = '0'
try: l1.append({'name': n1 % 'Home LIVE', 'url': h['live']['bitrate0'] + selectHomeGame, 'image': image})
except: pass
try: l2.append({'name': n2 % 'Home Whole', 'url': h['vod-whole']['bitrate0'], 'image': image})
except: pass
try: l2.append({'name': n2 % 'Home Continuous', 'url': h['vod-continuous']['bitrate0'], 'image': image})
except: pass
try: l2.append({'name': n2 % 'Home Condensed', 'url': h['vod-condensed']['bitrate0'], 'image': image})
except: pass
try: image = re.compile('"image" *: *"(.+?)"').findall(json.dumps(a))[-1]
except: image = '0'
try: l1.append({'name': n1 % 'Away LIVE', 'url': a['live']['bitrate0'] + selectAwayGame, 'image': image})
except: pass
try: l2.append({'name': n2 % 'Away Whole', 'url': a['vod-whole']['bitrate0'], 'image': image})
except: pass
try: l2.append({'name': n2 % 'Away Continuous', 'url': a['vod-continuous']['bitrate0'], 'image': image})
except: pass
try: l2.append({'name': n2 % 'Away Condensed', 'url': a['vod-condensed']['bitrate0'], 'image': image})
except: pass
if finish == 'false':
for i in l1: addDirectoryItem(i['name'], i['url'], 'nhlResolve', i['image'], '0', isFolder=False)
else:
for i in l2: addDirectoryItem(i['name'], i['url'], 'nhlResolve', i['image'], '0', isFolder=False)
if l1 == [] and l2 == []:
return control.infoDialog(control.lang(30755).encode('utf-8'), name, addonIcon)
endDirectory()
rlist[rand]['title'])
except:
pass
else:
try:
r += '&' + p + '=' + urllib.quote_plus(rlist[rand][p])
except:
pass
try:
r += '&meta=' + urllib.quote_plus(json.dumps(rlist[rand]))
except:
r += '&meta=' + urllib.quote_plus("{}")
if rtype == "movie":
try:
control.infoDialog(rlist[rand]['title'],
control.lang(32536).encode('utf-8'),
time=30000)
except:
pass
elif rtype == "episode":
try:
control.infoDialog(rlist[rand]['tvshowtitle'] + " - Season " +
rlist[rand]['season'] + " - " +
rlist[rand]['title'],
control.lang(32536).encode('utf-8'),
time=30000)
except:
pass
control.execute('RunPlugin(%s)' % r)
except:
control.infoDialog(control.lang(32537).encode('utf-8'), time=8000)
def authTrakt():
try:
if getTraktCredentialsInfo() == True:
if control.yesnoDialog(
control.lang(32511).encode('utf-8'),
control.lang(32512).encode('utf-8'), '', 'Trakt'):
control.setSetting(id='trakt.user', value='')
control.setSetting(id='trakt.token', value='')
control.setSetting(id='trakt.refresh', value='')
raise Exception()
result = getTraktAsJson('/oauth/device/code',
{'client_id': V2_API_KEY})
verification_url = (control.lang(32513) %
result['verification_url']).encode('utf-8')
user_code = (control.lang(32514) % result['user_code']).encode('utf-8')
expires_in = int(result['expires_in'])
device_code = result['device_code']
interval = result['interval']
progressDialog = control.progressDialog
progressDialog.create('Trakt', verification_url, user_code)
for i in range(0, expires_in):
try:
if progressDialog.iscanceled(): break
time.sleep(1)
if not float(i) % interval == 0: raise Exception()
r = getTraktAsJson(
'/oauth/device/token', {
'client_id': V2_API_KEY,
'client_secret': CLIENT_SECRET,
'code': device_code
})
if 'access_token' in r: break
except:
pass
try:
progressDialog.close()
except:
pass
token, refresh = r['access_token'], r['refresh_token']
headers = {
'Content-Type': 'application/json',
'trakt-api-key': V2_API_KEY,
'trakt-api-version': 2,
'Authorization': 'Bearer %s' % token
}
result = client.request(urlparse.urljoin(BASE_URL, '/users/me'),
headers=headers)
result = utils.json_loads_as_str(result)
user = result['username']
control.setSetting(id='trakt.user', value=user)
control.setSetting(id='trakt.token', value=token)
control.setSetting(id='trakt.refresh', value=refresh)
raise Exception()
except:
control.openSettings('3.1')
def update(self, query=None, info='true'):
if not query == None: control.idle()
try:
items = []
season, episode = [], []
show = [
os.path.join(self.library_folder, i)
for i in control.listDir(self.library_folder)[0]
]
for s in show:
try:
season += [
os.path.join(s, i) for i in control.listDir(s)[0]
]
except:
pass
for s in season:
try:
episode.append([
os.path.join(s, i) for i in control.listDir(s)[1]
if i.endswith('.strm')
][-1])
except:
pass
for file in episode:
try:
file = control.openFile(file)
read = file.read()
read = read.encode('utf-8')
file.close()
if not read.startswith(sys.argv[0]): raise Exception()
params = dict(urlparse.parse_qsl(read.replace('?', '')))
try:
tvshowtitle = params['tvshowtitle']
except:
tvshowtitle = None
try:
tvshowtitle = params['show']
except:
pass
if tvshowtitle == None or tvshowtitle == '':
raise Exception()
year, imdb, tvdb = params['year'], params['imdb'], params[
'tvdb']
imdb = 'tt' + re.sub('[^0-9]', '', str(imdb))
try:
tmdb = params['tmdb']
except:
tmdb = '0'
items.append({
'tvshowtitle': tvshowtitle,
'year': year,
'imdb': imdb,
'tmdb': tmdb,
'tvdb': tvdb
})
except:
pass
items = [i for x, i in enumerate(items) if i not in items[x + 1:]]
if len(items) == 0: raise Exception()
except:
return
try:
lib = control.jsonrpc(
'{"jsonrpc": "2.0", "method": "VideoLibrary.GetTVShows", "params": {"properties" : ["imdbnumber", "title", "year"]}, "id": 1}'
)
lib = unicode(lib, 'utf-8', errors='ignore')
lib = json.loads(lib)['result']['tvshows']
except:
return
if info == 'true' and not control.condVisibility(
'Window.IsVisible(infodialog)') and not control.condVisibility(
'Player.HasVideo'):
control.infoDialog(control.lang(32553).encode('utf-8'),
time=10000000)
self.infoDialog = True
try:
control.makeFile(control.dataPath)
dbcon = database.connect(control.libcacheFile)
dbcur = dbcon.cursor()
dbcur.execute("CREATE TABLE IF NOT EXISTS tvshows ("
"id TEXT, "
"items TEXT, "
"UNIQUE(id)"
");")
except:
return
try:
from resources.lib.indexers import episodes
except:
return
files_added = 0
# __init__ doesn't get called from services so self.date never gets updated and new episodes are not added to the library
self.datetime = (datetime.datetime.utcnow() -
datetime.timedelta(hours=5))
self.date = (self.datetime -
datetime.timedelta(hours=24)).strftime('%Y%m%d')
for item in items:
it = None
if xbmc.abortRequested == True: return sys.exit()
try:
dbcur.execute("SELECT * FROM tvshows WHERE id = '%s'" %
item['tvdb'])
fetch = dbcur.fetchone()
it = eval(fetch[1].encode('utf-8'))
except:
pass
try:
if not it == None: raise Exception()
it = episodes.episodes().get(item['tvshowtitle'],
item['year'],
item['imdb'],
item['tvdb'],
idx=False)
status = it[0]['status'].lower()
it = [{
'title': i['title'],
'year': i['year'],
'imdb': i['imdb'],
'tvdb': i['tvdb'],
'season': i['season'],
'episode': i['episode'],
'tvshowtitle': i['tvshowtitle'],
'premiered': i['premiered']
} for i in it]
if status == 'continuing': raise Exception()
dbcur.execute("INSERT INTO tvshows Values (?, ?)",
(item['tvdb'], repr(it)))
dbcon.commit()
except:
pass
try:
id = [item['imdb'], item['tvdb']]
if not item['tmdb'] == '0': id += [item['tmdb']]
ep = [
x['title'].encode('utf-8') for x in lib
if str(x['imdbnumber']) in id or (
x['title'].encode('utf-8') == item['tvshowtitle']
and str(x['year']) == item['year'])
][0]
ep = control.jsonrpc(
'{"jsonrpc": "2.0", "method": "VideoLibrary.GetEpisodes", "params": {"filter":{"and": [{"field": "tvshow", "operator": "is", "value": "%s"}]}, "properties": ["season", "episode"]}, "id": 1}'
% ep)
ep = unicode(ep, 'utf-8', errors='ignore')
ep = json.loads(ep).get('result', {}).get('episodes', {})
ep = [{
'season': int(i['season']),
'episode': int(i['episode'])
} for i in ep]
ep = sorted(ep, key=lambda x: (x['season'], x['episode']))[-1]
num = [
x for x, y in enumerate(it)
if str(y['season']) == str(ep['season'])
and str(y['episode']) == str(ep['episode'])
][-1]
it = [y for x, y in enumerate(it) if x > num]
if len(it) == 0: continue
except:
continue
for i in it:
try:
if xbmc.abortRequested == True: return sys.exit()
premiered = i.get('premiered', '0')
if (premiered != '0'
and int(re.sub('[^0-9]', '', str(premiered))) >
int(self.date)) or (premiered == '0'
and not self.include_unknown):
continue
libtvshows().strmFile(i)
files_added += 1
except:
pass
if self.infoDialog == True:
control.infoDialog(control.lang(32554).encode('utf-8'), time=1)
if self.library_setting == 'true' and not control.condVisibility(
'Library.IsScanningVideo') and files_added > 0:
control.execute('UpdateLibrary(video)')
def tvshows(tvshowtitle, year, imdb, tvdb, season, watched):
traktMode = False if trakt.getTraktCredentials() == False else True
watched = int(watched)
try:
if traktMode == True: raise Exception()
from metahandler import metahandlers
from resources.lib.indexers import episodes
metaget = metahandlers.MetaData(preparezip=False)
dialog = control.progressDialog
dialog.create(control.addonInfo('name'), str(tvshowtitle))
dialog.update(0, str(tvshowtitle),
control.lang(30451).encode('utf-8') + '...')
metaget.get_meta('tvshow', '', imdb_id=imdb)
items = episodes.episodes().get(tvshowtitle,
year,
imdb,
'0',
tvdb,
'0',
idx=False)
try:
items = [
i for i in items
if int('%01d' % int(season)) == int('%01d' % int(i['season']))
]
except:
pass
items = [{
'name': i['name'],
'season': int('%01d' % int(i['season'])),
'episode': int('%01d' % int(i['episode']))
} for i in items]
for i in range(len(items)):
if xbmc.abortRequested == True: return sys.exit()
if dialog.iscanceled(): return dialog.close()
dialog.update(int((100 / float(len(items))) * i), str(tvshowtitle),
str(items[i]['name']))
season, episode = items[i]['season'], items[i]['episode']
metaget.get_episode_meta('', imdb, season, episode)
metaget.change_watched('episode',
'',
imdb,
season=season,
episode=episode,
year='',
watched=watched)
try:
dialog.close()
except:
pass
except:
try:
dialog.close()
except:
pass
try:
if traktMode == False: raise Exception()
if watched == 7: trakt.markTVShowAsWatched(tvdb)
else: trakt.markTVShowAsNotWatched(tvdb)
trakt.syncTVShows()
except:
pass
control.refresh()
