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