class Kinotan(CBaseHostClass):
MAIN_URL = 'http://kinotan.ru/'
DEFAULT_ICON_URL = 'http://ipic.su/img/img7/fs/logo2.1460442551.png'
SRCH_URL = MAIN_URL + '?do = search & mode = advanced & subaction = search & story ='
SERIES_URL = MAIN_URL + 'serial/'
MAIN_CAT_TAB = [dict(category='cat_serials', title=_('Serials'), icon=DEFAULT_ICON_URL, url=SERIES_URL),
dict(category='cat_tv_shows', title=_('TV shows'), icon=DEFAULT_ICON_URL, url=MAIN_URL + 'tv-shou/'),
dict(category='cat_mult', title=_('Cartoons'), icon=DEFAULT_ICON_URL, url=MAIN_URL + 'multserial/'),
dict(category='search', title=_('Search'), search_item=True),
dict(category='search_history', title=_('Search history'))]
SERIALS_CAT_TAB = [dict(category='genre', title=_('Genre selection'), icon=DEFAULT_ICON_URL, url=SERIES_URL),
dict(category='country', title=_('By country'), icon=DEFAULT_ICON_URL, url=SERIES_URL),
dict(category='trans', title=_('Translations'), icon=DEFAULT_ICON_URL, url=SERIES_URL),
dict(category='sel', title=_('Collections'), icon=DEFAULT_ICON_URL, url=SERIES_URL),
dict(category='years', title=_('By Year'), icon=DEFAULT_ICON_URL, url=SERIES_URL)]
def __init__(self):
CBaseHostClass.__init__(self, {'history': 'Kinotan', 'cookie': 'Kinotan.cookie'})
self.moonwalkParser = MoonwalkParser()
def _getFullUrl(self, url):
mainUrl = self.MAIN_URL
if 0 < len(url) and not url.startswith('http'):
if url.startswith('/'):
url = url[1:]
url = mainUrl + url
if not mainUrl.startswith('https://'):
url = url.replace('https://', 'http://')
return url
def getPage(self, url, params={}, post_data=None):
sts, data = self.cm.getPage(url, params, post_data)
return sts, data
def listsTab(self, tab, cItem, type='dir'):
printDBG("Kinotan.listsTab")
for item in tab:
params = dict(cItem)
params.update(item)
params['name'] = 'category'
if type == 'dir':
self.addDir(params)
else:
self.addVideo(params)
def listMainMenu(self, cItem, category):
printDBG("Kinotan.listCategories")
sts, data = self.getPage(cItem['url'])
if not sts: return
datac = self.cm.ph.getDataBeetwenMarkers(data, '<ul class="head-menu">', '</ul>', False)[1]
datac = re.compile('<a[^"]+?href="(.*?)".*>(.*?)</a></li>').findall(datac)
for item in datac:
if item[0] in ['/novosti/', 'http://kinotan.ru/skoro/',
'http://kinotan.ru/index.php?do=orderdesc']: continue
params = dict(cItem)
params.update({'category': category, 'title': item[1], 'url': self._getFullUrl(item[0])})
self.addDir(params)
self.listsTab(self.MAIN_CAT_TAB, {'name': 'category'})
def listGenre(self, cItem, category):
printDBG("Kinotan.listGenre")
sts, data = self.getPage(cItem['url'])
if not sts: return
datag = self.cm.ph.getDataBeetwenMarkers(data, '<ul class="main-menu clearfix">', '</ul>', False)[1]
datag = re.compile('<a[^"]+?href="(.*?)">(.*?)</a></li>').findall(datag)
for item in datag:
params = dict(cItem)
params.update({'category': category, 'title': item[1], 'url': self._getFullUrl(item[0])})
self.addDir(params)
def listCountry(self, cItem, category):
printDBG("Kinotan.listCountry")
sts, data = self.getPage(cItem['url'])
if not sts: return
datacn = self.cm.ph.getDataBeetwenMarkers(data, '<div class="navigright2">', '</div>', False)[1]
datacn = re.compile('href="(/xf.*?)">(.*?)</a><br>').findall(datacn)
for item in datacn:
params = dict(cItem)
params.update({'category': category, 'title': item[1], 'url': self._getFullUrl(item[0][1:])})
self.addDir(params)
def listTrans(self, cItem, category):
printDBG("Kinotan.listTrans")
sts, data = self.getPage(cItem['url'])
if not sts: return
datatr = self.cm.ph.getDataBeetwenMarkers(data, '<div class="navigright3">', '</div>', False)[1]
datatr = re.compile('href="(/xf.*?)">(.*?)</a><br>').findall(datatr)
for item in datatr:
params = dict(cItem)
params.update({'category': category, 'title': item[1], 'url': self._getFullUrl(item[0][1:])})
self.addDir(params)
def listSel(self, cItem, category):
printDBG("Kinotan.listSel")
sts, data = self.getPage(cItem['url'])
if not sts: return
data1 = self.cm.ph.getDataBeetwenMarkers(data, '<div class="navigright">', '</div>', False)[1]
datasl = re.compile('href="(/xf.*?)">(.*?)</a><br>').findall(data1)
for item in datasl:
params = dict(cItem)
params.update({'category': category, 'title': item[1], 'url': self._getFullUrl(item[0][1:])})
self.addDir(params)
def listYears(self, cItem, category):
printDBG("Kinotan.listYears")
sts, data = self.getPage(cItem['url'])
if not sts: return
data1 = self.cm.ph.getDataBeetwenMarkers(data, '<div class="navigright">', '</div>', False)[1]
datay = re.compile('href="(/t.*?)">(.*?)</a><br>').findall(data1)
for item in datay:
params = dict(cItem)
params.update({'category': category, 'title': item[1][:-2], 'url': self._getFullUrl(item[0][1:])})
self.addDir(params)
def listItems(self, cItem, category):
printDBG("Kinotan.listItems")
tmp = cItem['url'].split('?')
url = tmp[0]
if len(tmp) > 1:
args = cItem.get('title', None)
url = self.SRCH_URL+args
page = cItem.get('page', 1)
if page > 1:
url += 'page/%s/' % page
post_data = cItem.get('post_data', None)
sts, data = self.getPage(url, {}, post_data)
if not sts: return
nextPage = False
if ('/page/%s/' % (page + 1)) in data:
nextPage = True
data = self.cm.ph.getDataBeetwenMarkers(data, '<div class="short-item">', '</div></div>', False)[1]
data = data.split('<div class="short-item">')
for item in data:
url = self.cm.ph.getSearchGroups(item, '<h3>.*"(.*?)">.*</a>')[0]
icon = self.cm.ph.getSearchGroups(item, 'src="(.*?)"')[0][1:]
icon = self._getFullUrl(icon)
title = self.cm.ph.getSearchGroups(item, '<h3>.*".*">(.*?)</a>')[0]
desc1 = self.cm.ph.getSearchGroups(item, 'label">(.*?)</div>')[0]
desc2 = self.cm.ph.getSearchGroups(item, 'update3">(.*?)</div>')[0]
desc = desc1 + ': ' + desc2
params = dict(cItem)
params.update({'category': category, 'title': title, 'icon': self._getFullUrl(icon), 'desc': desc, 'url': self._getFullUrl(url)})
self.addDir(params)
if nextPage:
params = dict(cItem)
params.update({'title': _('Next page'), 'page': cItem.get('page', 1) + 1})
self.addDir(params)
def listContent(self, cItem, category):
printDBG("Kinotan.listContent")
sts, data = self.getPage(cItem['url'])
if not sts: return
title = cItem['title']
d_url = self.cm.ph.getDataBeetwenMarkers(data, '<div class="full-text">', '</iframe>', False)[1]
url = re.compile('src="(.*?)"').findall(d_url)[0]
if url.startswith('//'):
url = 'http:' + url
desc = self.cm.ph.getDataBeetwenMarkers(data, '<h2 class="opisnie">', '<div style="display', False)[1]
desc = re.compile('>(.*?)</div>').findall(desc)[0]
desc = self.cleanHtmlStr(desc)
params = dict(cItem)
params['desc'] = desc
params['url'] = url
hostName = self.up.getHostName(url)
if hostName in ['serpens.nl', '37.220.36.15']:
hostName = 'moonwalk.cc'
if hostName == 'moonwalk.cc' and '/serial/' in url:
params.update({'category': category, 'serie_title': title})
season = self.moonwalkParser.getSeasonsList(url)
for item in season:
param = dict(params)
param.update(
{'host_name': 'moonwalk', 'title': item['title'], 'season_id': item['id'], 'url': item['url']})
self.addDir(param)
return
if 1 == self.up.checkHostSupport(url):
self.addVideo(params)
def listEpisodes(self, cItem):
printDBG("Kinotan.listEpisodes")
hostName = cItem['host_name']
if hostName == 'moonwalk':
title = cItem['serie_title']
id = cItem['season_id']
episodes = self.moonwalkParser.getEpiodesList(cItem['url'], id)
for item in episodes:
params = dict(cItem)
params.update(
{'title': '{0} - s{1}e{2} {3}'.format(title, id, item['id'], item['title']), 'url': item['url']})
self.addVideo(params)
def listSearchResult(self, cItem, searchPattern, searchType):
searchPattern = urllib.quote_plus(searchPattern)
cItem = dict(cItem)
cItem['url'] = self.SRCH_URL
cItem['post_data'] = {'do': 'search', 'subaction': 'search', 'x': 0, 'y': 0, 'story': searchPattern}
self.listItems(cItem, 'list_content')
def getLinksForVideo(self, cItem):
printDBG("Kinotan.getLinksForVideo [%s]" % cItem)
urlTab = []
urlTab.append({'name': 'Main url', 'url': cItem['url'], 'need_resolve': 1})
return urlTab
def getVideoLinks(self, videoUrl):
printDBG("Kinotan.getVideoLinks [%s]" % videoUrl)
urlTab = []
if videoUrl.startswith('http'):
urlTab = self.up.getVideoLinkExt(videoUrl)
return urlTab
def getFavouriteData(self, cItem):
return cItem['url']
def getLinksForFavourite(self, fav_data):
return self.getLinksForVideo({'url': fav_data})
def handleService(self, index, refresh=0, searchPattern='', searchType=''):
printDBG('handleService start')
CBaseHostClass.handleService(self, index, refresh, searchPattern, searchType)
name = self.currItem.get("name", '')
category = self.currItem.get("category", '')
printDBG("handleService: |||||||||||||||||||||||||||||||||||| name[%s], category[%s] " % (name, category))
self.currList = []
# MAIN MENU
if name == None:
self.listsTab(self.MAIN_CAT_TAB, {'name': 'category'})
elif category == 'cat_tv_shows':
self.listItems(self.currItem, 'list_content')
elif category == 'cat_mult':
self.listItems(self.currItem, 'list_content')
# SERIALES
elif category == 'cat_serials':
self.listsTab(self.SERIALS_CAT_TAB, {'name': 'category'})
elif category == 'genre':
self.listGenre(self.currItem, 'list_items')
elif category == 'country':
self.listCountry(self.currItem, 'list_items')
elif category == 'trans':
self.listTrans(self.currItem, 'list_items')
elif category == 'sel':
self.listSel(self.currItem, 'list_items')
elif category == 'years':
self.listYears(self.currItem, 'list_items')
elif category == 'list_items':
self.listItems(self.currItem, 'list_content')
elif category == 'list_content':
self.listContent(self.currItem, 'list_episodes')
elif category == 'list_episodes':
self.listEpisodes(self.currItem)
# SEARCH
elif category in ["search", "search_next_page"]:
cItem = dict(self.currItem)
cItem.update({'search_item': False, 'name': 'category'})
self.listSearchResult(cItem, searchPattern, searchType)
# HISTORIA SEARCH
elif category == "search_history":
self.listsHistory({'name': 'history', 'category': 'search'}, 'desc', _("Type: "))
else:
printExc()
CBaseHostClass.endHandleService(self, index, refresh)
def __init__(self):
CBaseHostClass.__init__(self, {'history': 'Kinotan', 'cookie': 'Kinotan.cookie'})
self.moonwalkParser = MoonwalkParser()
def __init__(self):
CBaseHostClass.__init__(self, {'history':'Kinopokaz', 'cookie':'Kinopokaz.cookie'})
self.catCache = []
self.moonwalkParser = MoonwalkParser()
class Kinopokaz(CBaseHostClass):
MAIN_URL = 'http://online-kinopokaz.ru/'
DEFAULT_ICON_URL = "http://ipic.su/img/img7/fs/logi.1456142273.png"
MAIN_CAT_TAB = [{'category':'categories', 'title':_('Movie categories'), 'url':MAIN_URL, 'icon':DEFAULT_ICON_URL},
{'category':'search', 'title':_('Search'), 'icon':DEFAULT_ICON_URL, 'search_item':True},
{'category':'search_history', 'title':_('Search history'), 'icon':DEFAULT_ICON_URL}]
def __init__(self):
CBaseHostClass.__init__(self, {'history':'Kinopokaz', 'cookie':'Kinopokaz.cookie'})
self.catCache = []
self.moonwalkParser = MoonwalkParser()
def _getFullUrl(self, url):
mainUrl = self.MAIN_URL
if 0 < len(url) and not url.startswith('http'):
if url.startswith('/'):
url = url[1:]
url = mainUrl + url
if not mainUrl.startswith('https://'):
url = url.replace('https://', 'http://')
return url
def cleanHtmlStr(self, str):
return self.cm.ph.removeDoubles(CBaseHostClass.cleanHtmlStr(str), ' ').replace(' ', ' ').strip()
def getPage(self, url, params={}, post_data=None):
sts,data = self.cm.getPage(url, params, post_data)
return sts,data
def listsTab(self, tab, cItem, type='dir'):
printDBG("Kinopokaz.listsTab")
for item in tab:
params = dict(cItem)
params.update(item)
params['name'] = 'category'
if type == 'dir':
self.addDir(params)
else: self.addVideo(params)
def listMainMenu(self, cItem, category):
printDBG("Kinopokaz.listCategories")
sts, data = self.getPage(cItem['url'])
if not sts: return
if 0 == len(self.catCache):
catData = self.cm.ph.getDataBeetwenMarkers(data, 'class="catsTable">', '</table>', False)[1]
catData = re.compile('href="([^"]+?)"[^>]*?>([^<]+?)<').findall(catData)
for item in catData:
if item[0] in ['http://online-kinopokaz.ru/load/serialy/12','http://online-kinopokaz.ru/load/multiplikacionnye/13', 'http://online-kinopokaz.ru/load/anime/24','http://online-kinopokaz.ru/load/tv_onlajn/23']:
continue
params = dict(cItem)
params.update({'category':category, 'title':item[1], 'url':item[0]})
self.catCache.append(params)
mainMenuData = self.cm.ph.getDataBeetwenMarkers(data, '<ul class="uMenuRoot">', '</ul>', False)[1]
mainMenuData = re.compile('href="/([^"]+?)"><span>([^<]+?)</span>').findall(mainMenuData)
for item in mainMenuData:
if item[0] in ['load/tv_onlajn/tv_onlajn_prjamoj_ehfir/23-1-0-4951','index/pomoshh/0-2', 'index/stol_zakazov/0-5','index/ne_rabotaet_film/0-6']:
continue
params = dict(cItem)
params.update({'category':category, 'title':item[1], 'url':self._getFullUrl(item[0])})
self.addDir(params)
self.listsTab(self.MAIN_CAT_TAB, {'name':'category'})
def listContent(self, cItem, category):
printDBG("Kinopokaz.listContent")
sts, data = self.getPage(cItem['url'])
if not sts: return
desc=''
title = cItem['title']
seriesData = self.cm.ph.getDataBeetwenMarkers(data, '<h2 style=', '<div id=', False)[1]#
if len(seriesData) == 0:
url = cItem['url']
else:
desc = self.cm.ph.getDataBeetwenMarkers(data, 'colspan="2">', '<h2 style="text-align:', False)[1]
desc = self.cleanHtmlStr(desc)
tranData = re.compile('<div align="center">(.*)</div>\n.*\s.+?src="(http:[^"]+?)"').findall(seriesData)
if tranData !=[]:
params = dict(cItem)
params['desc'] = desc
for item in tranData:
param = dict(params)
param.update({'category':'tran', 'title':item[0], 'url':item[1]})
self.addDir(param)
return
else:
url = self.cm.ph.getSearchGroups(seriesData, 'src="htt.*(//.*?)"')[0]
if url.startswith('//'):
url = 'http:' + url
params = dict(cItem)
params['desc'] = desc
params['url'] = url
hostName = self.up.getHostName(url)
if hostName in ['serpens.nl', '37.220.36.15']:
hostName = 'moonwalk.cc'
if hostName == 'moonwalk.cc' and '/serial/' in url:
params.update({'category':category, 'serie_title':title})
season = self.moonwalkParser.getSeasonsList(url)
for item in season:
param = dict(params)
param.update({'host_name':'moonwalk', 'title':item['title'], 'season_id':item['id'], 'url':item['url']})
self.addDir(param)
return
if self.up.checkHostSupport(url) == 1:
self.addVideo(params)
def listEpisodes(self, cItem):
printDBG("Kinopokaz.listEpisodes")
hostName = cItem['host_name']
if hostName == 'moonwalk':
title = cItem['serie_title']
id = cItem['season_id']
episodes = self.moonwalkParser.getEpiodesList(cItem['url'], id)
for item in episodes:
params = dict(cItem)
params.update({'title':'{0} - s{1}e{2} {3}'.format(title, id, item['id'], item['title']), 'url':item['url']})
self.addVideo(params)
def listItems(self, cItem, category):
printDBG("Kinopokaz.listItems")
tmp2 = cItem['url'].split('?')
url= tmp2[0]
tmp = cItem['url'].replace(self.MAIN_URL,'').split('/')
if 1 == len(tmp):
args = cItem.get('title', None)
url = '{0}search/?q={1}'.format(self.MAIN_URL, args)
tmp1 = 1
else:
arg = tmp[-1].split('-')
page = cItem.get('page', 1)
if 1 == page:
if 2 == len(tmp):
tmp1 = arg[0]+'-'+str(page+1)
else:
tmp1 = tmp[1]+'/'+arg[0]+'-'+str(page+1)
if 1 < page:
if 2 == len(tmp):
tmp1 = arg[0]+'-'+str(page+1)
url = self.MAIN_URL+tmp[0]+'/'+arg[0]+'-'+str(page)
else:
tmp1 = tmp[1]+'/'+arg[0]+'-'+str(page+1)
url = self.MAIN_URL+tmp[0]+'/'+tmp[1]+'/'+arg[0]+'-'+str(page)
post_data = cItem.get('post_data', None)
sts, data = self.getPage(url, {}, post_data)
if not sts: return
nextPage = False
if ('/load/%s' % tmp1) in data:
nextPage = True
m1 = '<div class="eTitle"'
data = self.cm.ph.getDataBeetwenMarkers(data, m1, '<div id="rightcol">', False)[1]
data = data.split(m1)
for item in data:
url = self.cm.ph.getSearchGroups(item, 'href="([^"]+?)"')[0]
title = self.cm.ph.getSearchGroups(item, 'alt="([^"]+?)"')[0]
if title == '':
title = self.cm.ph.getSearchGroups(item, 'href="[^"]+?">(.*?)</a>')[0]
title = self.cleanHtmlStr(title)
if title == '': continue
icon = self.cm.ph.getSearchGroups(item, 'src="([^"]+?)"')[0]
data = self.cm.ph.getDataBeetwenMarkers(item, '<div class="eMessage" style=','</p><br>', True)[1]
if data == '':
data = self.cm.ph.getDataBeetwenMarkers(item, '<div class="eMessage" style=','<br />', True)[1]
desc = data.replace(' ', '')
desc = self.cleanHtmlStr(desc)
params = dict(cItem)
params.update({'category':category, 'title':title, 'icon':self._getFullUrl(icon), 'desc':desc, 'url':self._getFullUrl(url)})
self.addDir(params)
if nextPage:
params = dict(cItem)
params.update({'title':_('Next page'), 'page':cItem.get('page', 1)+1})
self.addDir(params)
def listSearchResult(self, cItem, searchPattern, searchType):
searchPattern = searchPattern
searchPattern = urllib.quote_plus(searchPattern)
cItem = dict(cItem)
cItem['url'] = self.MAIN_URL
cItem['post_data'] = {'do':'search', 'subaction':'search', 'x':0, 'y':0, 'story':searchPattern}
self.listItems(cItem, 'list_content')
def getLinksForVideo(self, cItem):
printDBG("Kinopokaz.getLinksForVideo [%s]" % cItem)
urlTab = []
urlTab.append({'name':'Main url', 'url':cItem['url'], 'need_resolve':1})
return urlTab
def getVideoLinks(self, videoUrl):
printDBG("Kinopokaz.getVideoLinks [%s]" % videoUrl)
urlTab = []
if videoUrl.startswith('http'):
urlTab = self.up.getVideoLinkExt(videoUrl)
return urlTab
def getFavouriteData(self, cItem):
return cItem['url']
def getLinksForFavourite(self, fav_data):
return self.getLinksForVideo({'url':fav_data})
def handleService(self, index, refresh = 0, searchPattern = '', searchType = ''):
printDBG('handleService start')
CBaseHostClass.handleService(self, index, refresh, searchPattern, searchType)
name = self.currItem.get("name", '')
category = self.currItem.get("category", '')
printDBG( "handleService: |||||||||||||||||||||||||||||||||||| name[%s], category[%s] " % (name, category) )
self.currList = []
#MAIN MENU
if name == None:
self.listMainMenu({'name':'category', 'icon':self.DEFAULT_ICON_URL, 'url':self.MAIN_URL},'list_items')
elif category == 'categories':
self.listsTab(self.catCache, self.currItem)
elif category == 'list_items':
self.listItems(self.currItem, 'list_content')
elif category == 'list_content':
self.listContent(self.currItem, 'tran')
elif category == 'tran':
self.listContent(self.currItem, 'list_episodes')
elif category == 'list_episodes':
self.listEpisodes(self.currItem)
#SEARCH
elif category in ["search", "search_next_page"]:
cItem = dict(self.currItem)
cItem.update({'search_item':False, 'name':'category'})
self.listSearchResult(cItem, searchPattern, searchType)
#HISTORIA SEARCH
elif category == "search_history":
self.listsHistory({'name':'history', 'category': 'search'}, 'desc', _("Type: "))
else:
printExc()
CBaseHostClass.endHandleService(self, index, refresh)
class Kinotan(CBaseHostClass):
def __init__(self):
CBaseHostClass.__init__(self, {
'history': 'Kinotan',
'cookie': 'Kinotan.cookie'
})
self.moonwalkParser = MoonwalkParser()
self.hdgocc = HdgoccParser()
self.HEADER = {'User-Agent': 'Mozilla/5.0', 'Accept': 'text/html'}
self.AJAX_HEADER = dict(self.HEADER)
self.AJAX_HEADER.update({'X-Requested-With': 'XMLHttpRequest'})
self.MAIN_URL = 'http://kinotan.ru/'
self.DEFAULT_ICON_URL = 'http://ipic.su/img/img7/fs/logo2.1460442551.png'
self.MAIN_CAT_TAB = [{
'category': 'cat_serials',
'title': _('Serials'),
'url': self.getFullUrl('/serial/')
}, {
'category': 'cat_tv_shows',
'title': _('TV shows'),
'url': self.getFullUrl('/tv-shou/')
}, {
'category': 'cat_mult',
'title': _('Cartoons'),
'url': self.getFullUrl('/multserial/')
}, {
'category': 'search',
'title': _('Search'),
'search_item': True
}, {
'category': 'search_history',
'title': _('Search history')
}]
self.SERIALS_CAT_TAB = [{
'category': 'genre',
'title': _('Genre selection'),
'url': self.getFullUrl('/serial/')
}, {
'category': 'country',
'title': _('By country'),
'url': self.getFullUrl('/serial/')
}, {
'category': 'trans',
'title': _('Translations'),
'url': self.getFullUrl('/serial/')
}, {
'category': 'sel',
'title': _('Collections'),
'url': self.getFullUrl('/serial/')
}, {
'category': 'years',
'title': _('By Year'),
'url': self.getFullUrl('/serial/')
}]
self.cacheContentTab = {}
def getPage(self, url, params={}, post_data=None):
sts, data = self.cm.getPage(url, params, post_data)
return sts, data
def listMainMenu(self, cItem, category):
printDBG("Kinotan.listCategories")
sts, data = self.getPage(cItem['url'])
if not sts: return
datac = self.cm.ph.getDataBeetwenMarkers(data,
'<ul class="head-menu">',
'</ul>', False)[1]
datac = re.compile(
'<a[^"]+?href="([^"]*?)"[^>]*?>(.*?)</a></li>').findall(datac)
for item in datac:
if item[0] in [
'/novosti/', 'http://kinotan.ru/skoro/',
'http://kinotan.ru/index.php?do=orderdesc'
]:
continue
params = dict(cItem)
params.update({
'category': category,
'title': item[1],
'url': self.getFullUrl(item[0])
})
self.addDir(params)
self.listsTab(self.MAIN_CAT_TAB, {'name': 'category'})
def listGenre(self, cItem, category):
printDBG("Kinotan.listGenre")
sts, data = self.getPage(cItem['url'])
if not sts: return
datag = self.cm.ph.getDataBeetwenMarkers(
data, '<ul class="main-menu clearfix">', '</ul>', False)[1]
datag = re.compile('<a[^"]+?href="([^"]*?)">(.*?)</a></li>').findall(
datag)
for item in datag:
params = dict(cItem)
params.update({
'category': category,
'title': item[1],
'url': self.getFullUrl(item[0])
})
self.addDir(params)
def listCountry(self, cItem, category):
printDBG("Kinotan.listCountry")
sts, data = self.getPage(cItem['url'])
if not sts: return
datacn = self.cm.ph.getDataBeetwenMarkers(data,
'<div class="navigright2">',
'</div>', False)[1]
datacn = re.compile('href="(/xf[^"]*?)"[^>]+?>(.*?)</a><br>').findall(
datacn)
for item in datacn:
params = dict(cItem)
params.update({
'category': category,
'title': item[1],
'url': self.getFullUrl(item[0][1:])
})
self.addDir(params)
def listTrans(self, cItem, category):
printDBG("Kinotan.listTrans")
sts, data = self.getPage(cItem['url'])
if not sts: return
datatr = self.cm.ph.getDataBeetwenMarkers(data,
'<div class="navigright3">',
'</div>', False)[1]
datatr = re.compile('href="(/xf[^"]*?)"[^>]+?>(.*?)</a><br>').findall(
datatr)
for item in datatr:
params = dict(cItem)
params.update({
'category': category,
'title': item[1],
'url': self.getFullUrl(item[0][1:])
})
self.addDir(params)
def listSel(self, cItem, category):
printDBG("Kinotan.listSel")
sts, data = self.getPage(cItem['url'])
if not sts: return
data1 = self.cm.ph.getDataBeetwenMarkers(data,
'<div class="navigright">',
'</div>', False)[1]
datasl = re.compile('href="(/xf[^"]*?)"[^>]+?>(.*?)</a><br>').findall(
data1)
for item in datasl:
params = dict(cItem)
params.update({
'category': category,
'title': item[1],
'url': self.getFullUrl(item[0][1:])
})
self.addDir(params)
def listYears(self, cItem, category):
printDBG("Kinotan.listYears")
sts, data = self.getPage(cItem['url'])
if not sts: return
data1 = self.cm.ph.getDataBeetwenMarkers(data,
'<div class="navigright">',
'</div>', False)[1]
datay = re.compile('href="(/t[^"]*?)"[^>]+?>(.*?)</a><br>').findall(
data1)
for item in datay:
params = dict(cItem)
params.update({
'category': category,
'title': item[1][:-2],
'url': self.getFullUrl(item[0][1:])
})
self.addDir(params)
def listItems(self, cItem, category):
printDBG("Kinotan.listItems")
tmp = cItem['url'].split('?')
url = tmp[0]
if len(tmp) > 1:
args = cItem.get('title', None)
url = self.SRCH_URL + args
page = cItem.get('page', 1)
if page > 1:
url += 'page/%s/' % page
post_data = cItem.get('post_data', None)
sts, data = self.getPage(url, {}, post_data)
if not sts: return
nextPage = False
if ('/page/%s/' % (page + 1)) in data:
nextPage = True
data = self.cm.ph.getDataBeetwenMarkers(data,
'<div class="short-item">',
'</div></div>', False)[1]
data = data.split('<div class="short-item">')
for item in data:
url = self.cm.ph.getSearchGroups(item, '<h3>.*"(.*?)">.*</a>')[0]
icon = self.cm.ph.getSearchGroups(item, 'src="(.*?)"')[0][1:]
icon = self.getFullUrl(icon)
title = self.cm.ph.getSearchGroups(item, '<h3>.*".*">(.*?)</a>')[0]
desc1 = self.cm.ph.getSearchGroups(item, 'label">(.*?)</div>')[0]
desc2 = self.cm.ph.getSearchGroups(item, 'update3">(.*?)</div>')[0]
desc = desc1 + ': ' + desc2
params = dict(cItem)
params.update({
'category': category,
'title': title,
'icon': self.getFullUrl(icon),
'desc': desc,
'url': self.getFullUrl(url)
})
self.addDir(params)
if nextPage:
params = dict(cItem)
params.update({
'title': _('Next page'),
'page': cItem.get('page', 1) + 1
})
self.addDir(params)
def listIndexes(self, cItem, nextCategory, nextCategory2):
printDBG("Kinotan.listIndexes")
sts, data = self.getPage(cItem['url'])
if not sts: return
idx = 0
tmp = self.cm.ph.getAllItemsBeetwenNodes(data,
('<div', '>', 'news-item'),
('</div', '>'))
for item in tmp:
url = self.getFullUrl(
self.cm.ph.getSearchGroups(item,
'''\shref=['"]([^'^"]+?)['"]''', 1,
True)[0])
if url == '' and idx == 0: url = cItem['url']
title = self.cleanHtmlStr(item)
if url == '': continue
params = dict(cItem)
params.update({
'good_for_fav': False,
'category': nextCategory,
'title': title,
'url': url
})
self.addDir(params)
if len(self.currList) < 2:
self.currList = []
cItem = dict(cItem)
self.listContent(cItem, nextCategory2, data)
def listContent(self, cItem, category, data=None):
printDBG("Kinotan.listContent")
self.cacheContentTab = {}
if data == None:
sts, data = self.getPage(cItem['url'])
if not sts: return
tabs = []
tmp = self.cm.ph.getAllItemsBeetwenMarkers(data, '<div id="videotabs_',
'</div>')
printDBG(tmp)
for item in tmp:
title = self.cleanHtmlStr(item)
tab_block = self.cm.ph.getSearchGroups(item,
'''re_xfn="([^"]+?)"''')[0]
tab_id = self.cm.ph.getSearchGroups(item,
'''re_idnews="([0-9]+?)"''')[0]
tab_page = self.cm.ph.getSearchGroups(item,
'''re_page="([0-9]+?)"''')[0]
printDBG('>>>>>>>>> tab_block[%s] tab_id[%s] tab_page[%s]' %
(tab_block, tab_id, tab_page))
if '' != tab_block and '' != tab_id and '' != tab_page:
post_data = {
'block': tab_block,
'id': tab_id,
'page': tab_page
}
tabs.append({
'title':
title,
'url':
self.getFullUrl('/engine/ajax/re_video_part.php'),
'post_data':
post_data
})
if len(tabs):
params = dict(cItem)
params['category'] = 'list_tab_content'
self.listsTab(tabs, params)
return
tmp = self.cm.ph.getDataBeetwenMarkers(data, 'RalodePlayer.init(',
'"});', False)[1]
if tmp != '':
try:
tmp = byteify(json.loads('[' + tmp + '"}]'))[0]
for sKey in tmp:
tabs = []
sTitle = self.cleanHtmlStr(tmp[sKey]['name'])
sId = self.cleanHtmlStr(tmp[sKey]['id'])
for eKey in tmp[sKey]['items']:
title = self.cleanHtmlStr(
tmp[sKey]['items'][eKey]['sname'])
url = self.cm.ph.getSearchGroups(
tmp[sKey]['items'][eKey]['scode'],
'src="([^"]*?)"')[0]
if url.startswith('//'): url = 'http:' + url
try:
sortVal = int(
self.cm.ph.getSearchGroups(
' %s ' % title,
'''[^0-9]([0-9]+?)[^0-9]''')[0])
except Exception:
sortVal = 0
tabs.append({
'title': title,
'sort_value': sortVal,
'url': url
})
if len(tabs):
tabs.sort(key=lambda item: item['sort_value'])
params = dict(cItem)
params.update({
'category': 'list_tab_content',
'title': sTitle,
'tab_id': sId
})
self.addDir(params)
self.cacheContentTab[sId] = tabs
except Exception:
printExc()
d_url = self.cm.ph.getDataBeetwenMarkers(data,
'<div class="full-text">',
'</iframe>', False)[1]
url = self.cm.ph.getSearchGroups(d_url, 'src="([^"]*?)"')[0]
if url.startswith('//'): url = 'http:' + url
desc = self.cm.ph.getDataBeetwenMarkers(data, '<h2 class="opisnie">',
'</div>', True)[1]
desc = self.cm.ph.getSearchGroups(desc, '>(.*?)</div>')[0]
desc = self.cleanHtmlStr(desc)
self.exploreLink(cItem, category, url, desc)
def exploreLink(self, cItem, category, url, desc=''):
title = cItem['title']
params = dict(cItem)
params['desc'] = desc
params['url'] = url
hostName = self.up.getHostName(url)
if hostName in ['serpens.nl', '37.220.36.15']:
hostName = 'moonwalk.cc'
params.update({'category': category, 'serie_title': title})
if hostName == 'moonwalk.cc' and '/serial/' in url:
seasons = self.moonwalkParser.getSeasonsList(url)
for item in seasons:
param = dict(params)
param.update({
'host_name': 'moonwalk',
'title': item['title'],
'season_id': item['id'],
'url': item['url']
})
self.addDir(param)
return
elif hostName == 'hdgo.cc':
url = strwithmeta(url, {'Referer': cItem['url']})
seasons = self.hdgocc.getSeasonsList(url)
for item in seasons:
param = dict(params)
param.update({
'host_name': 'hdgo.cc',
'title': item['title'],
'season_id': item['id'],
'url': item['url']
})
self.addDir(param)
if 0 != len(seasons):
return
seasonUrl = url
episodes = self.hdgocc.getEpiodesList(seasonUrl, -1)
for item in episodes:
param = dict(params)
param.update({
'title':
'{0} - {1} - s01e{2} '.format(title, item['title'],
item['id']),
'url':
item['url']
})
self.addVideo(param)
if 0 != len(episodes):
return
if 1 == self.up.checkHostSupport(url):
self.addVideo(params)
def listTabContent(self, cItem, category):
printDBG("Kinotan.listTabContent")
tabId = cItem.get('tab_id', '')
if tabId != '':
tabs = self.cacheContentTab[tabId]
for item in tabs:
params = dict(cItem)
params['title'] = item['title']
self.exploreLink(params, category, item['url'])
else:
post_data = cItem.get('post_data')
sts, data = self.getPage(cItem['url'], {}, post_data)
if not sts: return
printDBG("==========================================")
printDBG(data)
printDBG("==========================================")
url = data.strip()
if url.startswith('http://') or url.startswith('https://'):
self.exploreLink(cItem, category, url)
def listEpisodes(self, cItem):
printDBG("Kinotan.listEpisodes")
title = cItem['serie_title']
id = cItem['season_id']
hostName = cItem['host_name']
episodes = []
if hostName == 'moonwalk':
episodes = self.moonwalkParser.getEpiodesList(cItem['url'], id)
elif hostName == 'hdgo.cc':
episodes = self.hdgocc.getEpiodesList(cItem['url'], id)
for item in episodes:
params = dict(cItem)
params.update({
'title':
'{0} - s{1}e{2} {3}'.format(title, id, item['id'],
item['title']),
'url':
item['url']
})
self.addVideo(params)
def listSearchResult(self, cItem, searchPattern, searchType):
#searchPattern = 'сезон'
post_data = {
'do': 'search',
'titleonly': 3,
'subaction': 'search',
'story': searchPattern
}
sts, data = self.getPage(self.getMainUrl(), post_data=post_data)
if not sts: return
m1 = '<div class="short-item">'
data = self.cm.ph.getDataBeetwenMarkers(data, m1,
'<div class="navigright">',
False)[1]
data = data.split(m1)
for item in data:
title = self.cleanHtmlStr(
self.cm.ph.getDataBeetwenMarkers(item, '<h3', '</h3>')[1])
if title == '':
title = self.cleanHtmlStr(
self.cm.ph.getSearchGroups(
item, '''alt=['"]([^'^"]+?)['"]''')[0])
icon = self.getFullIconUrl(
self.cm.ph.getSearchGroups(item,
'''src=['"]([^'^"]+?)['"]''')[0])
url = self.getFullUrl(
self.cm.ph.getSearchGroups(item,
'''href=['"]([^'^"]+?)['"]''')[0])
desc = self.cleanHtmlStr(
self.cm.ph.getDataBeetwenMarkers(item, '<a', '</a>')[1])
if self.cm.isValidUrl(url):
params = dict(cItem)
params.update({
'category': 'list_content',
'title': title,
'icon': icon,
'desc': desc,
'url': url
})
self.addDir(params)
def getLinksForVideo(self, cItem):
printDBG("Kinotan.getLinksForVideo [%s]" % cItem)
urlTab = []
urlTab.append({
'name': 'Main url',
'url': cItem['url'],
'need_resolve': 1
})
return urlTab
def getVideoLinks(self, videoUrl):
printDBG("Kinotan.getVideoLinks [%s]" % videoUrl)
urlTab = []
if videoUrl.startswith('http'):
urlTab = self.up.getVideoLinkExt(videoUrl)
return urlTab
def getFavouriteData(self, cItem):
return cItem['url']
def getLinksForFavourite(self, fav_data):
return self.getLinksForVideo({'url': fav_data})
def handleService(self, index, refresh=0, searchPattern='', searchType=''):
printDBG('handleService start')
CBaseHostClass.handleService(self, index, refresh, searchPattern,
searchType)
name = self.currItem.get("name", '')
category = self.currItem.get("category", '')
printDBG(
"handleService: |||||||||||||||||||||||||||||||||||| name[%s], category[%s] "
% (name, category))
self.currList = []
# MAIN MENU
if name == None:
self.listsTab(self.MAIN_CAT_TAB, {'name': 'category'})
elif category == 'cat_tv_shows':
self.listItems(self.currItem, 'list_indexes')
elif category == 'cat_mult':
self.listItems(self.currItem, 'list_indexes')
# SERIALES
elif category == 'cat_serials':
self.listsTab(self.SERIALS_CAT_TAB, {'name': 'category'})
elif category == 'genre':
self.listGenre(self.currItem, 'list_items')
elif category == 'country':
self.listCountry(self.currItem, 'list_items')
elif category == 'trans':
self.listTrans(self.currItem, 'list_items')
elif category == 'sel':
self.listSel(self.currItem, 'list_items')
elif category == 'years':
self.listYears(self.currItem, 'list_items')
elif category == 'list_items':
self.listItems(self.currItem, 'list_indexes')
elif category == 'list_indexes':
self.listIndexes(self.currItem, 'list_content', 'list_episodes')
elif category == 'list_content':
self.listContent(self.currItem, 'list_episodes')
elif category == 'list_tab_content':
self.listTabContent(self.currItem, 'list_episodes')
elif category == 'list_episodes':
self.listEpisodes(self.currItem)
# SEARCH
elif category in ["search", "search_next_page"]:
cItem = dict(self.currItem)
cItem.update({'search_item': False, 'name': 'category'})
self.listSearchResult(cItem, searchPattern, searchType)
# HISTORIA SEARCH
elif category == "search_history":
self.listsHistory({
'name': 'history',
'category': 'search'
}, 'desc', _("Type: "))
else:
printExc()
CBaseHostClass.endHandleService(self, index, refresh)
class Kinopokaz(CBaseHostClass):
MAIN_URL = 'http://online-kinopokaz.ru/'
DEFAULT_ICON_URL = "http://ipic.su/img/img7/fs/logi.1456142273.png"
MAIN_CAT_TAB = [{
'category': 'categories',
'title': _('Movie categories'),
'url': MAIN_URL,
'icon': DEFAULT_ICON_URL
}, {
'category': 'search',
'title': _('Search'),
'icon': DEFAULT_ICON_URL,
'search_item': True
}, {
'category': 'search_history',
'title': _('Search history'),
'icon': DEFAULT_ICON_URL
}]
def __init__(self):
CBaseHostClass.__init__(self, {
'history': 'Kinopokaz',
'cookie': 'Kinopokaz.cookie'
})
self.catCache = []
self.moonwalkParser = MoonwalkParser()
self.hdgocc = HdgoccParser()
self.HEADER = {'User-Agent': 'Mozilla/5.0', 'Accept': 'text/html'}
self.AJAX_HEADER = dict(self.HEADER)
self.AJAX_HEADER.update({'X-Requested-With': 'XMLHttpRequest'})
def _getFullUrl(self, url):
mainUrl = self.MAIN_URL
if 0 < len(url) and not url.startswith('http'):
if url.startswith('/'):
url = url[1:]
url = mainUrl + url
if not mainUrl.startswith('https://'):
url = url.replace('https://', 'http://')
return url
def cleanHtmlStr(self, str):
return self.cm.ph.removeDoubles(CBaseHostClass.cleanHtmlStr(str),
' ').replace(' ',
' ').strip()
def getPage(self, url, params={}, post_data=None):
sts, data = self.cm.getPage(url, params, post_data)
return sts, data
def listsTab(self, tab, cItem, type='dir'):
printDBG("Kinopokaz.listsTab")
for item in tab:
params = dict(cItem)
params.update(item)
params['name'] = 'category'
if type == 'dir':
self.addDir(params)
else:
self.addVideo(params)
def listMainMenu(self, cItem, category):
printDBG("Kinopokaz.listCategories")
sts, data = self.getPage(cItem['url'])
if not sts: return
if 0 == len(self.catCache):
catData = self.cm.ph.getDataBeetwenMarkers(data,
'class="catsTable">',
'</table>', False)[1]
catData = re.compile('href="(/[^"]+?)"[^>]*?>([^<]+?)<').findall(
catData)
for item in catData:
if item[0] in [
'/load/serialy/12', '/load/multiplikacionnye/13',
'/load/anime/24', '/load/tv_onlajn/23',
'/load/trillery/10'
]:
continue
params = dict(cItem)
params.update({
'category': category,
'title': item[1],
'url': self._getFullUrl(item[0])
})
self.catCache.append(params)
mainMenuData = self.cm.ph.getDataBeetwenMarkers(
data, '<ul class="uMenuRoot">', '</ul>', False)[1]
mainMenuData = re.compile(
'href="/([^"]+?)"><span>([^<]+?)</span>').findall(mainMenuData)
for item in mainMenuData:
if item[0] in [
'/load/tv_onlajn/tv_onlajn_prjamoj_ehfir/23-1-0-4951',
'index/pomoshh/0-2', 'index/stol_zakazov/0-5',
'index/ne_rabotaet_film/0-6'
]:
continue
params = dict(cItem)
params.update({
'category': category,
'title': item[1],
'url': self._getFullUrl(item[0])
})
self.addDir(params)
self.listsTab(self.MAIN_CAT_TAB, {'name': 'category'})
def listContent(self, cItem, category):
printDBG("Kinopokaz.listContent")
sts, data = self.getPage(cItem['url'])
if not sts: return
desc = ''
title = cItem['title']
seriesData = self.cm.ph.getDataBeetwenMarkers(data, '<h2 style=',
'<div id=', False)[1] #
if len(seriesData) == 0:
url = cItem['url']
else:
desc = self.cm.ph.getDataBeetwenMarkers(data, 'colspan="2">',
'<h2 style="text-align:',
False)[1]
desc = self.cleanHtmlStr(desc)
tranData = re.compile(
'<div align="center">(.*)</div>\n.*\s.+?src="(http:[^"]+?)"'
).findall(seriesData)
if tranData != []:
params = dict(cItem)
params['desc'] = desc
for item in tranData:
param = dict(params)
param.update({
'category': 'tran',
'title': item[0],
'url': item[1]
})
self.addDir(param)
return
else:
url = self.cm.ph.getSearchGroups(seriesData,
'src="htt.*(//.*?)"')[0]
if url.startswith('//'):
url = 'http:' + url
params = dict(cItem)
params['desc'] = desc
params['url'] = strwithmeta(url, {'Referer': cItem['url']})
hostName = self.up.getHostName(url)
if hostName in ['serpens.nl', '37.220.36.15']:
hostName = 'moonwalk.cc'
params.update({'category': category, 'serie_title': title})
if hostName == 'moonwalk.cc' and '/serial/' in url:
params.update({'category': category, 'serie_title': title})
season = self.moonwalkParser.getSeasonsList(url)
for item in season:
param = dict(params)
param.update({
'host_name': 'moonwalk',
'title': item['title'],
'season_id': item['id'],
'url': item['url']
})
self.addDir(param)
return
elif hostName == 'hdgo.cc':
url = strwithmeta(url, {'Referer': cItem['url']})
seasons = self.hdgocc.getSeasonsList(url)
for item in seasons:
param = dict(params)
param.update({
'host_name': 'hdgo.cc',
'title': item['title'],
'season_id': item['id'],
'url': item['url']
})
self.addDir(param)
if 0 != len(seasons):
return
seasonUrl = url
episodes = self.hdgocc.getEpiodesList(seasonUrl, -1)
for item in episodes:
param = dict(params)
param.update({
'title':
'{0} - {1} - s01e{2} '.format(title, item['title'],
item['id']),
'url':
item['url']
})
self.addVideo(param)
if 0 != len(episodes):
return
if self.up.checkHostSupport(url) == 1:
self.addVideo(params)
def listEpisodes(self, cItem):
printDBG("Kinopokaz.listEpisodes")
title = cItem['serie_title']
id = cItem['season_id']
hostName = cItem['host_name']
episodes = []
if hostName == 'moonwalk':
episodes = self.moonwalkParser.getEpiodesList(cItem['url'], id)
elif hostName == 'hdgo.cc':
episodes = self.hdgocc.getEpiodesList(cItem['url'], id)
for item in episodes:
params = dict(cItem)
params.update({
'title':
'{0} - s{1}e{2} {3}'.format(title, id, item['id'],
item['title']),
'url':
item['url']
})
self.addVideo(params)
def listItems(self, cItem, category):
printDBG("Kinopokaz.listItems")
tmp2 = cItem['url'].split('?')
url = tmp2[0]
tmp = cItem['url'].replace(self.MAIN_URL, '').split('/')
if 1 == len(tmp):
args = cItem.get('title', None)
url = '{0}search/?q={1}'.format(self.MAIN_URL, args)
tmp1 = 1
else:
arg = tmp[-1].split('-')
page = cItem.get('page', 1)
if 1 == page:
if 2 == len(tmp):
tmp1 = arg[0] + '-' + str(page + 1)
else:
tmp1 = tmp[1] + '/' + arg[0] + '-' + str(page + 1)
if 1 < page:
if 2 == len(tmp):
tmp1 = arg[0] + '-' + str(page + 1)
url = self.MAIN_URL + tmp[0] + '/' + arg[0] + '-' + str(
page)
else:
tmp1 = tmp[1] + '/' + arg[0] + '-' + str(page + 1)
url = self.MAIN_URL + tmp[0] + '/' + tmp[1] + '/' + arg[
0] + '-' + str(page)
post_data = cItem.get('post_data', None)
sts, data = self.getPage(url, {}, post_data)
if not sts: return
nextPage = False
if ('/load/%s' % tmp1) in data:
nextPage = True
m1 = '<div class="eTitle"'
data = self.cm.ph.getDataBeetwenMarkers(data, m1,
'<div id="rightcol">',
False)[1]
data = data.split(m1)
for item in data:
url = self.cm.ph.getSearchGroups(item, 'href="([^"]+?)"')[0]
title = self.cm.ph.getSearchGroups(item, 'alt="([^"]+?)"')[0]
if title == '':
title = self.cm.ph.getSearchGroups(
item, 'href="[^"]+?">(.*?)</a>')[0]
title = self.cleanHtmlStr(title)
if title == '': continue
icon = self.cm.ph.getSearchGroups(item, 'src="([^"]+?)"')[0]
data = self.cm.ph.getDataBeetwenMarkers(
item, '<div class="eMessage" style=', '</p><br>', True)[1]
if data == '':
data = self.cm.ph.getDataBeetwenMarkers(
item, '<div class="eMessage" style=', '<br />', True)[1]
desc = data.replace(
' ', '')
desc = self.cleanHtmlStr(desc)
params = dict(cItem)
params.update({
'category': category,
'title': title,
'icon': self._getFullUrl(icon),
'desc': desc,
'url': self._getFullUrl(url)
})
self.addDir(params)
if nextPage:
params = dict(cItem)
params.update({
'title': _('Next page'),
'page': cItem.get('page', 1) + 1
})
self.addDir(params)
def listSearchResult(self, cItem, searchPattern, searchType):
searchPattern = searchPattern
searchPattern = urllib.quote_plus(searchPattern)
cItem = dict(cItem)
cItem['url'] = self.MAIN_URL
cItem['post_data'] = {
'do': 'search',
'subaction': 'search',
'x': 0,
'y': 0,
'story': searchPattern
}
self.listItems(cItem, 'list_content')
def getLinksForVideo(self, cItem):
printDBG("Kinopokaz.getLinksForVideo [%s]" % cItem)
urlTab = []
urlTab.append({
'name': 'Main url',
'url': cItem['url'],
'need_resolve': 1
})
return urlTab
def getVideoLinks(self, videoUrl):
printDBG("Kinopokaz.getVideoLinks [%s]" % videoUrl)
urlTab = []
if videoUrl.startswith('http'):
urlTab = self.up.getVideoLinkExt(videoUrl)
return urlTab
def getFavouriteData(self, cItem):
return cItem['url']
def getLinksForFavourite(self, fav_data):
return self.getLinksForVideo({'url': fav_data})
def handleService(self, index, refresh=0, searchPattern='', searchType=''):
printDBG('handleService start')
CBaseHostClass.handleService(self, index, refresh, searchPattern,
searchType)
name = self.currItem.get("name", '')
category = self.currItem.get("category", '')
printDBG(
"handleService: |||||||||||||||||||||||||||||||||||| name[%s], category[%s] "
% (name, category))
self.currList = []
#MAIN MENU
if name == None:
self.listMainMenu(
{
'name': 'category',
'icon': self.DEFAULT_ICON_URL,
'url': self.MAIN_URL
}, 'list_items')
elif category == 'categories':
self.listsTab(self.catCache, self.currItem)
elif category == 'list_items':
self.listItems(self.currItem, 'list_content')
elif category == 'list_content':
self.listContent(self.currItem, 'tran')
elif category == 'tran':
self.listContent(self.currItem, 'list_episodes')
elif category == 'list_episodes':
self.listEpisodes(self.currItem)
#SEARCH
elif category in ["search", "search_next_page"]:
cItem = dict(self.currItem)
cItem.update({'search_item': False, 'name': 'category'})
self.listSearchResult(cItem, searchPattern, searchType)
#HISTORIA SEARCH
elif category == "search_history":
self.listsHistory({
'name': 'history',
'category': 'search'
}, 'desc', _("Type: "))
else:
printExc()
CBaseHostClass.endHandleService(self, index, refresh)
class HDKinoMir(CBaseHostClass):
def __init__(self):
CBaseHostClass.__init__(self, {'history':'HDKinoMir', 'cookie':'HDKinoMir.cookie'})
self.USER_AGENT = "Mozilla/5.0 (Linux; U; Android 4.1.1; en-us; androVM for VirtualBox ('Tablet' version with phone caps) Build/JRO03S) AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Safari/534.30"
self.HEADER = {'User-Agent': self.USER_AGENT, 'Accept': 'text/html'}
self.defaultParams = {'use_cookie': True, 'load_cookie': True, 'save_cookie': True, 'cookiefile': self.COOKIE_FILE}
self.sortCache = []
self.catCache = []
self.moonwalkParser = MoonwalkParser()
self.ytParser = YouTubeParser()
self.MAIN_URL = 'http://hdkinomir.com/'
self.DEFAULT_ICON_URL = self.getFullIconUrl('/templates/prokino/images/logo.png')
self.MAIN_CAT_TAB = [{'category':'categories', 'title': _('Movie categories'), 'url':self.getMainUrl() },
{'category':'search', 'title': _('Search'), 'search_item':True },
{'category':'search_history', 'title': _('Search history') }
]
self.encoding = ''
def getPage(self, url, params={}, post_data=None):
sts,data = self.cm.getPage(url, params, post_data)
if sts and self.encoding == '': self.encoding = self.cm.ph.getSearchGroups(data, 'charset=([^"]+?)"')[0]
return sts,data
def getFullUrl(self, url):
url = url.replace('&', '&')
return CBaseHostClass.getFullUrl(self, url)
def listMainMenu(self, cItem, category):
printDBG("HDKinoMir.listCategories")
sts, data = self.getPage(cItem['url'])
if not sts: return
if 0 == len(self.sortCache):
sorData = self.cm.ph.getDataBeetwenMarkers(data, '<form name="news_set_sort"', '/> ', False)[1]
sorData = re.compile("dle_change_sort\('([^']+?)','([^']+?)'\)[^>]*?>([^<]+?)<").findall(sorData)
for item in sorData:
post_data = {'dlenewssortby':item[0], 'dledirection':item[1], 'set_new_sort':'dle_sort_cat', 'set_direction_sort':'dle_direction_cat'}
params = {'title':item[2], 'post_data':post_data}
self.sortCache.append(params)
if 0 == len(self.catCache):
catData = self.cm.ph.getDataBeetwenMarkers(data, '<div class="films-category">', '</div> ', False)[1]
catData = re.compile('href="([^"]+?)"[^>]*?>([^<]+?)<').findall(catData)
for item in catData:
params = dict(cItem)
params.update({'category':category, 'title':item[1], 'url':self.getFullUrl(item[0])})
self.catCache.append(params)
mainMenuData = self.cm.ph.getDataBeetwenMarkers(data, '<div class="top-menu-block">', '</ul>', False)[1]
mainMenuData = re.compile('href="([^"]+?)"[^>]*?>([^<]+?)<').findall(mainMenuData)
for item in mainMenuData:
if item[0] in ['/actors/', '/podborki-filmov.html']: continue
params = dict(cItem)
params.update({'category':category, 'title':item[1], 'url':self.getFullUrl(item[0])})
self.addDir(params)
self.listsTab(self.MAIN_CAT_TAB, {'name':'category'})
def listContent(self, cItem, category):
printDBG("HDKinoMir.listContent")
sts, data = self.getPage(cItem['url'])
if not sts: return
desc = self.cm.ph.getDataBeetwenMarkers(data, '<div class="full-right-detailes">', '<div style="clear:both;">', False)[1]
desc = self.cleanHtmlStr(desc)
title = cItem['title']
seriesData = self.cm.ph.getAllItemsBeetwenMarkers(data, '<strong class="seria">', '</center>', False)
if len(seriesData) > 1:
for item in seriesData:
url = self.cm.ph.getSearchGroups(item, '<iframe[^>]+?src="([^"]+?)"', 1, True)[0]
if url.startswith('//'):
url = 'http:' + url
params = dict(cItem)
params['desc'] = desc
params['url'] = url
hostName = self.up.getHostName(url)
if 'youtube' in hostName and 'list=' in url:
params.update({'host_name':'youtube_tray', 'category':category, 'title':self.cleanHtmlStr( item ), 'serie_title':title})
self.addDir(params)
continue
if 1 == self.up.checkHostSupport(url):
params['title'] = '{0} - {1}'.format(title, self.cleanHtmlStr( item ))
self.addVideo(params)
return
data = re.compile('<iframe[^>]+?src="([^"]+?)"', re.IGNORECASE).findall(data)
for url in data:
if url.startswith('//'):
url = 'http:' + url
params = dict(cItem)
params['desc'] = desc
params['url'] = url
hostName = self.up.getHostName(url)
if hostName in ['serpens.nl', '37.220.36.15', 'daaidaij.com', 'mastarti.com']:
hostName = 'moonwalk.cc'
if hostName == 'moonwalk.cc' and '/serial/' in url:
params.update({'category':category, 'serie_title':title})
season = self.moonwalkParser.getSeasonsList(url)
for item in season:
param = dict(params)
param.update({'host_name':'moonwalk', 'title':item['title'], 'season_id':item['id'], 'url':item['url']})
self.addDir(param)
return
if 1 == self.up.checkHostSupport(url):
self.addVideo(params)
def listEpisodes(self, cItem):
printDBG("HDKinoMir.listEpisodes")
hostName = cItem['host_name']
if hostName == 'moonwalk':
title = cItem['serie_title']
id = cItem['season_id']
episodes = self.moonwalkParser.getEpiodesList(cItem['url'], id)
for item in episodes:
params = dict(cItem)
params.update({'title':'{0} - s{1}e{2} {3}'.format(title, id, item['id'], item['title']), 'url':item['url']})
self.addVideo(params)
elif hostName == 'youtube_tray':
try:
list = self.ytParser.getVideosFromTraylist(cItem['url'], 'video', 1, cItem)
except Exception:
printExc()
return
for item in list:
if item['category'] != 'video': continue
self.addVideo(item)
def listItems(self, cItem, category):
printDBG("HDKinoMir.listItems")
tmp = cItem['url'].split('?')
url = tmp[0]
if len(tmp) > 1:
arg = tmp[1]
else: arg = ''
page = cItem.get('page', 1)
if page > 1:
url += 'page/%s/' % page
if '' != arg:
url += '?' + arg
post_data = cItem.get('post_data', None)
sts, data = self.getPage(url, {}, post_data)
if not sts: return
nextPage = False
if ('/page/%s/' % (page+1)) in data:
nextPage = True
m1 = '<div class="filmposters">'
data = self.cm.ph.getDataBeetwenNodes(data, ('<div', '>', 'filmposters'), ('<div', '>', 'center'), False)[1]
data = data.split(m1)
if len(data): data[-1] = data[-1].split('<div class="navigation">')[0]
for item in data:
url = self.cm.ph.getSearchGroups(item, 'href="([^"]+?)"')[0]
title = self.cm.ph.getSearchGroups(item, 'alt="([^"]+?)"')[0]
if title == '{title}': title = self.cm.ph.getDataBeetwenMarkers(item, '<span>', '</span>', False)[1]
title = self.cleanHtmlStr( title )
if title == '': continue
icon = self.cm.ph.getSearchGroups(item, 'src="([^"]+?)"')[0]
desc = self.cleanHtmlStr( item.split('<div class="ribbon">')[-1] )
params = dict(cItem)
params.update({'category':category, 'title':title, 'icon':self.getFullUrl(icon), 'desc':desc, 'url':self.getFullUrl(url)})
self.addDir(params)
if nextPage:
params = dict(cItem)
params.update({'title':_('Next page'), 'page':cItem.get('page', 1)+1})
self.addDir(params)
def listSearchResult(self, cItem, searchPattern, searchType):
#searchPattern = 'ОРБИТА'
if self.encoding == '':
sts, data = self.getPage(self.getMainUrl())
if not sts: return
try: searchPattern = searchPattern.decode('utf-8').encode(self.encoding, 'ignore')
except Exception: searchPattern = ''
post_data = {'do':'search', 'subaction':'search', 'story':searchPattern, 'x': 0, 'y': 0}
sts, data = self.getPage(self.getMainUrl(), post_data=post_data)
if not sts: return
m1 = '<div class="filmposters">'
data = self.cm.ph.getDataBeetwenMarkers(data, m1, '<div class="main">', False)[1]
data = data.split(m1)
for item in data:
title = self.cleanHtmlStr(self.cm.ph.getDataBeetwenMarkers(item, '<h2', '</h2>')[1])
if title == '': title = self.cleanHtmlStr(self.cm.ph.getSearchGroups(item, '''alt=['"]([^'^"]+?)['"]''')[0])
icon = self.getFullIconUrl(self.cm.ph.getSearchGroups(item, '''src=['"]([^'^"]+?)['"]''')[0])
url = self.getFullUrl(self.cm.ph.getSearchGroups(item, '''href=['"]([^'^"]+?)['"]''')[0])
desc = self.cleanHtmlStr(self.cm.ph.getDataBeetwenMarkers(item, '</h2>', '</div>')[1])
if self.cm.isValidUrl(url):
params = dict(cItem)
params.update({'category': 'list_content', 'title': title, 'icon': icon, 'desc': desc, 'url': url})
self.addDir(params)
def getLinksForVideo(self, cItem):
printDBG("HDKinoMir.getLinksForVideo [%s]" % cItem)
urlTab = []
urlTab.append({'name':'Main url', 'url':cItem['url'], 'need_resolve':1})
return urlTab
def getVideoLinks(self, videoUrl):
printDBG("HDKinoMir.getVideoLinks [%s]" % videoUrl)
urlTab = []
if 'HDKinoMir.com' in videoUrl:
sts, data = self.getPage(videoUrl)
if not sts: return []
data = self.cm.ph.getDataBeetwenMarkers(data, '<div class="wbox2 video dark">', '</iframe>', False)[1]
videoUrl = self.cm.ph.getSearchGroups(data, '<iframe[^>]+?src="(http[^"]+?)"', 1, True)[0]
if videoUrl.startswith('http'):
urlTab = self.up.getVideoLinkExt(videoUrl)
return urlTab
def getFavouriteData(self, cItem):
return cItem['url']
def getLinksForFavourite(self, fav_data):
return self.getLinksForVideo({'url':fav_data})
def handleService(self, index, refresh = 0, searchPattern = '', searchType = ''):
printDBG('handleService start')
CBaseHostClass.handleService(self, index, refresh, searchPattern, searchType)
name = self.currItem.get("name", '')
category = self.currItem.get("category", '')
printDBG( "handleService: |||||||||||||||||||||||||||||||||||| name[%s], category[%s] " % (name, category) )
self.currList = []
#MAIN MENU
if name == None:
self.listMainMenu({'name':'category', 'icon':self.DEFAULT_ICON_URL, 'url':self.MAIN_URL}, 'show_sort')
elif category == 'categories':
self.listsTab(self.catCache, self.currItem)
elif category == 'show_sort':
cItem = dict(self.currItem)
cItem['category'] = 'list_items'
self.listsTab(self.sortCache, cItem)
elif category == 'list_items':
self.listItems(self.currItem, 'list_content')
elif category == 'list_content':
self.listContent(self.currItem, 'list_episodes')
elif category == 'list_episodes':
self.listEpisodes(self.currItem)
#SEARCH
elif category in ["search", "search_next_page"]:
cItem = dict(self.currItem)
cItem.update({'search_item':False, 'name':'category'})
self.listSearchResult(cItem, searchPattern, searchType)
#HISTORIA SEARCH
elif category == "search_history":
self.listsHistory({'name':'history', 'category': 'search'}, 'desc', _("Type: "))
else:
printExc()
CBaseHostClass.endHandleService(self, index, refresh)