def listItems(self, cItem, nextCategory):
printDBG("HD1080Online.listItems")
page = cItem.get('page', 1)
sts, data = self.getPage(cItem['url'])
if not sts: return
self.setMainUrl(self.cm.meta['url'])
nextPage = ph.find(data, ('<span', '>', 'pnext'), '</span>',
flags=0)[1]
nextPage = self.getFullUrl(ph.search(nextPage, ph.A)[1])
data = ph.find(data, ('<div', '>', 'dle-content'), ('<aside', '>'))[1]
data = ph.rfindall(data, '</div>', ('<div', '>', 'kino-item'))
if data and nextPage:
data[-1] = ph.find(data[-1], '<div', ('<div', '>', 'pagi-nav'))[1]
for item in data:
url = self.getFullUrl(ph.search(item, ph.A)[1])
icon = self.getFullIconUrl(ph.search(item, ph.IMG)[1])
title = self.cleanHtmlStr(
ph.find(item, ('<div', '>', 'title'), '</div>', flags=0)[1])
desc = []
tmp = ph.find(item, ('<ul', '>', 'lines'), '<ul', flags=0)[1]
tmp = ph.findall(tmp, ('<li', '>'), '</li>', flags=0)
for t in tmp:
t = ph.clean_html(t)
if t: desc.append(t)
# rating
desc.append(
ph.clean_html(
ph.rfind(item, ('<div', '>', 'ratig-layer'), ('<b', '>'),
flags=0)[1]))
t = ph.clean_html(
ph.find(item, ('<li', '>', 'current-rating'), '</li>',
flags=0)[1])
if t.isdigit(): desc[-1] += ' %s/10' % str(int(t) / 10.0)
desc.append(
ph.clean_html(
ph.find(item, ('<div', '>', 'desc'), '</div>',
flags=0)[1]))
self.addDir(
MergeDicts(
cItem, {
'good_for_fav': True,
'category': nextCategory,
'title': title,
'url': url,
'icon': icon,
'desc': '[/br]'.join(desc)
}))
if nextPage:
self.addDir(
MergeDicts(
cItem, {
'good_for_fav': False,
'title': _('Next page'),
'url': nextPage,
'page': page + 1
}))
def getDefaultParams(self, forAjax=False):
header = self.AJAX_HEADER if forAjax else self.HTTP_HEADER
return MergeDicts(self.defaultParams, {'header':header})
def exploreItem(self, cItem):
desc = ''
try:
if len(cItem) > 0:
tumd = cItem['md']
sts, data = self.cm.getPage(cItem['url'], self.defaultParams)
if not sts: return
if len(data) == 0: return
tmp_kat = self.cm.ph.getDataBeetwenMarkers(
data, '<h4 id="b">Kategória:</h4>', '</div>')[1]
if tmp_kat != '':
kat = self.cleanHtmlStr(tmp_kat)
tmp_kev = self.cm.ph.getDataBeetwenMarkers(
data, '<h4 id="b">Kiadás éve:</h4>', '</a>')[1]
if tmp_kev != '':
kev = self.cleanHtmlStr(tmp_kev)
nyelv = cItem["nylv"]
imdb = self.cm.ph.getDataBeetwenMarkers(
data, "itemprop='ratingValue'>", '</span>', False)[1]
if imdb == 'N/A':
imdb = ' '
leiras = self.cm.ph.getDataBeetwenMarkers(
data, "itemprop='description'>", '</p>', False)[1]
if leiras != '':
leiras = re.sub(r'^(.{600}).*$', '\g<1>...',
leiras.replace('\n', '').strip())
if nyelv != '':
desc = nyelv + '\n'
if kev != '':
desc = desc + kev
if kat != '':
desc = desc + ' | ' + kat
if imdb != '':
desc = desc + ' | IMDB pont: ' + imdb
else:
if kat != '':
desc = desc + kat
if imdb != '':
desc = desc + ' | IMDB pont: ' + imdb
if desc != '':
desc = desc + '\n\n' + leiras
else:
desc = leiras
if tumd == 'series':
temp_s = self.cm.ph.getDataBeetwenMarkers(
data, '<div class="blog-pagenat-wthree">', '</div>')[1]
if temp_s != '':
data_s = self.cm.ph.getAllItemsBeetwenMarkers(
temp_s, '<li>', '</li>')
if len(data_s) > 0:
for item_s in data_s:
epizod = self.cleanHtmlStr(item_s)
epizod_u = self.getFullUrl(
self.cm.ph.getSearchGroups(
item_s,
'''href=['"]([^"^']+?)['"]''')[0])
if not self.cm.isValidUrl(epizod_u): continue
params = MergeDicts(
cItem, {
'good_for_fav':
True,
'title':
cItem['title'] + ' :: ' + epizod +
'. epizód',
'url':
epizod_u,
'desc':
desc,
'icon':
cItem['icon']
})
self.addVideo(params)
else:
params = MergeDicts(
cItem, {
'good_for_fav': True,
'title': cItem['title'],
'url': cItem['url'],
'desc': desc,
'icon': cItem['icon']
})
self.addVideo(params)
except Exception:
return
def getList(self, cItem):
printDBG("InternetowaApi.getChannelsList")
self.tryTologin()
channelsTab = []
if cItem.get('priv_cat') == None:
sts, data = self.cm.getPage(self.getMainUrl(), self.http_params)
if not sts: return []
sectionsTitles = {}
tmp = self.cm.ph.getDataBeetwenNodes(
data, ('<select', '>', 'switchView'), ('</select', '>'),
False)[1]
tmp = self.cm.ph.getAllItemsBeetwenMarkers(tmp, '<option',
'</option>')
for item in tmp:
marker = self.cm.ph.getSearchGroups(
item, '''value=['"]([^"^']+?)['"]''')[0]
sectionsTitles[marker] = self.cleanHtmlStr(item)
data = self.cm.ph.getDataBeetwenNodes(
data, ('<div', '>', 'channelbiggrid'), ('<style', '>'))[1]
data = self.cm.ph.rgetAllItemsBeetwenNodes(
data, ('</div', '>'), ('<div', '>', 'channelbiggrid'))
for section in data:
tmp = self.cm.ph.getSearchGroups(
section, '''<div[^>]+?id=['"]([^'^"]+?)home['"]''')[0]
sTitle = sectionsTitles.get(tmp, tmp.upper())
subItems = []
section = section.split('</h2>')
for idx in range(1, len(section), 2):
sTitle2 = self.cleanHtmlStr(section[idx - 1])
subItems2 = []
subSections = self.cm.ph.getAllItemsBeetwenMarkers(
section[idx], '<a', '</a>')
for item in subSections:
url = self.getFullIconUrl(
self.cm.ph.getSearchGroups(
item, '''href=['"]([^'^"]+?)['"]''')[0])
if not self.cm.isValidUrl(url): continue
title = self.cleanHtmlStr(item)
if title == '':
title = self.cleanHtmlStr(
self.cm.ph.getSearchGroups(
item, '''title=['"]([^'^"]+?)['"]''')[0])
icon = self.getFullUrl(
self.cm.ph.getSearchGroups(
item, '''src=['"]([^"^']+?)['"]''')[0])
type = title.lower()
type = 'audio' if 'radio' in type or 'rmf ' in type else 'video'
subItems2.append(
MergeDicts(
cItem, {
'type': type,
'title': title,
'url': url,
'icon': icon
}))
if len(subItems2):
subItems.append(
MergeDicts(
cItem, {
'priv_cat': 'sub_items',
'title': sTitle2,
'sub_items': subItems2
}))
if len(subItems) == 1:
channelsTab.append(subItems[0])
elif len(subItems):
channelsTab.append(
MergeDicts(
cItem, {
'priv_cat': 'sub_items',
'title': sTitle,
'sub_items': subItems
}))
else:
channelsTab = cItem['sub_items']
return channelsTab
def exploreItem(self, cItem, nextCategory):
printDBG("Cinemaxx.exploreItem")
self.cacheLinks = {}
sts, data = self.getPage(cItem['url'])
if not sts:
return
cUrl = self.cm.meta['url']
self.setMainUrl(cUrl)
desc = []
descObj = self.getArticleContent(cItem, data)[0]
icon = descObj['images'][0]['url']
baseTitle = descObj['title']
for item in descObj['other_info']['custom_items_list']:
desc.append(item[1])
desc = ' | '.join(desc) + '[/br]' + descObj['text']
data = ph.find(data, ('<div', '>', 'dle-content'), ('<div', '>', 'fstory-info'), flags=0)[1]
trailer = ph.find(data, ('<', '>', '#trailer'), '</div>', flags=0)[1]
title = self.cleanHtmlStr(trailer)
trailer = self.getFullUrl(ph.search(trailer, ph.IFRAME_SRC_URI_RE)[1])
if trailer:
self.addVideo({'good_for_fav': True, 'prev_url': cUrl, 'title': '%s %s' % (title, baseTitle), 'url': trailer, 'icon': icon, 'desc': desc})
data = ph.find(data, ('<div', '>', 'full-video'), '</div>', flags=0)[1]
url = self.getFullUrl(ph.search(data, ph.IFRAME_SRC_URI_RE)[1])
if url:
if ('/video/' in url and '/serials/' in url) or 'playlist' in url:
url = strwithmeta(url, {'Referer': cUrl})
seasons = self.hdgocc.getSeasonsList(url)
for item in seasons:
self.addDir(MergeDicts(cItem, {'good_for_fav': False, 'prev_url': cUrl, 'category': nextCategory, 'serie_title': baseTitle, 'title': 'Staffel %s' % item['title'], 'season_id': item['id'], 'url': item['url'], 'icon': icon, 'desc': desc}))
if 0 != len(seasons):
return
seasonUrl = url
episodes = self.hdgocc.getEpiodesList(seasonUrl, -1)
for item in episodes:
title = '{0} - {1} - s01e{2} '.format(baseTitle, item['title'], str(item['id']).zfill(2))
self.addVideo({'good_for_fav': False, 'type': 'video', 'prev_url': cUrl, 'title': title, 'url': item['url'], 'icon': icon, 'desc': desc})
if 0 != len(episodes):
return
self.addVideo({'good_for_fav': False, 'prev_url': cUrl, 'title': baseTitle, 'url': url, 'icon': icon, 'desc': desc})
else:
data = ph.find(data, 'vk.show(', ');', flags=0)[1].split(',', 1)[-1]
ret = js_execute('print(JSON.stringify(%s));' % data)
if ret['sts'] and 0 == ret['code']:
try:
data = json_loads(ret['data'])
for sNum, season in enumerate(data, 1):
subItems = []
for eNum, episode in enumerate(season, 1):
title = baseTitle + ' s%se%s' % (str(sNum).zfill(2), str(eNum).zfill(2))
subItems.append({'good_for_fav': False, 'type': 'video', 'prev_url': cUrl, 'title': title, 'url': episode, 'icon': icon, 'desc': desc})
if subItems:
self.addDir(MergeDicts(cItem, {'good_for_fav': False, 'prev_url': cUrl, 'title': 'Staffel %s' % (str(sNum).zfill(2)), 'category': 'sub_items', 'sub_items': subItems}))
except Exception:
printExc()
def listEpisodes2(self, cItem):
printDBG("HDFull.listEpisodes [%s]" % cItem)
ITEMS = 24
baseIconUrl = '/tthumb/220x124/'
lang = config.plugins.iptvplayer.hdfull_language.value
page = cItem.get('page', 0)
baseEpisodeUrl = '/show/%s/season-%s/episode-%s' if lang == 'en' else '/serie/%s/temporada-%s/episodio-%s'
post_data = {
'action': cItem['f_action'],
'start': page * ITEMS,
'limit': ITEMS
}
if 'f_show' in cItem:
post_data['show'] = cItem['f_show']
if 'f_season' in cItem:
post_data['season'] = cItem['f_season']
if 'f_elang' in cItem:
post_data['elang'] = cItem['f_elang'].upper()
params = dict(self.defaultParams)
params['header'] = MergeDicts(
params['header'], {
'Referer': cItem['url'],
'Content-Type':
'application/x-www-form-urlencoded; charset=UTF-8'
})
sts, data = self.getPage(self.getFullUrl('/a/episodes'), params,
post_data)
if not sts:
return
try:
data = json_loads(data)
for item in data:
sNum = jstr(item, 'season')
eNum = jstr(item, 'episode')
icon = self.getFullIconUrl(baseIconUrl +
jstr(item, 'thumbnail'))
title = '%s - s%se%s %s' % (jstr(
item['show']['title'], lang), sNum.zfill(2), eNum.zfill(2),
jstr(item['title'], lang))
desc = jstr(item, 'date_aired') + ' | ' + (', '.join(
item.get('languages', [])))
url = self.getFullUrl(baseEpisodeUrl %
(jstr(item, 'permalink'), sNum, eNum))
self.addVideo({
'good_for_fav': True,
'title': title,
'url': url,
'icon': icon,
'desc': desc
})
except Exception:
printExc()
if len(self.currList) == ITEMS:
self.addDir(
MergeDicts(cItem, {
'title': _('Next page'),
'page': page + 1
}))
def listMainMenu(self, cItem):
printDBG("GuardaSerieClick.listMainMenu")
params = MergeDicts(
self.defaultParams, {
'user-agent': self.USER_AGENT,
'referer': self.MAIN_URL,
"accept-encoding": "gzip",
"accept": "text/html"
})
sts, data = self.getPageCF(self.getMainUrl(), params)
if not sts: return
self.setMainUrl(self.cm.meta['url'])
#item = self.cm.ph.getDataBeetwenNodes(data, ('<a', '>', 'lista-serie'), ('</a', '>'))[1]
#title = self.cleanHtmlStr(item)
#url = self.getFullUrl(self.cm.ph.getSearchGroups(item, '''href=['"]([^"^']+?)['"]''')[0])
params = dict(cItem)
#params.update({'name':'category', 'category':'sections', 'title':title, 'url':url})
params.update({
'name': 'category',
'category': 'sections',
'title': 'LISTA SERIE',
'url': self.getFullUrl('/lista-serie-tv')
})
self.addDir(params)
data = self.cm.ph.getDataBeetwenNodes(data, ('<a', '>', 'dropdown'),
('</ul', '>'))[1].split(
'<ul', 1)
sTitle = self.cleanHtmlStr(data[0])
subtItems = []
data = self.cm.ph.getAllItemsBeetwenMarkers(data[-1], '<a', '</a>')
for item in data:
url = self.getFullUrl(
self.cm.ph.getSearchGroups(item,
'''href=['"]([^"^']+?)['"]''')[0])
title = self.cleanHtmlStr(item)
params = dict(cItem)
params.update({
'name': 'category',
'category': 'list_items',
'title': title,
'url': url
})
subtItems.append(params)
params = dict(cItem)
params.update({
'name': 'category',
'category': 'sub_items',
'sub_items': subtItems,
'title': sTitle
})
self.addDir(params)
MAIN_CAT_TAB = [{
'category': 'search',
'title': _('Search'),
'search_item': True
}, {
'category': 'search_history',
'title': _('Search history')
}]
self.listsTab(MAIN_CAT_TAB, cItem)
def listMain(self, cItem, nextCategory):
printDBG("KKisteAG.listMain")
self.cacheFilters = {}
sts, data = self.getPage(self.getFullUrl('/featured'))
if not sts:
return
data = re.sub("<!--[\s\S]*?-->", "", data)
if 'myFilter()' in data:
tmp = ph.find(data, ('<ul', '>', 'menu-main-menu'),
'</div>',
flags=0)[1]
tmp = re.compile('</?ul[^>]*?>').split(tmp)
sTitle = ''
url = ''
for section in tmp:
subItems = []
section = ph.findall(section, ('<a', '>'),
'</a>',
flags=ph.START_S)
for idx in range(1, len(section), 2):
url = ph.search(section[idx - 1], ph.A)[1]
title = ph.clean_html(section[idx])
if url == '#':
continue
else:
subItems.append(
MergeDicts(
cItem, {
'category': nextCategory,
'title': title,
'url': self.getFullUrl(url)
}))
if subItems and sTitle:
self.addDir(
MergeDicts(
cItem, {
'category': 'sub_items',
'title': sTitle,
'sub_items': subItems
}))
sTitle = ''
else:
self.currList.extend(subItems)
if url == '#':
sTitle = title
# filter
filtersMap = {
'Sortieren nach': 'order_by',
'Auflösung': 'res',
'Yahr': 'year',
'Genres': 'genre'
}
tmp = ph.find(data, ('<div', '>', 'tag_cloud'),
('<div', '>', 'loop-'),
flags=0)[1]
tmp = ph.rfindall(tmp, '</div>', ('<h3', '</h3>'), flags=ph.END_S)
for idx in range(1, len(tmp), 2):
sTitle = ph.clean_html(tmp[idx - 1])
key = filtersMap.get(sTitle, '')
if not key:
continue
self.cacheFilters[key] = []
filters = []
items = ph.findall(tmp[idx], ('<a', '>'),
'</a>',
flags=ph.START_S)
for i in range(1, len(items), 2):
value = ph.search(ph.getattr(items[i - 1], 'href'),
'%s=([^&]+)' % key)[0]
self.cacheFilters[key].append({
'f_%s' % key:
value,
'title':
ph.clean_html(items[i])
})
if self.cacheFilters[key]:
self.cacheFilters[key].insert(0, {'title': _('All')})
self.cacheFiltersKeys.append(key)
if len(self.cacheFiltersKeys):
self.addDir(
MergeDicts(cItem, {
'category': 'list_filters',
'title': 'FILTER',
'f_idx': 0
}))
else:
pass
# ToDo
MAIN_CAT_TAB = [{
'category': 'search',
'title': _('Search'),
'search_item': True
}, {
'category': 'search_history',
'title': _('Search history'),
}]
self.listsTab(MAIN_CAT_TAB, cItem)
def handleSection(self, cItem, nextCategory, section):
printDBG("Redbull.handleSection")
section = ph.STRIP_HTML_COMMENT_RE.sub("", section)
tmp = section.split('</table>', 1)
sTitle = self.cleanHtmlStr(tmp[0])
if sTitle.lower() in ('linki', ): #'kategorie'
return
sIcon = self.getFullUrl(ph.search(section, ph.IMAGE_SRC_URI_RE)[1])
subItems = []
uniques = set()
iframes = ph.findall(section, '<center>', '</iframe>')
if iframes:
for iframe in iframes:
title = self.cleanHtmlStr(iframe).split('Video Platform',
1)[0].strip()
iframe = ph.search(iframe, ph.IFRAME_SRC_URI_RE)[1]
if iframe in uniques:
continue
uniques.add(iframe)
if not title: title = sTitle
subItems.append(
MergeDicts(cItem, {
'category': nextCategory,
'title': title,
'url': iframe
}))
iframes = ph.IFRAME_SRC_URI_RE.findall(section)
if iframes:
for iframe in iframes:
iframe = iframe[1]
if iframe in uniques:
continue
uniques.add(iframe)
subItems.append(
MergeDicts(cItem, {
'category': nextCategory,
'title': sTitle,
'url': iframe
}))
section = ph.findall(
section,
('<a', '>', ph.check(ph.any,
('articles.php', 'readarticle.php'))), '</a>')
for item in section:
url = self.getFullUrl(ph.search(item, ph.A_HREF_URI_RE)[1])
icon = self.getFullUrl(ph.search(item, self.reImgObj)[1])
title = self.cleanHtmlStr(item)
if not title:
title = icon.rsplit('/', 1)[-1].rsplit('.', 1)[0]
#title = self.titlesMap.get(title, title.upper())
subItems.append(
MergeDicts(
cItem, {
'good_for_fav': True,
'category': nextCategory,
'title': title,
'url': url,
'icon': icon
}))
if len(subItems) > 1:
self.addDir(
MergeDicts(
cItem, {
'category': 'sub_items',
'title': sTitle,
'icon': sIcon,
'sub_items': subItems
}))
elif len(subItems) == 1:
params = subItems[0]
params.update({'title': sTitle})
self.addDir(params)
def tryTologin(self):
printDBG('tryTologin start')
if None == self.loggedIn or self.login != config.plugins.iptvplayer.dixmax_login.value or\
self.password != config.plugins.iptvplayer.dixmax_password.value:
loginCookie = GetCookieDir('dixmax.com.login')
self.login = config.plugins.iptvplayer.dixmax_login.value
self.password = config.plugins.iptvplayer.dixmax_password.value
sts, data = self.getPage(self.getMainUrl())
if sts: self.setMainUrl(self.cm.meta['url'])
freshSession = False
if sts and 'logout.php' in data:
printDBG("Check hash")
hash = hexlify(md5('%s@***@%s' % (self.login, self.password)).digest())
prevHash = ReadTextFile(loginCookie)[1].strip()
printDBG("$hash[%s] $prevHash[%s]" % (hash, prevHash))
if hash == prevHash:
self.loggedIn = True
return
else:
freshSession = True
rm(loginCookie)
rm(self.COOKIE_FILE)
if freshSession:
sts, data = self.getPage(self.getMainUrl(), MergeDicts(self.defaultParams, {'use_new_session':True}))
self.loggedIn = False
if '' == self.login.strip() or '' == self.password.strip():
msg = _('The host %s requires registration. \nPlease fill your login and password in the host configuration. Available under blue button.' % self.getMainUrl())
self.sessionEx.waitForFinishOpen(MessageBox, msg, type=MessageBox.TYPE_INFO, timeout = 10)
return False
msgTab = [_('Login failed.')]
if sts:
actionUrl = self.getFullUrl('/session.php?action=1')
post_data = {'username':self.login, 'password':self.password, 'remember':'1'}
httpParams = dict(self.defaultParams)
httpParams['header'] = MergeDicts(httpParams['header'], {'Referer':self.cm.meta['url'], 'Accept':'*/*'})
sts, data = self.getPage(actionUrl, httpParams, post_data)
printDBG(data)
if sts: msgTab.append(self.cleanHtmlStr(data))
sts, data = self.getPage(self.getMainUrl())
if sts and 'logout.php' in data:
printDBG('tryTologin OK')
self.loggedIn = True
else:
printDBG(data)
self.sessionEx.waitForFinishOpen(MessageBox, '\n'.join(msgTab), type = MessageBox.TYPE_ERROR, timeout = 10)
printDBG('tryTologin failed')
if self.loggedIn:
hash = hexlify(md5('%s@***@%s' % (self.login, self.password)).digest())
WriteTextFile(loginCookie, hash)
return self.loggedIn
def tryTologin(self):
printDBG('tryTologin start')
self.selectDomain()
if None == self.loggedIn or self.login != config.plugins.iptvplayer.filmixco_login.value or\
self.password != config.plugins.iptvplayer.filmixco_password.value:
loginCookie = GetCookieDir('filmix.co.login')
self.login = config.plugins.iptvplayer.filmixco_login.value
self.password = config.plugins.iptvplayer.filmixco_password.value
sts, data = self.getPage(self.getMainUrl())
if sts: self.setMainUrl(self.cm.meta['url'])
freshSession = False
if sts and 'action=logout' in data:
printDBG("Check hash")
hash = hexlify(
md5('%s@***@%s' % (self.login, self.password)).digest())
prevHash = ReadTextFile(loginCookie)[1].strip()
printDBG("$hash[%s] $prevHash[%s]" % (hash, prevHash))
if hash == prevHash:
self.loggedIn = True
return
else:
freshSession = True
rm(loginCookie)
rm(self.COOKIE_FILE)
if freshSession:
sts, data = self.getPage(
self.getMainUrl(),
MergeDicts(self.defaultParams, {'use_new_session': True}))
self.loggedIn = False
if '' == self.login.strip() or '' == self.password.strip():
return False
msgTab = [_('Login failed.')]
if sts:
actionUrl = self.getFullUrl('/engine/ajax/user_auth.php')
post_data = {
'login_name': self.login,
'login_password': self.password,
'login_not_save': '1',
'login': '******'
}
httpParams = dict(self.defaultParams)
httpParams['header'] = MergeDicts(
httpParams['header'], {
'Referer':
self.cm.meta['url'],
'Accept':
'*/*',
'X-Requested-With':
'XMLHttpRequest',
'Content-Type':
'application/x-www-form-urlencoded; charset=UTF-8'
})
sts, data = self.getPage(actionUrl, httpParams, post_data)
printDBG(data)
if sts: msgTab.append(ph.clean_html(data))
sts, data = self.getPage(self.getMainUrl())
if sts and 'action=logout' in data:
printDBG('tryTologin OK')
self.loggedIn = True
else:
printDBG(data)
self.sessionEx.waitForFinishOpen(MessageBox,
'\n'.join(msgTab),
type=MessageBox.TYPE_ERROR,
timeout=10)
printDBG('tryTologin failed')
if self.loggedIn:
hash = hexlify(
md5('%s@***@%s' % (self.login, self.password)).digest())
WriteTextFile(loginCookie, hash)
return self.loggedIn
def exploreItem(self, cItem, nextCategory):
printDBG("DixMax.exploreItem")
self.cacheLinks = {}
apiKey = self.getDBApiKey()
type = 'tv' if cItem['f_isserie'] else 'movie'
url = 'https://api.themoviedb.org/3/%s/%s/videos?api_key=%s' % (type, cItem['f_id'], apiKey)
sts, data = self.getPage(url)
if not sts: return
try:
data = json_loads(data)
for item in data['results']:
if item['site'].lower() == 'youtube':
title = '[%s][%s] %s ' % (item['iso_3166_1'], item['size'], item['name'])
url = 'https://www.youtube.com/watch?v=%s' % item['key']
self.addVideo(MergeDicts(cItem, {'good_for_fav': True, 'title':title, 'url':url}))
except Exception:
printExc()
if type == 'tv':
url = self.getFullUrl('/serie/%s' % cItem['f_id'])
sts, data = self.getPage(url)
if not sts: return
try:
data = ph.find(data, 'gotoFuchaCrazy', '</script>', flags=0)[1]
data = data[data.find('{'):data.rfind('}')+1]
data = json_loads(data)
sTitle = data['result']['info']['title']
sIcon = self.getFullIconUrl(data['result']['info']['cover'])
for seasonData in data['result']['episodes']:
sNum = str(seasonData['season'])
sEpisodes = ''
subItems = []
for item in seasonData['episodesList']:
eNum = str(item['episode'])
sEpisodes = str(item['episodes'])
icon = self.getFullIconUrl(item['cover'])
if not icon: icon = sIcon
title = '%s: s%se%s %s' % (sTitle, sNum.zfill(2), eNum.zfill(2), item['name'])
type = _('Episode')
desc = [type]
desc.append(item['dateText'])
desc = ' | '.join(desc) + '[/br]' + item['sinopsis']
params = {'f_type':type, 'f_isepisode':1, 'f_date':item['dateText'], 'f_sinopsis':item['sinopsis'], 'f_season':sNum, 'f_episode':eNum}
params = MergeDicts(cItem, {'good_for_fav':True, 'type':'video', 'title':title, 'icon':icon, 'desc':desc, 'f_eid':item['id']}, params)
params.pop('f_seasons')
params.pop('f_episodes')
key = '%sx%sx%s' % (cItem['f_id'], params['f_episode'].zfill(2), params['f_season'].zfill(2))
subItems.append( params )
if len(subItems):
params = {'f_type':_('Season'), 'f_isseason':1, 'f_season':sNum}
params = MergeDicts(cItem, {'good_for_fav':False, 'category':nextCategory, 'sub_items':subItems, 'title':_('Season %s (%s)') % (sNum.zfill(2), sEpisodes), 'icon':sIcon}, params)
self.addDir( params )
except Exception:
printExc()
else:
self.addVideo( MergeDicts(cItem) )
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 exploreItem(self, cItem, nextCategory):
printDBG("HD1080Online.exploreItem")
self.cacheLinks = {}
sts, data = self.getPage(cItem['url'])
if not sts: return
cUrl = self.cm.meta['url']
self.setMainUrl(cUrl)
desc = []
descObj = self.getArticleContent(cItem, data)[0]
icon = descObj['images'][0]['url']
baseTitle = descObj['title']
for item in descObj['other_info']['custom_items_list']:
desc.append(item[1])
desc = ' | '.join(desc) + '[/br]' + descObj['text']
data = ph.find(data, ('<div', '>', 'player-section'),
('<div', '>', 'ratig'),
flags=0)[1]
printDBG(data)
titles = []
tmp = ph.findall(data, ('<li', '>'), '</li>', flags=0)
for t in tmp:
titles.append(ph.clean_html(t))
data = ph.findall(data, ('<div', '>', 'player-box'), '</div>', flags=0)
for idx, item in enumerate(data):
url = self.getFullUrl(ph.search(item, ph.IFRAME)[1])
if not url: continue
title = baseTitle
if idx < len(titles): title += ' - ' + titles[idx]
if ('/video/' in url and '/serials/' in url) or 'playlist' in url:
url = strwithmeta(url, {'Referer': cUrl})
seasons = self.hdgocc.getSeasonsList(url)
for item in seasons:
self.addDir(
MergeDicts(
cItem, {
'good_for_fav': False,
'prev_url': cUrl,
'category': nextCategory,
'serie_title': baseTitle,
'title': _('Season %s') % item['title'],
'season_id': item['id'],
'url': item['url'],
'icon': icon,
'desc': desc
}))
if 0 == len(seasons):
seasonUrl = url
episodes = self.hdgocc.getEpiodesList(seasonUrl, -1)
for item in episodes:
title = '{0} - {1} - s01e{2} '.format(
baseTitle, item['title'],
str(item['id']).zfill(2))
self.addVideo({
'good_for_fav': False,
'type': 'video',
'prev_url': cUrl,
'title': title,
'url': item['url'],
'icon': icon,
'desc': desc
})
elif '/video/' in url:
self.addVideo({
'good_for_fav': False,
'prev_url': cUrl,
'title': title,
'url': url,
'icon': icon,
'desc': desc
})
else: # trailes ??
self.addVideo({
'good_for_fav': False,
'prev_url': cUrl,
'title': title,
'url': url,
'icon': icon,
'desc': desc
})
def listMain(self, cItem):
printDBG("HDFull.listMain")
sts, data = self.getPage(self.getMainUrl())
if not sts:
return
self.setMainUrl(self.cm.meta['url'])
reObj = re.compile('<ul[^>]*?>')
data = self.cm.ph.getAllItemsBeetwenNodes(data,
('<li', '>', 'dropdown'),
('</ul', '>'), False)
for menuData in data:
menuData = reObj.split(menuData, 1)
menuUrl = self.getFullUrl(
self.cm.ph.getSearchGroups(menuData[0],
'''\shref=['"]([^'^"]+?)['"]''')[0])
category = menuUrl.rsplit('/')[-1]
if category in ['tv-shows', 'series']:
category = 'list_sort_series'
elif category in ['peliculas', 'movies']:
category = 'list_sort_movies'
elif category == '#':
category = ''
else:
continue
menuTitle = self.cleanHtmlStr(menuData[0])
menuData = self.cm.ph.getAllItemsBeetwenMarkers(
menuData[-1], '<li', '</li>')
subItems = []
if category:
subItems = [
MergeDicts(cItem, {
'url': menuUrl,
'title': _('All'),
'category': category
})
]
for item in menuData:
title = self.cleanHtmlStr(item)
url = self.getFullUrl(
self.cm.ph.getSearchGroups(
item, '''\shref=['"]([^'^"]+?)['"]''')[0])
params = {'url': url, 'title': title}
if category:
params['category'] = category
else:
tmp = url.split('#', 1)
if len(tmp) == 2:
params.update({
'category': 'list_episodes_langs',
'url': tmp[0],
'f_action': tmp[1]
})
else:
params['category'] = 'list_items'
subItems.append(MergeDicts(cItem, params))
if len(subItems):
self.addDir(
MergeDicts(
cItem, {
'url': menuUrl,
'title': menuTitle,
'category': 'sub_items',
'sub_items': subItems
}))
MAIN_CAT_TAB = [{
'category': 'search',
'title': _('Search'),
'search_item': True
}, {
'category': 'search_history',
'title': _('Search history'),
}]
self.listsTab(MAIN_CAT_TAB, cItem)
def exploreItem(self, cItem):
printDBG("<<<<<<<<<<<<< DSDA.exploreItem <<<<<<<<<<<<<<<<<<<<<<")
url = cItem.get('url', '')
printDBG(url)
sts, data = self.cm.getPage(url)
if not sts:
return
#video link
d = re.findall('''<h2>(.*?)<section class=''', data, re.S)[0]
#d = re.findall('''<a class="link-doc(.*?)</div>''', data, re.S)[0]
printDBG(d)
#printDBG("desc <<<<< "+ d+"\n<<<<<<<<<<<<<<<")
dd = re.findall('''<p>(.*?)</p>''', data, re.S)
printDBG(dd)
ddd = ""
for d in dd:
d = re.sub('''<(.*?)>''', "", d)
d = d.replace("<", "")
d = d.replace(">", "")
printDBG("d <<< " + d + "<<<")
ddd = ddd + d + "\n"
ddd = HTMLParser.HTMLParser().unescape(ddd).encode('utf-8')
printDBG(ddd)
#desc = re.findall('''<b style="color:#333333;">(.*?)</div>''', data, re.S)[0]
#desc = '''<b style="color:#333333;">'''+desc
#tmp = desc.split("</b></a> <br><br>")
#del tmp[-1]
desc = ddd
# check if is a series
is_serie = self.cleanHtmlStr(
self.cm.ph.getDataBeetwenMarkers(data, '<title>', '</title>')[1])
printDBG(is_serie)
if 'Serie' in is_serie:
title = re.findall('''<title>(.*?)</title>''', data, re.S)[0]
t = self.cm.ph.getDataBeetwenMarkers(data, ('<div class="panel">'),
('<script>'), False)[1]
printDBG(t)
#eps = self.cm.ph.getDataBeetwenMarkers(t, ('<p class="title-episodio">') , ('</p>'), False)[1]
#eps = re.findall('''<p class="title-episodio">(.*?)</p>''', t, re.S)
eps = self.cm.ph.getAllItemsBeetwenMarkers(
t, '<p class="title-episodio">', '</p>')
printDBG(eps)
printDBG(eps)
printDBG(eps)
names1 = re.findall(
'''target="_blank">\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t(.*?)</a>''',
t, re.S)
names = MergeDicts(cItem, {eps + " " + names1})
#names = eps + " " + names1
printDBG(names)
printDBG(names)
printDBG(names)
vurl = re.findall('''href="(.*?)"''', t, re.S)
else:
#for t in data:
t = self.cm.ph.getDataBeetwenMarkers(data, ('<h2>'),
('<section class='), False)[1]
#t = re.findall('''<h2>(.*?)<section class=''', data, re.S)[0]
printDBG(str(t))
t = '''</b>''' + t
title = re.findall('''<title>(.*?)</title>''', data, re.S)[0]
title = HTMLParser.HTMLParser().unescape(title).encode('utf-8')
printDBG(title)
names = re.findall('''noopener">(.*?)</a>''', t, re.S)
printDBG(names)
vurl = re.findall('''href="(.*?)"''', t, re.S)
printDBG(vurl)
urlTab = []
i = 0
for name in names:
urlTab.append({'name': name, 'url': vurl[i], 'need_resolve': 1})
i = i + 1
params = dict(cItem)
params.update({
'good_for_fav': False,
'title': title,
'urls_tab': urlTab,
'desc': ddd
})
#params.update({'good_for_fav':False, 'url':url, 'title':'%s %s' % (title, cItem['title'])})
printDBG(str(params))
self.addVideo(params)
def _listItems(self, cItem, nextCategory, data):
printDBG("HDFull._listItems")
retList = []
reLang = re.compile('/images/([^\.]+?)\.png')
data = self.cm.ph.getDataBeetwenNodes(data, ('<div', '>', 'view'),
('<div', '>', 'clear'), False)[1]
data = re.compile('''<div[^>]+?view[^>]+?>''').split(data)
for item in data:
icon = self.getFullIconUrl(
self.cm.ph.getSearchGroups(
item,
'''<img[^>]+?src=['"]([^"^']+?\.jpe?g(?:\?[^'^"]*?)?)['"]'''
)[0])
url = self.getFullUrl(
self.cm.ph.getSearchGroups(item, '''href=['"]([^"^']+?)["']''',
1, True)[0])
tmp = self.cm.ph.getDataBeetwenMarkers(item, '<h5', '</h5>')[1]
title = self.cleanHtmlStr(
self.cm.ph.getSearchGroups(tmp, '''title=['"]([^"^']+?)["']''',
1, True)[0])
if title == '':
title = self.cleanHtmlStr(tmp)
desc = []
# lang
tmp = self.cm.ph.getDataBeetwenNodes(item, ('<div', '>', 'left'),
('</div', '>'), False)[1]
tmp = reLang.findall(tmp)
for t in tmp:
t = self.cleanHtmlStr(t)
if t:
desc.append(t)
desc = [', '.join(desc)]
# rating
item = self.cm.ph.getDataBeetwenNodes(item, ('<div', '>', 'right'),
('</div', '>'), False)[1]
tmp = [
self.cleanHtmlStr(
self.cm.ph.getDataBeetwenNodes(item, ('<', '>', 'rating'),
('<', '>'), False)[1])
]
tmp.append(
self.cleanHtmlStr(
self.cm.ph.getDataBeetwenNodes(item, ('<', '>', 'dec'),
('</', '>'), False)[1]))
if tmp[0]:
desc.append('.'.join(tmp))
retList.append(
MergeDicts(
cItem, {
'good_for_fav': True,
'category': nextCategory,
'title': title,
'url': url,
'icon': icon,
'desc': ' | '.join(desc)
}))
return retList
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 tryTologin(self):
printDBG('tryTologin start')
if None == self.loggedIn or self.login != config.plugins.iptvplayer.hdfull_login.value or \
self.password != config.plugins.iptvplayer.hdfull_password.value:
self.cm.clearCookie(self.COOKIE_FILE, removeNames=['language'])
loginCookie = GetCookieDir('hdfull.me.login')
self.login = config.plugins.iptvplayer.hdfull_login.value
self.password = config.plugins.iptvplayer.hdfull_password.value
sts, data = self.getPage(self.getMainUrl())
if sts:
self.setMainUrl(self.cm.meta['url'])
freshSession = False
if sts and '/logout' in data:
printDBG("Check hash")
hash = hexlify(
md5('%s@***@%s' % (self.login, self.password)).digest())
prevHash = ReadTextFile(loginCookie)[1].strip()
printDBG("$hash[%s] $prevHash[%s]" % (hash, prevHash))
if hash == prevHash:
self.loggedIn = True
return
else:
freshSession = True
rm(loginCookie)
rm(self.COOKIE_FILE)
if freshSession:
sts, data = self.getPage(
self.getMainUrl(),
MergeDicts(self.defaultParams, {'use_new_session': True}))
self.loggedIn = False
if '' == self.login.strip() or '' == self.password.strip():
return False
if sts:
actionUrl = self.cm.meta['url']
post_data = {}
data = self.cm.ph.getDataBeetwenNodes(
data, ('<form', '>', 'login_form'), ('</form', '>'), True,
False)[1]
data = self.cm.ph.getAllItemsBeetwenMarkers(
data, '<input', '>', False)
for item in data:
name = self.cm.ph.getSearchGroups(
item, '''name=['"]([^"^']+?)['"]''')[0]
value = self.cm.ph.getSearchGroups(
item, '''value=['"]([^"^']+?)['"]''')[0]
if name != '':
post_data[name] = value
post_data.update({
'username': self.login,
'password': self.password,
'action': 'login'
})
httpParams = dict(self.defaultParams)
httpParams['header'] = MergeDicts(
httpParams['header'], {
'Referer': self.cm.meta['url'],
'Content-Type': 'application/x-www-form-urlencoded'
})
sts, data = self.getPage(actionUrl, httpParams, post_data)
if sts and '/logout' in data:
printDBG('tryTologin OK')
self.loggedIn = True
else:
msgTab = [_('Login failed.')]
self.sessionEx.waitForFinishOpen(MessageBox,
'\n'.join(msgTab),
type=MessageBox.TYPE_ERROR,
timeout=10)
printDBG('tryTologin failed')
if self.loggedIn:
hash = hexlify(
md5('%s@***@%s' % (self.login, self.password)).digest())
WriteTextFile(loginCookie, hash)
return self.loggedIn
def listSearchResult(self, cItem, searchPattern, searchType):
url = self.REDBULL_API + "search?q=%s" % urllib.quote_plus(searchPattern)
cItem = MergeDicts(cItem, {'category': 'list_search', 'url': url})
self.listSearchItems(cItem)
def exploreItems(self, cItem):
printDBG('Cinemalibero.exploreItem %s' % cItem)
url = cItem['url']
sts, data = self.getPage(url)
#printDBG(data)
if not sts:
return
# check if is a series
is_serie = self.cleanHtmlStr(
self.cm.ph.getDataBeetwenMarkers(
data,
'<a href="https://cinemalibero.plus/category/serie-tv/" rel="category tag">',
'</a>')[1])
#printDBG(is_serie)
if 'Serie' in is_serie:
# it is a series
seasons = {}
tmp_seasons = self.cm.ph.getDataBeetwenMarkers(
data, '<div class="at-above-post addthis_tool"',
'<div class="at-below-post addthis_tool"')[1]
tmp_seasons = tmp_seasons.split('<strong>')
if len(tmp_seasons) > 1:
del (tmp_seasons[0])
#printDBG("tmp_seasons: %s" % tmp_seasons)
for s in tmp_seasons:
s = '<strong>' + s
seasonName = self.cleanHtmlStr(
self.cm.ph.getDataBeetwenMarkers(s, '<strong>',
'</strong>', False)[1])
seasons[seasonName] = []
printDBG("new season: '%s'" % seasonName)
#eps = self.cm.ph.getAllItemsBeetwenMarkers(s, '×', '<br />')
eps = s.split('<br />')
for ep in eps:
printDBG('----------------------')
printDBG(ep)
printDBG('----------------------')
i1 = ep.find('<p>')
if i1 > 0:
ep = ep[i1 + 3:]
ep = ep.strip().encode('utf-8')
if '×' not in ep:
continue
printDBG('-----------dopo modifiche -----------')
printDBG(ep)
printDBG('-------------------------------------')
epName = self.cleanHtmlStr(ep.split('<a')[0])
epName = epName.replace('\xe2\x80\x93', "-")
if epName.endswith("-"):
epName = epName[:-1]
printDBG("new episode: '%s' of season '%s' " %
(epName, seasonName))
linksTab = []
links = self.cm.ph.getAllItemsBeetwenMarkers(
ep, '<a target', '</a>')
for l in links:
url = self.cm.ph.getSearchGroups(
l, "href=['\"]([^'^\"]+?)['\"]")[0]
host = self.cleanHtmlStr(l)
host = host.strip().encode('utf-8').replace(
'\xe2\x80\x93', "-")
if host.startswith("-"):
host = host[1:]
#printDBG("url: %s" % url)
#printDBG("host: %s" % host)
#printDBG("epname: %s" % epName)
title = "%s - %s - %s" % (seasonName, epName, host)
params = MergeDicts(cItem, {
'title': title,
'url': url
})
printDBG(str(params))
linksTab.append(params)
seasons[seasonName].append({
'title': epName,
'category': 'episode',
'links': linksTab
})
self.addDir({
'category': 'season',
'episodes_list': seasons[seasonName],
'title': seasonName
})
else:
#it is a movie
links = self.cm.ph.getAllItemsBeetwenMarkers(
data, '<a target', '</a>')
for l in links:
url = self.cm.ph.getSearchGroups(
l, "href=['\"]([^'^\"]+?)['\"]")[0]
host = self.cleanHtmlStr(l)
title = self.cleanHtmlStr(
self.cm.ph.getDataBeetwenMarkers(data, '<h1', '</a>')[1])
printDBG("found url %s" % url)
if not ('facebook' in url):
params = MergeDicts(cItem, {
'title': title + " - " + host,
'host': host,
'url': url
})
printDBG(str(params))
self.addVideo(params)
def listItems(self, cItem, nextCategory1, nextCategory2):
printDBG("CartoonHD.listItems")
page = cItem.get('page', 1)
if page == 1:
url = cItem['url'] + '/' + cItem.get('sort_by',
'') + '/' + str(page)
else:
url = cItem['url']
params = dict(self.defaultParams)
params['header'] = self.AJAX_HEADER
sts, data = self.cm.getPage(url, params)
if not sts: return
nextPage = self.cm.ph.getDataBeetwenNodes(
data, ('<a', '>', 'next-page-button'), ('</a', '>'))[1]
nextPage = self.getFullUrl(
self.cm.ph.getSearchGroups(nextPage,
'''href=["']([^"^']+?)['"]''')[0])
data = self.cm.ph.getDataBeetwenMarkers(data, '<div class="flipBox"',
'</main>', True)[1]
data = data.split('</section>')
if len(data): del data[-1]
for item in data:
icon = self.getFullUrl(
self.cm.ph.getSearchGroups(item,
'src="([^"]+?\.jpg[^"]*?)"')[0])
desc = 'IMDb ' + self.cm.ph.getSearchGroups(
item, '>([ 0-9.]+?)<')[0] + ', '
desc += self.cleanHtmlStr(' '.join(
self.cm.ph.getAllItemsBeetwenMarkers(item, '<p>', '</p>',
False)))
tmp = self.cm.ph.rgetAllItemsBeetwenMarkers(
item, '</a>', '<a', True)
url = ''
for t in tmp:
if url == '':
url = self.getFullUrl(
self.cm.ph.getSearchGroups(
t, '''href=["']([^"^']+?)['"]''')[0])
title = self.cleanHtmlStr(t)
if title != '': break
if url.startswith('http'):
params = MergeDicts(
cItem, {
'good_for_fav': True,
'title': title,
'url': url,
'desc': desc,
'icon': icon
})
if '/series/' in url and '/episode/' not in url:
params['category'] = nextCategory2
else:
params['category'] = nextCategory1
self.addDir(params)
if nextPage != '':
params = dict(cItem)
params.update({
'title': _("Next page"),
'url': nextPage,
'page': page + 1
})
self.addDir(params)
def getVideoLink(self, cItem):
printDBG("InternetowaApi.getVideoLink")
urlsTab = []
sts, data = self.cm.getPage(cItem['url'], self.http_params)
if not sts: return urlsTab
cUrl = self.cm.meta['url']
SetIPTVPlayerLastHostError(
self.cleanHtmlStr(
self.cm.ph.getDataBeetwenNodes(data, ('<div', '>', 'nostream'),
('</div', '>'), False)[1]))
data = self.cm.ph.getAllItemsBeetwenMarkers(data,
'<iframe',
'>',
caseSensitive=False)
printDBG(data)
for item in data:
url = self.getFullUrl(
self.cm.ph.getSearchGroups(item,
'''src=['"]([^'^"]+?)['"]''')[0])
if not self.cm.isValidUrl(url): continue
if 1 == self.up.checkHostSupport(url):
url = strwithmeta(url, {'Referer': cUrl})
urlsTab.extend(self.up.getVideoLinkExt(url))
else:
params = dict(self.http_params)
params['header'] = MergeDicts(self.HTTP_HEADER,
{'Referer': cUrl})
sts, tmp = self.cm.getPage(url, params)
if not sts: continue
tmp2 = self.cm.ph.getDataBeetwenMarkers(
tmp, '<audio', '</audio>', False)[1]
tmp2 = self.cm.ph.getDataBeetwenMarkers(
tmp, '<audio', '</audio>', False)[1]
tmp = self.cm.ph.getAllItemsBeetwenMarkers(
tmp2, '<source', '>')
for it in tmp:
printDBG(it)
type = self.cm.ph.getSearchGroups(
it, '''type=['"]([^"^']+?)['"]''')[0].lower().split(
'/', 1)
mediaUrl = self.cm.getFullUrl(
self.cm.ph.getSearchGroups(
it, '''src=['"]([^"^']+?)['"]''')[0],
self.cm.meta['url'])
if type[0] in ('audio', 'video'):
mediaUrl = strwithmeta(
mediaUrl, {
'User-Agent': params['header']['User-Agent'],
'Referer': self.cm.meta['url']
})
urlsTab.append({
'name':
'[%s] %s' %
(type[1], self.cm.getBaseUrl(url, True)),
'url':
mediaUrl,
'need_resolve':
0
})
return urlsTab
def getList(self, cItem):
printDBG("SportStream365Api.getList cItem[%s]" % cItem)
channelsList = []
if self.lang != config.plugins.iptvplayer.sportstream365_language.value:
self.lang = config.plugins.iptvplayer.sportstream365_language.value
lang = self.lang
if lang == '':
userLang = GetDefaultLang()
if userLang in [
'de', 'en', 'es', 'fr', 'it', 'pt', 'ru', 'tr', 'cn'
]:
lang = userLang
if lang != '': self.defaultParams['cookie_items'] = {'lng': lang}
else:
self.defaultParams['cookie_items'] = {
'lng': 'en'
} #self.defaultParams.pop('cookie_items', None)
category = cItem.get('priv_cat')
if category == None:
sts, data = self.cm.getPage(self.getMainUrl(), self.defaultParams)
if not sts: return []
self.setMainUrl(self.cm.meta['url'])
data = self.cm.ph.getDataBeetwenNodes(
data, ('<div', '>', 'modal_menu_filter'), ('</div', '>'))[1]
data = self.cm.ph.getAllItemsBeetwenMarkers(data, '<a', '</a>')
for item in data:
url = self.cm.ph.getSearchGroups(
item, '''\shref=['"]([^'^"]+?)['"]''')[0]
icon = url.rsplit('/', 1)[-1]
if icon == '': icon = 'all'
elif 'tennis' in icon: icon = 'footballtennis'
elif 'formula' in icon: icon = 'f1'
icon = self.getFullIconUrl('/img/%s.jpg' % icon)
title = self.cleanHtmlStr(item)
channelsList.append({
'name': 'sportstream365.com',
'type': 'dir',
'priv_cat': 'list_items',
'title': title,
'url': self.getFullUrl(url),
'icon': icon
})
else:
iconsMap = {
0: 'other',
1: 'football',
2: 'hockey',
3: 'basketball',
6: 'volleyball',
26: 'f1',
4: 'footballtennis',
9: 'boxing'
}
sts, data = self.cm.getPage(cItem['url'], self.defaultParams)
if not sts: return []
allowSports = self.cm.ph.getSearchGroups(
data, '''var\s+?allow_sports\s*=\s*['"]([^'^"]+?)['"]''')[0]
tagz = self.cm.ph.getSearchGroups(
data, '''var\s+?tagz\s*=\s*['"]([^'^"]+?)['"]''')[0]
try:
from Plugins.Extensions.IPTVPlayer.libs import websocket
lang = self.defaultParams['cookie_items']['lng']
for i in range(3):
url = self.getFullUrl('/signcon/negotiate')
sts, data = self.cm.getPage(
url,
MergeDicts(self.defaultParams, {
'header': self.AJAX_HEADER,
'raw_post_data': True
}),
post_data='')
if not sts: return []
data = json_loads(data)
uri = 'ws:' + self.getFullUrl('/signcon?id=').split(
':', 1)[-1] + data['connectionId']
printDBG("URI: %s" % uri)
ws1 = websocket.create_connection(uri)
ws1.send('{"protocol":"json","version":1}\x1E')
ws1.send(
'{"arguments":[{"partner":2,"lng":"%s","typegame":3}],"invocationId":"0","target":"ConnectClient","type":1}\x1E'
% lang) #
ws1.send(
'{"arguments":["%s","en",24],"invocationId":"1","target":"GetFeed","type":1}\x1E'
% allowSports)
ws1.send(
'{"arguments":["%s","en",24],"invocationId":"2","target":"GetFeed","type":1}\x1E'
% allowSports)
for j in range(4):
data = ws1.recv()
printDBG(data)
if 'updateFeed' in data:
break
ws1.close()
try:
data = json_loads(data.split('\x1E', 1)[0])
except Exception:
printExc()
continue
break
parseInt = lambda sin: int(''.join([
c for c in str(sin).replace(',', '.').split('.')[0]
if c.isdigit()
])) if sum(map(int, [s.isdigit()
for s in str(sin)])) and not callable(
sin) and str(sin)[0].isdigit() else 0
def parseInt2(string):
try:
return int(''.join([x for x in string if x.isdigit()]))
except Exception:
return 0
def cmp(x, y):
if x['SportId'] != y['SportId']:
return parseInt(x['SportId']) - parseInt(y['SportId'])
elif x['Liga'] != y['Liga']:
try:
int(x['Liga']) - int(y['Liga'])
except Exception:
return 0
else:
return parseInt(x['FirstGameId']) - parseInt(
y['FirstGameId'])
data = json_loads(data['arguments'][0])['Value']
data.sort(
cmp=cmp
) #key = lambda item: (parseInt(item['SportId']), item['Liga'], parseInt(item['FirstGameId']))
printDBG(data)
for item in data:
if None == item.get('VI'): continue
url = self.getFullUrl(
'/viewer?sport=%s&game=%s&tagz=%s' %
(item['SportId'], item['FirstGameId'], tagz))
icon = self.getFullIconUrl(
'/img/flag_%s.png' %
iconsMap.get(item['SportId'], 'other'))
title = []
if item['Opp1'] != '': title.append(item['Opp1'])
if item['Opp2'] != '': title.append(item['Opp2'])
title = ' - '.join(title)
if title == '': title = item['Liga']
desc = item['Liga']
desc += '[/br]' + datetime.fromtimestamp(
int(item['Start'] / 1000)).strftime('%A, %-d %B %H:%M')
if self.GMTOffset != '':
desc += ' (GMT %s)' % self.GMTOffset
channelsList.append({
'name': 'sportstream365.com',
'type': 'video',
'title': self.cleanHtmlStr(title),
'url': url,
'icon': icon,
'desc': self.cleanHtmlStr(desc)
})
except Exception:
printExc()
return channelsList
def getLinksForVideo(self, cItem):
printDBG("FilmyNaDzis.getLinksForVideo [%s]" % cItem)
if 1 == self.up.checkHostSupport(cItem['url']):
return self.up.getVideoLinkExt(cItem['url'])
urlTab = []
cacheKey = cItem['url']
cacheTab = self.cacheLinks.get(cacheKey, [])
if cacheTab:
return cacheTab
self.cacheLinks = {}
sts, data = self.getPage(cItem['url'])
if not sts:
return
cUrl = self.cm.meta['url']
token = ph.find(data, ('<meta', '>', 'token'))[1]
token_name = ph.getattr(token, 'name')
token_content = ph.getattr(token, 'content')
printDBG("FilmyNaDzis.getLinksForVideo --> token --> name '%s' - content '%s'" % (token_name, token_content))
urlParams = self.getDefaultParams(True)
urlParams['header'] = MergeDicts(urlParams['header'], {'Referer': cUrl, 'x-csrf-' + token_name: token_content })
data = ph.find(data, ('<div', '>', 'video_thumbnail'), '</div>', flags=0)[1]
printDBG("------------------------")
printDBG(data)
printDBG("------------------------")
tmp = self.getFullUrl(ph.search(data, ph.A)[1], cUrl)
if tmp:
if self.cm.getBaseUrl(tmp) != self.cm.getBaseUrl(cUrl):
name = self.cm.getBaseUrl(tmp)
params = {'name': name, 'url':strwithmeta(tmp, {'Referer': cUrl, 'x-csrf-' + token_name: token_content }), 'need_resolve':1}
printDBG("-------> link: %s" % str(params))
urlTab.append(params)
else:
printDBG("-------> %s" % tmp)
tmp = ph.find(data, ('<a', '>', ph.check(ph.all, ('data-id', ))))[1]
tmp = re.compile('''data-([^=]+?)="([^"]*?)"''').findall(tmp)
sts, data = self.getPage(cUrl, urlParams, MergeDicts({'action':'get_video_player'}, dict(tmp)))
if not sts:
return
tmp = self.cm.ph.getAllItemsBeetwenMarkers(data, '<source', '>')
if len(tmp):
for item in tmp:
type = self.cm.ph.getSearchGroups(item, '''type=['"]([^'^"]+?)['"]''')[0].lower()
url = self.cm.ph.getSearchGroups(item, '''src=['"]([^'^"]+?)['"]''')[0]
if 'video/mp4' == type:
urlTab.append({'name':self.up.getHostName(url), 'url':self.getFullUrl(url), 'need_resolve':0})
elif 'm3u' in url:
urlTab.extend(getDirectM3U8Playlist(url, checkExt=False, checkContent=True, sortWithMaxBitrate=999999999))
if urlTab:
self.cacheLinks[cacheKey] = urlTab
return urlTab
def listItems(self, cItem, nextCategory=''):
printDBG("FaselhdCOM.listItems [%s]" % cItem)
page = cItem.get('page', 1)
sts, data = self.getPage(cItem['url'])
if not sts:
return
baseData = data
nextPage = self.cm.ph.getDataBeetwenNodes(data, ('<div', '>', 'pagination'), ('</div', '>'))[1]
nextPage = self.getFullUrl(self.cm.ph.getSearchGroups(nextPage, '''<a[^>]+?href=['"]([^'^"]+?)['"][^>]*?>%s<''' % (page + 1))[0])
data = self.cm.ph.getAllItemsBeetwenNodes(data, ('<div', '>', 'one-movie'), ('</a', '>'))
printDBG(data)
for item in data:
url = self.getFullUrl(self.cm.ph.getSearchGroups(item, '''href=['"]([^'^"]+?)['"]''')[0])
icon = self.getFullIconUrl(self.cm.ph.getSearchGroups(item, '''[\s\-]src=['"]([^'^"]+?)['"]''')[0])
title = self.cleanHtmlStr(self.cm.ph.getDataBeetwenMarkers(item, '<h1', '</h1>')[1])
if title == '':
title = self.cleanHtmlStr(self.cm.ph.getSearchGroups(item, '''alt=['"]([^'^"]+?)['"]''')[0])
if title == '':
continue
desc = []
tmp = self.cm.ph.getDataBeetwenNodes(item, ('<div', '>', 'movie-meta'), ('</div', '>'))[1]
tmp = self.cm.ph.getAllItemsBeetwenMarkers(tmp, '<span', '</span>')
for t in tmp:
label = ''
if 'fa-star' in t:
label = _('Rating:')
elif 'fa-eye' in t:
label = _('Views:')
t = self.cleanHtmlStr(t)
if t != '':
if label != '':
desc.append('%s %s' % (label, t))
else:
desc.append(t)
if '/seasons/' in self.cm.meta['url'] and not cItem.get('sub_view'):
title = '%s - %s' % (cItem['title'], title)
self.addDir(MergeDicts(cItem, {'url': url, 'title': title, 'sub_view': True}))
else:
params = dict(cItem)
params.update({'good_for_fav': True, 'title': title, 'url': url, 'icon': icon, 'desc': '[/br]'.join(desc)})
if nextCategory == '' or cItem.get('f_list_episodes'):
self.addVideo(params)
else:
params['category'] = nextCategory
self.addDir(params)
if not cItem.get('sub_view'):
data = ph.findall(baseData, ('<span', '>', 'sub-view'), '</span>')
for item in data:
if 'display:none' in item:
continue
url = self.getFullUrl(ph.getattr(item, 'href'), self.cm.meta['url'])
title = '%s - %s' % (cItem['title'], ph.clean_html(item))
self.addDir(MergeDicts(cItem, {'url': url, 'title': title, 'sub_view': True}))
if self.cm.isValidUrl(nextPage):
params = dict(cItem)
params.update({'good_for_fav': False, 'title': _("Next page"), 'url': nextPage, 'page': page + 1})
self.addDir(params)
def listItems(self, cItem, nextCategory):
nextPage = False
try:
tuhe = cItem['url']
page = cItem.get('page', 1)
tumd = cItem['md']
if tuhe != '':
tuhe = tuhe + '/oldal/' + str(page)
sts, data = self.cm.getPage(tuhe, self.defaultParams)
if not sts: return
if len(data) == 0: return
Pgntr = self.cm.ph.getDataBeetwenMarkers(
data, '<div class="blog-pagenat-wthree">', '</div>')[1]
if 'Következő' in Pgntr:
nextPage = True
else:
nextPage = False
data = self.cm.ph.getAllItemsBeetwenMarkers(
data, "<div class='col-md-2 w3l-movie-gride-agile'",
"div class='clearfix'>")
if len(data) == 0: return
for item in data:
url = self.getFullUrl(
self.cm.ph.getSearchGroups(
item, 'href=[\'"]([^"^\']+?)[\'"]')[0])
if not self.cm.isValidUrl(url):
continue
title = self.cm.ph.getSearchGroups(
item, '<a title=[\'"]([^"^\']+?)[\'"]')[0].strip()
if title == '': continue
icon = self.cm.ph.getSearchGroups(
item, 'src=[\'"]([^"^\']+?)[\'"]')[0].strip()
tmp_ny = self.cm.ph.getDataBeetwenMarkers(
item, '<img src=', '>')[1]
nyelv = self.cm.ph.getSearchGroups(
tmp_ny, 'title=[\'"]([^"^\']+?)[\'"]')[0].strip()
if nyelv == '': nyelv = ' '
kev = self.cm.ph.getDataBeetwenMarkers(
item, "<div class='mid-2'>(", ")<", False)[1]
if kev == '': kev = ' '
desc = nyelv + '\nKiadás éve: ' + kev
params = MergeDicts(
cItem, {
'category': nextCategory,
'title': title,
'url': url,
'desc': desc,
'icon': icon,
'nylv': nyelv,
'md': tumd
})
self.addDir(params)
if nextPage and len(self.currList) > 0:
params = dict(cItem)
params.update({
'title':
_("Next page"),
'page':
page + 1,
'desc':
'Nyugi...\nVan még további tartalom, lapozz tovább!!!'
})
self.addDir(params)
except Exception:
return
def download_img(self, img_url, filename):
# if at start there was NOT enough space on disk
# new icon will not be downloaded
if False == self.downloadNew:
return False
if len(self.currDownloadDir) < 4:
printDBG('IconMenager.download_img: wrong path for IPTVCache')
return False
path = self.currDownloadDir + '/'
# if at start there was enough space on disk
# we will check if we still have free space
if 0 >= self.checkSpace:
printDBG('IconMenager.download_img: checking space on device')
if not iptvtools_FreeSpace(path, 10):
printDBG(
'IconMenager.download_img: not enough space for new icons, new icons will not be downloaded any more'
)
self.downloadNew = False
return False
else:
# for another 50 check again
self.checkSpace = 50
else:
self.checkSpace -= 1
file_path = "%s%s" % (path, filename)
params = {} #{'maintype': 'image'}
if config.plugins.iptvplayer.allowedcoverformats.value != 'all':
subtypes = config.plugins.iptvplayer.allowedcoverformats.value.split(
',')
#params['subtypes'] = subtypes
params['check_first_bytes'] = []
if 'jpeg' in subtypes:
params['check_first_bytes'].extend(['\xFF\xD8', '\xFF\xD9'])
if 'png' in subtypes:
params['check_first_bytes'].append('\x89\x50\x4E\x47')
if 'gif' in subtypes:
params['check_first_bytes'].extend(['GIF87a', 'GIF89a'])
# formato webp 'RI'
if 'webp' in subtypes: params['check_first_bytes'].extend(['RI'])
else:
params['check_first_bytes'] = [
'\xFF\xD8', '\xFF\xD9', '\x89\x50\x4E\x47', 'GIF87a', 'GIF89a',
'RI'
]
if img_url.endswith('|cf'):
img_url = img_url[:-3]
params_cfad = {
'with_metadata': True,
'use_cookie': True,
'load_cookie': True,
'save_cookie': True
}
domain = urlparser.getDomain(img_url, onlyDomain=True)
if domain.startswith("www."):
domain = domain[4:]
params_cfad[
'cookiefile'] = '/hdd/IPTVCache//cookies/{0}.cookie'.format(
domain)
else:
params_cfad = {}
if img_url.endswith('need_resolve.jpeg'):
domain = urlparser.getDomain(img_url)
if domain.startswith('www.'): domain = domain[4:]
# link need resolve, at now we will have only one img resolver,
# we should consider add img resolver to urlparser if more will be needed
sts, data = self.cm.getPage(img_url)
if not sts: return False
if 'imdb.com' in domain:
img_url = self.cm.ph.getDataBeetwenMarkers(
data, 'class="poster"', '</div>')[1]
img_url = self.cm.ph.getSearchGroups(img_url,
'src="([^"]+?)"')[0]
if not self.cm.isValidUrl(img_url):
img_url = self.cm.ph.getDataBeetwenMarkers(
data, 'class="slate"', '</div>')[1]
img_url = self.cm.ph.getSearchGroups(
img_url, 'src="([^"]+?)"')[0]
elif 'bs.to' in domain:
baseUrl = img_url
img_url = self.cm.ph.getSearchGroups(
data, '(<img[^>]+?alt="Cover"[^>]+?>)')[0]
img_url = self.cm.ph.getSearchGroups(img_url,
'src="([^"]+?)"')[0]
if img_url.startswith('/'): img_url = urljoin(baseUrl, img_url)
elif 'watchseriesmovie.' in domain or 'gowatchseries' in domain:
baseUrl = img_url
img_url = self.cm.ph.getDataBeetwenNodes(
data, ('<div', '>', 'picture'), ('</div', '>'), False)[1]
img_url = self.cm.ph.getSearchGroups(
img_url, '<img[^>]+?src="([^"]+?)"')[0]
if img_url.startswith('/'): img_url = urljoin(baseUrl, img_url)
elif 'classiccinemaonline.com' in domain:
baseUrl = img_url
img_url = self.cm.ph.getDataBeetwenNodes(
data, ('<center>', '</center>', '<img'), ('<', '>'))[1]
img_url = self.cm.ph.getSearchGroups(
img_url,
'<img[^>]+?src="([^"]+?\.(:?jpe?g|png)(:?\?[^"]+?)?)"')[0]
if img_url.startswith('/'): img_url = urljoin(baseUrl, img_url)
elif 'nasze-kino.tv' in domain:
baseUrl = img_url
img_url = self.cm.ph.getDataBeetwenNodes(
data, ('<div', '>', 'single-poster'), ('<img', '>'))[1]
img_url = self.cm.ph.getSearchGroups(
img_url,
'<img[^>]+?src="([^"]+?\.(:?jpe?g|png)(:?\?[^"]+?)?)"')[0]
if img_url.startswith('/'): img_url = urljoin(baseUrl, img_url)
elif 'allbox.' in domain:
baseUrl = img_url
img_url = self.cm.ph.getDataBeetwenNodes(
data, ('<img', '>', '"image"'), ('<', '>'))[1]
if img_url != '':
img_url = self.cm.ph.getSearchGroups(
img_url,
'<img[^>]+?src="([^"]+?\.(:?jpe?g|png)(:?\?[^"]+?)?)"'
)[0]
else:
img_url = self.cm.ph.getSearchGroups(
data,
'url\(([^"^\)]+?\.(:?jpe?g|png)(:?\?[^"^\)]+?)?)\);'
)[0].strip()
if img_url.startswith('/'): img_url = urljoin(baseUrl, img_url)
elif 'efilmy.' in domain:
baseUrl = img_url
img_url = self.cm.ph.getDataBeetwenNodes(
data, ('<img', '>', 'align="left"'), ('<', '>'))[1]
img_url = self.cm.ph.getSearchGroups(
img_url,
'<img[^>]+?src="([^"]+?\.(:?jpe?g|png)(:?\?[^"]+?)?)"')[0]
img_url = self.cm.getFullUrl(img_url, baseUrl)
elif 'bajeczki.org' == domain:
baseUrl = img_url
img_url = self.cm.ph.getDataBeetwenNodes(
data, ('<img', '>', 'wp-post-image'), ('<', '>'))[1]
if img_url != '':
img_url = self.cm.ph.getSearchGroups(
img_url,
'<img[^>]+?src="([^"]+?\.(:?jpe?g|png)(?:\?[^"]+?)?)"'
)[0]
if img_url.startswith('/'): img_url = urljoin(baseUrl, img_url)
elif '7tv.de' == domain:
data = ph.find(data, ('<meta', '>', 'thumbnail_image_url'))[1]
img_url = ph.getattr(data, 'content')
if not self.cm.isValidUrl(img_url): return False
else:
img_url = strwithmeta(img_url)
if img_url.meta.get('icon_resolver', None) is not None:
try:
img_url = img_url.meta['icon_resolver'](self.cm, img_url)
except Exception:
printExc()
return False
if not self.cm.isValidUrl(img_url): return False
params = MergeDicts(params, params_cfad)
return self.cm.saveWebFile(file_path, img_url, addParams=params)['sts']
def listSearchResult(self, cItem, searchPattern, searchType):
uagnt = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:68.0) Gecko/20100101 Firefox/68.0'
phdre = {
'User-Agent': uagnt,
'DNT': '1',
'Accept':
'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
'Accept-Encoding': 'gzip, deflate, br',
'Accept-Language': 'hu-HU,hu;q=0.8,en-US;q=0.5,en;q=0.3',
'Host': 'nonstopmozi.com',
'Upgrade-Insecure-Requests': '1',
'Connection': 'keep-alive',
'Content-Type': 'application/x-www-form-urlencoded',
'Referer': 'https://nonstopmozi.com'
}
phdr = {
'header': phdre,
'use_cookie': True,
'load_cookie': True,
'save_cookie': True,
'cookiefile': self.COOKIE_FILE
}
db = 0
try:
cItem = dict(cItem)
if searchPattern != '':
self.suskrbt('2', '14', searchPattern)
krsstr = searchPattern
krsstr_lnk = self.getStringToLowerWithout(
searchPattern.replace(' ', '-'))
uhe = zlib.decompress(
base64.b64decode(
'eJzLKCkpKLbS18/LzysuyS/Iza/K1EvOz9XPz8vJzEvVTcvMyU3N1s9OLUotTi3WBwCjDBGy'
)) + krsstr_lnk
pstd = {'keres': krsstr, 'submit': 'Keresés'}
sts, data = self.cm.getPage(uhe, phdr, pstd)
data = self.cm.ph.getAllItemsBeetwenMarkers(
data, "<div class='col-md-2 w3l-movie-gride-agile'",
"div class='clearfix'>")
if len(data) == 0: return
for item in data:
url = self.getFullUrl(
self.cm.ph.getSearchGroups(
item, 'href=[\'"]([^"^\']+?)[\'"]')[0])
if not self.cm.isValidUrl(url):
continue
if 'online-sorozatok' in url:
tumd = 'series'
else:
tumd = 'movie'
title = self.cm.ph.getSearchGroups(
item, '<a title=[\'"]([^"^\']+?)[\'"]')[0].strip()
if title == '': continue
icon = self.cm.ph.getSearchGroups(
item, 'src=[\'"]([^"^\']+?)[\'"]')[0].strip()
tmp_ny = self.cm.ph.getDataBeetwenMarkers(
item, '<img src=', '>')[1]
nyelv = self.cm.ph.getSearchGroups(
tmp_ny, 'title=[\'"]([^"^\']+?)[\'"]')[0].strip()
if nyelv == '': nyelv = ' '
kev = self.cm.ph.getDataBeetwenMarkers(
item, "<div class='mid-2'>(", ")<", False)[1]
if kev == '': kev = ' '
desc = nyelv + '\nKiadás éve: ' + kev
db += 1
params = MergeDicts(
cItem, {
'category': 'explore_item',
'title': title,
'url': url,
'desc': desc,
'icon': icon,
'nylv': nyelv,
'md': tumd
})
self.addDir(params)
if db > 60:
break
except Exception:
return
def tryTologin(self):
printDBG('tryTologin start')
if None == self.loggedIn or self.login != config.plugins.iptvplayer.cda_login.value or\
self.password != config.plugins.iptvplayer.cda_password.value:
loginCookie = GetCookieDir('cda.pl.login')
self.login = config.plugins.iptvplayer.cda_login.value
self.password = config.plugins.iptvplayer.cda_password.value
sts, data = self.getPage(self.getMainUrl(), self.defaultParams)
if sts: self.setMainUrl(self.cm.meta['url'])
freshSession = False
if sts and '/logout' in data:
printDBG("Check hash")
hash = hexlify(md5('%s@***@%s' % (self.login, self.password)).digest())
prevHash = ReadTextFile(loginCookie)[1].strip()
printDBG("$hash[%s] $prevHash[%s]" % (hash, prevHash))
if hash == prevHash:
self.loggedIn = True
return
else:
freshSession = True
rm(loginCookie)
rm(self.COOKIE_FILE)
if freshSession:
sts, data = self.getPage(self.getMainUrl(), MergeDicts(self.defaultParams, {'use_new_session':True}))
self.loggedIn = False
if '' == self.login.strip() or '' == self.password.strip():
return False
actionUrl = 'https://www.cda.pl/login'
sitekey = ''
sts, data = self.getPage(actionUrl, self.defaultParams)
tries = 0
while tries < 2:
msgTab = [_('Login failed.')]
tries += 1
if sts:
r = ph.search(data, '''name=['"]r['"][^>]+?value=['"]([^'^"]+?)['"]''', flags=ph.I)[0]
post_data = {"r":r, "username":self.login, "password":self.password, "login":"******"}
params = dict(self.defaultParams)
HEADER = dict(self.AJAX_HEADER)
HEADER['Referer'] = self.MAIN_URL
params.update({'header':HEADER})
tmp = ph.findall(data, ('<form', '>', '/login'), '</form>', flags=ph.I)
for item in tmp:
if 'data-sitekey' in item:
sitekey = ph.search(item, '''data\-sitekey=['"]([^'^"]+?)['"]''')[0]
break
if sitekey != '':
token, errorMsgTab = self.processCaptcha(sitekey, self.cm.meta['url'])
if token != '': post_data['g-recaptcha-response'] = token
# login
sts, data = self.getPage(actionUrl, params, post_data)
printDBG(data)
if sts: msgTab.append(ph.clean_html(ph.find(data, ('<p', '>', 'error-form'), '</p>', flags=0)[1]))
if sts and '/logout' in data:
printDBG('tryTologin OK')
self.loggedIn = True
elif sts and sitekey == '' and 'data-sitekey' in data:
continue
else:
#printDBG(data)
self.sessionEx.waitForFinishOpen(MessageBox, '\n'.join(msgTab), type = MessageBox.TYPE_ERROR, timeout = 10)
printDBG('tryTologin failed')
break
if self.loggedIn:
hash = hexlify(md5('%s@***@%s' % (self.login, self.password)).digest())
WriteTextFile(loginCookie, hash)
return self.loggedIn
