def listVideos(self, cItem):
printDBG("TVProart.listVideos [%s]" % cItem)
page = cItem.get('page', 1)
url = self.API_URL + 'movies?type=cats&crit_id={0}'.format(cItem['slug'])
sts, data = self.cm.getPage(url + '&page={0}'.format(page))
if not sts: return
nextPage = False
try:
data = byteify(json.loads(data))
if data['status'] != '200': return
for item in data['content']:
icon = self._getFullUrl( item['thumb'] )
item = item['data']
url = self.API_URL + 'video?id={0}&slug={1}'.format(item['id'], item['slug'])
params = {'title':item['title'], 'url':url, 'icon':icon, 'desc':item['date']}
self.addVideo(params)
except:
printExc()
nextPage = False
try:
sts, data = self.cm.getPage(url + '&page={0}'.format(page+1))
data = byteify(json.loads(data))
if len(data['content']) > 0:
nextPage = True
except:
pass
self.addNextPage(cItem, nextPage, page)
def _download_json(self, url, video_id, note='', errnote='', fatal=True, params={}):
sts, data = self.cm.getPage(url, params)
if not sts: return None
if fatal:
data = byteify(json.loads(data))
else:
try:
data = byteify(json.loads(data))
except:
printExc()
data = None
return data
def getVideoLink(self, cItem):
printDBG("TelewizjadaNetApi.getVideoLink")
url = self.MAIN_URL + 'live.php?cid=%s' % cItem['cid']
sts, data = self.cm.getPage(url, self.http_params)
if not sts: return []
http_params = dict(self.http_params)
HTTP_HEADER= { 'User-Agent':'Mozilla/5.0 (X11; Ubuntu; Linux i686; rv:21.0) Gecko/20100101 Firefox/21.0'}
http_params.update({'header':HTTP_HEADER})
http_params['header']['Referer'] = url
url = self.MAIN_URL + 'get_mainchannel.php'
sts, data = self.cm.getPage(url, http_params, {'cid':cItem['cid']})
if not sts: return []
try:
data = byteify(json.loads(data))
vid_url = data['url']
except:
printExc()
return []
url = self.MAIN_URL + 'set_cookie.php'
sts, data = self.cm.getPage(url, http_params, {'url':vid_url})
if not sts: return []
url = self.MAIN_URL + 'get_channel_url.php'
sts, data = self.cm.getPage(url, http_params, {'cid':cItem['cid']})
if not sts: return []
try:
vid_url = byteify(json.loads(data))
vid_url = vid_url['url']
except:
vid_url = data
urlsTab = []
vid_url = vid_url.strip()
if vid_url.startswith('http://') and 'm3u8' in vid_url:
try:
sessid = self.cm.getCookieItem(self.COOKIE_FILE, 'sessid')
msec = self.cm.getCookieItem(self.COOKIE_FILE, 'msec')
statid = self.cm.getCookieItem(self.COOKIE_FILE, 'statid')
url = strwithmeta(vid_url, {'Cookie':'sessid=%s; msec=%s; statid=%s;' % (sessid, msec, statid)})
urlsTab = getDirectM3U8Playlist(url)
except:
SetIPTVPlayerLastHostError("Problem z dostępem do pliku \"%\".\nSprawdź, czy masz wolne miejsce na pliki cookies." % self.COOKIE_FILE)
return urlsTab
def listPseudoStreaming(self, cItem):
printDBG("TVJWORG.listPseudoStreaming")
baseUrl = 'schedules/%s/%s?utcOffset=60' % (self._getLangCode(), cItem['key'])
url = self._getFullUrl(baseUrl)
sts, data = self.cm.getPage(url)
if not sts: return
try:
data = byteify(json.loads(data))
for item in data['category']['media']:
icon = self._getIcon(item)
title = item['title']
duration = item['durationFormattedHHMM']
if len(duration): title += ' [%s]' % duration
type = item['type']
date = item['firstPublished']
if len(date):
desc = date + '[/br]'
else: desc = ''
desc += item['description']
files = item['files']
params = {'title':title, 'icon':icon, 'desc':desc, 'files':files}
if type == 'video':
self.addVideo(params)
elif type == 'audio':
self.addAudio(params)
else:
params['title'] += ' COS ZLE SPRAWDZ type[%s]' % type
self.addVideo(params)
except:
printExc()
def getLinksForVideo(self, cItem):
printDBG("SemBilheteTV.getLinksForVideo [%s]" % cItem)
urlTab = []
if 0 == len(self.loginData['api_key']) and 0 == len(self.loginData['username']):
self.requestLoginData()
if 'imdb_id' in cItem:
url = 'content/request/%s/?api_key=%s&username=%s' % (cItem['imdb_id'], self.loginData['api_key'], self.loginData['username'])
url = self._getFullUrl(url)
sts, data = self.cm.getPage(url)
if not sts: return []
try:
printDBG(data)
data = byteify(json.loads(data))
linkVideo = data['url']
if not linkVideo.startswith('http'):
SetIPTVPlayerLastHostError(self.cleanHtmlStr(url))
return []
subTracks = []
for track in data.get('subtitles', []):
subUrl = self._getFullUrl(track['url'], False)
subLang = track['language']
subTracks.append({'title':subLang, 'url':subUrl, 'lang':subLang, 'format':'srt'})
urlTab.append({'name': 'main', 'url':urlparser.decorateUrl(linkVideo, {'external_sub_tracks':subTracks}), 'need_resolve':1})
except:
printExc()
return urlTab
def getLinksForFavourite(self, fav_data):
links = []
try:
cItem = byteify(json.loads(fav_data))
links = self.getLinksForVideo(cItem)
except: printExc()
return links
def _doGetEpisodesCallback(self, code, data):
sts = False
list = []
promotItem = {}
if code == 0:
try:
season = self.tmpData["episode_data"].get("season", -1)
episode = self.tmpData["episode_data"].get("episode", -1)
printDBG("_doGetEpisodesCallback s[%s] e[%s]" % (season, episode))
data = byteify(json.loads(data))
key, value = data.popitem()
for item in value["episodes"]:
params = dict(self.tmpData["private_data"])
params.update({"season": item["season"], "episode_title": item["name"], "episode": item["number"]})
title = "s{0}e{1} {2}".format(
str(item["season"]).zfill(2), str(item["number"]).zfill(2), item["name"]
)
if season == item["season"] and episode == item["number"] and promotItem == {}:
promotItem = {"title": title, "private_data": params}
else:
list.append({"title": title, "private_data": params})
sts = True
except:
printExc()
self.lastApiError = {"code": -999, "message": _("json load error 2")}
if promotItem != {}:
list.insert(0, promotItem)
self.tmpData = {}
self.outerCallback(sts, list)
def listItems(self, cItem, url):
printDBG("UstreamTV.listItems")
sts, data = self.cm.getPage(url)
if not sts: return
nextPage = False
try:
data = byteify(json.loads(data))
if not data['success']: return
nextPage = data['pageMeta']['infinite']
data = data['pageContent']
data = data.split('<div class="item media-item">')
del data[0]
for item in data:
params = dict(cItem)
url = self.cm.ph.getSearchGroups(item, 'href="([^"]+?)"')[0]
title = self.cm.ph.getSearchGroups(item, 'title="([^"]+?)"')[0]
icon = self.cm.ph.getSearchGroups(item, 'src="([^"]+?)"')[0]
desc = self.cleanHtmlStr( item )
params.update({'title':self.cleanHtmlStr( title ), 'icon':self._getFullUrl(icon), 'desc':desc, 'url':self._getFullUrl(url)})
self.addVideo(params)
except:
printExc()
if nextPage:
params = dict(cItem)
params.update({'title':_('Next page'), 'page':cItem.get('page', 1)+1})
self.addDir(params)
def fillBrowse(self):
if self.translations == {} or self.browseCategoryList == []:
sts, data = self.cm.getPage(self.MAIN_URL + 'browse')
if not sts: return
translations = self.cm.ph.getDataBeetwenMarkers(data, 'translations:', 'config:', False)[1]
translations = '{"translations":%s}' % translations.strip()[:-2]
#printDBG(translations)
browseCategoryList = self.cm.ph.getDataBeetwenMarkers(data, '"browseCategoryList":', ']', True)[1]
browseCategoryList = '{%s}' % browseCategoryList
self.language = self.cm.ph.getSearchGroups(data, 'language:[^"]*?"([^"]+?)"')[0].split('-')
try:
self.translations = byteify(json.loads(translations))['translations']
self.browseCategoryList = byteify(json.loads(browseCategoryList))['browseCategoryList']
except:
printExc()
return
def listBrowseShows(self, cItem, category):
printDBG("Vevo.listBrowseShows")
if [] == self.cacheShows:
if 2 != len(self.language): return
url = self.MAIN_URL + 'c/{0}/{1}/shows.json?platform=web'.format(self.language[0], self.language[1])
sts, data = self.cm.getPage(url)
if not sts: return
try:
data = byteify(json.loads(data))
if data['success']:
self.cacheShows = data['result']
except:
printExc()
return
for idx in range(len(self.cacheShows)):
params = dict(cItem)
item = self.cacheShows[idx]
icon = item.get('header_image_url', '')
if '' == icon: icon = item.get('mobile_image_url', '')
if '' == icon: icon = item.get('thumbnail_image_url', '')
if 1 <= len(item.get('seasons', [])):
category = 'list_show_videos'
params.update({'category':category, 'title':item['title'], 'icon':icon, 'desc':item['description'], 'show_id':idx, 'season_id':0})
self.addDir(params)
def _getChannelsNames(self):
printDBG("UstvnowApi._getChannelsNames")
url = 'http://m.ustvnow.com/gtv/1/live/listchannels?%s' % urllib.urlencode({'token': self.token})
sts, data = self.cm.getPage(url)
if not sts: return []
channelList = []
try:
data = byteify(json.loads(data))
for item in data['results']['streamnames']:
params = {}
params['sname'] = item['sname']
params['img'] = item['img']
params['scode'] = item['scode']
params['t'] = item['t']
params['callsign'] = item['callsign']
params['prgsvcid'] = item['prgsvcid']
params['data_provider'] = item['data_provider']
params['lang'] = item['lang']
params['af'] = item['af']
channelList.append(params)
except:
printExc()
return channelList
def getLinksForVideo(self, cItem):
printDBG("WpTV.getLinksForVideo [%s]" % cItem)
urlTab = []
sts, data = self.cm.getPage(cItem['url'], self.defaultParams)
if not sts: return []
vidId = self.cm.ph.getSearchGroups(data, 'data-mid="([^"]+?)"')[0]
vidUrl = self.MAIN_URL + "player/mid,%s,embed.json" % vidId
try:
sts, data = self.cm.getPage(vidUrl, self.defaultParams)
if not sts: return []
tmpTab = []
qMap = {"HQ":'2', "LQ":'1'}
data = byteify(json.loads(data))
for item in data['clip']['url']:
if 'mp4' not in item['type']: continue
urlTab.append({'name':item['quality'] + ' ' + item['type'], 'url':self._getFullUrl(item['url']), 'quality':qMap.get(item['quality'], '3'), 'need_resolve':0})
if 0 < len(urlTab):
max_bitrate = int(config.plugins.iptvplayer.wpDefaultformat.value)
def __getLinkQuality( itemLink ):
if 'mobile' in itemLink['name']: return 0
return int(itemLink['quality'])
urlTab = CSelOneLink(urlTab, __getLinkQuality, max_bitrate).getSortedLinks()
if config.plugins.iptvplayer.wpUseDF.value:
urlTab = [urlTab[0]]
except:
printExc()
return urlTab
def listMedia(self, cItem):
printDBG("Hitbox.listMedia")
page = cItem.get('page', 0)
sts, data = self.cm.getPage(cItem['url'].format(Hitbox.NUM_OF_ITEMS, page*Hitbox.NUM_OF_ITEMS) )
if not sts: return
try:
data = byteify(json.loads(data))
if 'live' == data['media_type']: key = 'livestream'
elif 'video' == data['media_type']: key = 'video'
else:
printExc("Uknown type [%s]" % data['media_type'])
return
data = data[key]
for item in data:
params = dict(cItem)
params.update( self._getLiveStreamsBaseParams(item) )
if key == 'video': params['media_id'] = item['media_id']
else: params['channel_link'] = item['channel']['channel_link']
self.addVideo(params)
# check next page
sts, data = self.cm.getPage(cItem['url'].format(1, (page+1)*Hitbox.NUM_OF_ITEMS) )
if not sts: return
if len(json.loads(data)[key]):
params = dict(cItem)
params.update( {'title':_('Next page'), 'page':page+1} )
self.addDir(params)
except: printExc()
def listLiveChannels(self, cItem):
printDBG("listLiveChannels")
sts, data = self.cm.getPage(cItem['url'])
if not sts: return
try:
if 'video' == cItem['channel_type']:
video = True
else:
video = False
data = byteify(json.loads(data))
#if video: data.sort(key=lambda item: item["WebChannel"])
for item in data:
if item.get("WebChannel", False): continue
item.update({'title':item['Title'], 'icon':item.get('PrimaryImageUri')})
if video:
self.addVideo(item)
else:
self.addAudio(item)
if video:
data = self.tv2r.getChannels()
for item in data:
params = {'title':item['title'], 'Type':'tv2r', 'tv2r_data':item}
self.addVideo(params)
except:
printExc()
def getVideoLinks(self, videoUrl):
printDBG("HDFilmeTV.getVideoLinks [%s]" % videoUrl)
urlTab = []
sts, data = self.getPage(videoUrl)
if not sts: return []
googleUrls = self.cm.ph.getSearchGroups(data, '''var hdfilme[^=]*?=[^[]*?(\[[^;]+?);''')[0].strip()
if googleUrls != '':
try:
googleUrls = byteify( json.loads(googleUrls) )
for item in googleUrls:
if item['type'] != 'mp4':
continue
urlTab.append({'name':item['label'], 'url':self._getFullUrl(item['file'])})
except:
printExc()
if len(urlTab):
return urlTab
data = self.cm.ph.getAllItemsBeetwenMarkers(data, '<iframe', '</iframe>', caseSensitive=False)
for item in data:
vidUrl = self._getFullUrl(self.cm.ph.getSearchGroups(item, 'src="([^"]+?)"', ignoreCase=True)[0])
if 1 != self.up.checkHostSupport(vidUrl): continue
urlTab.extend( self.up.getVideoLinkExt(vidUrl) )
return urlTab
def listItems(self, cItem):
printDBG("FilmyDokumentalneEU.listItems")
page = cItem.get('page', 1)
url = cItem['url'] + '?json=1&page=%d' % page
sts, data = self.cm.getPage(url)
if not sts: return
nextPage = False
try:
data = byteify(json.loads(data))
if page < data.get('pages', 0):
nextPage = True
else: nextPage = False
for item in data['posts']:
url = item['url']
title = self.cleanHtmlStr(item['title'])
desc = self.cleanHtmlStr(item.get('excerpt', ''))
icon = item.get('thumbnail', '')
if '' == icon: icon = self.DEFAULT_ICON
params = dict(cItem)
params.update({ 'url':url, 'title':title, 'icon':icon, 'desc':desc})
self.addVideo(params)
except:
printExc()
if nextPage:
params = dict(cItem)
params.update({'title':_("Next page"), 'page':page+1})
self.addDir(params)
def _encryptPlayerUrl(self, data):
printDBG("_encryptPlayerUrl data[%s]" % data)
decrypted = ''
try:
data = byteify( json.loads(data) )
salt = a2b_hex(data["v"])
key, iv = EVP_BytesToKey(md5, "s05z9Gpd=syG^7{", salt, 32, 16, 1)
if iv != a2b_hex(data.get('b', '')):
prinDBG("_encryptPlayerUrl IV mismatched")
if 0:
from Crypto.Cipher import AES
aes = AES.new(key, AES.MODE_CBC, iv, segment_size=128)
decrypted = aes.decrypt(a2b_base64(data["a"]))
decrypted = decrypted[0:-ord(decrypted[-1])]
else:
kSize = len(key)
alg = AES_CBC(key, keySize=kSize)
decrypted = alg.decrypt(a2b_base64(data["a"]), iv=iv)
decrypted = decrypted.split('\x00')[0]
decrypted = "%s" % json.loads( decrypted ).encode('utf-8')
except:
printExc()
decrypted = ''
return decrypted
def getResolvedURL(self, url):
printDBG( 'Host getResolvedURL url[%r] ' % url )
videoUrls = []
sts, data = self.cm.getPage(url)
if not sts: return []
videoUrl = self.cm.ph.getSearchGroups(data, '<iframe[^>]+?src="(http[^"]+?)"', 1, True)[0]
sts, data = self.cm.getPage(videoUrl)
if not sts: return []
data = self.cm.ph.getDataBeetwenMarkers(data, 'var t={', '};', False)[1]
printDBG(data)
try:
data = byteify( json.loads('{%s}' % data) )
for item in data['request']['files']['progressive']:
videoUrls.append({'name':item['quality'], 'url':item['url'], 'height':item['height']})
except:
printExc()
if 0 < len(videoUrls):
max_bitrate = int(config.plugins.iptvplayer.vimeo_default_quality.value)
def __getLinkQuality( itemLink ):
return int(itemLink['height'])
videoUrls = CSelOneLink(videoUrls, __getLinkQuality, max_bitrate).getSortedLinks()
if config.plugins.iptvplayer.vimeo_use_default_quality.value:
videoUrls = [videoUrls[0]]
return videoUrls
def listCategories(self, cItem, sub=''):
printDBG("TVJWORG.listCategories")
if 'key' in cItem:
baseUrl = 'categories/%s/%s?detailed=1' % (self._getLangCode(), cItem['key'])
else:
baseUrl = 'categories/' + self._getLangCode()
url = self._getFullUrl(baseUrl)
sts, data = self.cm.getPage(url)
if not sts: return
try:
data = byteify(json.loads(data))
if sub != '':
data = data['category'][sub]
else:
data = data['categories']
for item in data:
icon = self._getIcon(item)
key = item['key']
title = item['name']
category = item['type']
desc = item['description']
params = dict(cItem)
params.update({'category':category, 'key':key, 'title':title, 'icon':icon, 'desc':desc})
self.addDir(params)
except:
printExc()
def getLinksForVideo(self, cItem):
printDBG("Veetle.getLinksForVideo [%s]" % cItem)
urlTab = []
from copy import deepcopy
params = deepcopy(self.defaultParams)
try:
channelId = cItem['channel_id']
url = self._getFullUrl('index.php/channel/view/' + channelId)
sts, data = self.cm.getPage(url, params)
if not sts: return []
url = self._getFullUrl('index.php/stream/ajaxInfo/' + channelId)
sts, data = self.cm.getPage(url, params)
if not sts: return []
data = byteify(json.loads(data))
if not data['success']: return []
data = data['payload']
channelId = data['channelId']
sessionId = data['sessionId']
linksTypesTab = []
if data.get('flashEnabled', False):
linksTypesTab.append('flash')
if data.get('iPadEnabled', False) or data.get('iPhoneEnabled', False):
linksTypesTab.append('hls')
for type in linksTypesTab:
try:
baseVidUrl = self._getFullUrl('index.php/stream/ajaxStreamLocation/%s_%s/' %(channelId, sessionId) + type)
params['header']['Referer'] = url
sts, data = self.cm.getPage(baseVidUrl, params)
if not sts: continue
data = byteify(json.loads(data))
if data['success'] and data['payload'].startswith('http'):
if type == 'flash':
need_resolve = 0
else:
need_resolve = 1
urlTab.append({'name':type, 'url':data['payload'], 'need_resolve':need_resolve})
except:
printExc()
except:
printExc()
return urlTab
def getLinksForFavourite(self, fav_data):
printDBG("NaszeKino.getLinksForFavourite")
try:
cItem = byteify(json.loads(fav_data))
except:
printExc()
return []
return self.getLinksForVideo(cItem)
def getCountryCode(self, lower=True):
if 'countryCode' not in self.geolocation:
sts, data = self.getPage('http://ip-api.com/json')
if sts:
try:
self.geolocation['countryCode'] = byteify(json.loads(data))['countryCode']
except:
printExc()
return self.geolocation.get('countryCode', '').lower()
def fillCache(self):
printDBG("WolnelekturyPL.fillCache")
self.cache = []
sts, data = self.cm.getPage('http://iptvplayer.pl/resources/wolnelektury3.db')
if not sts: return
try:
self.cache = byteify(json.loads(data))
except:
printExc()
def getLinksForFavourite(self, fav_data):
if None == self.loggedIn and self.PREMIUM:
self.loggedIn = self.tryTologin()
try:
favItem = byteify( json.loads(fav_data) )
return self.getHostingTable(favItem)
except: printExc()
return []
def getChannelsList(self, cItem):
printDBG("UstvnowApi.getChannelsList")
login = config.plugins.iptvplayer.ustvnow_login.value
passwd = config.plugins.iptvplayer.ustvnow_password.value
if '' != login.strip() and '' != passwd.strip():
self.token = self.doLogin(login, passwd)
if self.token == '':
self.sessionEx.open(MessageBox, _('An error occurred when try to sign in the user "%s.\nPlease check your login credentials and try again later..."') % login, type = MessageBox.TYPE_INFO, timeout = 10 )
return []
else:
self.sessionEx.open(MessageBox, _('You need to enter email and password in configuration.'), type = MessageBox.TYPE_INFO, timeout = 10 )
return []
sts, data = self.cm.getPage(self.LIVE_URL, self.defParams)
if not sts: return []
channelsNames = self._getChannelsNames()
channelsTab = []
data = self.cm.ph.getDataBeetwenMarkers(data, '<div data-role="content" data-theme="c">', '</ul>', False)[1]
data = data.split('</li>')
prgsvcidMap = {}
for item in data:
url = self.cm.ph.getSearchGroups(item, 'href="([^"]+?)"')[0]
ui = url.split('ui-page=')[-1]
icon = self.cm.ph.getSearchGroups(item, 'src="([^"]+?)"')[0]
desc = self.cleanHtmlStr(item)
params = dict(cItem)
params.pop('url')
params.update({'priv_url':self._getFullUrl(url), 'ui_page':ui, 'icon':icon, 'desc':desc})
for nameItem in channelsNames:
if nameItem['img'] in icon:
if config.plugins.iptvplayer.ustvnow_only_available.value and 0 == nameItem['t']:
break
params['title'] = nameItem['sname'] + ' [%s]' % nameItem['t']
params['prgsvcid'] = nameItem['prgsvcid']
prgsvcidMap[params['prgsvcid']] = len(channelsTab)
channelsTab.append(params)
break
if config.plugins.iptvplayer.ustvnow_epg.value:
sts, data = self.cm.getPage(self.MAIN_URL + 'gtv/1/live/channelguide', self.defParams)
if sts:
try:
data = byteify(json.loads(data))
for item in data['results']:
if item['prgsvcid'] in prgsvcidMap:
idx = prgsvcidMap[item['prgsvcid']]
channelsTab[idx]['desc'] += '[/br][/br] [%s %s][/br]%s[/br]%s[/br]%s[/br]%s' % (item.get('event_date', ''), item.get('event_time', ''), item.get('title', ''), item.get('synopsis', ''), item.get('description', ''), item.get('episode_title', ''))
except:
printExc()
return channelsTab
def _fillChannelsCache(self, url):
printDBG("EskaGo._fillChannelsCache")
sts, data = self.cm.getPage(url)
if not sts:
return
try:
data = byteify(json.loads(data))
self.cacheChannels = data
except:
printExc()
def getLinksForFavourite(self, fav_data):
printDBG("NaszeKino.getLinksForFavourite")
try:
cItem = byteify(json.loads(fav_data))
if cItem['type'] == 'picture':
return[{'name':'url', 'url':cItem['url'], 'need_resolve':0}]
except:
printExc()
return []
return self.getLinksForVideo(cItem)
def listSearchResult(self, cItem, searchPattern, searchType):
printDBG(
"CartoonHD.listSearchResult cItem[%s], searchPattern[%s] searchType[%s]"
% (cItem, searchPattern, searchType)
)
sts, data = self.cm.getPage(self.MAIN_URL, self.defaultParams)
if not sts:
return
tor = self.cm.ph.getSearchGroups(data, "tor='([^']+?)'")[0]
q = searchPattern
post_data = {"q": q, "limit": 100, "timestamp": str(time.time()).split(".")[0], "verifiedCheck": tor}
httpParams = dict(self.defaultParams)
httpParams["header"] = {
"Referer": self.MAIN_URL,
"User-Agent": self.cm.HOST,
"X-Requested-With": "XMLHttpRequest",
"Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
}
sts, data = self.cm.getPage(self.SEARCH_URL, httpParams, post_data=post_data)
if not sts:
return
try:
data = byteify(json.loads(data))
for item in data:
desc = item["meta"]
if "Movie" in desc:
category = "video"
elif "TV show" in desc:
category = "list_seasons"
else:
category = None
if None != category:
title = item["title"]
url = item["permalink"].replace("\\/", "/")
icon = item.get("image", "").replace("\\/", "/")
if url.startswith("http"):
params = {
"name": "category",
"title": title,
"url": url,
"desc": desc,
"icon": icon,
"category": category,
}
if category == "video":
self.addVideo(params)
else:
self.addDir(params)
except:
printExc()
def getLinksForVideo(self, cItem):
printDBG("TVProart.getLinksForVideo [%s]" % cItem)
urlTab = []
sts, data = self.cm.getPage(cItem['url'])
if not sts: return []
try:
data = byteify(json.loads(data))
urlTab.append({'name':'vod', 'url':data['content']['video']['movieFile'], 'need_resolve':0})
except:
pass
return urlTab
def getLinksForFavourite(self, fav_data):
links = []
try:
favItem = byteify( json.loads(fav_data) )
printDBG(favItem)
sts, data = self.cm.getPage(favItem['url'], {'host' : Ipla.HOST})
if sts:
sts, data = self.cm.ph.getDataBeetwenReMarkers(data, re.compile('<vod[^>]+?id="%s"[^>]*?>'% favItem['vod_id']), re.compile('</vod>' ), False)
if sts: links = self._getVideoUrls(data)
except: printExc()
return links
def listEpisodes(self, cItem):
printDBG("PlayRTSIW.listEpisodes cItem[%s]" % (cItem))
sts, data = self.cm.getPage(cItem['f_show_url'])
if not sts:
return
try:
data = byteify(json.loads(data))
self._listItems(cItem, data['episodes'])
nextPage = self.getFullUrl(data['nextPageUrl'])
if nextPage != '':
params = dict(cItem)
params.update({
'good_for_fav': False,
'title': _('Next page'),
'f_show_url': nextPage
})
self.addDir(params)
except Exception:
printExc()
def getChannelsList(self, url=''):
printDBG("NettvPw.getChannelsList url[%s]" % url)
channelsList = []
sts, data = self.cm.getPage(NettvPw.MAINURL)
if not sts: return channelsList
data = self.cm.ph.getDataBeetwenMarkers(data, 'var programs = [', ']',
False)[1]
try:
data = byteify(json.loads("[%s]" % data))
for item in data:
url = item['link']
icon = item['image_color']
title = item['title']
if '' == url: continue
if not url.startswith('http'): url = NettvPw.MAINURL + url
if '' == icon: continue
if not icon.startswith('http'): icon = NettvPw.MAINURL + icon
channelsList.append({'title': title, 'url': url, 'icon': icon})
except Exception:
printExc()
return channelsList
def getMoreItem(self, cUrl, data):
moreItem = {}
data = self.cm.ph.getDataBeetwenNodes(data, ('<div', '>', 'show_more'),
('</div', '>'))[1]
ajaxData = clean_html(
self.cm.ph.getSearchGroups(
data, '''\sdata\-infiniteAjaxScroll=['"]([^'^"]+?)['"]''')[0])
queryData = clean_html(
self.cm.ph.getSearchGroups(
data, '''\sdata\-query=['"]([^'^"]+?)['"]''')[0])
try:
data = byteify(json.loads(ajaxData))
moreItem['params'] = data
moreItem['query'] = queryData
moreItem['next'] = self.getFullUrl(
data['url'] + '?' + queryData + '&page={0}', cUrl)
moreItem['pages'] = data.get('k', 0)
except Exception:
printExc()
printDBG(moreItem)
return moreItem
def _listItems(self, cItem, data, nextPage):
printDBG("YifyTV.listItems")
try:
data = byteify(json.loads(data), noneReplacement='', baseTypesAsString=True)
printDBG(data)
for item in data['posts']:
item['url'] = self.getFullUrl(item['link'])
item['title'] = self.cleanHtmlStr(item['title'])
desc = ' | '.join([item['year'], item['runtime'], item['genre']])
desc += '[/br]' + self.cleanHtmlStr(item['post_content'])
item['desc'] = desc
item['icon'] = self.getFullUrl(item['image'])
self.addVideo(item)
except Exception:
printExc()
if nextPage:
page = cItem.get('page', 1)
params = dict(cItem)
params.update( {'title':_('Next page'), 'page':page+1} )
self.addDir(params)
def _loadItems(self, groupIdx):
ret = True
filePath = os_path.join(
self.favDir,
IPTVFavourites.FILE_NAME_MACRO % self.groups[groupIdx]['group_id'])
if os_path.isfile(filePath):
try:
data = self._loadFromFile(filePath)
printDBG(data)
data = byteify(json.loads(data))
favItems = []
for item in data:
favItems.append(CFavItem().setFromDict(item))
self.groups[groupIdx]['items'] = favItems
except:
printExc()
self.lastError = _("Error reading file \"%s\".\n") % filePath
ret = False
else:
self.groups[groupIdx]['items'] = []
return ret
def listSearchItems(self, cItem):
printDBG("PlayRTSIW.listSearchItems cItem[%s]" % (cItem))
type = self.ITEMS_TYPE_MAP[cItem.get('f_type', 'tv')]
sts, data = self.cm.getPage(cItem['url'])
if not sts:
return
try:
data = byteify(json.loads(data))
self._listItems(cItem, data[type])
nextPage = self.getFullUrl(data['nextPageUrl'])
if nextPage != '':
params = dict(cItem)
params.update({
'good_for_fav': False,
'title': _('Next page'),
'url': nextPage
})
self.addDir(params)
except Exception:
printExc()
def listItems(self, cItem, nextCategory):
printDBG("TrailersApple.listItems [%s]" % cItem)
sts, data = self.getPage(cItem['url'])
if not sts: return
self.setMainUrl(self.cm.meta['url'])
try:
data = byteify(json.loads(data))
if 'results' in data: data = data['results']
for item in data:
printDBG(item)
if len(item['trailers']) == 0: continue
title = self.cleanHtmlStr(item['title'])
url = self.getFullUrl(item['location'])
icon = self.getFullIconUrl(item['poster'])
desc = []
if 'releasedate' in item: desc.append(item['releasedate'][:16])
for it in [(_('Studio:'), 'studio'),
(_('Director:'), 'director'),
(_('Directors:'), 'directors'),
(_('Genres:'), 'genres'), (_('Genre:'), 'genre'),
(_('Actors:'), 'actors')]:
if it[1] not in item: continue
if isinstance(item[it[1]], list):
value = ', '.join(item[it[1]])
else:
value = item[it[1]]
desc.append('%s %s' % (it[0], value))
params = {
'good_for_fav': True,
'name': 'category',
'category': nextCategory,
'title': title,
'url': url,
'icon': icon,
'desc': '[/br]'.join(desc)
}
self.addDir(params)
except Exception:
printExc()
def getVideoLinks(self, url):
printDBG('Spryciarze.getVideoLink: ' + url)
linkstTab = []
if None == url or 0 == len(url):
return linkstTab
post_data = None
tries = 2
while tries > 0:
tries -= 1
# get videoID
sts, data = self.cm.getPage(url, {'use_cookie': True, 'save_cookie': True, 'load_cookie': False, 'cookiefile': self.COOKIEFILE}, post_data)
if not sts: return []
sts, block = self.cm.ph.getDataBeetwenMarkers(data, '<div class="film_blokada">', '</form>', False)
if sts:
url = self.cm.ph.getSearchGroups(block, 'action="(http[^"]+?)"')[0]
val_s = self.cm.ph.getSearchGroups(block, 'name="s"[^>]*?value="([^"]+?)"')[0]
post_data = {}
post_data['s'] = val_s
post_data['yes'] = ''
continue
player = self.cm.ph.getSearchGroups(data, 'src="(http://player.spryciarze.pl[^"]+?)"')[0]
sts, player = self.cm.getPage(player, {'use_cookie': True, 'save_cookie': False, 'load_cookie': True, 'cookiefile': self.COOKIEFILE})
if not sts: break
player = self.cm.ph.getSearchGroups(player, 'var data[^=]*?=[^\{]*?(\{[^;]+?);')[0]
try:
printDBG(player)
player = byteify(json.loads(player))
player = player['mediaFiles']
for item in player:
if 'mp4' in item['type']:
linkstTab.append({'name':'Native player', 'url':item['src']})
except:
printExc()
if len(linkstTab):
break
return linkstTab
def getVideoLinks(self, baseUrl):
printDBG("TfarjoCom.getVideoLinks [%s]" % baseUrl)
baseUrl = strwithmeta(baseUrl)
urlTab = []
# mark requested link as used one
if len(self.cacheLinks.keys()):
for key in self.cacheLinks:
for idx in range(len(self.cacheLinks[key])):
if baseUrl in self.cacheLinks[key][idx]['url']:
if not self.cacheLinks[key][idx]['name'].startswith(
'*'):
self.cacheLinks[key][idx][
'name'] = '*' + self.cacheLinks[key][idx][
'name'] + '*'
break
paramsUrl = dict(self.defaultParams)
paramsUrl['header'] = dict(self.AJAX_HEADER)
paramsUrl['header']['Referer'] = baseUrl.meta['Referer']
post_data = {
'csrf_test_name': baseUrl.meta['iptv_link_test'],
baseUrl.meta['iptv_link_type']: baseUrl.meta['iptv_link_data']
}
sts, data = self.getPage(
baseUrl.split('#', 1)[0], paramsUrl, post_data)
if not sts: return
printDBG(data)
try:
data = byteify(json.loads(data), '', True)
data = data['iframe']
videoUrl = self.getFullUrl(
self.cm.ph.getSearchGroups(
data, '''<iframe[^>]+?src=['"]([^"^']+?)['"]''', 1,
True)[0])
urlTab = self.up.getVideoLinkExt(videoUrl)
except Exception:
printExc()
return urlTab
def getLinksForVideo(self, cItem):
printDBG("Twitch.getLinksForVideo [%s]" % cItem)
urlTab = []
id = ''
if cItem['video_type'] == 'clip':
url = 'https://clips.twitch.tv/api/v2/clips/%s/status' % cItem['clip_slug']
sts, data = self.getPage(url)
if not sts: return urlTab
try:
data = byteify(json.loads(data))
for item in data['quality_options']:
urlTab.append({'name':'%sp, %sfps' % (item['quality'], item['frame_rate']), 'url':item['source'], 'need_resolve':0})
except Exception:
printExc()
elif cItem['video_type'] == 'live':
id = cItem['channel_id']
tokenUrl = self.CHANNEL_TOKEN_URL
vidUrl = self.LIVE_URL
liveStream = True
else:
id = cItem.get('video_id', '')
tokenUrl = self.VOD_TOKEN_URL
vidUrl = self.VOD_URL
liveStream = False
if id != '':
url = tokenUrl % id
sts, data = self.getPage(url)
if sts:
try:
data = json.loads(data)
url = vidUrl % (id, urllib.quote(jstr(data, 'token')), jstr(data, 'sig'))
data = getDirectM3U8Playlist(url, checkExt=False)
for item in data:
item['url'] = urlparser.decorateUrl(item['url'], {'iptv_proto':'m3u8', 'iptv_livestream':liveStream})
urlTab.append(item)
except Exception: printExc()
return urlTab
def _listItems(self, cItem, url, key, onlyLiveItems):
sts, data = self.getPage(url)
if not sts: return
try:
liveItem = None
NOW = datetime.now()
data = byteify(json.loads(data), '')
for item in data[key]:
if onlyLiveItems and not item.get('is_live', False): continue
url = self.getFullUrl(item['url'])
icon = self.getFullIconUrl(item['picture_url'])
if icon == '': icon = self.getFullIconUrl(item['thumbnail_url'])
title = self.cleanHtmlStr(item['title'])
desc = []
if item['is_future_publication']: desc.append('Już za ' + self.delta2str(self.str2date(item['starts_at']) - NOW))
desc.append(item['division_name'])
if item['duration'] != '': desc.append(self.delta2str(timedelta(seconds=item['duration'])))
params = dict(cItem)
params.update({'good_for_fav':True, 'title':title, 'url':url, 'icon':icon, 'desc':' | '.join(desc)})
if item['is_future_publication']:
params['good_for_fav'] = False
self.addArticle(params)
else:
if item.get('is_current_live', False) and liveItem == None: liveItem = params
else: self.addVideo(params)
if liveItem != None:
liveItem['type'] = 'video'
self.currList.insert(0, liveItem)
else:
url = data['main_video']['video_url']
if self.cm.isValidUrl(url) and onlyLiveItems:
params = dict(cItem)
params.update({'good_for_fav':False, 'type':'video', 'title':'Na żywo', 'url':url, 'icon':'', 'desc':''})
self.currList.insert(0, params)
except Exception:
printExc()
def listAZMenu(self, cItem, nextCategory):
self.programsAZCache = {'keys': [], 'dict': {}}
url = self.getFullUrl(cItem['url'])
sts, data = self.cm.getPage(url, self.defaultParams)
if not sts: return
data = self.cm.ph.getDataBeetwenMarkers(data,
"root['__svtplay'] = ",
";\n",
withMarkers=False)[1]
try:
data = byteify(json.loads(data))
data = data['programsPage']['alphabeticList']
for item in data:
letter = item['letter']
self.programsAZCache['keys'].append(letter)
self.programsAZCache['dict'][letter] = []
for program in item['titles']:
self.programsAZCache['dict'][letter].append(program)
except Exception:
printExc()
params = {
'good_for_fav': False,
'category': nextCategory,
'title': _('--All--'),
'letters': list(self.programsAZCache['keys'])
}
self.addDir(params)
for letter in self.programsAZCache['keys']:
params = {
'good_for_fav': False,
'category': nextCategory,
'title': letter,
'letters': [letter]
}
self.addDir(params)
def listPseudoStreaming(self, cItem):
printDBG("TVJWORG.listPseudoStreaming")
baseUrl = 'schedules/%s/%s?utcOffset=60' % (self._getLangCode(),
cItem['key'])
url = self._getFullUrl(baseUrl)
sts, data = self.cm.getPage(url)
if not sts: return
try:
data = byteify(json.loads(data))
for item in data['category']['media']:
icon = self._getIcon(item)
title = item['title']
duration = item['durationFormattedHHMM']
if len(duration): title += ' [%s]' % duration
type = item['type']
date = item['firstPublished']
if len(date):
desc = date + '[/br]'
else:
desc = ''
desc += item['description']
files = item['files']
params = {
'title': title,
'icon': icon,
'desc': desc,
'files': files
}
if type == 'video':
self.addVideo(params)
elif type == 'audio':
self.addAudio(params)
else:
params['title'] += ' COS ZLE SPRAWDZ type[%s]' % type
self.addVideo(params)
except Exception:
printExc()
def getLinksForVideo(self, cItem):
printDBG("KissCartoonMe.getLinksForVideo [%s]" % cItem)
urlTab = []
sts, data = self.getPage(cItem['url'])
if not sts:
return urlTab
episodeId = self.cm.ph.getSearchGroups(
data, r'''var\s*['"]?episode_id['"]?\s*=\s*['"]([0-9]+)['"]''')[0]
url = self._getFullUrl('/ajax/anime/load_episodes')
params = dict(self.defaultParams)
params['header'] = dict(self.AJAX_HEADER)
params['header']['Referer'] = cItem['url']
sts, data = self.getPage(url,
params,
post_data={'episode_id': episodeId})
if not sts:
return urlTab
try:
data = byteify(json.loads(data))
if not data['status']:
return urlTab
url = data['value']
if url.startswith('//'):
url = 'https:' + url
if not self.cm.isValidUrl(url):
url = self.cm.ph.getSearchGroups(
url,
'''<iframe[^>]+?src=['"]([^'^"]+?)['"]''',
ignoreCase=True)[0]
url = self._getFullUrl(url)
url = strwithmeta(url, {'Referer': cItem['url']})
urlTab.append({'name': 'default', 'url': url, 'need_resolve': 1})
except Exception:
printExc()
return urlTab
def Billboard_charts(self, url):
sts, data = self.cm.getPage(url, {'header': HEADER})
if not sts:
return
try:
data = byteify(json.loads(data))['query']['results']['item']
for x in range(0, len(data)):
item = data[x]
name = item['title']
artist = item['artist']
track_name = item['chart_item_title']
search_string = urllib.quote(artist + ' ' + track_name +
' music video')
params = {
'title': name + ' - ' + artist,
'page': search_string,
'icon': '',
'plot': ''
}
self.addVideo(params)
except Exception:
printExc() # wypisz co poszło nie tak
def listLetters(self, cItem, nextCategory):
printDBG("UKTVPlay.listLetters [%s]" % cItem)
try:
url = self.tmpUrl % cItem['url']
sts, data = self.getPage(url)
if not sts: return
data = byteify(json.loads(data), '', True)
for item in data:
url = 'brand_list?channel=&letter=%s&' % item[0]
title = self.cleanHtmlStr(item)
params = {
'good_for_fav': False,
'category': nextCategory,
'url': url,
'title': title
}
self.addDir(params)
except Exception:
printExc()
def listGames(self, cItem, category):
printDBG("Hitbox.listGames")
page = cItem.get('page', 0)
sts, data = self.cm.getPage(cItem['url'].format(Hitbox.NUM_OF_ITEMS, page*Hitbox.NUM_OF_ITEMS) )
if not sts: return
try:
data = byteify(json.loads(data))["categories"]
for item in data:
params = dict(cItem)
params['url'] = item['category_id']
params['category'] = category
params.update( self._getCategoryBaseParams(item) )
#params['seo_key'] = item['category_seo_key']
self.addDir(params)
# check next page
sts, data = self.cm.getPage(cItem['url'].format(1, (page+1)*Hitbox.NUM_OF_ITEMS) )
if not sts: return
if len(json.loads(data)["categories"]):
params = dict(cItem)
params.update( {'title':_('Next page'), 'page':page+1} )
self.addDir(params)
except: printExc()
def getVideoLinks(self, videoUrl):
printDBG("FilmPalastTo.getVideoLinks [%s]" % videoUrl)
linksTab = []
videoUrl = strwithmeta(videoUrl)
key = videoUrl.meta.get('links_key', '')
if key != '':
if key in self.cacheLinks:
for idx in range(len(self.cacheLinks[key])):
if self.cacheLinks[key][idx][
'url'] == videoUrl and not self.cacheLinks[key][
idx]['name'].startswith('*'):
self.cacheLinks[key][idx][
'name'] = '*' + self.cacheLinks[key][idx]['name']
data_id = videoUrl.meta.get('data_id', '')
data_stamp = videoUrl.meta.get('data_stamp', '')
#sts, data = self.getPage(key, self.defaultParams)
#if not sts: return []
url = self.getFullUrl('/stream/%s/%s' % (data_id, data_stamp))
urlParams = dict(self.defaultParams)
urlParams['header'] = dict(self.AJAX_HEADER)
urlParams['header']['Referer'] = key
sts, data = self.getPage(url, urlParams, {'streamID': data_id})
if not sts: return []
try:
data = byteify(json.loads(data))
url = data.get('url', '')
if self.cm.isValidUrl(url):
return self.up.getVideoLinkExt(url)
SetIPTVPlayerLastHostError(data['msg'])
except Exception:
printExc()
return linksTab
def getPage(self, url, addParams={}, post_data=None):
if addParams == {}:
addParams = dict(self.defaultParams)
addParams['cloudflare_params'] = {'cookie_file': self.COOKIE_FILE, 'User-Agent': self.HTTP_HEADER['User-Agent']}
sts,data = self.cm.getPageCFProtection(url, addParams, post_data)
if sts:
if 'sucuri_cloudproxy' in data:
cookieItems = {}
jscode = self.cm.ph.getDataBeetwenNodes(data, ('<script', '>'), ('</script', '>'), False)[1]
if 'eval' in jscode:
jscode = '%s\n%s' % (base64.b64decode('''dmFyIGlwdHZfY29va2llcz1bXSxkb2N1bWVudD17fTtPYmplY3QuZGVmaW5lUHJvcGVydHkoZG9jdW1lbnQsImNvb2tpZSIse2dldDpmdW5jdGlvbigpe3JldHVybiIifSxzZXQ6ZnVuY3Rpb24obyl7bz1vLnNwbGl0KCI7IiwxKVswXS5zcGxpdCgiPSIsMiksb2JqPXt9LG9ialtvWzBdXT1vWzFdLGlwdHZfY29va2llcy5wdXNoKG9iail9fSk7dmFyIHdpbmRvdz10aGlzLGxvY2F0aW9uPXt9O2xvY2F0aW9uLnJlbG9hZD1mdW5jdGlvbigpe3ByaW50KEpTT04uc3RyaW5naWZ5KGlwdHZfY29va2llcykpfTs='''), jscode)
ret = js_execute( jscode )
if ret['sts'] and 0 == ret['code']:
cookies = byteify(json.loads(ret['data'].strip()))
for cookie in cookies: cookieItems.update(cookie)
self.defaultParams['cookie_items'] = cookieItems
addParams = dict(self.defaultParams)
addParams['cloudflare_params'] = {'cookie_file': self.COOKIE_FILE, 'User-Agent': self.HTTP_HEADER['User-Agent']}
removeCookieItems = False
sts,data = self.cm.getPageCFProtection(url, addParams, post_data)
return sts,data
def getVideoLinks(self, videoUrl):
printDBG("PlayRTSIW.getVideoLinks [%s]" % videoUrl)
meta = strwithmeta(videoUrl).meta
tokenUrl = meta['priv_token_url']
type = meta['priv_type']
sts, data = self.cm.getPage(tokenUrl)
try:
data = byteify(json.loads(data))['token']['authparams']
if '?' not in videoUrl: videoUrl += '?' + data
else: videoUrl += '&' + data
except Exception:
printExc()
urlTab = []
if type == 'hls':
urlTab = getDirectM3U8Playlist(videoUrl,
checkContent=True,
sortWithMaxBitrate=999999999)
else:
urlTab.append({'name': 'direct', 'url': videoUrl})
return urlTab
def listSearchResult(self, cItem, searchPattern, searchType):
printDBG(
"TVProart.listSearchResult cItem[%s], searchPattern[%s] searchType[%s]"
% (cItem, searchPattern, searchType))
page = cItem.get('page', 0)
url = self.SEARCH_URL + urllib.quote(searchPattern)
sts, data = self.cm.getPage(url + '&page={0}'.format(page))
if not sts:
return
nextPage = False
try:
data = byteify(json.loads(data))
if data['status'] != '200':
return
for item in data['content']['movies']:
tmp = item['href'].split('/')
url = self.API_URL + 'video?id={0}&slug={1}'.format(
tmp[-2], tmp[-1])
params = {'title': item['text'], 'url': url}
self.addVideo(params)
except Exception:
printExc()
def _getLangCode(self):
langCode = 'E'
if config.plugins.iptvplayer.tvjworg_language.value == 'default':
if self.defaultLangCode != '':
return self.defaultLangCode
else:
sts, data = self.cm.getPage(
self._getFullUrl('languages/E/web'))
if sts:
try:
lang = GetDefaultLang()
data = byteify(json.loads(data))
for item in data['languages']:
if item['locale'] == lang:
self.defaultLangCode = str(item['code'])
langCode = self.defaultLangCode
break
except Exception:
printExc()
else:
langCode = config.plugins.iptvplayer.tvjworg_language.value
return langCode
def listVideos(self, cItem):
printDBG("TVProart.listVideos [%s]" % cItem)
page = cItem.get('page', 1)
url = self.API_URL + 'movies?type=cats&crit_id={0}'.format(
cItem['slug'])
sts, data = self.cm.getPage(url + '&page={0}'.format(page))
if not sts: return
nextPage = False
try:
data = json.loads(data)
if data['status'] != '200': return
for item in data['content']:
icon = self.getFullUrl(item['thumb'].encode('utf-8'))
item = item['data']
url = self.API_URL + 'video?id={0}&slug={1}'.format(
str(item['id']), item['slug'].encode('utf-8'))
title = item['title'].encode('utf-8')
date = item['date'].encode('utf-8')
if date not in title:
title += ' [%s]' % date
params = {
'title': title,
'url': url,
'icon': icon,
'desc': date
}
self.addVideo(params)
except Exception:
printExc()
nextPage = False
try:
sts, data = self.cm.getPage(url + '&page={0}'.format(page + 1))
data = byteify(json.loads(data))
if len(data['content']) > 0:
nextPage = True
except Exception:
pass
self.addNextPage(cItem, nextPage, page)
def getVideoLinks(self, baseUrl):
printDBG("Movie4kTO.getVideoLinks [%s]" % baseUrl)
urlTab = []
sub_tracks = strwithmeta(baseUrl).meta.get('external_sub_tracks', [])
header = dict(self.AJAX_HEADER)
header['Referer'] = baseUrl.meta['Referer']
souTab = [baseUrl.meta.get('sou', '')]
#if souTab[0] == 'pic':
# souTab.append('adr')
for sou in souTab:
post_data = {'fv':'18', 'url':baseUrl, 'sou':baseUrl.meta.get('sou', '')}
url = 'http://yify.tv/player/pk/pk/plugins/player_p2.php'
sts, data = self.cm.getPage(url, {'header':header}, post_data)
if not sts: return []
#printDBG('>>>>>>>>>>>>>>>>>>>>>>>\n%s\n<<<<<<<<<<<<<<<' % data)
try:
if 'jscode' in data:
data = self._evalJscode(data)
data = byteify(json.loads(data))
for item in data:
#printDBG('++++++++++++++++++++++\n%s\n++++++++++++++++++++++' % item)
if item.get('type', '').startswith('video/') and item.get('url', '').startswith('http'):
urlTab.append({'name':'{0}x{1}'.format(item.get('height', ''), item.get('width', '')), 'url':item['url'], 'need_resolve':0})
except:
SetIPTVPlayerLastHostError('The Mirror is broken.\nIf available you can choose other source.')
printExc()
if len(urlTab): break;
if False:
videoUrl = url
if url.startswith('//'):
videoUrl = 'http:' + videoUrl
urlTab = self.up.getVideoLinkExt(videoUrl)
for idx in range(len(urlTab)):
urlTab[idx]['url'] = strwithmeta(urlTab[idx]['url'], {'external_sub_tracks':sub_tracks})
return urlTab
def getVideoLinks(self, videoUrl):
printDBG("Kinox.getVideoLinks [%s]" % videoUrl)
videoUrl = strwithmeta(videoUrl)
urlTab = []
orginUrl = str(videoUrl)
# mark requested link as used one
if len(self.cacheLinks.keys()):
for key in self.cacheLinks:
for idx in range(len(self.cacheLinks[key])):
if videoUrl in self.cacheLinks[key][idx]['url']:
if not self.cacheLinks[key][idx]['name'].startswith('*'):
self.cacheLinks[key][idx]['name'] = '*' + self.cacheLinks[key][idx]['name']
break
sts, data = self.getPage(videoUrl)
if not sts: return []
try:
data = byteify(json.loads(data))
if 'Stream' in data:
data = data['Stream']
videoUrl = self.cm.ph.getSearchGroups(data, '''<iframe[^>]+?src=['"]([^"^']+?)['"]''', 1, True)[0]
if videoUrl == '': videoUrl = self.cm.ph.getSearchGroups(data, '''<a[^>]+?href=['"]([^"^']+?)['"]''', 1, True)[0]
printDBG(">>>>>> [%s]" % videoUrl)
if videoUrl.startswith('//'):
videoUrl = 'https:' + videoUrl
if not self.cm.isValidUrl(videoUrl):
url = videoUrl.split('?s=', 1)[1]
if videoUrl.startswith('//'):
videoUrl = 'https:' + videoUrl
except Exception:
printExc()
return []
if self.cm.isValidUrl(videoUrl):
urlTab = self.up.getVideoLinkExt(videoUrl)
return urlTab
def listSearchItems(self, cItem):
printDBG("EuroSportPlayer.listSearchItems [%s]" % cItem)
try:
page = cItem.get('page', 1)
variables = {"index":"eurosport_global","preferredLanguages":["pl","en"],"uiLang":"pl","mediaRights":["GeoMediaRight"],"page":page,"pageSize":20,"q":cItem['f_query'],"type":["Video","Airing","EventPage"],"include_images":True}
url = self.serverApiData['server_path']['search'] + '/persisted/query/core/sitesearch?variables=' + urllib.quote(json.dumps(variables, separators=(',', ':')))
sts, data = self.getJSPage(url)
if not sts: return
data = byteify(json.loads(data))['data']['sitesearch']
NOW = datetime.now()
for item in data['hits']:
self._addItem(cItem, item['hit'], NOW)
if page*20 < data['meta']['hits']:
params = dict(cItem)
params.pop('priv_item', None)
params.update({'good_for_fav':False, 'title':_('Next page'), 'page':page+1})
self.addDir(params)
except Exception:
printExc()
def listGenres(self, cItem, nextCategory):
printDBG("CineTO.listGenres")
url = self.getFullUrl('/request/search')
post_data = self._getSearchParams(cItem)
sts, data = self.getPage(url, post_data=post_data)
if not sts: return []
cItem = dict(cItem)
cItem['category'] = nextCategory
try:
data = byteify(json.loads(data), '', True)['genres']
for item in self.cacheFilters['genres']:
params = dict(cItem)
params.update(item)
if item['f_genres'] in data:
params['title'] = item['title'] + (
' (%s)' % data.get(item['f_genres'], '0'))
self.addDir(params)
except Exception:
printExc()
def _scriptStderrAvail(self, data):
self.workconsole['stderr'] += data
self.workconsole['stderr'] = self.workconsole['stderr'].split('\n')
if data.endswith('\n'):
data = ''
else:
data = self.workconsole['stderr'].pop(-1)
for line in self.workconsole['stderr']:
line = line.strip()
if line == '':
continue
try:
line = byteify(json.loads(line))
if line['type'] == 'captcha_result':
self.result = line['data']
# timeout timer
if self.timer['is_started']:
self.timer['timer'].stop()
# start timeout timer 3s
self.timer['timer'].start(3000, True)
self.timer['is_started'] = True
self["console"].setText(
_('Captcha solved.\nWaiting for notification.'))
elif line['type'] == 'status':
self["console"].setText(_(str(line['data'])))
elif line['type'] == 'error':
if line['code'] == 500:
self["console"].setText(_('Invalid email.'))
elif line['code'] == 403:
self["console"].setText(
_('Access denied. Please check password.'))
else:
self["console"].setText(
_("Error code: %s\nError message: %s") %
(line['code'], line['data']))
self.errorCodeSet = True
except Exception:
printExc()
self.workconsole['stderr'] = data
def getArticleContent(self, cItem):
printDBG("MoviesNight.getArticleContent [%s]" % cItem)
retTab = []
if 'resource_uri' not in cItem:
return []
if 0 == len(self.loginData['api_key']) and 0 == len(self.loginData['username']):
self.requestLoginData()
url = cItem['resource_uri']
url += '?api_key=%s&username=%s' % (self.loginData['api_key'], self.loginData['username'])
url = self.getFullUrl(url)
sts, data = self.getPage(url)
if not sts: return []
title = cItem['title']
desc = cItem.get('desc', '')
icon = cItem.get('icon', '')
otherInfo = {}
try:
data = byteify(json.loads(data))
icon = self._viaProxy( self.getFullUrl(data['poster']) )
title = data['title']
desc = data['overview']
otherInfo['actors'] = data['actors']
otherInfo['director'] = data['director']
genres = []
for item in data['genre']:
genres.append(item['name'])
otherInfo['genre'] = ', '.join(genres)
otherInfo['rating']= data['imdb_rating']
otherInfo['year'] = data['year']
otherInfo['duration'] = str(datetime.timedelta(seconds=data['runtime']))
except Exception:
printExc()
return [{'title':self.cleanHtmlStr( title ), 'text': self.cleanHtmlStr( desc ), 'images':[{'title':'', 'url':icon}], 'other_info':otherInfo}]
def listItems(self, cItem, url):
printDBG("UstreamTV.listItems")
sts, data = self.cm.getPage(url)
if not sts:
return
nextPage = False
try:
data = byteify(json.loads(data))
if not data['success']:
return
nextPage = data['pageMeta']['infinite']
data = data['pageContent']
data = data.split('<div class="item media-item">')
del data[0]
for item in data:
params = dict(cItem)
url = self.cm.ph.getSearchGroups(item, 'href="([^"]+?)"')[0]
title = self.cm.ph.getSearchGroups(item, 'title="([^"]+?)"')[0]
icon = self.cm.ph.getSearchGroups(item, 'src="([^"]+?)"')[0]
desc = self.cleanHtmlStr(item)
params.update({
'title': self.cleanHtmlStr(title),
'icon': self._getFullUrl(icon),
'desc': desc,
'url': self._getFullUrl(url)
})
self.addVideo(params)
except Exception:
printExc()
if nextPage:
params = dict(cItem)
params.update({
'title': _('Next page'),
'page': cItem.get('page', 1) + 1
})
self.addDir(params)
