def getLinksForVideo(self, cItem):
printDBG("TheWatchseriesTo.getLinksForVideo [%s]" % cItem)
urlTab = []
if len(self.cacheLinks.get(cItem['url'], [])):
return self.cacheLinks[cItem['url']]
sts, data = self.cm.getPage(cItem['url'])
if not sts: return []
data = self.cm.ph.getAllItemsBeetwenMarkers(data, '<tr class="download_link_', '</tr>')
for item in data:
host = self.cm.ph.getSearchGroups(item, '''"download_link_([^'^"]+?)['"]''')[0]
#if self.up.checkHostSupport('http://'+host+'/') != 1: continue
url = self.cm.ph.getSearchGroups(item, '''href=['"][^'^"]*?\?r=([^'^"]+?)['"][^>]*?buttonlink''')[0]
if url == '': continue
try:
url = base64.b64decode(url)
except:
printExc()
continue
if self.up.checkHostSupport(url) != 1: continue
urlTab.append({'name':host, 'url':self._getFullUrl(url), 'need_resolve':1})
if len(urlTab):
self.cacheLinks[cItem['url']] = urlTab
return urlTab
def handleService(self, index, refresh = 0, searchPattern = '', searchType = ''):
printDBG('handleService start')
CBaseHostClass.handleService(self, index, refresh, searchPattern, searchType)
name = self.currItem.get("name", '')
category = self.currItem.get("category", '')
printDBG( "handleService: |||||||||||||||||||||||||||||||||||| name[%s], category[%s] " % (name, category) )
self.currList = []
#MAIN MENU
if name == None:
self.listMainMenu()
elif category == 'cats':
self.listCategories(self.currItem, 'show_sort')
elif category == 'show_sort':
cItem = dict(self.currItem)
cItem['category'] = 'list_items'
self.listsTab(self.sortCache, cItem)
elif category == 'list_items':
self.listItems(self.currItem, 'list_episodes')
elif category == 'list_episodes':
self.listEpisodes(self.currItem)
#SEARCH
elif category in ["search", "search_next_page"]:
cItem = dict(self.currItem)
cItem.update({'search_item':False, 'name':'category'})
self.listSearchResult(cItem, searchPattern, searchType)
#HISTORIA SEARCH
elif category == "search_history":
self.listsHistory({'name':'history', 'category': 'search'}, 'desc', _("Type: "))
else:
printExc()
CBaseHostClass.endHandleService(self, index, refresh)
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 getLinksForVideo(self, cItem):
printDBG("DRDK.getLinksForVideo [%s]" % cItem)
urlTab = []
try:
if cItem["Type"] == "Channel":
for serv in cItem["StreamingServers"]:
if "HLS" not in serv["LinkType"]: continue
for qual in serv["Qualities"]:
for stream in qual["Streams"]:
url = self.up.decorateUrl(serv["Server"] + "/" + stream["Stream"])
title = serv["LinkType"] #+ " [{0}Kbps]".format(qual["Kbps"])
ip = config.plugins.iptvplayer.drdk_myip.value
if '' != ip:
url.meta['X-Forwarded-For'] = ip
urlTab.append({'name':title, 'url': url, 'need_resolve':1})
elif cItem["Type"] == "tv2r":
urls = self.tv2r.getLinksForChannel(cItem['tv2r_data'])
for item in urls:
url = self.up.decorateUrl(item['url'])
title = item['name']
ip = config.plugins.iptvplayer.drdk_myip.value
if '' != ip:
url.meta['X-Forwarded-For'] = ip
urlTab.append({'name':title, 'url': url, 'need_resolve':1})
except:
printExc()
return urlTab
def getVideoTab(self, ckmId):
#MD5('gastlich') = d2dd64302895d26784c706717a1996b0
#contentUrl = 'http://vod.pl/' + ckmId + ',d2dd64302895d26784c706717a1996b0.html?dv=aplikacja_androidVOD%2Ffilmy&back=onetvod%3A%2F%2Fback'
tm = str(int(time.time() * 1000))
jQ = str(random.randrange(562674473039806,962674473039806))
authKey = '22D4B3BC014A3C200BCA14CDFF3AC018'
contentUrl = 'http://qi.ckm.onetapi.pl/?callback=jQuery183040'+ jQ + '_' + tm + '&body%5Bid%5D=' + authKey + '&body%5Bjsonrpc%5D=2.0&body%5Bmethod%5D=get_asset_detail&body%5Bparams%5D%5BID_Publikacji%5D=' + ckmId + '&body%5Bparams%5D%5BService%5D=vod.onet.pl&content-type=application%2Fjsonp&x-onet-app=player.front.onetapi.pl&_=' + tm
valTab = []
query_data = {'url': contentUrl, 'use_host': False, 'use_cookie': False, 'use_post': False, 'return_data': True}
try:
data = self.cm.getURLRequestData(query_data)
#extract json
result = json.loads(data[data.find("(")+1:-2])
strTab = []
for items in result['result']['0']['formats']['wideo']:
for i in range(len(result['result']['0']['formats']['wideo'][items])):
strTab.append(items)
strTab.append(result['result']['0']['formats']['wideo'][items][i]['url'].encode('UTF-8'))
if result['result']['0']['formats']['wideo'][items][i]['video_bitrate']:
strTab.append(int(float(result['result']['0']['formats']['wideo'][items][i]['video_bitrate'])))
else:
strTab.append(0)
valTab.append(strTab)
strTab = []
except:
printExc()
return valTab
def getTeamCastList(self, cItem):
printDBG('getTeamCastList start')
#http://team-cast.pl.cp-21.webhostbox.net/kanalyFlash/
#http://team-cast.pl.cp-21.webhostbox.net/
#src="http://team-cast.pl.cp-21.webhostbox.net/kanalyFlash/film/hbo.html"
url = cItem['url']
# list categories
if '' == url :
self.teamCastTab = {}
url = 'http://team-cast.pl.cp-21.webhostbox.net/'
sts, data = self.cm.getPage(url)
if not sts: return
data = CParsingHelper.getDataBeetwenMarkers(data, '<div id="stream-frame">', '<div id="now-watching">', False)[1]
# remove commented channels
data = re.sub('<!--[^!]+?-->', '', data)
data = data.split('<li class="menu_right">')
del data[0]
for cat in data:
catName = CParsingHelper.getDataBeetwenMarkers(cat, '<a href="#" class="drop">', '</a>', False)[1].strip()
channels = re.findall('<a href="([^"]+?)">([^<]+?)<img src="http://wrzucaj.net/images/2014/09/12/flash-player-icon.png"', cat)
if len(channels):
self.teamCastTab[catName] = channels
newItem = dict(cItem)
newItem.update({'url':catName, 'title':catName + ' (%d)' % len(channels)})
self.addDir(newItem)
elif url in self.teamCastTab:
# List channels
for item in self.teamCastTab[url]:
newItem = dict(cItem)
newItem.update({'url':item[0], 'title':item[1]})
self.playVideo(newItem)
else:
printExc()
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 ParseM3u(data):
printDBG('ParseM3u')
list = []
data = data.replace("\r","\n").replace('\n\n', '\n').split('\n')
printDBG(">>>>>>>>>>>>> data0[%s]" % data[0])
if '#EXTM3U' not in data[0]:
return list
params = {'title':'', 'length':'', 'uri':''}
for line in data:
line = line.strip()
printDBG(line)
if line.startswith('#EXTINF:'):
try:
length, title = line.split('#EXTINF:')[1].split(',', 1)
params = {'title':title, 'length':length, 'uri':''}
except:
printExc()
params = {'title':'', 'length':'', 'uri':''}
else:
if '' != params['title']:
line = line.replace('rtmp://$OPT:rtmp-raw=', '')
cTitle = re.sub('\[[^\]]*?\]', '', params['title'])
if len(cTitle): params['title'] = cTitle
params['uri'] = urlparser.decorateParamsFromUrl(line)
list.append(params)
params = {'title':'', 'length':'', 'uri':''}
return list
def handleService(self, index, refresh = 0, searchPattern = '', searchType = ''):
printDBG('handleService start')
CBaseHostClass.handleService(self, index, refresh, searchPattern, searchType)
name = self.currItem.get("name", '')
category = self.currItem.get("category", '')
printDBG( "handleService: |||||||||||||||||||||||||||||||||||| name[%s], category[%s] " % (name, category) )
self.currList = []
#MAIN MENU
if name == None:
self.listsTab(self.MAIN_CAT_TAB, {'name':'category'})
#MOVIES
elif category == 'genres_movies':
self.listFilters(self.currItem, 'category', 'list_version_filter')
elif category == 'list_version_filter':
self.listFilters(self.currItem, 'version', 'list_yer_filter')
elif category == 'list_yer_filter':
self.listFilters(self.currItem, 'year', 'list_movies')
elif category == 'list_movies':
self.listMovies(self.currItem)
elif category == 'list_rank':
self.listsTab(self.RANK_TAB, {'name':'category'})
elif category == 'list_rank_movie_view':
self.listRankViewMovies(self.currItem)
elif category == 'list_rank_movie':
self.listRankMovie(self.currItem)
elif category == 'list_rank_series_view':
self.listRankViewSeries(self.currItem, 'list_seasons')
#SERIES
elif category == 'cat_series':
self.listsTab(self.SERIES_CAT_TAB, {'name':'category'})
elif category == 'list_series_abc':
self.listSeriesABC(self.currItem, 'list_series')
elif category == 'list_series':
self.listSeries(self.currItem, 'list_seasons')
elif category == 'list_seasons':
self.listSeasons(self.currItem, 'list_episodes')
elif category == 'list_episodes':
self.listEpisodes(self.currItem)
#LATEST ADDED
elif category == 'latest_added':
self.listsTab(self.LAST_ADDED_TAB, {'name':'category'})
elif category == 'latest_added_movies':
self.listLatestAddedMovies(self.currItem)
elif category == 'latest_added_series':
self.listLatestAddedSeries(self.currItem, 'list_seasons')
#SEARCH
elif category in ["search", "search_next_page"]:
cItem = dict(self.currItem)
cItem.update({'search_item':False, 'name':'category'})
self.listSearchResult(cItem, searchPattern, searchType)
#HISTORIA SEARCH
elif category == "search_history":
self.listsHistory({'name':'history', 'category': 'search'}, 'desc', _("Type: "))
else:
printExc()
CBaseHostClass.endHandleService(self, index, refresh)
def handleService(self, index, refresh = 0, searchPattern = '', searchType = ''):
printDBG('handleService start')
CBaseHostClass.handleService(self, index, refresh, searchPattern, searchType)
name = self.currItem.get("name", '')
category = self.currItem.get("category", '')
mode = self.currItem.get("mode", '')
printDBG( "handleService: |||||||||||||||||||||||||||||||||||| name[%s], category[%s] " % (name, category) )
self.currList = []
#MAIN MENU
if name == None:
self.listCategories({'name':'category'})
elif category == 'ondemand':
self.listMedia(self.currItem)
elif category == 'pseudostreaming':
self.listPseudoStreaming(self.currItem)
elif category == 'container':
self.listCategories(self.currItem, 'subcategories')
else:
printExc()
CBaseHostClass.endHandleService(self, index, refresh)
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 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("TVJWORG.getLinksForVideo [%s]" % cItem)
urlTab = []
try:
tmpTab = cItem.get('files', [])
for item in tmpTab:
try:
linkVideo = item['progressiveDownloadURL']
linkVideo = urlparser.decorateUrl(linkVideo, {'Referer': 'http://tv.jw.org/'})
urlTab.append({'name':item['label'], 'url': linkVideo, 'need_resolve':0})
except:
printExc()
if 1 < len(urlTab):
error = False
max_bitrate = int(config.plugins.iptvplayer.tvjworg_default_format.value)
def __getLinkQuality( itemLink ):
try:
return int(itemLink['name'][0:-1])
except:
error = True
return 0
oneLink = CSelOneLink(urlTab, __getLinkQuality, max_bitrate)
if not error and config.plugins.iptvplayer.tvjworg_use_df.value:
urlTab = oneLink.getOneLink()
else:
urlTab = oneLink.getSortedLinks()
except:
printExc()
return urlTab
def listCategory(self, cItem, searchMode=False):
printDBG("Playpuls.listCategory cItem[%s]" % cItem)
data = None
if 'data' not in cItem:
sts, data = self.cm.getPage(cItem['url'])
if not sts: return
if searchMode:
data = self.cm.ph.getDataBeetwenMarkers(data, '<ol class="search-results', '</ol>', False)[1]
elif '<div class="region region-vod-list">' in data:
data = self.cm.ph.getDataBeetwenMarkers(data, '<div class="region region-vod-list">', '</section>', False)[1]
data = data.split('<div class="line-break">')
del data[0]
tmpList = []
for item in data:
title = self.cm.ph.getDataBeetwenReMarkers(item, re.compile('<h2[^>]*?>'), re.compile('</h2>'), False)[1].strip()
if '' == title or 'Zobacz również' in title:
continue
tmpList.append({'title':title, 'data':item})
if 1 == len(tmpList):
data = tmpList[0]['data']
elif 1 < len(tmpList):
for item in tmpList:
params = dict(cItem)
params.update(item)
self.addDir(params)
data = None
else:
printExc()
data = None
else:
data = self.cm.ph.getDataBeetwenMarkers(data, '<div class="view-content">', '</section>', False)[1]
else:
data = cItem['data']
if None != data:
self._listItems(data)
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 _get_subtitles(self, video_id):
sub_tracks = []
try:
url = 'https://video.google.com/timedtext?hl=%s&type=list&v=%s' % (GetDefaultLang(), video_id)
sts, data = self.cm.getPage(url)
if not sts: return sub_tracks
def getArg(item, name):
return self.cm.ph.getDataBeetwenMarkers(item, '%s="' % name, '"', False)[1].encode('utf-8')
data = data.split('/>')
for item in data:
if 'lang_code' not in item: continue
id = getArg(item, 'id')
name = getArg(item, 'name')
lang_code = getArg(item, 'lang_code')
lang_original = getArg(item, 'lang_original')
lang_translated = getArg(item, 'lang_translated')
title = (name + ' ' + lang_translated).strip()
params = {'lang':lang_code, 'v':video_id, 'fmt':'srt', 'name':name}
url = 'https://www.youtube.com/api/timedtext?' + urllib.urlencode(params)
sub_tracks.append({'title':title, 'url':url, 'lang':lang_code, 'format':'srt'})
except:
printExc()
return sub_tracks
def addFile(self, filePath, encoding='utf-8', addItemParams = {}):
printDBG('IPTVFileHost.addFile file[%s]' % filePath)
try:
with codecs.open(filePath, 'r', encoding, 'replace') as fp:
lineNum = 0
while True:
lineNum += 1
line = fp.readline()
if not line: break;
line = line.strip()
if type(line) == type(u''): line = line.encode('utf-8', 'replace')
if 0 == len(line) or '#' == line[0]: continue
idx = line.find(';')
if -1 < idx:
fullTitle = line[0:idx].strip()
url = line[idx+1:].strip()
if '' != fullTitle and url != '':
# get group
groupTitle, titleInGroup = self._getGroup(fullTitle)
if groupTitle not in self.groups:
self.groups.append(groupTitle)
params = {'full_title':fullTitle, 'url':url, 'group':groupTitle, 'title_in_group':titleInGroup}
params.update(addItemParams)
self.items.append(params)
continue
printDBG('IPTVFileHost.addFile wrong line[%d]' % (lineNum))
except:
printExc()
def listsCategory_ETV(self, cItem):
printDBG("Ekstraklasa.listsCategory_ETV")
ITEM_MARKER = '<div class="listItem'
sts, data = self.cm.getPage(cItem['url'])
if not sts: return
printDBG('----------------------------------------')
# check if we should check for sub categories
if 0 == cItem['depth']:
subMenuData = self.cm.ph.getDataBeetwenMarkers(data, '<ul class="subMenu">', '</ul>', False)[1]
subMenuData = re.compile('<a[ ]+?href="(http[^">]+?)"[ ]*?>([^<]+?)</a>').findall(subMenuData)
if 0 < len(subMenuData):
params = dict(cItem)
params.update({'title':'Najnowsze', 'depth':1})
self.addDir(params)
for item in subMenuData:
params = dict(cItem)
params.update({'url':item[0], 'title': self.cleanHtmlStr(item[1]), 'depth':1, })
self.addDir(params)
return
data = self.cm.ph.getDataBeetwenMarkers(data, ITEM_MARKER, '<script')[1]
moreData = self.cm.ph.getSearchGroups(data, "id=\"moredata\" value='([^']+?)'")[0]
data = data.split(ITEM_MARKER)
del data[0]
for item in data:
icon = self.cm.ph.getSearchGroups(item, '<img[^>]+?data-original="([^"]+?)"')[0]
title = self.cm.ph.getDataBeetwenMarkers(item, '<h3 class="itemTitle">', '</h3>', False)[1].strip() + ', ' +self.cm.ph.getDataBeetwenMarkers(item, '<div class="datePublished">', '</div>', False)[1].strip()
# self.cm.ph.getDataBeetwenMarkers(item, '<div class="itemLead hyphenate">', '</div>', False)[1]
desc = self.cleanHtmlStr(ITEM_MARKER + item)
url = self.cm.ph.getSearchGroups(item, '<a href="([^"]+?)" title="([^"]+?)"', 2)[0]
params = {'title':title, 'url':url, 'icon':icon, 'desc': desc, 'host':'ekstraklasa.tv'}
self.addVideo(params)
#if "mediaType mediaVideo" in item:
# self.addVideo(params)
#else:
# self.addArticle(params)
# checkNewItemsAvailability
a = len(data)
if '' != moreData and 0 < a:
try:
# check if there are more data
moreData = json.loads(moreData)
prevLimit = moreData['limit']
moreData['offset'] += a
moreData['limit'] = 1
moreData = {'params':moreData}
url = urllib.quote(json.dumps(moreData, sort_keys=False, separators=(',', ':')))
url = Ekstraklasa.ETV_MAIN_URL + '_cdf/api?json=' + url + '&____presetName=liststream'
sts, data = self.cm.getPage(url)
if ITEM_MARKER in data:
moreData['params']['limit'] = prevLimit
url = urllib.quote(json.dumps(moreData, sort_keys=False, separators=(',', ':')))
url = Ekstraklasa.ETV_MAIN_URL + '_cdf/api?json=' + url + '&____presetName=liststream'
params = dict(cItem)
params.update({'title':'Następna strona', 'url':url })
self.addDir(params)
except:
printExc()
def _fillSeriesCache(self, url):
printDBG("JooglePL._fillSeriesCache")
sts, data = self.cm.getPage(url)
if not sts: return []
self.cacheSeries = {'all':[]}
data = self.cm.ph.getDataBeetwenMarkers(data, '<ul class="list">', '</ul>', False)[1]
data = data.split('</li>')
seriesABC = []
for item in data:
url = self.cm.ph.getSearchGroups(item, 'href="(http[^"]+?)"')[0]
title = self.cleanHtmlStr(item)
try:
cat_id = ''
if not self.cm.ph.isalpha(title, 0):
cat_id = '0-9'
else:
cat_id = self.cm.ph.getNormalizeStr(title, 0).upper()
if cat_id not in seriesABC:
seriesABC.append(cat_id)
if cat_id not in self.cacheSeries:
self.cacheSeries[cat_id] = []
self.cacheSeries[cat_id].append({'title':title, 'url':url})
self.cacheSeries['all'].append({'title':title, 'url':url})
except:
printExc()
return seriesABC
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 getVideoTab_ETV(self, ckmId):
printDBG("Ekstraklasa.getVideoTab_ETV ckmId[%r]" % ckmId )
tm = str(int(time.time() * 1000))
jQ = str(random.randrange(562674473039806,962674473039806))
authKey = 'FDF9406DE81BE0B573142F380CFA6043'
contentUrl = 'http://qi.ckm.onetapi.pl/?callback=jQuery183040'+ jQ + '_' + tm + '&body%5Bid%5D=' + authKey + '&body%5Bjsonrpc%5D=2.0&body%5Bmethod%5D=get_asset_detail&body%5Bparams%5D%5BID_Publikacji%5D=' + ckmId + '&body%5Bparams%5D%5BService%5D=ekstraklasa.onet.pl&content-type=application%2Fjsonp&x-onet-app=player.front.onetapi.pl&_=' + tm
sts, data = self.cm.getPage(contentUrl)
if sts:
try:
#extract json
result = json.loads(data[data.find("(")+1:-2])
strTab = []
valTab = []
for items in result['result']['0']['formats']['wideo']:
for i in range(len(result['result']['0']['formats']['wideo'][items])):
strTab.append(items)
strTab.append(result['result']['0']['formats']['wideo'][items][i]['url'].encode('UTF-8'))
if result['result']['0']['formats']['wideo'][items][i]['video_bitrate']:
strTab.append(int(float(result['result']['0']['formats']['wideo'][items][i]['video_bitrate'])))
else:
strTab.append(0)
valTab.append(strTab)
strTab = []
except:
printExc()
return valTab
def listFilms(self, cItem):
printDBG("KinoPecetowiec.listFilms cItem[%r]" % cItem)
page = cItem.get('page', '0')
url = self.MAINURL + '%s,0,%s,wszystkie,dowolny-rok,,%s.html' % (cItem['cat'], cItem['lang'], cItem['qual']) + '?' + self.filmssortField + '&load=1&moviesCount=%s&promotedCount=%s' % (cItem.get('moviesCount', 0), cItem.get('promotedCount', 0),)
HEADER = dict(self.AJAX_HEADER)
HEADER['Referer'] = url
http_params = {'header': HEADER}
sts, data = self.cm.getPage( url, http_params, {'page':page} )
if False == sts: return
sts, data = self._getfromJson(data)
if sts:
nextPageItem = None
# Unfortunately nextPage can not be checked based on filed 'lastPage'
# because its contain wrong information sometimes
#if False == data.get('lastPage', True):
try:
url = self.MAINURL + '%s,0,%s,wszystkie,dowolny-rok,,%s.html' % (cItem['cat'], cItem['lang'], cItem['qual']) + '?' + self.filmssortField + '&load=1&moviesCount=%s&promotedCount=%s' % (data.get('moviesCount', 0), data.get('promotedCount', 0),)
sts, data2 = self.cm.getPage( url, http_params, {'page':str(int(page)+1)} )
sts, data2 = self._getfromJson(data2)
data2 = data2['html']
if '</li>' in data2:
page = str(int(page)+1)
nextPageItem = dict(cItem)
nextPageItem['page'] = page
nextPageItem['title'] = 'Następna strona'
nextPageItem['moviesCount'] = data['moviesCount']
nextPageItem['promotedCount'] = data['promotedCount']
del data2
except:
printExc()
data = data['html'].split('</li>')
self.listItems(itemsTab=data, itemType='video', nextPageItem=nextPageItem, addParams= {'lang': cItem['lang'], 'qual': cItem['qual']})
def handleService(self, index, refresh=0, searchPattern="", searchType=""):
printDBG("FuufPL.handleService start")
CBaseHostClass.handleService(self, index, refresh, searchPattern, searchType)
name = self.currItem.get("name", None)
category = self.currItem.get("category", "")
printDBG("FuufPL.handleService: ---------> name[%s], category[%s] " % (name, category))
searchPattern = self.currItem.get("search_pattern", searchPattern)
self.currList = []
# MAIN MENU
if None == name:
self.listsTab(FuufPL.MAIN_CAT_TAB, {"name": "category"})
# CATEGORIES
elif "categories" == category:
self.listCategories(self.currItem, "list_videos")
# LIST_VIDEOS
elif "list_videos" == category:
self.listVideosFromCategory(self.currItem)
# WYSZUKAJ
elif category in ["search", "search_next_page"]:
cItem = dict(self.currItem)
cItem.update({"search_item": False, "name": "category"})
self.listSearchResult(cItem, searchPattern, searchType)
# HISTORIA WYSZUKIWANIA
elif category == "search_history":
self.listsHistory({"name": "history", "category": "search"}, "desc", _("Type: "))
else:
printExc()
CBaseHostClass.endHandleService(self, index, refresh)
def setOpenSSLVersion(self, ret=None):
printDBG('Check opennSSL version')
self.setInfo(_("Detection of the OpenSSL version."), _("OpenSSL lib is needed by wget and rtmpdump utilities."))
for ver in ['.0.9.8', '.1.0.0']:
libsslExist = False
libryptoExist = False
for path in ['/usr/lib/', '/lib/', '/usr/local/lib/', '/local/lib/', '/lib/i386-linux-gnu/']:
try:
filePath = path + 'libssl.so' + ver
if os_path.isfile(filePath) and not os_path.islink(filePath):
libsslExist = True
filePath = path + 'libcrypto.so' + ver
if os_path.isfile(filePath) and not os_path.islink(filePath):
libryptoExist = True
if libsslExist and libryptoExist:
break
except:
printExc()
continue
if libsslExist and libryptoExist:
break
if libsslExist and libryptoExist:
self.openSSLVersion = ver
#self.showMessage(_("Your OpenSSL version is [%s]") % self.openSSLVersion, MessageBox.TYPE_INFO, self.wgetDetect)
self.getGstreamerVer()
else:
self.openSSLVersion = ""
self.showMessage(_("Fatal Error!\nOpenssl could not be found. Please install it and retry."), MessageBox.TYPE_ERROR, boundFunction(self.finish, False) )
def getLinksForVideo(self, cItem):
printDBG("FuufPL.getLinksForVideo [%s]" % cItem)
urlTab = []
http_params = {"use_cookie": True, "save_cookie": True, "load_cookie": False, "cookiefile": self.COOKIE_FILE}
sts, data = self.cm.getPage(self.MAIN_URL, http_params)
if not sts:
return urlTab
http_params.update({"load_cookie": True})
sts, data = self.cm.getPage(cItem["url"], http_params)
if not sts:
return urlTab
try:
PHPSESSID = self.cm.getCookieItem(self.COOKIE_FILE, "PHPSESSID")
except:
printExc()
SetIPTVPlayerLastHostError(_("Not valid cookie: [%s]") % self.COOKIE_FILE)
return urlTab
url = self.cm.ph.getSearchGroups(data, 'file: "(http[^"]+?)"')[0]
if "" == url:
return urlTab
printDBG(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> url[%s]" % url)
retUrl = strwithmeta(url)
retUrl.meta["Referer"] = "http://static.fuuf.pl/player/jwplayer.flash.swf"
retUrl.meta["Cookie"] = "PHPSESSID={0}".format(PHPSESSID)
urlTab.append({"name": "fuuf.pl", "url": retUrl})
return urlTab
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 platformDetect(self):
printDBG("IPTVSetupImpl.platformDetect")
self.setInfo(_("Detection of the platform."), _("Plugin can be run on one of the following platforms: sh4, mipsel, i686, arm."))
if 'j00zekFork' in globals():
from Plugins.Extensions.IPTVPlayer.j00zekScripts.j00zekToolSet import getPlatform
platform = getPlatform()
if platform != 'unknown':
self.platform = platform
config.plugins.iptvplayer.plarform.value = self.platform
printDBG("IPTVSetupImpl.j00zekFork platform[%s]" % self.platform)
config.plugins.iptvplayer.plarform.save()
configfile.save()
self.setOpenSSLVersion()
return
cmdTabs = []
for platform in self.supportedPlatforms:
platformtesterPath = resolveFilename(SCOPE_PLUGINS, "Extensions/IPTVPlayer/bin/%s/platformtester" % platform)
try: os_chmod(platformtesterPath, 0777)
except: printExc()
cmdTabs.append(platformtesterPath + " 2>&1 ")
def _platformValidator(code, data):
printDBG("IPTVSetupImpl._platformValidator")
if "Test platform OK" in data: return True,False
else: return False,True
self.workingObj = CCmdValidator(self.platformDetectFinished, _platformValidator, cmdTabs)
self.workingObj.start()
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 handleService(self, index, refresh = 0, searchPattern = '', searchType = ''):
printDBG('handleService start')
CBaseHostClass.handleService(self, index, refresh, searchPattern, searchType)
name = self.currItem.get("name", '')
category = self.currItem.get("category", '')
printDBG( "handleService: |||||||||||||||||||||||||||||||||||| name[%s], category[%s] " % (name, category) )
self.currList = []
#MAIN MENU
if name == None:
self.listsTab(self.MAIN_CAT_TAB, {'name':'category'})
#MOVIES
elif category == 'dr_live_channels':
self.listLiveChannels(self.currItem)
#SEARCH
elif category in ["search", "search_next_page"]:
cItem = dict(self.currItem)
cItem.update({'search_item':False, 'name':'category'})
self.listSearchResult(cItem, searchPattern, searchType)
#HISTORIA SEARCH
elif category == "search_history":
self.listsHistory({'name':'history', 'category': 'search'}, 'desc', _("Type: "))
else:
printExc()
CBaseHostClass.endHandleService(self, index, refresh)
def getChannelsList(self, url):
printDBG("WeebTvApi.getChannelsList url[%s]" % url )
channelsList = []
channelsArray = self._jsonToSortedTab(self._getJsonFromAPI(url))
if len(channelsArray) > 0:
try:
if channelsArray[0][1] != 'Error' and channelsArray[0][1] != 'Null':
for i in range(len(channelsArray)):
try:
k = channelsArray[i][1]
name = self._getStr(k['channel_name']).replace("\"", '')
title = self._getStr(k['channel_title']).replace("\"", '')
desc = self._getStr(k['channel_description']).replace("\"", '')
tags = self._getStr(k['channel_tags']).replace("\"", '')
image = self._getStr(k['channel_logo_url'])
online = int(k['channel_online'])
rank = k['rank']
bitrate = k['multibitrate']
user = self._getStr(k['user_name']).replace("\"", '')
if 0 == len(title): title = name
if 0 == online:
online = 'offline'
channel = ''
elif 2 == online:
online = 'online'
channel = name
title = '%s - %s %s' % (title, user, online)
params = {'url':channel, 'title':title, 'desc':desc, 'icon':image, 'rank':rank, 'bitrate':bitrate, 'user':user}
channelsList.append(params)
except: printExc()
except: printExc()
return channelsList
def getLinksForVideo(self, cItem):
printDBG("SpiegelTv.getLinksForVideo [%s]" % cItem)
cacheKey = cItem['url']
cacheTab = self.cacheLinks.get(cacheKey, [])
if len(cacheTab): return cacheTab
self.cacheLinks = {}
retTab = []
sts, data = self.getPage(cItem['url'])
if not sts: return
self._fillOneConfig(cItem, data)
self._initiSession(cItem)
videoId = self.cm.ph.getDataBeetwenMarkers(data, 'video.start(', ')', False)[1].split(',')[0].strip()
if videoId == '': videoId = cItem['url'].split('/videos/', 1)[-1].split('-')[0]
try:
cid = self.oneconfig['session_data']['general']['cid']
clientToken = self.oneconfig['session_data']['device']['clienttoken']
clientId = self.oneconfig['session_data']['general']['clid']
deviceId = self.oneconfig['session_data']['device_id']
secret = clientToken[int(deviceId[0]):]
secret = secret[0:len(secret) - int(deviceId[-1])]
op = 'byid'
requestToken = hashlib.md5(''.join((op, clientId, secret))).hexdigest()
urlParams = dict(self.defaultParams)
urlParams['header'] = dict(self.AJAX_HEADER)
urlParams['header'].update({'Referer':cItem['url'], 'X-Request-Enable-Auth-Fallback':'1', 'X-Request-CID':cid, 'X-Request-Token':requestToken})
post_data = {'additionalfields': 'language,channel,actors,studio,licenseby,slug,subtitle,teaser,description',
'addInteractionOptions': '1',
'addStatusDetails': '1',
'addStreamDetails': '1',
'addCaptions': '1',
'addScenes': '1',
'addHotSpots': '1',
'addBumpers': '1',
'captionFormat': 'data',}
url = 'https://api.nexx.cloud/v3/%s/videos/%s/%s' % (clientId, op, videoId)
sts, data = self.getPage(url, urlParams, post_data)
if not sts: return
data = byteify(json.loads(data), '', True)['result']
try: protectionToken = data['protectiondata']['token']
except Exception: protectionToken = None
language = data['general'].get('language_raw') or ''
data = data['streamdata']
printDBG(data)
cdn = data['cdnType']
azureLocator = data['azureLocator']
AZURE_URL = 'http://nx%s%02d.akamaized.net/'
def getCdnShieldBase(shieldType='', prefix='-p'):
for secure in ('', 's'):
cdnShield = data.get('cdnShield%sHTTP%s' % (shieldType, secure.upper()))
if cdnShield:
return 'http%s://%s' % (secure, cdnShield)
else:
return AZURE_URL % (prefix, int(data['azureAccount'].replace('nexxplayplus', '')))
azureStreamBase = getCdnShieldBase()
isML = ',' in language
azureManifestUrl = '%s%s/%s_src%s.ism/Manifest' % (azureStreamBase, azureLocator, videoId, ('_manifest' if isML else '')) + '%s'
if protectionToken:
azureManifestUrl += '?hdnts=%s' % protectionToken
try:
azureProgressiveBase = getCdnShieldBase('Prog', '-d')
azureFileDistribution = data.get('azureFileDistribution')
if azureFileDistribution:
fds = azureFileDistribution.split(',')
if fds:
for fd in fds:
ss = fd.split(':')
if len(ss) != 2: continue
tbr = int(ss[0] or 0)
if not tbr: continue
retTab.append({'name':'[%s] %s' % (tbr, ss[1]), 'tbr':tbr, 'url': '%s%s/%s_src_%s_%d.mp4' % (azureProgressiveBase, azureLocator, videoId, ss[1], tbr)})
except Exception:
printExc()
retTab.sort(key=lambda item: item['tbr'], reverse=True)
if len(retTab) == 0:
retTab = getMPDLinksWithMeta(azureManifestUrl % '(format=mpd-time-csf)', checkExt=False, sortWithMaxBandwidth=999999999)
if len(retTab) == 0:
retTab = getDirectM3U8Playlist(azureManifestUrl % '(format=m3u8-aapl)', checkExt=False, checkContent=True, sortWithMaxBitrate=999999999)
except Exception:
printExc()
if len(retTab):
self.cacheLinks[cacheKey] = retTab
for idx in range(len(retTab)):
retTab[idx]['need_resolve'] = 1
return retTab
def _unshorten_iivpl(self, baseUri):
baseUri = strwithmeta(baseUri)
ref = baseUri.meta.get('Referer', baseUri)
USER_AGENT = 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:40.0) Gecko/20100101 Firefox/40.0'
HTTP_HEADER = {
'User-Agent': USER_AGENT,
'Accept': '*/*',
'Accept-Encoding': 'gzip, deflate',
'Referer': ref
}
HTTP_HEADER_AJAX = {
'User-Agent': USER_AGENT,
'Accept': '*/*',
'Accept-Encoding': 'gzip, deflate',
'Referer': baseUri,
'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
'X-Requested-With': 'XMLHttpRequest'
}
COOKIE_FILE = GetCookieDir('iit.pl')
tries = 0
retUri, retSts = '', 'KO'
while tries < 2 and retSts != 'OK':
tries += 1
rm(COOKIE_FILE)
try:
params = {
'header': HTTP_HEADER,
'use_cookie': True,
'load_cookie': True,
'save_cookie': True,
'cookiefile': COOKIE_FILE
}
sts, data = self.cm.getPage(baseUri, params)
sts, headers = self.cm.getPage(
'http://iiv.pl/modules/system/assets/js/framework.js',
params)
headers = self.cm.ph.getDataBeetwenMarkers(
headers, 'headers', '}')[1]
headers = re.compile('''['"]([^'^"]+?)['"]''').findall(headers)
salt = self.cm.ph.getSearchGroups(
data, '''data\-salt="([^"]+?)"''')[0]
time = self.cm.ph.getSearchGroups(
data, '''data\-time="([^"]+?)"''')[0]
action = self.cm.ph.getSearchGroups(
data, '''data\-action="([^"]+?)"''')[0]
banner = self.cm.ph.getSearchGroups(
data, '''data\-banner="([^"]+?)"''')[0]
component = self.cm.ph.getSearchGroups(
data, '''data\-component="([^"]+?)"''')[0]
if tries > 1: GetIPTVSleep().Sleep(int(time))
sts, partials = self.cm.getPage(
'http://iiv.pl/themes/cutso/assets/javascript/shortcut/shortcut.js',
params)
partials = self.cm.ph.getDataBeetwenMarkers(
partials, 'update:', '}')[1]
partials = self.cm.ph.getSearchGroups(
partials, '''['"]([^'^"]+?)['"]''')[0]
if partials == '': partials = 'shortcut/link_show'
for header in headers:
if 'HANDLER' in header:
HTTP_HEADER_AJAX[header] = action
elif 'PARTIALS' in header:
HTTP_HEADER_AJAX[header] = partials
post_data = {'salt': salt, 'banner': banner, 'blocker': 0}
params['header'] = HTTP_HEADER_AJAX
sts, data = self.cm.getPage(baseUri, params, post_data)
data = byteify(json.loads(data))
printDBG(">>>%s<<<" % data)
uri = self.cm.ph.getSearchGroups(
data[partials], '''href="(https?://[^"]+?)"''')[0]
retUri, retSts = uri, 'OK'
except Exception as e:
retUri, retSts = baseUri, str(e)
printExc()
return retUri, retSts
def exploreItem(self, cItem, nextCategory):
printDBG("KinogoCC.listItems")
sts, data = self.getPage(cItem['url'])
if not sts: return
self.setMainUrl(data.meta['url'])
data = self.cm.ph.getDataBeetwenNodes(data, ('<div', '>', 'section'),
('<', '>', 'social'))[1]
printDBG(data)
titles = self.cm.ph.getDataBeetwenNodes(data, ('<ul', '>', 'tabs'),
('</ul', '>'))[1]
titles = self.cm.ph.getAllItemsBeetwenMarkers(titles, '<li', '</li>')
if len(titles) == 0: titles.append(_('watch'))
if len(titles) < 2: titles.append(_('trailer'))
# trailer
iTrailer = self.cm.ph.getSearchGroups(
data,
'''['"](https?://[^'^"]*?youtube[^'^"]*?watch[^'^"]*?)['"]''')[0]
if iTrailer != '':
params = dict(cItem)
params.update({
'good_for_fav':
False,
'url':
iTrailer,
'title':
'%s - %s' % (cItem['title'], self.cleanHtmlStr(titles[-1]))
})
self.addVideo(params)
# watch online
tmp = self.cm.ph.getDataBeetwenMarkers(data, 'Base64.decode(', ')',
False)[1].strip()
if tmp != '':
try:
data = base64.b64decode(tmp[1:-1])
data = self.cm.ph.getSearchGroups(
data,
'''(<param[^>]+?flashvars[^>]+?>)''',
ignoreCase=True)[0]
data = self.cm.ph.getSearchGroups(
data, '''value=['"]([^'^"]+?)['"]''')[0]
data = data.split('&')
fileMarker = 'file='
playlistMarker = 'pl='
for item in data:
item = item.strip()
if item.startswith(fileMarker):
url = item[len(fileMarker):]
printDBG(">> url[%s]" % url)
tmp = url.lower().split('?', 1)[0]
if self.cm.isValidUrl(url) and \
tmp.split('.')[-1] in ['flv', 'mp4']:
params = dict(cItem)
params.update({'good_for_fav': False, 'url': url})
self.addVideo(params)
if item.startswith(playlistMarker):
url = item[len(playlistMarker):]
printDBG(">> url[%s]" % url)
tmp = url.lower().split('?', 1)[0]
if self.cm.isValidUrl(url) and \
tmp.endswith('.txt'):
urlParams = dict(self.defaultParams)
urlParams['convert_charset'] = False
sts, tmp = self.getPage(url, urlParams)
if not sts: continue
printDBG(">>\n%s\n<<" % tmp)
tmp = tmp.split('},')
for item in tmp:
title = self.cleanHtmlStr(
self.cm.ph.getSearchGroups(
item,
'''['"]comment['"]\s*?:\s*?['"]([^'^"]+?)['"]'''
)[0])
url = self.cm.ph.getSearchGroups(
item,
'''['"]file['"]\s*?:\s*?['"](https?://[^'^"]+?)['"]'''
)[0]
if url == '': continue
params = dict(cItem)
params.update({
'good_for_fav':
False,
'title':
'%s %s' % (cItem['title'], title),
'url':
url
})
self.addVideo(params)
except Exception:
printExc()
else:
urlsTab = []
data = re.compile(
'''['"]?file['"]?\s*?:\s*?['"](https?://[^'^"]+?(?:\.flv|\.mp4)(?:\?[^'^"]*?)?)['"]''',
re.I).findall(data)
for item in data:
name = item.split('?', 1)[0].split('.')[-1]
params = {
'name': name,
'url': strwithmeta(item, {'Referer': self.getMainUrl()}),
'need_resolve': 0
}
if name == 'flv': urlsTab.insert(0, params)
else: urlsTab.append(params)
if len(urlsTab):
params = dict(cItem)
params.update({'good_for_fav': False, 'urls_tab': urlsTab})
self.addVideo(params)
def listsCategory_ETV(self, cItem):
printDBG("Ekstraklasa.listsCategory_ETV")
ITEM_MARKER = '<div class="listItem'
sts, data = self.cm.getPage(cItem['url'])
if not sts: return
printDBG('----------------------------------------')
# check if we should check for sub categories
if 0 == cItem['depth']:
subMenuData = self.cm.ph.getDataBeetwenMarkers(
data, '<ul class="subMenu">', '</ul>', False)[1]
subMenuData = re.compile(
'<a[ ]+?href="(http[^">]+?)"[ ]*?>([^<]+?)</a>').findall(
subMenuData)
if 0 < len(subMenuData):
params = dict(cItem)
params.update({'title': 'Najnowsze', 'depth': 1})
self.addDir(params)
for item in subMenuData:
params = dict(cItem)
params.update({
'url': item[0],
'title': self.cleanHtmlStr(item[1]),
'depth': 1,
})
self.addDir(params)
return
data = self.cm.ph.getDataBeetwenMarkers(data, ITEM_MARKER,
'<script')[1]
moreData = self.cm.ph.getSearchGroups(
data, "id=\"moredata\" value='([^']+?)'")[0]
data = data.split(ITEM_MARKER)
del data[0]
for item in data:
icon = self.cm.ph.getSearchGroups(
item, '<img[^>]+?data-original="([^"]+?)"')[0]
title = self.cm.ph.getDataBeetwenMarkers(
item, '<h3 class="itemTitle">', '</h3>',
False)[1].strip() + ', ' + self.cm.ph.getDataBeetwenMarkers(
item, '<div class="datePublished">', '</div>',
False)[1].strip()
# self.cm.ph.getDataBeetwenMarkers(item, '<div class="itemLead hyphenate">', '</div>', False)[1]
desc = self.cleanHtmlStr(ITEM_MARKER + item)
url = self.cm.ph.getSearchGroups(
item, '<a href="([^"]+?)" title="([^"]+?)"', 2)[0]
params = {
'title': title,
'url': url,
'icon': icon,
'desc': desc,
'host': 'ekstraklasa.tv'
}
self.addVideo(params)
#if "mediaType mediaVideo" in item:
# self.addVideo(params)
#else:
# self.addArticle(params)
# checkNewItemsAvailability
a = len(data)
if '' != moreData and 0 < a:
try:
# check if there are more data
moreData = json.loads(moreData)
prevLimit = moreData['limit']
moreData['offset'] += a
moreData['limit'] = 1
moreData = {'params': moreData}
url = urllib.quote(
json.dumps(moreData,
sort_keys=False,
separators=(',', ':')))
url = Ekstraklasa.ETV_MAIN_URL + '_cdf/api?json=' + url + '&____presetName=liststream'
sts, data = self.cm.getPage(url)
if ITEM_MARKER in data:
moreData['params']['limit'] = prevLimit
url = urllib.quote(
json.dumps(moreData,
sort_keys=False,
separators=(',', ':')))
url = Ekstraklasa.ETV_MAIN_URL + '_cdf/api?json=' + url + '&____presetName=liststream'
params = dict(cItem)
params.update({'title': 'Następna strona', 'url': url})
self.addDir(params)
except:
printExc()
def getLinksForVideo(self, cItem, data=None):
printDBG("CartoonHD.getLinksForVideo [%s]" % cItem)
if not data and 1 == self.up.checkHostSupport(cItem['url']):
return self.up.getVideoLinkExt(cItem['url'])
def gettt():
data = str(int(time.time()))
b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
i = 0
enc = ""
tmp_arr = []
mask = 0x3f
while True:
o1 = ord(data[i])
i += 1
if i < len(data):
o2 = ord(data[i])
else:
o2 = 0
i += 1
if i < len(data):
o3 = ord(data[i])
else:
o3 = 0
i += 1
bits = o1 << 16 | o2 << 8 | o3
h1 = bits >> 18 & mask
h2 = bits >> 12 & mask
h3 = bits >> 6 & mask
h4 = bits & mask
tmp_arr.append(b64[h1] + b64[h2] + b64[h3] + b64[h4])
if i >= len(data):
break
enc = ''.join(tmp_arr)
r = len(data) % 3
if r > 0:
fill = '==='
enc = enc[0:r - 3] + fill[r:]
return enc
def getCookieItem(name):
value = ''
try:
value = self.cm.getCookieItem(self.COOKIE_FILE, name)
except Exception:
printExc()
return value
urlTab = self.cacheLinks.get(cItem['url'], [])
if len(urlTab):
return urlTab
self.cacheLinks = {}
if not data:
sts, data = self.cm.getPage(cItem['url'], self.defaultParams)
if not sts:
return []
printDBG(">> url: %s" % self.cm.meta['url'])
jsUrl = ''
tmp = re.compile(
'''<script[^>]+?src=['"]([^'^"]*?videojs[^'^"^/]*?\.js(?:\?[^'^"]*?v=[0-9\.]+?)?)['"]''',
re.I).findall(data)
printDBG("TMP JS: %s" % tmp)
for item in tmp:
if '.min.' in item.rsplit('/', 1)[-1]:
continue
jsUrl = self.getFullUrl(item)
printDBG("jsUrl: %s" % jsUrl)
if not self.cm.isValidUrl(jsUrl):
printDBG(">>>>>>\n%s\n" % data)
return []
sts, jsUrl = self.cm.getPage(jsUrl, self.defaultParams)
if not sts:
return []
jsUrl = self.cm.ph.getSearchGroups(
jsUrl.split('getEpisodeEmb', 1)[-1],
'''['"]([^'^"]*?/ajax/[^'^"]+?)['"]''')[0]
printDBG("jsUrl [%s]" % jsUrl)
if jsUrl == '':
return []
baseurl = self.getFullUrl(
self.cm.ph.getSearchGroups(
data, '''\s+?baseurl\s*=\s*['"]([^'^"]+?)['"]''')[0])
printDBG("baseurl [%s]" % baseurl)
if not self.cm.isValidUrl(baseurl):
baseurl = self.cm.getBaseUrl(cItem['url'])
tor = self._getToken(data)
elid = self.cm.ph.getSearchGroups(
data, '''elid[\s]*=[\s]['"]([^"^']+?)['"]''')[0]
if '' == elid:
elid = self.cm.ph.getSearchGroups(data, 'data-id="([^"]+?)"')[0]
if '' == elid:
elid = self.cm.ph.getSearchGroups(data, 'data-movie="([^"]+?)"')[0]
if '' == elid:
return []
if "movieInfo['season']" not in data and 'movieInfo["season"]' not in data:
type = 'getMovieEmb'
else:
type = 'getEpisodeEmb'
#if '/movie/' in cItem['url']:
# type = 'getMovieEmb'
#else: type = 'getEpisodeEmb'
tmp = self.cm.ph.getDataBeetwenMarkers(data, '<select', '</select>',
False)[1]
hostings = []
tmp = re.compile(
'<option[^>]*?value="([^"]+?)"[^>]*?>([^<]+?)</option>').findall(
tmp)
for item in tmp:
hostings.append({'id': item[0], 'name': item[1]})
httpParams = dict(self.defaultParams)
httpParams['header'] = {
'Referer': cItem['url'],
'User-Agent': self.cm.HOST,
'X-Requested-With': 'XMLHttpRequest',
'Accept': 'application/json, text/javascript, */*; q=0.01',
'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8'
}
encElid = gettt()
__utmx = getCookieItem('__utmx')
httpParams['header']['Authorization'] = 'Bearer ' + urllib.unquote(
__utmx)
requestLinks = [urljoin(baseurl, jsUrl)]
if 'class="play"' in data and 'id="updateSources"' not in data:
requestLinks.append('ajax/embeds.php')
#httpParams['header']['Cookie'] = '%s=%s; PHPSESSID=%s; flixy=%s;'% (elid, urllib.quote(encElid), getCookieItem('PHPSESSID'), getCookieItem('flixy'))
for url in requestLinks:
post_data = {
'action': type,
'idEl': elid,
'token': tor,
'elid': urllib.quote(encElid),
'nopop': ''
}
sts, data = self.cm.getPage(url, httpParams, post_data)
if not sts:
continue
printDBG(
'==============================================================='
)
printDBG(data)
printDBG(
'==============================================================='
)
printDBG(hostings)
try:
keys = re.compile('"(_[0-9]+?)"').findall(data)
data = json_loads(data)
for key in data.keys():
if key not in keys:
keys.append(key)
for key in keys:
if key not in keys:
continue
url = data[key]['embed'].replace('\\/', '/')
url = self.cm.ph.getSearchGroups(
url, '''src=['"]([^"^']+?)['"]''', 1,
ignoreCase=True)[0]
name = data[key]['type']
if 'googlevideo.com' in url or 'googleusercontent.com' in url:
need_resolve = 0
elif 1 == self.up.checkHostSupport(url):
need_resolve = 1
else:
need_resolve = 0
if url.startswith('http'):
urlTab.append({
'name': name,
'url': url,
'need_resolve': need_resolve
})
except Exception:
printExc()
if len(urlTab):
break
urlTab = urlTab[::-1]
self.cacheLinks[cItem['url']] = urlTab
return urlTab
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
vars = self.cm.ph.getDataBeetwenMarkers(data, 'var ', '</script>')[1]
if vars == '':
return
vars = vars[:-9]
jsUrl = self.getFullUrl(
self.cm.ph.getSearchGroups(
data,
'''<script[^>]+?src=['"]([^'^"]*?foxycomplete.js[^'^"]*?)['"]'''
)[0])
if not self.cm.isValidUrl(jsUrl):
return
jsHash = jsUrl.rsplit('=', 1)[-1]
js_execute_ext, is_js_cached
if not is_js_cached('cartoonhd', jsHash):
sts, jsdata = self.cm.getPage(jsUrl, self.defaultParams)
if not sts:
return
else:
jsdata = ''
post_data = {
'q': searchPattern,
'limit': 100,
'timestamp': str(int(time.time() * 1000))
}
try:
js_params = [{'path': GetJSScriptFile('cartoonhd.byte')}]
js_params.append({'code': vars})
js_params.append({
'name': 'cartoonhd',
'hash': jsHash,
'code': jsdata
})
ret = js_execute_ext(js_params)
if ret['sts'] and 0 == ret['code']:
decoded = ret['data'].strip()
printDBG('DECODED DATA -> [%s]' % decoded)
decoded = json_loads(decoded)
self.SEARCH_URL = decoded.pop('url', None)
post_data.update(decoded)
except Exception:
printExc()
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
printDBG(data)
try:
data = json_loads(data)
for item in data:
desc = item['meta']
if 'movie' in desc.lower():
category = 'explore_item'
elif 'tv show' in desc.lower():
category = 'list_seasons'
else:
category = None
if None != category:
title = item['title']
url = item['permalink'].replace('\\/', '/')
icon = item.get('image', '').replace('\\/', '/')
if '' != url:
params = {
'good_for_fav': True,
'name': 'category',
'title': title,
'url': self.getFullUrl(url),
'desc': desc,
'icon': self.getFullUrl(icon),
'category': category
}
if category == 'explore_item':
self.addVideo(params)
else:
self.addDir(params)
except Exception:
printExc()
def __init__(self):
# fill aac_mix option
options = [(None, _("From E2 settings"))]
tmp = GetE2AudioCodecMixChoices('aac')
for item in tmp:
options.append((item,_(item)))
if config.plugins.iptvplayer.aac_mix.value not in tmp:
config.plugins.iptvplayer.aac_mix.value = None
if len(tmp):
self.aac_mix_avaliable = True
else: self.aac_mix_avaliable = False
config.plugins.iptvplayer.aac_mix = ConfigSelection(default = None, choices = options)
# fill ac3_mix option
options = [(None, _("From E2 settings"))]
tmp = GetE2AudioCodecMixChoices('ac3')
for item in tmp:
options.append((item,_(item)))
if config.plugins.iptvplayer.ac3_mix.value not in tmp:
config.plugins.iptvplayer.ac3_mix.value = None
if len(tmp):
self.ac3_mix_avaliable = True
else: self.ac3_mix_avaliable = False
config.plugins.iptvplayer.ac3_mix = ConfigSelection(default = None, choices = options)
# fill aspect option
options = [(None, _("From E2 settings"))]
tmp = GetE2VideoAspectChoices()
for item in tmp:
options.append((item,_(item)))
if config.plugins.iptvplayer.extplayer_aspect.value not in tmp:
config.plugins.iptvplayer.extplayer_aspect.value = None
if len(tmp):
self.aspect_avaliable = True
else: self.aspect_avaliable = False
config.plugins.iptvplayer.extplayer_aspect = ConfigSelection(default = None, choices = options)
# fill policy option
options = [(None, _("From E2 settings"))]
tmp = GetE2VideoPolicyChoices()
for item in tmp:
options.append((item,_(item)))
if config.plugins.iptvplayer.extplayer_policy.value not in tmp:
config.plugins.iptvplayer.extplayer_policy.value = None
if len(tmp):
self.policy_avaliable = True
else: self.policy_avaliable = False
config.plugins.iptvplayer.extplayer_policy = ConfigSelection(default = None, choices = options)
# fill policy 2 option
options = [(None, _("From E2 settings"))]
if None != GetE2VideoPolicy('2'):
tmp = GetE2VideoPolicyChoices()
for item in tmp:
options.append((item,_(item)))
else: tmp = []
if config.plugins.iptvplayer.extplayer_policy2.value not in tmp:
config.plugins.iptvplayer.extplayer_policy2.value = None
if len(tmp):
self.policy2_avaliable = True
else: self.policy2_avaliable = False
config.plugins.iptvplayer.extplayer_policy2 = ConfigSelection(default = None, choices = options)
# fill fonts option
options = [("Regular", "Regular")]
fonts = ["Regular"]
try:
for key in skin.fonts:
font = skin.fonts[key][0]
if font not in fonts:
fonts.append(font)
options.append((font, font))
except Exception: printExc()
config.plugins.iptvplayer.extplayer_subtitle_font = ConfigSelection(default = "Regular", choices = options)
# check if border is avaliable
self.subtitle_border_avaliable = False
try:
tmp = dir(eLabel)
if 'setBorderColor' in tmp:
self.subtitle_border_avaliable = True
except Exception: printExc()
if not self.subtitle_border_avaliable:
config.plugins.iptvplayer.extplayer_subtitle_border_enabled.value = False
def _addItem(self, cItem, item, NOW, sData=None, eData=None, fType=None):
try:
printDBG("*********************************************************")
printDBG(item)
printDBG("*********************************************************")
title = self.cleanHtmlStr(item['titles'][0]['title'])
try:
icon = item['photos'][0].get('uri', None)
if icon == None: icon = item['photos'][0]['rawImage'] + ''
except Exception: icon = ''
duration = self.cleanHtmlStr(item['runTime'])
startDate = item.get('startDate', None)
if startDate == None: startDate = item.get('releaseDate', None)
if startDate == None: startDate = item.get('appears', None)
if startDate != None: startDate = self._gmt2local(startDate)
if startDate != None and sData != None and eData != None and \
(startDate < sData or startDate > eData):
return
endDate = item.get('endDate', None)
if endDate != None: endDate = self._gmt2local(endDate)
try:
language = item['titles'][0].get('language', None)
for tmp in item['titles'][0]['tags']:
if tmp.get('type', '') == 'language':
language = tmp['value']
language = self._getLanguageDisplayName(language)
except Exception: language = None
categories = self._getCatsDisplay(item['genres'])
try: channel = item['channel']['callsign']
except Exception: channel = None
episodeName = item['titles'][0].get('episodeName', None)
desc = []
desc.insert(0, categories)
if language != None: desc.insert(0, str(language))
if channel != None: desc.insert(0, self.cleanHtmlStr(channel))
try: prefix = item['mediaConfig']['productType'].lower()
except Exception: prefix = ''
upcoming = False
type = item.get('type', '').lower()
if type == 'airing' and prefix != 'vod':
try: state = item['mediaConfig']['state'].lower()
except Exception: state = ''
if item.get('liveBroadcast', True) and state != 'off' and (None == startDate or startDate <= NOW ):
prefix = self.serverApiData['i18n_dictionary']['Live']
elif startDate != None and NOW < startDate and self._absTimeDelta(NOW, startDate, 60) > 5:
prefix = self.serverApiData['i18n_dictionary']['Header_Upcoming']
upcoming = True
else:
prefix = ''
else:
try: prefix = item['mediaConfig']['type'].upper()
except Exception: prefix = item['type'].upper()
if fType != None:
if fType == 'VIDEO' and prefix != 'VIDEO': return
elif fType != 'VIDEO' and prefix == 'VIDEO': return
if prefix != '': title = '[%s] %s' % (prefix, title)
if episodeName != None: title = '%s - %s' % (title, self.cleanHtmlStr(episodeName))
printDBG("+++++++++++++++++++++++++++++++++++++++++++ [%s]" % prefix)
if prefix.lower() == 'video' or startDate == None or endDate == None: dateStr = str(item['runTime'])
else: dateStr = '%s - %s' % (startDate.strftime('%H:%M'), endDate.strftime('%H:%M'))
if startDate != None:
month = self.ABBREVIATED_MONTH_NAME_TAB[startDate.month-1]
if startDate.year == NOW.year: dateStr += ' | %s %s' % (startDate.day, self.serverApiData['i18n_dictionary'].get(month, month))
else: dateStr += ' | %s %s, %s' % (startDate.day, self.serverApiData['i18n_dictionary'].get(month, month), startDate.year)
summary = ''
try: summary = item['titles'][0]['descriptionLong']
except Exception: summary = item['titles'][0]['summaryLong']
desc.insert(0, dateStr)
desc = ' | '.join(desc) + '[/br]' + self.cleanHtmlStr(str(summary))
params = dict(cItem)
params.update({'good_for_fav':False, 'title':title, 'icon':icon, 'desc':desc, 'priv_item':item})
if upcoming: self.addArticle(params)
else: self.addVideo(params)
except Exception:
printExc()
def getLinksForVideo(self, cItem):
printDBG("LuxVeritatisPL.getLinksForVideo [%s]" % cItem)
linksTab = []
url = cItem['url']
if 'radiomaryja.pl' in url and url.endswith('/live/'):
sts, data = self.getPage(url)
if not sts: return
url = ph.search(
data,
'''<a[^>]+?href=['"](https?://[^>]+?\.pls(?:\?[^'^"]*?)?)['"]'''
)[0]
if url:
sts, tmp = self.getPage(url)
if sts:
tmp = re.compile(
'''(File[0-9]+?)=(https?://.+)''').findall(tmp)
for item in tmp:
linksTab.append({
'name': item[0],
'url': item[1],
'need_resolve': 0
})
url = ph.find(data, ('<a', '>', '/live2'))[1]
url = self.getFullUrl(ph.getattr(url, 'href'))
if url:
sts, data = self.getPage(url)
if not sts: return linksTab
url = ph.search(
data,
'''<a[^>]+?href=['"](https?://[^>]+?\.m3u8(?:\?[^'^"]*?)?)['"]'''
)[0]
linksTab.extend(getDirectM3U8Playlist(url, checkContent=True))
elif 'tv-trwam' in url:
sts, data = self.getPage(url)
if not sts: return
data = self.cm.ph.getSearchGroups(
data, '''sources\s*?:\s*?(\[[^\]]+?\])''')[0]
try:
data = json_loads(data)
hlsTab = []
dashTab = []
mp4Tab = []
for item in data:
vidUrl = item['src']
type = item['type'].lower()
if 'dash' in type:
dashTab.extend(
getMPDLinksWithMeta(
vidUrl,
checkExt=False,
cookieParams=self.defaultParams,
sortWithMaxBandwidth=999999999))
elif 'x-mpegurl' in type:
hlsTab.extend(
getDirectM3U8Playlist(
vidUrl,
checkExt=False,
checkContent=True,
cookieParams=self.defaultParams,
sortWithMaxBitrate=999999999))
elif 'mp4' in type:
mp4Tab.append({
'name':
'[mp4] %s' % vidUrl.split('/')[-1].split(
'_', 1)[-1].split('.', 1)[0],
'url':
vidUrl
})
linksTab.extend(hlsTab)
linksTab.extend(dashTab)
linksTab.extend(mp4Tab)
except Exception:
printExc()
elif 1 == self.up.checkHostSupport(url):
return self.up.getVideoLinkExt(url)
elif url.split('?', 1)[0].endswith('.mp3'):
return [{'name': 'MP3', 'url': url}]
return linksTab
def tryTologin(self):
printDBG('EuroSportPlayer.tryTologin start')
errorMsg = _('Error communicating with the server.')
if None == self.loggedIn or self.login != config.plugins.iptvplayer.eurosportplayer_login.value or\
self.password != config.plugins.iptvplayer.eurosportplayer_password.value:
self.login = config.plugins.iptvplayer.eurosportplayer_login.value
self.password = config.plugins.iptvplayer.eurosportplayer_password.value
rm(self.COOKIE_FILE)
self.loggedIn = False
self.loginMessage = ''
if '' == self.login.strip() or '' == self.password.strip():
msg = ''
sts, data = self.getPage(self.getMainUrl())
if sts and '/subscribe' not in data: msg = self.cleanHtmlStr(self.cm.ph.getDataBeetwenNodes(data, ('<div', '>', '"message"'), ('</div', '>'))[1])
if msg == '': msg = _('The host %s requires subscription.\nPlease fill your login and password in the host configuration - available under blue button.') % self.getMainUrl()
GetIPTVNotify().push(msg, 'info', 10)
return False
if not self.getToken('init'):
msg = _(errorMsg) + _('\nError[1].')
GetIPTVNotify().push(msg, 'error', 10)
return False
try:
baseUrl = self.serverApiData['server_path']['server'] + '/'
url = self.getFullUrl('/login', baseUrl)
sts, data = self.getPage(url)
if not sts: return False
getParams = dict(self.defaultParams)
getParams['raw_post_data'] = True
getParams['header'] = dict(self.AJAX_HEADER)
clientData = self.serverApiData['prod']['authentication']['client']
url = clientData['links'][0]['href']
getParams['header'].update(clientData['links'][0]['headers'])
getParams['header']['Authorization'] = getParams['header']['Authorization'].replace('{encodedUserToken}', self.tokenData['access_token'])
post_data = '{"type":"email-password","email":{"address":"%s"},"password":{"value":"%s"}}' % (self.login, self.password)
sts, data = self.getPage(url, getParams, post_data)
if not sts and '401' in str(data):
msg = _('Login failed. Invalid email or password.')
GetIPTVNotify().push(msg, 'error', 10)
return False
else:
data = json_loads(data)
printDBG(data)
self.tokenData['access_code'] = data['code']
self.tokenData['access_timeout'] = time.time() + (data['exp'] - data['iat']) / 1000.0
if not self.getToken('code'):
msg = _(errorMsg) + _('\nError[2].')
GetIPTVNotify().push(msg, 'error', 10)
return False
self.loggedIn = True
except Exception:
printExc()
printDBG('EuroSportPlayer.tryTologin end loggedIn[%s]' % self.loggedIn)
return self.loggedIn
def handleService(self, index, refresh=0, searchPattern='', searchType=''):
printDBG('Raiplay - handleService start')
CBaseHostClass.handleService(self, index, refresh, searchPattern,
searchType)
self.informAboutGeoBlockingIfNeeded('IT')
name = self.currItem.get("name", '')
category = self.currItem.get("category", '')
mode = self.currItem.get("mode", '')
subtype = self.currItem.get("sub-type", '')
printDBG("handleService: >> name[%s], category[%s] " %
(name, category))
self.currList = []
#MAIN MENU
if name == None:
self.listMainMenu({'name': 'category'})
elif category == 'live_tv':
self.listLiveTvChannels(self.currItem)
elif category == 'live_radio':
self.listLiveRadioChannels(self.currItem)
elif category == 'replay':
self.listReplayDate(self.currItem)
elif category == 'replay_date':
self.listReplayChannels(self.currItem)
elif category == 'replay_channel':
self.listEPG(self.currItem)
elif category == 'ondemand':
self.listOnDemandMain(self.currItem)
elif category == 'ondemand_items':
if subtype == "RaiPlay Tipologia Page" or subtype == "RaiPlay Genere Page" or subtype == "RaiPlay Tipologia Editoriale Page":
self.listOnDemandCategory(self.currItem)
elif subtype in ("Raiplay Tipologia Item",
"RaiPlay V2 Genere Page"):
self.listOnDemandAZ(self.currItem)
elif subtype in ("PLR programma Page", "RaiPlay Programma Item"):
self.listOnDemandProgram(self.currItem)
else:
printDBG("Raiplay - item '%s' - Sub-type not handled '%s' " %
(name, subtype))
elif category == 'ondemand_list':
self.listOnDemandIndex(self.currItem)
elif category == 'ondemand_program':
self.listOnDemandProgramItems(self.currItem)
elif category == 'tg':
self.listTg(self.currItem)
elif category == 'tgr' or category == 'tgr-root':
self.listTgr(self.currItem)
elif category in ['tg1', 'tg2', 'tg3']:
self.searchLastTg(self.currItem)
elif category == 'nop':
printDBG('raiplay no link')
elif category == 'raisport_main':
self.listRaiSportMain(self.currItem)
elif category == 'raisport_item':
self.listRaiSportItems(self.currItem)
elif category == 'raisport_subitem':
self.listRaiSportVideos(self.currItem)
else:
printExc()
CBaseHostClass.endHandleService(self, index, refresh)
def getLinksForVideo(self, cItem):
urlsTab = []
rm(self.COOKIE_FILE)
sts, data = self.getPage(cItem['url'])
if not sts: return []
tmp = ph.find(data, ('<glomex-player', '>'))[1]
if tmp:
player_id = ph.getattr(tmp, 'data-player-id')
playlist_id = ph.getattr(tmp, 'data-playlist-id')
url = 'https://integration-cloudfront-eu-west-1.mes.glomex.cloud/?integration_id=%s&playlist_id=%s¤t_url=' % (
player_id, playlist_id)
sts, data = self.getPage(url)
if not sts: return []
try:
data = json_loads(data)['videos'][0]['source']
if data.get('hls'):
hlsUrl = self.cm.getFullUrl(data['hls'],
self.cm.meta['url'])
urlsTab = getDirectM3U8Playlist(
hlsUrl,
checkContent=True,
sortWithMaxBitrate=999999999,
mergeAltAudio=True)
if len(urlsTab):
urlsTab.append({
'name': 'Variable M3U8/HLS',
'url': hlsUrl,
'need_resolve': 0
})
# progressive links seem do not work why?
if False and data.get('progressive'):
mp4Url = self.cm.getFullUrl(data['progressive'],
self.cm.meta['url'])
urlsTab.append({
'name': 'progressive mp4',
'url': mp4Url,
'need_resolve': 0
})
except Exception:
printExc()
else:
urlParams = dict(self.defaultParams)
urlParams['header'] = MergeDicts(urlParams['header'],
{'Referer': self.cm.meta['url']})
urlParams['raw_post_data'] = True
urlParams['use_new_session'] = True
playerData = ph.find(data, 'getPlayer(', ');',
flags=0)[1].split(',')
printDBG("playerData <<< %s" % playerData)
if len(playerData) == 6:
url = self.cm.getFullUrl(
'/videoplayer/playerhls.php?play=%s&key=%d&identifier=web&v5partner=%s&autoplay=true&event'
% (playerData[1].strip(), int(
time.time() * 1000), playerData[3].strip()),
self.cm.meta['url'])
sts, data = self.getPage(url, urlParams)
urlParams['header'] = MergeDicts(
urlParams['header'], {'Referer': self.cm.meta['url']})
url = self.cm.getFullUrl(
'/server/videoConfig.php?videoid=%s&partnerid=%s&language=%s&format=iphone'
% (playerData[1].strip(), playerData[3].strip(),
playerData[5].strip()[1:-1]), self.cm.meta['url'])
sts, data = self.getPage(url, urlParams)
try:
url = json_loads(data)['video']['streamAccess']
url = self.cm.getFullUrl(url, self.cm.meta['url'])
sts, data = self.getPage(url, urlParams, '[""]')
try:
printDBG("++++")
printDBG(data)
printDBG("++++")
data = json_loads(data)['data']['stream-access']
for url in data:
sts, streamData = self.getPage(
self.cm.getFullUrl(url, self.cm.meta['url']),
urlParams)
if not sts: continue
printDBG("?----?")
printDBG(data)
printDBG("?----?")
token = ph.getattr(streamData, 'auth')
hlsUrl = self.cm.getFullUrl(
ph.getattr(streamData, 'url'),
self.cm.meta['url']) + '?hdnea=' + token
urlsTab = getDirectM3U8Playlist(
hlsUrl,
checkContent=True,
sortWithMaxBitrate=999999999,
mergeAltAudio=True)
break
except Exception:
printExc()
except Exception:
printExc()
return urlsTab
def getVideoLinks(self, videoUrl):
printDBG("TreeTv.getVideoLinks [%s]" % videoUrl)
urlTab = []
# mark requested link as used one
for idx in range(len(self.cacheLinks)):
if videoUrl == self.cacheLinks[idx]['url']:
if not self.cacheLinks[idx]['name'].startswith('*'):
self.cacheLinks[idx]['name'] = '*' + self.cacheLinks[idx]['name']
break
#sts, data = self.getPage('http://tree.tv/film/index/imprint', self.defaultParams, {'result':self.defaultParams['cookie_items']['mycook']})
params = dict(self.defaultParams)
params['header'] = dict(self.AJAX_HEADER)
params['header']['Referer'] = str('http://tree.tv/')
params['raw_post_data'] = True
sts, data = self.getPage(self.getFullUrl('/film/index/imprint'), params, 'result=' + self.defaultParams['cookie_items']['mycook'] + '&components%5B0%5D%5Bkey%5D=user_agent&components%5B0%5D%5Bvalue%5D=Mozilla%2F5.0+(Windows+NT+6.1%3B+WOW64)+AppleWebKit%2F537.36+(KHTML%2C+like+Gecko)+Chrome%2F52.0.2743.116+Safari%2F537.36&components%5B1%5D%5Bkey%5D=language&components%5B1%5D%5Bvalue%5D=&components%5B2%5D%5Bkey%5D=color_depth&components%5B2%5D%5Bvalue%5D=24&components%5B3%5D%5Bkey%5D=pixel_ratio&components%5B3%5D%5Bvalue%5D=1&components%5B4%5D%5Bkey%5D=hardware_concurrency&components%5B4%5D%5Bvalue%5D=unknown&components%5B5%5D%5Bkey%5D=resolution&components%5B5%5D%5Bvalue%5D%5B%5D=1920&components%5B5%5D%5Bvalue%5D%5B%5D=1080&components%5B6%5D%5Bkey%5D=available_resolution&components%5B6%5D%5Bvalue%5D%5B%5D=1920&components%5B6%5D%5Bvalue%5D%5B%5D=1040&components%5B7%5D%5Bkey%5D=timezone_offset&components%5B7%5D%5Bvalue%5D=-60&components%5B8%5D%5Bkey%5D=session_storage&components%5B8%5D%5Bvalue%5D=1&components%5B9%5D%5Bkey%5D=local_storage&components%5B9%5D%5Bvalue%5D=1&components%5B10%5D%5Bkey%5D=indexed_db&components%5B10%5D%5Bvalue%5D=1&components%5B11%5D%5Bkey%5D=cpu_class&components%5B11%5D%5Bvalue%5D=unknown&components%5B12%5D%5Bkey%5D=navigator_platform&components%5B12%5D%5Bvalue%5D=unknown&components%5B13%5D%5Bkey%5D=do_not_track&components%5B13%5D%5Bvalue%5D=1&components%5B14%5D%5Bkey%5D=regular_plugins&components%5B14%5D%5Bvalue%5D%5B%5D=&components%5B15%5D%5Bkey%5D=canvas&components%5B15%5D%5Bvalue%5D=&components%5B16%5D%5Bkey%5D=webgl&components%5B16%5D%5Bvalue%5D=&components%5B17%5D%5Bkey%5D=adblock&components%5B17%5D%5Bvalue%5D=false&components%5B18%5D%5Bkey%5D=has_lied_languages&components%5B18%5D%5Bvalue%5D=false&components%5B19%5D%5Bkey%5D=has_lied_resolution&components%5B19%5D%5Bvalue%5D=false&components%5B20%5D%5Bkey%5D=has_lied_os&components%5B20%5D%5Bvalue%5D=false&components%5B21%5D%5Bkey%5D=has_lied_browser&components%5B21%5D%5Bvalue%5D=true&components%5B22%5D%5Bkey%5D=touch_support&components%5B22%5D%5Bvalue%5D%5B%5D=0&components%5B22%5D%5Bvalue%5D%5B%5D=false&components%5B22%5D%5Bvalue%5D%5B%5D=false&components%5B23%5D%5Bkey%5D=js_fonts&components%5B23%5D%5Bvalue%5D%5B%5D=Arial')
params['header']['Referer'] = str(videoUrl)
sts, data = self.getPage(self.getFullUrl('/film/index/imprint'), params, 'result=' + self.defaultParams['cookie_items']['mycook'] + '&components%5B0%5D%5Bkey%5D=user_agent&components%5B0%5D%5Bvalue%5D=Mozilla%2F5.0+(Windows+NT+6.1%3B+WOW64)+AppleWebKit%2F537.36+(KHTML%2C+like+Gecko)+Chrome%2F52.0.2743.116+Safari%2F537.36&components%5B1%5D%5Bkey%5D=language&components%5B1%5D%5Bvalue%5D=&components%5B2%5D%5Bkey%5D=color_depth&components%5B2%5D%5Bvalue%5D=24&components%5B3%5D%5Bkey%5D=pixel_ratio&components%5B3%5D%5Bvalue%5D=1&components%5B4%5D%5Bkey%5D=hardware_concurrency&components%5B4%5D%5Bvalue%5D=unknown&components%5B5%5D%5Bkey%5D=resolution&components%5B5%5D%5Bvalue%5D%5B%5D=1920&components%5B5%5D%5Bvalue%5D%5B%5D=1080&components%5B6%5D%5Bkey%5D=available_resolution&components%5B6%5D%5Bvalue%5D%5B%5D=1920&components%5B6%5D%5Bvalue%5D%5B%5D=1040&components%5B7%5D%5Bkey%5D=timezone_offset&components%5B7%5D%5Bvalue%5D=-60&components%5B8%5D%5Bkey%5D=session_storage&components%5B8%5D%5Bvalue%5D=1&components%5B9%5D%5Bkey%5D=local_storage&components%5B9%5D%5Bvalue%5D=1&components%5B10%5D%5Bkey%5D=indexed_db&components%5B10%5D%5Bvalue%5D=1&components%5B11%5D%5Bkey%5D=cpu_class&components%5B11%5D%5Bvalue%5D=unknown&components%5B12%5D%5Bkey%5D=navigator_platform&components%5B12%5D%5Bvalue%5D=unknown&components%5B13%5D%5Bkey%5D=do_not_track&components%5B13%5D%5Bvalue%5D=1&components%5B14%5D%5Bkey%5D=regular_plugins&components%5B14%5D%5Bvalue%5D%5B%5D=&components%5B15%5D%5Bkey%5D=canvas&components%5B15%5D%5Bvalue%5D=&components%5B16%5D%5Bkey%5D=webgl&components%5B16%5D%5Bvalue%5D=&components%5B17%5D%5Bkey%5D=adblock&components%5B17%5D%5Bvalue%5D=false&components%5B18%5D%5Bkey%5D=has_lied_languages&components%5B18%5D%5Bvalue%5D=false&components%5B19%5D%5Bkey%5D=has_lied_resolution&components%5B19%5D%5Bvalue%5D=false&components%5B20%5D%5Bkey%5D=has_lied_os&components%5B20%5D%5Bvalue%5D=false&components%5B21%5D%5Bkey%5D=has_lied_browser&components%5B21%5D%5Bvalue%5D=true&components%5B22%5D%5Bkey%5D=touch_support&components%5B22%5D%5Bvalue%5D%5B%5D=0&components%5B22%5D%5Bvalue%5D%5B%5D=false&components%5B22%5D%5Bvalue%5D%5B%5D=false&components%5B23%5D%5Bkey%5D=js_fonts&components%5B23%5D%5Bvalue%5D%5B%5D=Arial')
if sts: self.setMainUrl(self.cm.meta['url'])
sts, data = self.getPage(videoUrl, self.defaultParams)
if not sts: return []
data = re.sub("<!--[\s\S]*?-->", "", data)
url = self.getFullUrl(self.cm.ph.getSearchGroups(data, '''<iframe[^>]+?src=['"]([^"^']+?)['"]''', 1, True)[0].replace('\t', ''))
if 1 == self.up.checkHostSupport(url):
return self.up.getVideoLinkExt(url)
params = dict(self.defaultParams)
params['header'] = dict(params['header'])
params['header']['Referer'] = str(videoUrl)
sts, data = self.getPage(url, params)
if not sts: return []
printDBG(data)
sourceUrl = self.cm.ph.getSearchGroups(data, '''['"]?sourceUrl['"]?\s*:\s*['"]([^'^"]+?)['"]''', 1, True)[0]
filmId = self.cm.ph.getSearchGroups(data, '''['"]?filmId['"]?\s*:\s*['"]([^'^"]+?)['"]''', 1, True)[0]
fileId = self.cm.ph.getSearchGroups(data, '''['"]?fileId['"]?\s*:\s*['"]([^'^"]+?)['"]''', 1, True)[0]
source = self.cm.ph.getSearchGroups(data, '''['"]?source['"]?\s*:\s*['"]([^'^"]+?)['"]''', 1, True)[0]
#if source == '': source = self.cm.ph.getSearchGroups(url+'|', '''source=([0-9]+?)[^0-9]''', 1, True)[0]
#if fileId == '': fileId = self.cm.ph.getSearchGroups(url+'|', '''file=([0-9]+?)[^0-9]''', 1, True)[0]
params['header'] = dict(self.AJAX_HEADER)
params['header']['Referer'] = str(url)
playerKeyParams = {'key':'', 'g':2, 'p':293}
serverData = {'g':-1, 'p':-1, 's_key':''}
tmpurl = 'http://player.tree.tv/guard'
tries = 0
try:
while tries < 5:
if serverData['g'] != playerKeyParams['g'] or serverData['p'] != playerKeyParams['p']:
if tries > 0:
playerKeyParams['g'] = serverData['g']
playerKeyParams['p'] = serverData['p']
playerKeyParams['key'] = random.randrange(1, 8)
numClient = math.pow(playerKeyParams['g'], playerKeyParams['key']);
clientKey = math.fmod(numClient, playerKeyParams['p']);
post_data = {'key':int(clientKey)}
sts, data = self.getPage(tmpurl, params, post_data)
if not sts: return []
printDBG("++++++++++++++")
printDBG(data)
printDBG("++++++++++++++")
serverData = json_loads(data)
else:
break
tries += 1
if serverData['g'] != playerKeyParams['g'] or serverData['p'] != playerKeyParams['p']:
printDBG("WRONG DATA")
printDBG("serverData [%s]" % serverData)
printDBG("playerKeyParams [%s]" % playerKeyParams)
return []
b = math.pow(serverData['s_key'], playerKeyParams['key']);
skc = int(math.fmod(b, serverData['p']))
except Exception:
printExc()
return []
post_data = {'file':fileId, 'source':source, 'skc':skc}
sts, data = self.getPage(sourceUrl, params, post_data)
if not sts: return []
printDBG('url[%s]' % url)
printDBG('sourceUrl[%s]' % sourceUrl)
printDBG('filmId[%s]' % filmId)
printDBG('fileId[%s]' % fileId)
printDBG('source[%s]' % source)
printDBG(data)
#uri = self.up.getDomain(sourceUrl, False) + 'm3u8/{0}.m3u8'.format(fileId)
#return getDirectM3U8Playlist(uri, checkContent=True)
# sometimes return string is not valid json
try:
name = self.cm.ph.getSearchGroups(data, '''['"]?name['"]?\s*:\s*['"]([^'^"]+?)['"]''', 1, True)[0]
data = re.compile('''['"]?sources['"]?\s*\:\s*\[([^\]]+?)\]''').findall(data)
for sources in data:
sources = sources.split('}')
for item in sources:
uri = self.cm.ph.getSearchGroups(item, '''['"]?src['"]?\s*:\s*['"]([^'^"]+?)['"]''', 1, True)[0]
if not self.cm.isValidUrl(uri): continue
uri = strwithmeta(uri, {'User-Agent':params['header']['User-Agent'] , 'Referer':params['header']['Referer'], 'Origin':'http://player.tree.tv'})
point = self.cm.ph.getSearchGroups(item, '''['"]?point['"]?\s*:\s*['"]([^'^"]+?)['"]''', 1, True)[0]
label = self.cm.ph.getSearchGroups(item, '''['"]?label['"]?\s*:\s*['"]([^'^"]+?)['"]''', 1, True)[0]
if label == '': label = name
if str(fileId) == str(point) or point == '':
if '/playlist/' in uri:
urlTab.extend( getDirectM3U8Playlist(uri, checkExt=False, cookieParams=params, checkContent=True) )
elif source == '3':
urlTab.extend( [{'name':label, 'url':uri}] )
except Exception:
printExc()
return urlTab
def handleService(self, index, refresh=0, searchPattern='', searchType=''):
printDBG('handleService start')
self.tryTologin()
CBaseHostClass.handleService(self, index, refresh, searchPattern,
searchType)
name = self.currItem.get("name", '')
category = self.currItem.get("category", '')
mode = self.currItem.get("mode", '')
printDBG("handleService: |||| name[%s], category[%s] " %
(name, category))
self.cacheLinks = {}
self.currList = []
#MAIN MENU
if name == None:
self.listMainMenu({'name': 'category'}, 'sub_menu')
#MOVIES
elif category == 'movies':
self.listMoviesCats(self.currItem, 'list_movies_cmd')
elif category == 'movies_top':
self.listMoviesTop(self.currItem, 'list_movies_cmd')
elif category == 'list_movies_cmd':
self.listCmdItems(self.currItem, 'video')
elif category == 'movies_all':
self.listMoviesFilters(self.currItem, 'list_sorts')
elif category == 'list_sorts':
self.listSort(self.currItem, 'list_movies')
elif category == 'list_movies':
self.listMovies(self.currItem)
#SERIES
elif category == 'series':
self.listSeriesCats(self.currItem, 'list_series_cmd')
elif category == 'series_top':
self.listSeriesTop(self.currItem, 'list_series_cmd')
elif category == 'list_series_cmd':
self.listCmdItems(self.currItem, 'list_seasons')
elif category == 'series_last':
self.listSeriesUpdated(self.currItem, 'list_seasons')
elif category == 'series_abc':
self.listSeriesAbc(self.currItem, 'series_by_letter')
elif category == 'series_by_letter':
self.listSeriesByLetter(self.currItem, 'list_seasons')
elif category == 'series_all':
self.listSeriesAll(self.currItem, 'list_seasons')
elif category == 'list_seasons':
self.listSeriesSeasons(self.currItem, 'list_episodes')
elif category == 'list_episodes':
self.listSeriesEpisodes(self.currItem)
#SEARCH
elif category in ["search", "search_next_page"]:
cItem = dict(self.currItem)
cItem.update({'search_item': False, 'name': 'category'})
self.listSearchResult(cItem, searchPattern, searchType)
#HISTORIA SEARCH
elif category == "search_history":
self.listsHistory({
'name': 'history',
'category': 'search'
}, 'desc', _("Type: "))
else:
printExc()
CBaseHostClass.endHandleService(self, index, refresh)
def _getFileSize(self, data):
try:
return int(self.parseReObj['size'].search(data).group(1)) * 1024
except Exception:
printExc()
return 0
def getDirectM3U8Playlist(M3U8Url,
checkExt=True,
variantCheck=True,
cookieParams={}):
if checkExt and not M3U8Url.split('?')[0].endswith('.m3u8'):
return []
cm = common()
meta = strwithmeta(M3U8Url).meta
params, postData = cm.getParamsFromUrlWithMeta(M3U8Url)
params.update(cookieParams)
retPlaylists = []
try:
finallM3U8Url = meta.get('iptv_m3u8_custom_base_link', '')
if '' == finallM3U8Url:
params['return_data'] = False
sts, response = cm.getPage(M3U8Url, params, postData)
finallM3U8Url = response.geturl()
data = response.read().strip()
response.close()
else:
sts, data = cm.getPage(M3U8Url, params, postData)
data = data.strip()
m3u8Obj = m3u8.inits(data, finallM3U8Url)
if m3u8Obj.is_variant:
for playlist in m3u8Obj.playlists:
item = {}
if not variantCheck or playlist.absolute_uri.split(
'?')[-1].endswith('.m3u8'):
meta.update({
'iptv_proto': 'm3u8',
'iptv_bitrate': playlist.stream_info.bandwidth
})
item['url'] = strwithmeta(playlist.absolute_uri, meta)
else:
meta.pop('iptv_proto', None)
item['url'] = decorateUrl(playlist.absolute_uri, meta)
item['bitrate'] = playlist.stream_info.bandwidth
if None != playlist.stream_info.resolution:
item['with'] = playlist.stream_info.resolution[0]
item['heigth'] = playlist.stream_info.resolution[1]
else:
item['with'] = 0
item['heigth'] = 0
item['codec'] = playlist.stream_info.codecs
item['name'] = "bitrate: %s res: %dx%d kodek: %s" % ( item['bitrate'], \
item['with'], \
item['heigth'], \
item['codec'] )
retPlaylists.append(item)
else:
item = {
'name': 'm3u8',
'url': M3U8Url,
'codec': 'unknown',
'with': 0,
'heigth': 0,
'bitrate': 'unknown'
}
retPlaylists.append(item)
except:
printExc()
return retPlaylists
def getEpisodeList(self, url):
query_data = {
'url': url + '/odcinki',
'use_host': True,
'host': self.HOST,
'use_cookie': True,
'save_cookie': False,
'load_cookie': True,
'cookiefile': self.COOKIEFILE,
'use_post': False,
'return_data': True
}
query_data1 = {
'url': url,
'use_host': False,
'use_cookie': False,
'use_post': False,
'return_data': True
}
try:
data = self.cm.getURLRequestData(query_data) # episodes data
data2 = self.cm.getURLRequestData(query_data1) # cover, desc. data
except:
printExc()
# Description
match = re.search(
"<h2>Opis anime</h2></div><div class='content'><div class='con'>(.+?)</div>",
data2)
if match:
plot = match.group(1)
else:
match = re.search(
"<h2>Opis anime</h2></div><div class='content'><div class='con'>(.+?)<",
data2)
if match:
plot = match.group(1)
else:
match = re.search("<h2>Opis anime</h2></div><.+?>(.+?)<",
data2)
if match:
plot = match.group(1)
else:
plot = ''
# Cover
grafika = re.search(
"</div><div class='content'><div class='con'><a href='(.+?)' class='fbox'>",
data2)
if grafika:
icon = self.MAINURL + grafika.group(1)
else:
icon = ''
# Episodes
match = re.compile(
"<span class='head2'>Statystyki:</span>(.+?)<div class='mainCon'>",
re.DOTALL).findall(data)
if len(match) > 0:
match2 = re.compile(
"#(.+?)</div><div class=.+?</div><div class='con3'><a href='(.+?)' class='i'>"
).findall(match[0])
if len(match2) > 0:
for i in range(len(match2)):
value = match2[i]
page = self.MAINURL + value[1]
title = 'Odcinek ' + value[0]
params = {
'title': title,
'page': page,
'plot': self.cm.html_entity_decode(plot),
'icon': icon
}
self.addVideo(params)
def start(self, url, filePath, params={}):
'''
Owervrite start from BaseDownloader
'''
self.url = url
self.filePath = filePath
self.downloaderParams = params
self.fileExtension = '' # should be implemented in future
self.outData = ''
self.contentType = 'unknown'
cmdTab = [DMHelper.GET_FFMPEG_PATH(), '-y']
tmpUri = strwithmeta(url)
if 'iptv_video_rep_idx' in tmpUri.meta:
cmdTab.extend(
['-video_rep_index',
str(tmpUri.meta['iptv_video_rep_idx'])])
if 'iptv_audio_rep_idx' in tmpUri.meta:
cmdTab.extend(
['-audio_rep_index',
str(tmpUri.meta['iptv_audio_rep_idx'])])
if 'iptv_m3u8_live_start_index' in tmpUri.meta:
cmdTab.extend([
'-live_start_index',
str(tmpUri.meta['iptv_m3u8_live_start_index'])
])
if 'iptv_m3u8_key_uri_replace_old' in tmpUri.meta and 'iptv_m3u8_key_uri_replace_new' in tmpUri.meta:
cmdTab.extend([
'-key_uri_old',
str(tmpUri.meta['iptv_m3u8_key_uri_replace_old']),
'-key_uri_new',
str(tmpUri.meta['iptv_m3u8_key_uri_replace_new'])
])
if "://" in self.url:
url, httpParams = DMHelper.getDownloaderParamFromUrlWithMeta(
tmpUri, True)
headers = []
for key in httpParams:
if key == 'Range': #Range is always used by ffmpeg
continue
elif key == 'User-Agent':
cmdTab.extend(['-user-agent', httpParams[key]])
else:
headers.append('%s: %s' % (key, httpParams[key]))
if len(headers):
cmdTab.extend(['-headers', '\r\n'.join(headers)])
if self.url.startswith("merge://"):
try:
urlsKeys = self.url.split('merge://', 1)[1].split('|')
for item in urlsKeys:
cmdTab.extend(['-i', self.url.meta[item]])
except Exception:
printExc()
else:
cmdTab.extend(['-i', url])
cmdTab.extend([
'-c:v', 'copy', '-c:a', 'copy', '-f',
tmpUri.meta.get('ff_out_container', self.ffmpegOutputContener),
self.filePath
])
self.fileCmdPath = self.filePath + '.iptv.cmd'
rm(self.fileCmdPath)
WriteTextFile(self.fileCmdPath, '|'.join(cmdTab))
cmd = GetCmdwrapPath() + (' "%s" "|" %s ' %
(self.fileCmdPath, GetNice() + 2))
printDBG("FFMPEGDownloader::start cmd[%s]" % cmd)
self.console = eConsoleAppContainer()
self.console_appClosed_conn = eConnectCallback(self.console.appClosed,
self._cmdFinished)
self.console_stderrAvail_conn = eConnectCallback(
self.console.stderrAvail, self._dataAvail)
self.console.execute(cmd)
self.status = DMHelper.STS.DOWNLOADING
self.onStart()
return BaseDownloader.CODE_OK
def getLinksForVideo(self, cItem):
printDBG("YifyTV.getLinksForVideo [%s]" % cItem)
urlTab = self.cacheLinks.get(cItem['url'], [])
if len(urlTab):
return urlTab
url = cItem['url']
if not url.endswith('/'):
url += '/'
sts, data = self.getPage(url + 'watching/?playermode=')
if not sts:
return urlTab
#printDBG("+++++++++++++++++++++++ data ++++++++++++++++++++++++")
#printDBG(data)
#printDBG("+++++++++++++++++++++++++++++++++++++++++++++++++++++++")
trailer = self.cm.ph.getDataBeetwenReMarkers(
data, re.compile('''<a[^>]+?class=['"]video'''),
re.compile('''</a>'''))[1]
trailerUrl = self.cm.ph.getSearchGroups(
trailer, '''href=['"](https?://[^'^"]+?)['"]''')[0]
imdbid = self.cm.ph.getSearchGroups(
data, '''var\s+imdbid\s*=\s*['"]([^'^"]+?)['"]''')[0]
videoTable = self.cm.ph.getDataBeetwenMarkers(
data, ("<table", ">", "videos-table"), "</table>")[1]
mirrors = self.cm.ph.getAllItemsBeetwenMarkers(videoTable,
"<tr><td data-label",
"</tr>")
for mirror in mirrors:
name = self.cleanHtmlStr(
self.cm.ph.getDataBeetwenMarkers(mirror, ("<h6", ">"), "</h6>",
False)[1])
quality = self.cleanHtmlStr(
self.cm.ph.getDataBeetwenMarkers(mirror,
("<td", ">", "Quality"),
"</td>", False)[1])
if quality:
name = name + " " + quality
lang = self.cleanHtmlStr(
self.cm.ph.getDataBeetwenMarkers(mirror,
("<td", ">", "Language"),
"</td>", False)[1])
if lang:
name = name + " " + lang
subtitle = self.cleanHtmlStr(
self.cm.ph.getDataBeetwenMarkers(mirror,
("<td", ">", "Subtitle"),
"</td>", False)[1])
if len(subtitle) > 0 and (not "n/d" in subtitle.lower()):
name = name + " " + subtitle
printDBG("mirror name : %s" % name)
jscode = self.cm.ph.getDataBeetwenMarkers(mirror, ("<script", ">"),
"</script>", False)[1]
if jscode:
jscode = "var window={ eval: function(t){ console.log(t); } }; \n\n " + jscode
#printDBG("+++++++++++++++++++++++ CODE ++++++++++++++++++++++++")
#printDBG(jscode)
#printDBG("+++++++++++++++++++++++++++++++++++++++++++++++++++++++")
ret = js_execute(jscode)
if ret['sts'] and 0 == ret['code']:
action_params = self.cm.ph.getDataBeetwenMarkers(
ret['data'], "ajaxActionGet(\'", "\'",
False)[1] + "play"
ajax_url = self.AJAX_URL + action_params
printDBG("ajax url: %s" % ajax_url)
params = {
'header': self.AJAX_HEADER,
'use_cookie': True,
'load_cookie': True,
'save_cookie': True,
'cookiefile': self.COOKIE_FILE
}
params['header']['Referer'] = url
sts, ajaxData = self.cm.getPage(ajax_url, params)
if sts:
#printDBG("-------------")
#printDBG( ajaxData)
#printDBG("-------------")
try:
response = json_loads(ajaxData)
htmlcode = response["htmlcode"]
#printDBG(htmlcode)
objs = re.findall("(\{[^\}]+?\})", htmlcode)
for obj in objs:
if "linkTo" in obj:
printDBG("-------------------")
printDBG(obj)
printDBG("-------------------")
try:
videoData = json_loads(obj)
videoUrl = videoData["linkTo"]
#printDBG("mirror video url : %s" % videoUrl)
videoUrl = strwithmeta(
videoUrl, {
'Referer': cItem['url'],
'imdbid': imdbid
}
) #'external_sub_tracks':sub_tracks})
params = {
'name': name,
'url': videoUrl,
'need_resolve': 1
}
printDBG(str(params))
urlTab.append(params)
except:
printExc()
break
except:
printExc()
if len(urlTab):
self.cacheLinks[cItem['url']] = urlTab
if self.cm.isValidUrl(trailerUrl) and 1 == self.up.checkHostSupport(
trailerUrl):
if not 'listType' in trailerUrl:
params = {
'name': self.cleanHtmlStr(trailer),
'url': trailerUrl,
'need_resolve': 1
}
printDBG(str(params))
urlTab.insert(0, params)
return urlTab
def _get_automatic_captions(self, video_id, webpage=None):
sub_tracks = []
if None == webpage:
url = 'http://www.youtube.com/watch?v=%s&hl=%s&has_verified=1' % (
video_id, GetDefaultLang())
sts, data = self.cm.getPage(url)
if not sts: return sub_tracks
sts, data = self.cm.ph.getDataBeetwenMarkers(data,
';ytplayer.config =',
'};', False)
if not sts: return sub_tracks
try:
player_config = json_loads(data.strip() + '}')
args = player_config['args']
caption_url = args.get('ttsurl')
if caption_url:
timestamp = args['timestamp']
# We get the available subtitles
list_params = urllib.urlencode({
'type': 'list',
'tlangs': 1,
'asrs': 1,
})
list_url = caption_url + '&' + list_params
caption_list = self.cm.getPage(list_url)
printDBG(caption_list)
return sub_lang_list
original_lang_node = caption_list.find('track')
if original_lang_node is None:
return []
original_lang = original_lang_node.attrib['lang_code']
caption_kind = original_lang_node.attrib.get('kind', '')
sub_lang_list = {}
for lang_node in caption_list.findall('target'):
sub_lang = lang_node.attrib['lang_code']
sub_formats = []
for ext in self._SUBTITLE_FORMATS:
params = urllib.urlencode({
'lang': original_lang,
'tlang': sub_lang,
'fmt': ext,
'ts': timestamp,
'kind': caption_kind,
})
sub_formats.append({
'url': caption_url + '&' + params,
'ext': ext,
})
sub_lang_list[sub_lang] = sub_formats
return sub_lang_list
# Some videos don't provide ttsurl but rather caption_tracks and
# caption_translation_languages (e.g. 20LmZk1hakA)
caption_tracks = args['caption_tracks']
caption_translation_languages = args[
'caption_translation_languages']
caption_url = compat_parse_qs(caption_tracks.split(',')[0])['u'][0]
parsed_caption_url = urlparse(caption_url)
caption_qs = compat_parse_qs(parsed_caption_url.query)
sub_lang_list = {}
for lang in caption_translation_languages.split(','):
lang_qs = compat_parse_qs(urllib.unquote_plus(lang))
sub_lang = lang_qs.get('lc', [None])[0]
if not sub_lang: continue
caption_qs.update({
'tlang': [sub_lang],
'fmt': ['vtt'],
})
sub_url = urlunparse(
parsed_caption_url._replace(
query=urllib.urlencode(caption_qs, True)))
sub_tracks.append({
'title': lang_qs['n'][0].encode('utf-8'),
'url': sub_url,
'lang': sub_lang.encode('utf-8'),
'ytid': len(sub_tracks),
'format': 'vtt'
})
except Exception:
printExc()
return sub_tracks
###################################################
# FOREIGN import
###################################################
from Tools.BoundFunction import boundFunction
from enigma import eConsoleAppContainer
from time import sleep
import re
import datetime
try:
try:
import json
except Exception:
import simplejson as json
except Exception:
printExc()
###################################################
###################################################
# One instance of this class can be used only for
# one download
###################################################
class MergeDownloader(BaseDownloader):
def __init__(self):
printDBG('MergeDownloader.__init__ ----------------------------------')
BaseDownloader.__init__(self)
# instance of E2 console
self.console = None
self.iptv_sys = None
def getVideoLinks(self, baseUrl):
printDBG("YifyTV.getVideoLinks [%s]" % baseUrl)
# 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
urlTab = []
baseUrl = strwithmeta(baseUrl)
imdbid = baseUrl.meta.get('imdbid', '')
sub_tracks = baseUrl.meta.get('external_sub_tracks', [])
header = dict(self.AJAX_HEADER)
#header['Referer'] = baseUrl.meta['Referer']
if 'sou' in baseUrl.meta:
souTab = [baseUrl.meta['sou']]
if souTab[0] == 'pic':
souTab.append('adr')
if souTab[0] == 'adr':
souTab.append('pic')
for sou in souTab:
post_data = {'fv': '27', 'url': baseUrl, 'sou': sou}
url = 'https://ymovies.to/playerlite/pk/pk/plugins/player_p2.php'
sts, data = self.getPage(url, {'header': header}, post_data)
if not sts:
return []
printDBG(
"+++++++++++ player_p2.php javascript code +++++++++")
printDBG(data)
printDBG(
"+++++++++++++++++++++++++++++++++++++++++++++++++++++++")
if 'jscode' in data:
data = byteify(json_loads(data))[0]['jscode'][1:-1]
if 'eval(' in data:
evalCode = self.cm.ph.getSearchGroups(
data, "(eval\(.*?\));")[0]
evalCode2 = evalCode[5:-1]
evalCodeSub = "print(" + evalCode2 + ");\n" + evalCode
printDBG("eval code: %s, %s ----> %s" %
(evalCode, evalCode2, evalCodeSub))
data = data.replace(evalCode, evalCodeSub)
jsTab = ['']
jsTab.append(
'''var iptv_href="%s"; var iptv_domain="%s"; var iptv_video_id="%s"; var iptv_jwpath="%s";\n'''
% (self.getMainUrl(),
self.up.getDomain(self.getMainUrl()), imdbid, url))
jsTab.append(
base64.b64decode(
'''ZnVuY3Rpb24gU2hvd0Rpdigpe31mdW5jdGlvbiBzaG93aUZyYW1lKCl7cHJpbnQoYXJndW1lbnRzWzBdKX1mdW5jdGlvbiBnZXRKd1BhdGgoKXtyZXR1cm4gaXB0dl9qd3BhdGh9ZnVuY3Rpb24gZ2V0X3BhcmFtc19ub19zb3JjZXMoKXtyZXR1cm4gaXB0dl92aWRlb19pZH1mdW5jdGlvbiBzZXRUaW1lb3V0KHQsbil7aWYoaXB0dl9kaXJlY3QpdHJ5e3QoKX1jYXRjaChlKXtwcmludCgiXG4iKX1lbHNlIHRoaXMudHJ5dXAoKX12YXIgZG9jdW1lbnQ9e30sd2luZG93PXRoaXMsbG9jYXRpb249e307bG9jYXRpb24uaHJlZj1pcHR2X2hyZWYsbG9jYXRpb24uaG9zdG5hbWU9aXB0dl9kb21haW4sbG9jYXRpb24udG9TdHJpbmc9ZnVuY3Rpb24oKXtyZXR1cm4gaXB0dl9ocmVmfSxkb2N1bWVudC5sb2NhdGlvbj1sb2NhdGlvbjt2YXIgZWxlbWVudD1mdW5jdGlvbih0KXt0aGlzLnRleHQ9ZnVuY3Rpb24oKXtyZXR1cm4ibm9uZSJ9LHRoaXMuZmlyc3Q9ZnVuY3Rpb24oKXtyZXR1cm4gbmV3IGVsZW1lbnR9fSwkPWZ1bmN0aW9uKHQpe3JldHVybiBuZXcgZWxlbWVudCh0KX0scGxheWVybW9kZT0iIixzb3VyY2VTZWxlY3RlZD0wLHNvdXJjZXM9W3tzdWJfZGVsYXk6MCxzdWJfZmFjdG9yOjF9XTskLmdldD1mdW5jdGlvbigpe3JldHVybiBwcmludChhcmd1bWVudHNbMF0pLHtkb25lOlNob3dEaXYsZXJyb3I6U2hvd0Rpdn19LCQucG9zdD1mdW5jdGlvbigpe3ByaW50KCJcbklQVFZfUE9TVF9TVEFSVFxuIikscHJpbnQoSlNPTi5zdHJpbmdpZnkoe3VybDphcmd1bWVudHNbMF0scGFyYW1zOmFyZ3VtZW50c1sxXX0pKSxwcmludCgiXG5JUFRWX1BPU1RfRU5EXG4iKX07'''
))
jsTab.append('var iptv_fun = %s; iptv_fun();' % data)
for iptv_direct in ["false", "true"]:
jsTab[0] = 'var iptv_direct = %s;' % iptv_direct
jscode = '\n'.join(jsTab)
printDBG(
"+++++++++++++ code after replaces ++++++++++++++++++++++++"
)
printDBG(jscode)
printDBG(
"+++++++++++++++++++++++++++++++++++++++++++++++++++++++"
)
ret = js_execute(jscode)
if ret['sts']: #and 0 == ret['code']:
decoded = ret['data'].strip()
printDBG('DECODED DATA -> [%s]' % decoded)
# various forms of data answer
try_url = decoded.split('\n')[-1]
if self.cm.isValidUrl(try_url):
urlTab.extend(self.up.getVideoLinkExt(try_url))
break
elif 'parseRes2' in decoded:
printDBG("Search for ParseRes2 argument")
prData = self.cm.ph.getSearchGroups(
decoded, "parseRes2\(\"(.*?)\"\)")[0]
printDBG("ParseRes2 function argument : %s" %
prData)
#decoded2 = json_loads(prData.replace('\"','"'))
decoded2 = json_loads(eval('"' + prData + '"'))
printDBG("------------decoded2-------------")
printDBG(str(decoded2))
for l in decoded2:
if 'url' in l:
if l['url'].endswith('.m3u8'):
params = getDirectM3U8Playlist(
self.getFullUrl(l['url']),
checkExt=False,
variantCheck=True,
checkContent=True,
sortWithMaxBitrate=99999999)
printDBG(str(params))
urlTab.extend(params)
else:
if not 'image' in l.get(
'type', ''):
params = {
'name':
l.get('type', 'link'),
'url':
self.getFullUrl(l['url'])
}
printDBG(str(params))
urlTab.append(params)
break
elif 'showiFrame' in decoded:
arg = self.cm.ph.getSearchGroups(
decoded,
"showiFrame\(['\"](.*?)['\"]\)")[0]
printDBG(
"Search for showiFrame argument: %s " %
arg)
if 'emb=' in decoded:
url = urllib.unquote(
self.cm.ph.getDataBeetwenMarkers(
decoded, "emb='+'", "*", False)[1])
if not url:
url = urllib.unquote(
self.cm.ph.getDataBeetwenMarkers(
decoded, "emb='+'", "'",
False)[1])
printDBG("---> found url: %s " % url)
if 'sub.file' in url:
tmp = url.split('sub.file')
url = tmp[0]
subTrack = urllib.unquote(tmp[1])
if url.startswith('//'):
url = 'http:' + url
if subTrack.startswith('//'):
subTrack = 'http:' + subTrack
tmpUrlTab = self.up.getVideoLinkExt(
url)
if self.cm.isValidUrl(subTrack):
format = subTrack[-3:]
for idx in range(len(tmpUrlTab)):
tmpUrlTab[idx][
'url'] = strwithmeta(
tmpUrlTab[idx]['url'],
{
'external_sub_tracks':
[{
'title': '',
'url':
subTrack,
'lang': 'en',
'format':
format
}]
})
urlTab.extend(tmpUrlTab)
printDBG(urlTab)
else:
urlTab.extend(
self.up.getVideoLinkExt(url))
else:
if self.cm.isValidUrl(arg):
urlTab = self.up.getVideoLinkExt(arg)
break
elif 'sources[sourceSelected]["paramId"]' in decoded:
data = data.replace('"+"', '').replace(' ', '')
paramSite = self.cm.ph.getSearchGroups(
data,
'sources\[sourceSelected\]\["paramSite"\]="([^"]+?)"'
)[0]
data = self.cm.ph.getSearchGroups(
data,
'sources\[sourceSelected\]\["paramId"\]="([^"]+?)"'
)[0]
printDBG(
'data ------------------------- [%s]' %
data)
if data.startswith('enc'):
encrypted = base64.b64decode(data[3:])
key = unhexlify(
base64.b64decode(
'MzAzOTM4NzMzOTM3MzU0MTMxMzIzMzczMzEzMzM1NjQ2NDY2Njc3NzQ4MzczODM0MzczNTMzMzQzNjcyNjQ3Nw=='
))
iv = unhexlify(
base64.b64decode(
'NWE0MTRlMzEzNjMzNjk2NDZhNGM1MzUxMzU0YzY0MzU='
))
cipher = AES_CBC(key=key,
padding=noPadding(),
keySize=32)
data = cipher.decrypt(encrypted,
iv).split('\x00')[0]
if 'ucl' == paramSite:
params = self.up.getVideoLinkExt(
"https://userscloud.com/embed-" +
data + "-1280x534.html")
printDBG(str(params))
urlTab.extend(params)
elif 'tus' == paramSite:
params = self.up.getVideoLinkExt(
"https://tusfiles.net/embed-" +
data + "-1280x534.html?v=34")
printDBG(str(params))
urlTab.extend(params)
elif 'up' == paramSite:
params = self.up.getVideoLinkExt(
"http://uptobox.com/" + data)
printDBG(str(params))
urlTab.extend(params)
break
elif 'IPTV_POST_START' in decoded:
data = self.cm.ph.getDataBeetwenMarkers(
data, 'IPTV_POST_START', 'IPTV_POST_END',
0)[1]
try:
tmp = byteify(json_loads(data.strip()))
sts, data = self.getPage(
tmp['url'], {
'header': header,
'raw_post_data': True
}, tmp['params'])
if not sts:
return []
tmp = byteify(json_loads(data))
for hostDomain in tmp['hosts']:
params = {
'name':
hostDomain,
'url':
'http://%s%s' %
(hostDomain, tmp['path'])
}
printDBG(str(params))
urlTab.append(params)
if len(urlTab):
break
except Exception:
printExc()
else:
data = json_loads(decoded)
elif self.cm.isValidUrl(baseUrl):
urlTab = self.up.getVideoLinkExt(baseUrl)
printDBG(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
printDBG(urlTab)
for idx in range(len(urlTab)):
subs = list(
strwithmeta(urlTab[idx]['url']).meta.get(
'external_sub_tracks', []))
subs.extend(sub_tracks)
urlTab[idx]['url'] = strwithmeta(urlTab[idx]['url'],
{'external_sub_tracks': subs})
printDBG(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
printDBG(urlTab)
return urlTab
def setIcon(self):
if 0 < len(self.icon.get('icon_path', '')):
try:
self["cover"].updateIcon( self.icon['icon_path'] )
except Exception:
printExc()
def getPage(self, baseUrl, addParams={}, post_data=None):
if addParams == {}:
addParams = dict(self.defaultParams)
proxy = config.plugins.iptvplayer.yify_proxy.value
if proxy != 'None':
if proxy == 'proxy_1':
proxy = config.plugins.iptvplayer.alternative_proxy1.value
else:
proxy = config.plugins.iptvplayer.alternative_proxy2.value
addParams = dict(addParams)
addParams.update({'http_proxy': proxy})
def _getFullUrl(url):
if url == '':
return ''
if self.cm.isValidUrl(url):
return url
else:
return urlparse.urljoin(baseUrl, url)
addParams['cloudflare_params'] = {
'domain': self.up.getDomain(baseUrl),
'cookie_file': self.COOKIE_FILE,
'User-Agent': self.USER_AGENT,
'full_url_handle': _getFullUrl
}
url = baseUrl
urlParams = deepcopy(addParams)
urlData = deepcopy(post_data)
unloadUrl = None #
tries = 0
removeCookieItems = False
while tries < 20:
tries += 1
sts, data = self.cm.getPageCFProtection(url, urlParams, urlData)
if not sts:
return sts, data
if unloadUrl != None:
self.cm.getPageCFProtection(unloadUrl, urlParams)
unloadUrl = None
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']:
try:
cookies = byteify(json_loads(ret['data'].strip()))
for cookie in cookies:
cookieItems.update(cookie)
except Exception:
printExc()
self.defaultParams['cookie_items'] = cookieItems
urlParams['cookie_items'] = cookieItems
removeCookieItems = False
sts, data = self.cm.getPageCFProtection(
url, urlParams, urlData)
# remove not needed used cookie
if removeCookieItems:
self.defaultParams.pop('cookie_items', None)
self.cm.clearCookie(self.COOKIE_FILE, removeNames=['___utmvc'])
printDBG(data)
return sts, data
return self.cm.getPageCFProtection(baseUrl, addParams, post_data)
def exploreItem(self, cItem):
printDBG("HDFilmeTV.exploreItem")
params = MergeDicts(
self.defaultParams, {
'user-agent': self.USER_AGENT,
'referer': self.MAIN_URL,
"accept-encoding": "gzip",
"accept": "text/html"
})
sts, data = self.getPageCF(cItem['url'], params)
#printDBG(data)
if not sts:
return
movieId = self.cm.ph.getSearchGroups(
data, '''data-movie-id=['"]([^'^"]+?)['"]''')[0]
printDBG("movieId ------->" + movieId)
trailerUrl = ''
linksPageUrl = ''
links = re.findall(
'''<a[^>]*?class="btn btn-xemnow pull-right"[^>]*?href=['"]([^'^"]+?)['"][^>]*?>(.*?)</a>''',
data, re.S)
for l in links:
if 'Trailer' in l[1]:
trailerUrl = l[0]
elif 'STREAM' in l[1]:
linksPageUrl = l[0]
# trailer section
if trailerUrl:
if trailerUrl == "javascript:":
# find url in javascript code
printDBG(
"HDFilmeTV.exploreItem. Find trailer url in javascript code"
)
movieData = self.getMovieDatainJS(data)
if 'id' in movieData:
trailerUrl = self.getTrailerUrlinJS(data, movieData)
printDBG("trailerUrl: \"%s\" " % trailerUrl)
params['referer'] = movieData['url']
sts, trailer_data = self.getPageCF(trailerUrl, params)
if not sts:
return
#printDBG(data)
# find url in iframe
#<iframe class="film-screen-content" width="100%" height="100%" frameborder="0" allowfullscreen="" allow="autoplay" src="https://www.youtube.com/embed/JH0WldpM8Hw?autohide=1&fs=1&modestbranding=1&iv_load_policy=3&rel=0&showinfo=0&version=2&hd=0&fs=0&enablejsapi=1&playerapiid=ytplayer&autoplay=1&loop=1"></iframe>
tmp = self.cm.ph.getDataBeetwenMarkers(
trailer_data, '<iframe', '</iframe>')[1]
trailerUrl = self.cm.ph.getSearchGroups(
tmp, '''src=['"]([^'^"]+?)['"]''')[0]
params = dict(cItem)
params.update({
'good_for_fav':
False,
'title':
'%s [%s]' % (cItem['title'], _('Trailer')),
'urls': [{
'name':
'trailer',
'url':
strwithmeta(trailerUrl.replace('&', '&'),
{'trailer': 1}),
'need_resolve':
1
}]
})
self.addVideo(params)
else:
trailerUrl = self.getFullUrl(trailerUrl)
params = dict(cItem)
params.update({
'good_for_fav':
False,
'title':
'%s [%s]' % (cItem['title'], _('Trailer')),
'urls': [{
'name':
'trailer',
'url':
strwithmeta(trailerUrl.replace('&', '&'),
{'trailer': 1}),
'need_resolve':
1
}]
})
self.addVideo(params)
# find links page url
# example
#<a title="The Ranch staffel 4 Stream" class="btn btn-xemnow pull-right" style="margin-left:5px" href="https://hdfilme.cx/the-ranch-staffel-4-13803-stream/folge-1">
printDBG(
"HDFilmeTV.exploreItem. Find url of page with links - often url + '/deutsch' "
)
sts, linkspage_data = self.getPageCF(linksPageUrl, params)
if not sts:
return
#printDBG(data)
#printDBG(">>>>>>>>>>>>>>>>>>>>>>>>")
episodesTab = []
episodesLinks = {}
data = []
parts = self.cm.ph.getAllItemsBeetwenMarkers(linkspage_data,
'<section class="box">',
'</section>')
for part in parts:
data_part = self.cm.ph.getAllItemsBeetwenMarkers(
part, '<i class="fa fa-chevron-right">',
'</ul>') #'<ul class="list-inline list-film"'
if data_part:
data.extend(data_part)
for server in data:
serverName = self.cleanHtmlStr(
self.cm.ph.getDataBeetwenMarkers(server, '<i ', '</div>')[1])
serverData = ph.findall(server, '<li>', '</li>')
for link in serverData:
#printDBG("----->" + link)
episodeName = self.cleanHtmlStr(link)
episodeUrl = self.getFullUrl(
self.cm.ph.getSearchGroups(
link, '''href=['"]([^'^"]+?)['"]''')[0])
episodeId = self.cm.ph.getSearchGroups(
link, '''data-episode-id=['"]([^'^"]+?)['"]''')[0]
if not episodeUrl.startswith('http'):
continue
if episodeName not in episodesTab:
episodesTab.append(episodeName)
episodesLinks[episodeName] = []
params = {
'name':
serverName,
'url':
strwithmeta(episodeUrl.replace('&', '&'), {
'episodeId': episodeId,
'movieId': movieId
}),
'need_resolve':
1
}
#printDBG("------------->" + str(params))
episodesLinks[episodeName].append(params)
baseTitleReObj = re.compile('''staffel\s*[0-9]+?$''',
flags=re.IGNORECASE)
baseTitle = cItem['title']
season = self.cm.ph.getSearchGroups(cItem['url'],
'''staf[f]+?el-([0-9]+?)-''')[0]
if season == '':
season = self.cm.ph.getSearchGroups(baseTitle,
'''staffel\s*([0-9]+?)$''',
ignoreCase=True)[0]
if season != '':
baseTitle = baseTitleReObj.sub('', baseTitle, 1).strip()
try:
episodesTab.sort(key=lambda item: self.c_int(item))
except Exception:
printExc()
for episode in episodesTab:
title = baseTitle
if season != '':
title += ': ' + 's%se%s' % (season.zfill(2), episode.zfill(2))
elif len(episodesTab) > 1:
title += ': ' + 'e%s' % (episode.zfill(2))
params = dict(cItem)
params.update({
'good_for_fav': False,
'title': title,
'urls': episodesLinks[episode]
})
self.addVideo(params)
def listItems(self, cItem, nextCategory):
printDBG("GamatoMovies.listItems")
perPage = 18
page = cItem.get('page', 1)
baseUrl = 'titles/paginate?_token=' + self.cacheFilters[
'token'] + '&perPage={0}'.format(perPage) + '&type={0}'.format(
cItem['priv_type']
) + '&availToStream=true' + '&page={0}'.format(page)
if 'genres' in cItem:
baseUrl += '&genres%5B%5D={0}'.format(urllib.quote(
cItem['genres']))
if 'order' in cItem:
baseUrl += '&order={0}'.format(cItem['order'])
if 'year' in cItem:
baseUrl += '&after={0}-12-31'.format(cItem['year'] - 1)
baseUrl += '&before={0}-1-1'.format(cItem['year'] + 1)
if 'min_rating' in cItem:
baseUrl += '&minRating={0}'.format(cItem['min_rating'])
if 'query' in cItem:
baseUrl += '&query={0}'.format(cItem['query'])
sts, data = self.cm.getPage(self.getFullUrl(baseUrl),
{'header': self.AJAX_HEADER})
if not sts:
return
try:
data = byteify(json.loads(data))
for item in data['items']:
try:
if item['type'] == 'movie':
url = 'movies'
else:
url = item['type']
url = self.getFullUrl(url + '/' + str(item['id']))
title = '{0} ({1})'.format(self.getStr(item, 'title'),
self.getStr(item, 'year'))
desc = '{0}/10|{1}[/br]{2}'.format(
self.getStr(item, 'imdb_rating'),
self.getStr(item, 'genre'), self.getStr(item, 'plot'))
params = dict(cItem)
params.update({
'good_for_fav': True,
'title': title,
'url': url,
'priv_type': self.getStr(item, 'type'),
'priv_id': self.getStr(item, 'id'),
'icon': self.getStr(item, 'poster'),
'desc': desc
})
if item['type'] == 'movie':
self.addVideo(params)
else:
params['category'] = nextCategory
self.addDir(params)
except Exception:
printExc()
if data['totalItems'] > page * perPage:
params = dict(cItem)
params.update({'title': _('Next page'), 'page': page + 1})
self.addDir(params)
except Exception:
printExc()
def getVideoLinks(self, videoUrl):
printDBG("IceFilms.getVideoLinks [%s]" % videoUrl)
urlTab = []
# mark requested link as used one
if len(self.cacheLinks.keys()):
key = self.cacheLinks.keys()[0]
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
sourceId = videoUrl
url = strwithmeta(videoUrl).meta.get('url')
sts, data = self.getPage(url, self.defaultParams)
if not sts: return []
url = self.getFullUrl(
self.cm.ph.getSearchGroups(
data, '''<iframe[^>]+?src=['"]([^"^']+?)['"]''', 1, True)[0])
frameUrl = self.getFullUrl(url)
sts, data = self.getPage(frameUrl, self.defaultParams)
if not sts: return []
baseUrl = '/membersonly/components/com_iceplayer/video.phpAjaxResp.php?s=%s&t=%s'
secret = self.cm.ph.getSearchGroups(
data, '<input[^>]+?name="secret"[^>]+?value="([^"]+?)"')[0]
try:
match = re.search(
'lastChild\.value="([^"]+)"(?:\s*\+\s*"([^"]+))?', data)
secret = ''.join(match.groups(''))
except Exception:
printExc()
return []
captcha = self.cm.ph.getSearchGroups(
data, '<input[^>]+?name="captcha"[^>]+?value="([^"]+?)"')[0]
iqs = self.cm.ph.getSearchGroups(
data, '<input[^>]+?name="iqs"[^>]+?value="([^"]+?)"')[0]
uri = self.cm.ph.getSearchGroups(
data, '<input[^>]+?name="url"[^>]+?value="([^"]+?)"')[0]
try:
t = self.cm.ph.getSearchGroups(data, '"&t=([^"]+)')[0]
except Exception:
printExc()
return []
try:
baseS = int(
self.cm.ph.getSearchGroups(data, '(?:\s+|,)s\s*=(\d+)')[0])
except Exception:
printExc()
return []
try:
baseM = int(
self.cm.ph.getSearchGroups(data, '(?:\s+|,)m\s*=(\d+)')[0])
except Exception:
printExc()
return []
s = baseS + random.randint(3, 1000)
m = baseM + random.randint(21, 1000)
#url = self.getFullUrl(baseUrl % (sourceId, s, m, secret, t))
url = self.getFullUrl(baseUrl % (sourceId, t))
params = dict(self.defaultParams)
params['header'] = dict(params['header'])
params['header']['Referer'] = frameUrl
sts, data = self.getPage(url,
params,
post_data={
'id': sourceId,
's': s,
'iqs': iqs,
'url': uri,
'm': m,
'cap': ' ',
'sec': secret,
't': t
})
if not sts: return []
printDBG(data)
videoUrl = urllib.unquote(data.split('?url=')[-1].strip())
if self.cm.isValidUrl(videoUrl):
return self.up.getVideoLinkExt(videoUrl)
return urlTab
def __init__(self,
session,
inList,
outList,
numOfLockedItems=0,
groupName='',
groupObj=None):
printDBG(
"PlayerSelectorWidget.__init__ --------------------------------")
screenwidth = getDesktop(0).size().width()
iconSize = GetAvailableIconSize()
if len(
inList
) >= 30 and iconSize == 100 and screenwidth and screenwidth > 1100:
numOfRow = 4
numOfCol = 8
elif len(inList) > 16 and iconSize == 100:
numOfRow = 4
numOfCol = 5
elif len(inList) > 12 and iconSize == 100:
numOfRow = 4
numOfCol = 4
elif len(inList) > 9:
if screenwidth and screenwidth == 1920:
numOfRow = 4
numOfCol = 8
else:
numOfRow = 3
numOfCol = 4
elif len(inList) > 6:
numOfRow = 3
numOfCol = 3
elif len(inList) > 3:
numOfRow = 2
numOfCol = 3
else:
numOfRow = 1
numOfCol = 3
try:
confNumOfRow = int(config.plugins.iptvplayer.numOfRow.value)
confNumOfCol = int(config.plugins.iptvplayer.numOfCol.value)
# 0 - means AUTO
if confNumOfRow > 0: numOfRow = confNumOfRow
if confNumOfCol > 0: numOfCol = confNumOfCol
except Exception:
pass
# position of first img
offsetCoverX = 25
if screenwidth and screenwidth == 1920:
offsetCoverY = 100
else:
offsetCoverY = 80
# image size
coverWidth = iconSize
coverHeight = iconSize
# space/distance between images
disWidth = int(coverWidth / 3)
disHeight = int(coverHeight / 4)
# marker size should be larger than img
markerWidth = 45 + coverWidth
markerHeight = 45 + coverHeight
# position of first marker
offsetMarkerX = offsetCoverX - (markerWidth - coverWidth) / 2
offsetMarkerY = offsetCoverY - (markerHeight - coverHeight) / 2
# how to calculate position of image with indexes indxX, indxY:
#posX = offsetCoverX + (coverWidth + disWidth) * indxX
#posY = offsetCoverY + (coverHeight + disHeight) * indxY
# how to calculate position of marker for image with posX, posY
#markerPosX = posX - (markerWidth - coverWidth)/2
#markerPosY = posY - (markerHeight - coverHeight)/2
tmpX = coverWidth + disWidth
tmpY = coverHeight + disHeight
self.numOfRow = numOfRow
self.numOfCol = numOfCol
# position of first cover
self.offsetCoverX = offsetCoverX
self.offsetCoverY = offsetCoverY
# space/distance between images
self.disWidth = disWidth
self.disHeight = disHeight
# image size
self.coverWidth = coverWidth
self.coverHeight = coverHeight
# marker size should be larger than img
self.markerWidth = markerWidth
self.markerHeight = markerHeight
self.inList = list(inList)
self.currList = self.inList
self.outList = outList
self.groupName = groupName
self.groupObj = groupObj
self.numOfLockedItems = numOfLockedItems
self.IconsSize = iconSize #do ladowania ikon
self.MarkerSize = self.IconsSize + 45
self.lastSelection = PlayerSelectorWidget.LAST_SELECTION.get(
self.groupName, 0)
self.calcDisplayVariables()
# pagination
self.pageItemSize = 16
self.pageItemStartX = (offsetCoverX + tmpX * numOfCol + offsetCoverX -
disWidth -
self.numOfPages * self.pageItemSize) / 2
if screenwidth and screenwidth == 1920:
self.pageItemStartY = 60
else:
self.pageItemStartY = 40
if screenwidth and screenwidth == 1920:
skin = """
<screen name="IPTVPlayerPlayerSelectorWidget" position="center,center" title="E2iPlayer %s" size="%d,%d">
<widget name="statustext" position="0,0" zPosition="1" size="%d,50" font="Regular;36" halign="center" valign="center" transparent="1"/>
<widget name="marker" zPosition="2" position="%d,%d" size="%d,%d" transparent="1" alphatest="blend" />
<widget name="page_marker" zPosition="3" position="%d,%d" size="%d,%d" transparent="1" alphatest="blend" />
<widget name="menu" zPosition="3" position="%d,10" size="70,30" transparent="1" alphatest="blend" />
""" % (
GetIPTVPlayerVerstion(),
offsetCoverX + tmpX * numOfCol + offsetCoverX -
disWidth, # width of window
offsetCoverY + tmpY * numOfRow + offsetCoverX -
disHeight, # height of window
offsetCoverX + tmpX * numOfCol + offsetCoverX -
disWidth, # width of status line
offsetMarkerX,
offsetMarkerY, # first marker position
markerWidth,
markerHeight, # marker size
self.pageItemStartX,
self.pageItemStartY, # pagination marker
self.pageItemSize,
self.pageItemSize,
offsetCoverX + tmpX * numOfCol + offsetCoverX - disWidth - 70,
)
else:
skin = """
<screen name="IPTVPlayerPlayerSelectorWidget" position="center,center" title="E2iPlayer %s" size="%d,%d">
<widget name="statustext" position="0,0" zPosition="1" size="%d,50" font="Regular;26" halign="center" valign="center" transparent="1"/>
<widget name="marker" zPosition="2" position="%d,%d" size="%d,%d" transparent="1" alphatest="blend" />
<widget name="page_marker" zPosition="3" position="%d,%d" size="%d,%d" transparent="1" alphatest="blend" />
<widget name="menu" zPosition="3" position="%d,10" size="70,30" transparent="1" alphatest="blend" />
""" % (
GetIPTVPlayerVerstion(),
offsetCoverX + tmpX * numOfCol + offsetCoverX -
disWidth, # width of window
offsetCoverY + tmpY * numOfRow + offsetCoverX -
disHeight, # height of window
offsetCoverX + tmpX * numOfCol + offsetCoverX -
disWidth, # width of status line
offsetMarkerX,
offsetMarkerY, # first marker position
markerWidth,
markerHeight, # marker size
self.pageItemStartX,
self.pageItemStartY, # pagination marker
self.pageItemSize,
self.pageItemSize,
offsetCoverX + tmpX * numOfCol + offsetCoverX - disWidth - 70,
)
for y in range(1, numOfRow + 1):
for x in range(1, numOfCol + 1):
skinCoverLine = """<widget name="cover_%s%s" zPosition="4" position="%d,%d" size="%d,%d" transparent="1" alphatest="blend" />""" % (
x,
y,
(offsetCoverX + tmpX * (x - 1)), # pos X image
(offsetCoverY + tmpY * (y - 1)), # pos Y image
coverWidth,
coverHeight)
skin += '\n' + skinCoverLine
# add pagination items
for pageItemOffset in range(self.numOfPages):
pageItemX = self.pageItemStartX + pageItemOffset * self.pageItemSize
skinCoverLine = """<ePixmap zPosition="2" position="%d,%d" size="%d,%d" pixmap="%s" transparent="1" alphatest="blend" />""" % (
pageItemX, self.pageItemStartY, self.pageItemSize,
self.pageItemSize, GetIconDir('radio_button_off.png'))
skin += '\n' + skinCoverLine
skin += '</screen>'
self.skin = skin
self.session = session
Screen.__init__(self, session)
self.session.nav.event.append(self.__event)
self.onClose.append(self.__onClose)
# Create TSLedia icons
try:
import Image
for idx in range(0, self.numOfItems):
path = GetIconDir('PlayerSelector/' + self.currList[idx][1] +
'%i.png' % self.IconsSize)
if self.currList[idx][1].startswith('TSM_'):
printDBG('path=' + path)
if not os.path.exists(path):
try:
if self.IconsSize == 135:
size_ = 80
pos_x = 51
pos_y = 6
elif self.IconsSize == 120:
size_ = 69
pos_x = 45
pos_y = 5
else:
size_ = 58
pos_x = 38
pos_y = 5
background = Image.open(
"/usr/lib/enigma2/python/Plugins/Extensions/IPTVPlayer/icons/PlayerSelector/tsmedia_back%i.png"
% self.IconsSize)
section, plugin_id = self.currList[idx][1].replace(
'TSM_', '').split('__', 1)
icon = '/usr/lib/enigma2/python/Plugins/Extensions/TSmedia/addons/' + section + '/' + plugin_id + '/icon.png'
foreground = Image.open(icon)
foreground = foreground.convert('RGBA')
foreground = foreground.resize((size_, size_),
Image.ANTIALIAS)
background.paste(foreground, (pos_x, pos_y),
foreground)
background.save(path)
except Exception, e:
printDBG('problem convert' +
self.currList[idx][1] + ' ' + str(e))
except Exception:
printExc()
# Load Icons
self.pixmapList = []
for idx in range(0, self.numOfItems):
path = GetIconDir('PlayerSelector/' + self.currList[idx][1] +
'%i.png' % self.IconsSize)
if self.currList[idx][1].startswith('TS_'):
if not os.path.exists(path):
path = GetIconDir('PlayerSelector/' + 'TS_no' +
'%i.png' % self.IconsSize)
elif self.currList[idx][1].startswith('TSM_'):
if not os.path.exists(path):
path = GetIconDir('PlayerSelector/' + 'TSM_no' +
'%i.png' % self.IconsSize)
self.pixmapList.append(LoadPixmap(path))
self.markerPixmap = LoadPixmap(
GetIconDir('PlayerSelector/marker%i.png' % self.MarkerSize))
self.markerPixmapSel = LoadPixmap(
GetIconDir('PlayerSelector/markerSel%i.png' % self.MarkerSize))
self.pageMarkerPixmap = LoadPixmap(GetIconDir('radio_button_on.png'))
self.menuPixmap = LoadPixmap(GetIconDir('menu.png'))
self["actions"] = ActionMap(
[
"WizardActions", "DirectionActions", "ColorActions",
"IPTVPlayerListActions"
], {
"ok": self.ok_pressed,
"back": self.back_pressed,
"left": self.keyLeft,
"right": self.keyRight,
"up": self.keyUp,
"down": self.keyDown,
"blue": self.keyBlue,
"menu": self.keyMenu,
}, -1)
self["marker"] = Cover3()
self["page_marker"] = Cover3()
self["menu"] = Cover3()
for y in range(1, self.numOfRow + 1):
for x in range(1, self.numOfCol + 1):
strIndex = "cover_%s%s" % (x, y)
self[strIndex] = Cover3()
self["statustext"] = Label(self.currList[0][0])
self.onLayoutFinish.append(self.onStart)
self.visible = True
self.reorderingMode = False
self.reorderingItemSelected = False
def handleService(self, index, refresh=0, searchPattern='', searchType=''):
printDBG('cda.handleService start')
CBaseHostClass.handleService(self, index, refresh, searchPattern,
searchType)
self.tryTologin()
name = self.currItem.get("name", None)
category = self.currItem.get("category", '')
printDBG("cda.handleService: ---------> name[%s], category[%s] " %
(name, category))
searchPattern = self.currItem.get("search_pattern", searchPattern)
self.currList = []
if None == name:
self.listsTab(self.MAIN_TAB, {'name': 'category'})
elif 'premium' == category:
idx = self.currItem.get('f_idx', 0)
if idx == 0:
self.fillFilters({
'name': 'category',
'url': self.getFullUrl('premium')
})
if idx < len(self.filtersTab):
self.listFilter(self.currItem, self.filtersTab)
else:
self.listPremiumItems(self.currItem)
elif 'video' == category:
self.listsTab(self.VIDEO_TAB, self.currItem)
elif 'categories' == category:
self.listsTab(self.CATEGORIES_TAB, self.currItem)
elif 'category' == category:
self.listCategory(self.currItem)
# CHANNELS
elif 'channels_cats' == category:
self.listChannelsCategories(self.currItem, 'list_channels')
elif 'list_channels' == category:
self.listChannels(self.currItem, 'list_folders')
elif 'list_folders' == category:
self.listFolders(self.currItem, 'list_folder_sort')
elif 'list_folder_sort' == category:
self.listFolderSort(self.currItem, 'list_folder_items')
elif 'list_folder_items' == category:
self.listFolderItems(self.currItem)
#SEARCH
elif category == "search":
cItem = dict(self.currItem)
cItem.update({'search_item': False, 'name': 'category'})
self.listSearchResult(cItem, searchPattern, searchType)
elif 'search_next_page' == category:
self.listItems(self.currItem, search=True)
#HISTORIA SEARCH
elif category == "search_history":
self.listsHistory({
'name': 'history',
'category': 'search'
}, 'desc', _("Type: "))
else:
printExc()
CBaseHostClass.endHandleService(self, index, refresh)
def getVideoLinks(self, videoUrl):
printDBG("KissCartoonMe.getVideoLinks [%s]" % videoUrl)
urlTab = []
referer = strwithmeta(videoUrl).meta.get('Referer', videoUrl)
params = dict(self.defaultParams)
params['header'] = dict(params['header'])
params['header']['Referer'] = referer
sts, data = self.getPage(videoUrl, params)
videoUrl = self.cm.meta.get('url', videoUrl)
if 'kisscartoon' not in self.up.getDomain(videoUrl):
return self.up.getVideoLinkExt(videoUrl)
if not sts:
return urlTab
try:
data = byteify(json.loads(data))
printDBG(data)
for item in data['playlist'][0].get('sources', []):
if 'mp4' not in item['type']:
continue
url = item['file']
name = item['label']
urlTab.append({'name': name, 'url': url, 'need_resolve': 0})
for item in data['playlist']:
url = item.get('file', '')
type = url.split('?', 1)[0].rsplit('.', 1)[-1].lower()
if self.cm.isValidUrl(url):
if type == 'mp4':
name = item.get('label', 'mp4')
urlTab.append({
'name': name,
'url': url,
'need_resolve': 0
})
else:
urlTab.extend(
getDirectM3U8Playlist(url, checkContent=True))
except Exception:
printExc()
if 0 < len(urlTab):
max_bitrate = int(
config.plugins.iptvplayer.kisscartoon_defaultformat.value)
def __getLinkQuality(itemLink):
try:
return int(
self.cm.ph.getSearchGroups(
'|' + itemLink['name'] + '|',
'[^0-9]([0-9]+?)[^0-9]')[0])
except Exception:
return 0
urlTab = CSelOneLink(urlTab, __getLinkQuality,
max_bitrate).getBestSortedList()
return urlTab
