def getMovieData(self):
list = []
#-- get serial play list & parameters -------------------------------------
html = self.Auth.get_HTML(self.serial_url, None, 'http://serialu.net/media/uppod.swf')
# -- parsing web page
html = re.compile('<body>(.+?)<\/body>', re.MULTILINE|re.DOTALL).findall(html)[0]
soup = BeautifulSoup(html)
pl_url = ''
is_multiseason = len(soup.findAll('object', {'type':'application/x-shockwave-flash'}))
for rec in soup.findAll('object', {'type':'application/x-shockwave-flash'}):
if is_multiseason > 1:
season = rec.parent.previousSibling.previousSibling.text+r' '
else:
season = r''
for par in rec.find('param', {'name':'flashvars'})['value'].split('&'):
if par.split('=')[0] == 'pl':
pl_url = par[3:]
if pl_url.find('http:') == -1:
pl_url = xppod.Decode(pl_url)
#-- get playlist details ---------------------------------------------------
html = self.Auth.get_HTML(pl_url, None, 'http://serialu.net/media/uppod.swf')
self.pl_url = pl_url
# -- check if playlist is encoded
if html.find('{"playlist":[') == -1:
html = xppod.Decode(html).encode('utf-8').split(' or ')[0] #-- TODO: make smart choice
# -- parsing web page
s_url = ''
s_num = 0
movie_list = []
for rec in re.compile('{(.+?)}', re.MULTILINE|re.DOTALL).findall(html.replace('{"playlist":[', '')):
for par in rec.replace('"','').split(','):
if par.split(':')[0]== 'comment':
name = str(s_num+1) + ' серия' #par.split(':')[1]+' '
if par.split(':')[0]== 'file':
if 'http' in par.split(':')[1]:
s_url = par.split(':')[1]+':'+par.split(':')[2]
else:
s_url = xppod.Decode(par.split(':')[1]).split(' or ')[0]
s_num += 1
# mark part for history
name = season.encode('utf-8') + name
movie_list.append({'movie_name': name, 'url': s_url})
#if h_part <> '-':
# if name == h_part:
# name = '[COLOR FF00FF00]'+name+'[/COLOR]'
#-- parse data
list.append({'name':self.serial_name, 'img': self.serial_img, 'descr': self.serial_descr, 'season_number':s_num, 'name_orig':'', 'movie': movie_list})
#-- return movie list
return list
def Get_PlayList(url):
plist = []
#-- check if playlist should be decode
if url[:4] != 'http':
url = xppod.Decode(url)
if url[:4] != 'http':
return []
html = get_HTML(url)
try:
pl = json.loads(html)
except:
pl = json.loads(xppod.Decode(html))
for rec in pl['playlist']:
plist.append({
'comment':
rec['comment'].encode('iso-8859-1').decode('utf-8'),
'file':
rec['file']
})
return plist
def getVideoUrl(self, url):
self.cm.checkDir(ptv.getAddonInfo('path') + os.path.sep + "cookies")
#show adult content
self.cm.addCookieItem(COOKIEFILE, {
'name': 'AnyF18',
'value': 'mam18',
'domain': 'video.anyfiles.pl'
}, False)
query_data = {
'url': url,
'use_host': False,
'use_cookie': True,
'cookiefile': COOKIEFILE,
'load_cookie': True,
'save_cookie': True,
'use_post': False,
'return_data': True
}
data = self.cm.getURLRequestData(query_data)
#var flashvars = {"uid":"player-vid-8552","m":"video","st":"c:1LdwWeVs3kVhWex2PysGP45Ld4abN7s0v4wV"};
match = re.search("""var flashvars = {.+?"st":"(.+?)"}""", data)
if match:
nUrl = xppod.Decode(match.group(1)[2:]).encode('utf-8').strip()
if 'http://' in nUrl: url2 = nUrl
else: url2 = 'http://video.anyfiles.pl' + nUrl
query_data = {
'url': url2 + "&ref=" + urllib.quote_plus(url),
'use_host': False,
'use_cookie': True,
'cookiefile': COOKIEFILE,
'load_cookie': True,
'save_cookie': False,
'use_post': False,
'return_data': True
}
data = self.cm.getURLRequestData(query_data)
data = xppod.Decode(data).encode('utf-8').strip()
#json cleanup
while data[-2:] != '"}':
data = data[:-1]
result = simplejson.loads(data)
if (result['ytube'] == '0'):
vUrl = result['file'].split("or")
return vUrl[0]
else:
p = result['file'].split("/")
if 'watch' in p[3]: videoid = p[3][8:19]
else: videoid = p[3]
plugin = 'plugin://plugin.video.youtube/?action=play_video&videoid=' + videoid
return plugin
return False
def Get_Play_List(self, selected):
pl_url = self.pl_url
img = self.serial_img
# create play list
pl = xbmc.PlayList(1)
pl.clear()
#-- get playlist details -----
html = self.Auth.get_HTML(pl_url, None,
'http://serialu.net/media/uppod.swf')
if html == '':
return pl
# -- check if playlist is encoded
if html.find('{"playlist":[') == -1:
html = xppod.Decode(html).encode('utf-8')
# -- parsing web page
s_url = ''
s_num = 0
is_Found = False
for rec in re.compile('{(.+?)}', re.MULTILINE | re.DOTALL).findall(
html.replace('{"playlist":[', '')):
for par in rec.replace('"', '').split(','):
if par.split(':')[0] == 'comment':
name = str(s_num + 1) + ' серия' #par.split(':')[1]+' '
if par.split(':')[0] == 'file':
if 'http' in par.split(':')[1]:
s_url = par.split(':')[1] + ':' + par.split(':')[2]
else:
s_url = xppod.Decode(par.split(':')[1]).split(
' or ') #[0]
s_url = s_url[len(s_url) - 1]
s_num += 1
if name == selected.getLabel():
is_Found = True
if is_Found == True:
i = xbmcgui.ListItem(
self.serial_name + ' ' + name,
path=urllib.unquote(selected.getProperty('url')),
thumbnailImage=selected.getProperty('img'))
i.setProperty('IsPlayable', 'true')
pl.add(s_url, i)
if self.Auth.Addon.getSetting('continue_play') == 'false':
break
return pl
def Get_PlayList(pl_url, season = '', start_item = '', mode = 's'): #-- mode: s - seasons, e - episodes
plist = []
#-- get playlist items
post = None
html = get_HTML(pl_url, post)
pl = xppod.Decode(html)
pl = pl.encode('iso-8859-1').decode('utf-8').replace('\r','')
is_found = False
for r in json.loads(pl)['playlist']:
if mode == 's':
try:
x = r['playlist']
except:
pl = []
return pl
plist.append({'comment':r['comment'].lstrip().encode('utf-8'), 'file':pl_url})
else:
if r['comment'].lstrip().encode('utf-8') == season or season == '' or season == '-':
if season == '-':
if r['comment'].lstrip().encode('utf-8') == start_item or start_item == '':
is_found = True
if is_found:
plist.append({'comment':r['comment'].lstrip().encode('utf-8'), 'file':r['file']})
else:
for rec in r['playlist']:
if rec['comment'].lstrip().encode('utf-8') == start_item or start_item == '':
is_found = True
if is_found:
plist.append({'comment':rec['comment'].lstrip().encode('utf-8'), 'file':rec['file']})
return plist
def PLAY(params):
# -- parameters
url = urllib.unquote_plus(params['url'])
img = urllib.unquote_plus(params['img'])
serial = urllib.unquote_plus(params['serial'])
tag = urllib.unquote_plus(params['serial_tag'])
serial_url = urllib.unquote_plus(params['serial_url'])
name = urllib.unquote_plus(params['name'])
pl_url = urllib.unquote_plus(params['pl_url'])
pl_pos = int(urllib.unquote_plus(params['pl_pos']))
# -- if requested continious play
if Addon.getSetting('continue_play') == 'true':
pl = Get_Play_List(pl_url, pl_pos, img)
#xbmc.Player().play(pl)
xbmcplugin.setResolvedUrl(h, True, pl[0])
# -- play only selected item
else:
if url.find('http:') == -1:
url = xppod.Decode(url).split(' or ')
url = url[len(url) - 1]
i = xbmcgui.ListItem(name,
path=urllib.unquote(url),
thumbnailImage=img)
xbmcplugin.setResolvedUrl(h, True, i)
# -- save view history -----------------------------------------------------
Save_Last_Serial_Info(tag, serial, serial_url, img, name)
def Get_Play_List(pl_url, pos, img):
# create play list
pl = xbmc.PlayList(1)
pl.clear()
#-- get playlist details ---------------------------------------------------
html = get_HTML(pl_url, None, 'http://serialu.net/media/uppod.swf')
if html == '':
return pl
# -- check if playlist is encoded
if html.find('{"playlist":[') == -1:
html = xppod.Decode(html).encode('utf-8')
# -- parsing web page
s_url = ''
s_num = 0
for rec in re.compile('{(.+?)}', re.MULTILINE | re.DOTALL).findall(
html.replace('{"playlist":[', '')):
for par in rec.replace('"', '').split(','):
if par.split(':')[0] == 'comment':
name = str(s_num + 1) + ' серия' #par.split(':')[1]+' '
if par.split(':')[0] == 'file':
if 'http' in par.split(':')[1]:
s_url = par.split(':')[1] + ':' + par.split(':')[2]
else:
s_url = xppod.Decode(par.split(':')[1]).split(' or ')
s_url = s_url[len(s_url) - 1]
s_num += 1
if s_num >= pos:
i = xbmcgui.ListItem(name,
path=urllib.unquote(s_url),
thumbnailImage=img)
pl.add(s_url, i)
return pl
def PLAY(params):
# -- parameters
url = urllib.unquote_plus(params['url'])
img = urllib.unquote_plus(params['img'])
name = urllib.unquote_plus(params['name'])
# -- check if video available
html = get_HTML(url)
soup = BeautifulSoup(html)
for rec in soup.findAll("script"):
if 'id:"mediaplayer"' in rec.text:
html = rec.text
# -- parsing web page ----------------------------------------------------------
try:
str = re.compile('<embed (.+?)><\/embed>',
re.MULTILINE | re.DOTALL).findall(html)[0]
str = re.compile('flashvars="(.+?)"',
re.MULTILINE | re.DOTALL).findall(str)[0]
str = urllib.unquote(str).replace('src=', '')
except:
try:
str = re.compile('"file":"(.+?)"',
re.MULTILINE | re.DOTALL).findall(html)[0]
except:
print '###'
if str.find('http:') == -1:
str = xppod.Decode(str)
p_r = "rtmp://stream.nogomya.ch:1935/live"
p_a = "live?" + str.split('&')[0].split('?')[1]
p_f = "WIN 13,0,0,206"
p_W = "http://nogomya.ch/player/StrobeMediaPlayback.swf"
p_p = "http://nogomya.ch/stream/" + str.split('?')[0].split('/')[-1].split(
'.')[0]
p_y = str.split('&')[0].split('/')[-1]
video = str #'%s app=%s swfUrl=%s pageUrl=%s playpath=%s swfVfy=1 live=1'%(p_r, p_a, p_W, p_p, p_y, )
i = xbmcgui.ListItem(name, path=urllib.unquote(video), thumbnailImage=img)
xbmc.Player().play(video, i)
def Get_Play_List(self):
pl_url = self.serial_url
img = self.serial_img
# create play list
pl=xbmc.PlayList(1)
pl.clear()
#-- get playlist details -----
html = self.Auth.get_HTML(pl_url)
if html=='':
return pl
soup = BeautifulSoup(html, fromEncoding="windows-1251")
all_video = soup.findAll('object', {'type' : 'application/x-shockwave-flash'})
part = 1
if len(all_video) == 0:
return pl
for rec in all_video:
i_name = self.serial_name
if len(all_video) > 1:
i_name = i_name + ' (часть '+str(part)+')'
part = part+1
#--- get UPPOD flash parameters
flash_param = str(rec.find('param', {'name' : 'flashvars'})['value'])
video = re.compile('file=(.+?)&', re.MULTILINE|re.DOTALL).findall(flash_param)
video_url = video[0]
if video_url.find('http:') == -1:
video_url = xppod.Decode(video_url)
video_url = video_url.split(' or ') #[0]
video_url = video_url[len(video_url)-1]
i = xbmcgui.ListItem(i_name, video_url, thumbnailImage=img)
i.setProperty('IsPlayable', 'true')
pl.add(video_url, i)
return pl
return False
for rec in all_video:
i_name = name
if len(all_video) > 1:
i_name = i_name + ' (часть ' + str(part) + ')'
part = part + 1
#--- get UPPOD flash parameters
flash_param = str(rec.find('param', {'name': 'flashvars'})['value'])
video = re.compile('file=(.+?)&',
re.MULTILINE | re.DOTALL).findall(flash_param)
video_url = video[0]
if video_url.find('http:') == -1:
video_url = xppod.Decode(video_url)
#---
i = xbmcgui.ListItem(i_name, iconImage=image, thumbnailImage=image)
u = sys.argv[0] + '?mode=PLAY'
u += '&name=%s' % urllib.quote_plus(i_name)
u += '&url=%s' % urllib.quote_plus(video_url)
u += '&img=%s' % urllib.quote_plus(image)
#i.setProperty('IsPlayable', 'true')
xbmcplugin.addDirectoryItem(h, u, i, False)
xbmcplugin.endOfDirectory(h)
#-------------------------------------------------------------------------------
def getSeasonEpisods(self, url):
print "*** Get episods %s" % url
response = common.fetchPage({"link": url})
if response["status"] == 200:
content = response["content"]
player = common.parseDOM(content,
"object",
attrs={"id": "showday"})
pl = common.parseDOM(player,
"param",
attrs={"name": "flashvars"},
ret="pl")
url = xppod.Decode(pl[0].replace('"', ''))
uhash = self.getPlaylist(url)
playlist = xppod.Decode(uhash)
image_container = common.parseDOM(content,
"div",
attrs={"class": "image"})
image = self.url + common.parseDOM(
image_container, "img", ret="src")[0]
text = common.parseDOM(content, "div", attrs={"class": "text"})
infos = common.parseDOM(text, "p")
title = self.encode(common.parseDOM(text, "h4")[0])
desc = common.stripTags(self.encode(infos[0]))
genres = self.encode(', '.join(common.parseDOM(infos[1], "a")))
print "******* URL %s" % url
print url
#http://wx12.poiuytrew.pw/s/666f85f63f6c23aa777cbc9bfcaef508/neposeda.zy/e01_480.mp4
#http://wx12.poiuytrew.pw/s/666f85f63f6c23aa777cbc9bfcaef508/neposeda.zy/e01_[,480,].mp4
try:
response = eval(
playlist.replace('\t', '').replace(
'\r\n', '').encode('latin1').decode('utf-8'))
if 'playlist' in response['playlist'][0]:
print "This is a season multiple seasons"
seasons = response['playlist']
for season in seasons:
episods = season['playlist']
for episode in episods:
url = episode['file'].replace(',', '').replace(
'[', '').replace(']', '')
uri = sys.argv[
0] + '?mode=play&url=%s' % episode['file']
item = xbmcgui.ListItem(episode['comment'],
iconImage=image,
thumbnailImage=image)
info = {
'title': title,
'genre': genres,
'plot': desc,
'overlay': xbmcgui.ICON_OVERLAY_WATCHED,
'playCount': 0
}
item.setInfo(type='Video', infoLabels=info)
item.setProperty('IsPlayable', 'true')
xbmcplugin.addDirectoryItem(
self.handle, uri, item, False)
else:
print "This is one season"
for episode in response['playlist']:
etitle = episode['comment']
url = episode['file'].replace(',', '').replace(
'[', '').replace(']', '')
uri = sys.argv[0] + '?mode=play&url=%s' % url
item = xbmcgui.ListItem(etitle,
iconImage=image,
thumbnailImage=image)
info = {
'title': title,
'genre': genres,
'plot': desc,
'overlay': xbmcgui.ICON_OVERLAY_WATCHED,
'playCount': 0
}
item.setInfo(type='Video', infoLabels=info)
item.setProperty('IsPlayable', 'true')
xbmcplugin.addDirectoryItem(self.handle, uri, item,
False)
except Exception, e:
print e
def show(self, url):
print "*** Get film/episods %s" % url
response = common.fetchPage({"link": url})
if response["status"] == 200:
content = common.parseDOM(response["content"],
"div",
attrs={"id": "dle-content"})
body = common.parseDOM(content, "div", attrs={"class": "body"})
post = common.parseDOM(content,
"div",
attrs={"class": "text post"})
info = common.parseDOM(content, "div", attrs={"class": "info-box"})
player = common.parseDOM(content, "object")
film = common.parseDOM(player,
"param",
attrs={"name": "flashvars"},
ret="file")
season = common.parseDOM(player,
"param",
attrs={"name": "flashvars"},
ret="pl")
title = common.parseDOM(content, "h1")[0]
image = common.parseDOM(post,
"img",
attrs={"style": "float:left;"},
ret="src")[0]
title = self.encode(title)
image = image if 'http' in image else self.url + image
desc = self.encode(post[0].split('<br />')[1])
genre = common.parseDOM(info, "li", attrs={"class": "genre"})
genres = self.encode(', '.join(common.parseDOM(genre, "a")))
if film:
uppod_url = film[0].split('&')[0]
url = xppod.Decode(uppod_url.replace('"', ''))
uri = sys.argv[0] + '?mode=play&url=%s' % url
item = xbmcgui.ListItem(title,
iconImage=image,
thumbnailImage=image)
info = {
'title': title,
'genre': genres,
'plot': desc,
'overlay': xbmcgui.ICON_OVERLAY_WATCHED,
'playCount': 0
}
item.setInfo(type='Video', infoLabels=info)
item.setProperty('IsPlayable', 'true')
xbmcplugin.addDirectoryItem(self.handle, uri, item, False)
else:
print "This is a season"
uppod_url = season[0].split('&')[0]
url = xppod.Decode(uppod_url.replace('"', ''))
uhash = self.getPlaylist(url)
try:
playlist = xppod.Decode(uhash)
response = eval(
playlist.replace('\t', '').replace(
'\r\n', '').encode('latin1').decode('utf-8'))
if 'playlist' in response['playlist'][0]:
print "This is a season multiple seasons"
seasons = response['playlist']
for season in seasons:
episods = season['playlist']
for episode in episods:
uri = sys.argv[
0] + '?mode=play&url=%s' % episode['file']
item = xbmcgui.ListItem(episode['comment'],
iconImage=image,
thumbnailImage=image)
info = {
'title': title,
'genre': genres,
'plot': desc,
'overlay': xbmcgui.ICON_OVERLAY_WATCHED,
'playCount': 0
}
item.setInfo(type='Video', infoLabels=info)
item.setProperty('IsPlayable', 'true')
xbmcplugin.addDirectoryItem(
self.handle, uri, item, False)
else:
print "This is one season"
for episode in response['playlist']:
etitle = episode['comment']
url = episode['file']
uri = sys.argv[0] + '?mode=play&url=%s' % url
item = xbmcgui.ListItem(etitle,
iconImage=image,
thumbnailImage=image)
info = {
'title': title,
'genre': genres,
'plot': desc,
'overlay': xbmcgui.ICON_OVERLAY_WATCHED,
'playCount': 0
}
item.setInfo(type='Video', infoLabels=info)
item.setProperty('IsPlayable', 'true')
xbmcplugin.addDirectoryItem(
self.handle, uri, item, False)
except Exception, e:
print e
def readFile(params):
http = GET(params['href'])
#print http
if http == None: return False
beautifulSoup = BeautifulSoup(http)
content = beautifulSoup.find('param', attrs={'name': 'flashvars'})
#print content
findfile = str(content)
#print findfile
pat = re.compile('le=.+"', re.S)
pat_pl = re.compile('pl=.+"', re.S)
mfil = pat.findall(findfile)
pfil = pat_pl.findall(findfile)
flname = None
if mfil:
#print mfil[0][3:-1]
flname = xppod.Decode(mfil[0][3:-1])
#print flname
if pfil:
#print pfil[0][3:-1]
flname = xppod.Decode(pfil[0][3:-1])
#print flname
if not flname: return False
vurl = findfile.split('&')
for ur in vurl:
findfile = ur
vurl = findfile.split('"')
lurl = vurl[0]
#print 'lurl'+lurl
if mfil:
#print 'play file ' + mfil[0]
try:
li = xbmcgui.ListItem(params['title'],
addon_icon,
thumbnailImage=params['src'])
except:
li = xbmcgui.ListItem(params['title'],
addon_icon,
thumbnailImage=addon_icon)
li.setProperty('IsPlayable', 'true')
#print 'mfil0: '+xppod.Decode(lurl.split('=')[1])
uri = construct_request({'func': 'play', 'file': flname})
#print 'uri for addDir: '+uri
xbmcplugin.addDirectoryItem(hos, uri, li, False)
else:
#print 'playlist in ' + lurl.split('=')[1]
http = flname
#print 'after xppod: '+http
http = GET(http)
#print 'http pl='+http
f = http.find('{')
f1 = 0
f1 = http.rfind('}]}]}{')
pat = re.compile('[\w\d=.,+]+', re.S)
http = pat.findall(http)[0]
#print http
http = xppod.Decode(http).replace('', '')
#print http.encode('utf-8')
'''
print 'f1: '+str(f1)
if f1 == -1:
#print 'f1=0'
http=http[f:len(http)]
else:
#print 'f<>0'
http=http[f:f1+5]
http=http.replace('}]}]}{','}]}]')
#print 'http after replace: '+http
print http
'''
try:
jsdata = json.loads(str(http), 'iso-8859-1')
except:
#f1=http.rfind(']}')
#http=http[0:f1-1]
jsdata = json.loads(http)
#print jsdata
has_sesons = False
playlist = jsdata['playlist']
#print playlist
for file in playlist:
tt = file['comment']
tt = tt.encode("latin-1", "ignore")
l = ''
#for n in tt: l=l+ str(ord(n))+','
#print l
try:
li = xbmcgui.ListItem(tt,
addon_icon,
thumbnailImage=params['src'])
li.setProperty('IsPlayable', 'true')
uri = construct_request({'func': 'play', 'file': file['file']})
xbmcplugin.addDirectoryItem(hos, uri, li, False)
except:
pass
try:
for t in file['playlist']:
#print t
li = xbmcgui.ListItem(t['comment'].encode(
"latin-1", "ignore"),
addon_icon,
thumbnailImage=params['src'])
li.setProperty('IsPlayable', 'true')
uri = construct_request({
'func': 'play',
'file': t['file']
})
has_sesons = True
xbmcplugin.addDirectoryItem(hos, uri, li, False)
if has_sesons == False:
li = xbmcgui.ListItem(file['comment'].encode(
"latin-1", "ignore"),
addon_icon,
thumbnailImage=params['src'])
li.setProperty('IsPlayable', 'true')
uri = construct_request({
'func': 'play',
'file': file['file']
})
xbmcplugin.addDirectoryItem(hos, uri, li, False)
except:
pass
xbmcplugin.endOfDirectory(hos)
def Get_Serial(params):
url = urllib.unquote_plus(params['url'])
if url == None:
return False
image = urllib.unquote_plus(params['img'])
s_name = urllib.unquote_plus(params['name'])
tag = urllib.unquote_plus(params['tag'])
h_part = Check_History(tag)
#-- get serial play list & parameters -------------------------------------
xbmc.log("URL: " + url)
html = get_HTML(url, None, 'http://serialu.net/media/uppod.swf')
if html == '':
return False
# -- parsing web page
html = re.compile('<body>(.+?)<\/body>',
re.MULTILINE | re.DOTALL).findall(html)[0]
soup = BeautifulSoup(html) #, fromEncoding="windows-1251")
pl_url = ''
is_multiseason = len(
soup.findAll('object', {'type': 'application/x-shockwave-flash'}))
for rec in soup.findAll('object',
{'type': 'application/x-shockwave-flash'}):
if is_multiseason > 1:
season = rec.parent.previousSibling.previousSibling.text + r' '
else:
season = r''
for par in rec.find('param',
{'name': 'flashvars'})['value'].split('&'):
if par.split('=')[0] == 'pl':
pl_url = par[3:]
if pl_url.find('http:') == -1:
pl_url = xppod.Decode(pl_url)
#-- get playlist details ---------------------------------------------------
xbmc.log("Playlist: " + pl_url)
html = get_HTML(pl_url, None, 'http://serialu.net/media/uppod.swf')
if html == '':
return False
# -- check if playlist is encoded
if html.find('{"playlist":[') == -1:
html = xppod.Decode(html).encode('utf-8').split(' or ')[0]
# -- parsing web page
s_url = ''
s_num = 0
for rec in re.compile('{(.+?)}', re.MULTILINE | re.DOTALL).findall(
html.replace('{"playlist":[', '')):
for par in rec.replace('"', '').split(','):
if par.split(':')[0] == 'comment':
name = str(s_num + 1) + ' серия' #par.split(':')[1]+' '
if par.split(':')[0] == 'file':
if 'http' in par.split(':')[1]:
s_url = par.split(':')[1] + ':' + par.split(':')[2]
else:
s_url = xppod.Decode(
par.split(':')[1]).split(' or ')[0]
s_num += 1
# mark part for history
name = season.encode('utf-8') + name
if h_part <> '-':
if name == h_part:
name = '[COLOR FF00FF00]' + name + '[/COLOR]'
i = xbmcgui.ListItem(name, iconImage=image, thumbnailImage=image)
u = sys.argv[0] + '?mode=PLAY'
u += '&name=%s' % urllib.quote_plus(name)
u += '&url=%s' % urllib.quote_plus(s_url)
u += '&serial=%s' % urllib.quote_plus(s_name)
u += '&serial_tag=%s' % urllib.quote_plus(tag)
u += '&serial_url=%s' % urllib.quote_plus(url)
u += '&img=%s' % urllib.quote_plus(image)
u += '&pl_url=%s' % urllib.quote_plus(pl_url)
u += '&pl_pos=%s' % urllib.quote_plus(str(s_num))
i.setProperty('IsPlayable', 'true')
xbmcplugin.addDirectoryItem(h, u, i, False)
#xbmc.executebuiltin('Container.SetViewMode(51)')
xbmcplugin.endOfDirectory(h, True)
def getMovieItem(self, url):
print "*** Get movie item: %s" % url
response = common.fetchPage({"link": url})
content = common.parseDOM(response["content"], "div", attrs={"id": "dle-content"})
movie = common.parseDOM(content, "div", attrs={"class": "dpad"})
flashvars = common.parseDOM(movie, "param", attrs={"name": "flashvars"}, ret="value")
title = common.parseDOM(movie, "h1", attrs={"class": "btl"})[0]
image = common.parseDOM(movie, "img", attrs={"id": "single_image"}, ret="src")[0]
infos = common.parseDOM(movie, "div", attrs={"style": "display:inline;"})[0]
desc = common.stripTags(infos.split('</b></div><br /><br />')[-1].encode('utf-8'))
info = common.stripTags(common.parseDOM(infos, "div", attrs={"align": "right"})[0])
if 'file' in flashvars[0].split('&')[-1]:
print "This is a movie"
file_hash = flashvars[0].split('&')[-1].replace('file=', '')
url = xppod.Decode(file_hash)
uri = sys.argv[0] + '?mode=play&url=%s' % url
item = xbmcgui.ListItem(title, iconImage=image, thumbnailImage=image)
info = {
'title': title,
'genre': info,
'plot': desc,
'overlay': xbmcgui.ICON_OVERLAY_WATCHED, 'playCount': 0
}
item.setInfo(type='Video', infoLabels=info)
item.setProperty('IsPlayable', 'true')
xbmcplugin.addDirectoryItem(self.handle, uri, item, False)
xbmc.executebuiltin('Container.SetViewMode(52)')
elif 'pl' in flashvars[0].split('&')[-1]:
file_hash = flashvars[0].split('&')[-1].replace('pl=', '')
print "This is a season"
url = xppod.Decode(file_hash)
pattern = re.compile('[\w\d=.,+]+', re.S)
xppod_hash = pattern.findall(self.getPlaylist(url))[0]
jsdata = xppod.Decode(xppod_hash)
try:
response = json.loads(jsdata.encode('latin1').decode('utf-8'))
except Exception, e:
print e
if 'playlist' in response['playlist'][0]:
print "This is a season multiple seasons"
seasons = response['playlist']
for season in seasons:
episods = season['playlist']
for episode in episods:
try:
uri = sys.argv[0] + '?mode=play&url=%s' % episode['file']
item = xbmcgui.ListItem(episode['comment'], iconImage=image, thumbnailImage=image)
info = {
'title': title,
'genre': info,
'plot': desc,
'overlay': xbmcgui.ICON_OVERLAY_WATCHED, 'playCount': 0
}
item.setInfo(type='Video', infoLabels=info)
item.setProperty('IsPlayable', 'true')
xbmcplugin.addDirectoryItem(self.handle, uri, item, False)
xbmc.executebuiltin('Container.SetViewMode(51)')
except KeyError:
tmp = episode['playlist']
for episode in tmp:
uri = sys.argv[0] + '?mode=play&url=%s' % episode['file']
item = xbmcgui.ListItem(episode['comment'], iconImage=image, thumbnailImage=image)
info = {
'title': title,
'genre': info,
'plot': desc,
'overlay': xbmcgui.ICON_OVERLAY_WATCHED, 'playCount': 0
}
item.setInfo(type='Video', infoLabels=info)
item.setProperty('IsPlayable', 'true')
xbmcplugin.addDirectoryItem(self.handle, uri, item, False)
xbmc.executebuiltin('Container.SetViewMode(51)')
else:
print "This is one season"
for episode in response['playlist']:
etitle = episode['comment']
url = episode['file']
uri = sys.argv[0] + '?mode=play&url=%s' % url
item = xbmcgui.ListItem(etitle, iconImage=image, thumbnailImage=image)
info = {
'title': title,
'genre': info,
'plot': desc,
'overlay': xbmcgui.ICON_OVERLAY_WATCHED, 'playCount': 0
}
item.setInfo(type='Video', infoLabels=info)
item.setProperty('IsPlayable', 'true')
xbmcplugin.addDirectoryItem(self.handle, uri, item, False)
xbmc.executebuiltin('Container.SetViewMode(51)')
def Get_Movie_Info(url):
html = get_HTML(url)
soup = BeautifulSoup(html, fromEncoding="utf-8")
main_rec = soup.find('div', {'id': 'main'})
# raiting
try:
mi.raiting = float(
main_rec.find('div', {
'class': " field field-serial-rates"
}).find('span', {
'class': "kp-rate"
}).text)
except:
mi.raiting = 0
#genre
try:
mi.genre = ''
for g in main_rec.find(
'div',
{
'class':
"field field-name-serial-genres field-type-taxonomy-term-reference field-label-inline"
}).findAll('span', {'class': "field-item even"}):
mi.genre += g.text + ','
mi.genre = mi.genre[:-1].encode('utf-8')
except:
mi.genre = ''
# coutry
try:
mi.country = ''
for c in main_rec.find(
'div',
{
'class':
"field field-name-serial-country field-type-taxonomy-term-reference field-label-inline"
}).findAll('span', {'class': "field-item even"}):
mi.country += c.text + ','
mi.country = mi.country[:-1].encode('utf-8')
except:
mi.country = ''
#year
try:
mi.year = main_rec.find(
'div', {
'class':
"field field-name-field-serial-date field-type-text field-label-inline"
}).find('span', {
'class': "field-item even"
}).text.encode('utf-8')
if mi.year[-4:].isnumeric():
mi.year = mi.year[-4:]
else:
mi.year = mi.year[:4]
except:
mi.year = '0'
# directors
try:
mi.director = main_rec.find(
'div', {
'class':
"field field-name-field-serial-producer field-type-text field-label-inline"
}).find('span', {
'class': "field-item even"
}).text.encode('utf-8')
except:
mi.director = ''
#actors
try:
mi.actors = main_rec.find(
'div', {
'class':
"field field-name-field-serial-actors field-type-text-long field-label-inline"
}).find('span', {
'class': "field-item even"
}).text.encode('utf-8')
mi.actors = mi.actors.split(',')
except:
mi.actors = ''
#text
try:
mi.text = main_rec.find(
'div', {
'class':
"field field-name-body field-type-text-with-summary field-label-hidden"
}).find('div', {
'class': "field-item even"
}).text.encode('utf-8')
except:
mi.text = ''
# img
try:
mi.img = main_rec.find(
'div', {
'class':
"field field-name-field-serial-image field-type-image field-label-hidden"
}).find('img')['src']
except:
mi.img = ''
#playlist_url
try:
for rec in urllib.unquote_plus(
main_rec.find('object', {
'id': 'videoplayer'
}).find('param', {'name': 'flashvars'
})['value'].encode('utf-8')).split('&'):
if rec.split('=')[0] == 'pl':
mi.pl_url = rec.split('=', 1)[1]
#-- check if playlist should be decode
if mi.pl_url[:4] != 'http':
mi.pl_url = xppod.Decode(mi.pl_url)
except:
mi.pl_url = ''
# title
str = main_rec.find('h1', {'class': 'title'}).text
str = str[:-len(main_rec.find('h1', {
'class': 'title'
}).find('span').text)] + ' ' + str[
-len(main_rec.find('h1', {
'class': 'title'
}).find('span').text):]
mi.title = str.replace(u'сериал ', '').replace(u' онлайн',
'').encode('utf-8')
# season
mi.season[:] = []
if len(
main_rec.findAll(
'div', {'class': 'field field-seasons-list clearfix'})) > 0:
#-- generate list of seasons
season_rec = main_rec.find(
'div', {'class': 'field field-seasons-list clearfix'})
for rec in season_rec.findAll('div', {'class': 'serial-season'}):
mi.season.append('http://allserials.tv' + rec.find('a')['href'])
def Serial_Info(params):
#-- get filter parameters
par = Get_Parameters(params)
#== get serial details =================================================
post = None
html = get_HTML(par.url, post)
soup = BeautifulSoup(html, fromEncoding="utf-8")
mi = Get_Info(soup)
#-- get play list url
flashvar = soup.find('object', {
'id': 'showday'
}).find('param', {'name': 'flashvars'})['value']
for rec in flashvar.split('&'):
if rec.split('=', 1)[0] == 'pl':
pl_url = xppod.Decode(rec.split('=', 1)[1])
#-- get play list
season_list = Get_PlayList(pl_url, mode='s')
# -- check if serial has seasons and provide season list
if par.is_season == '' and len(season_list) > 0:
# -- mane of season
i = xbmcgui.ListItem('[COLOR FFFFF000]' + mi.title + '[/COLOR]',
path='',
thumbnailImage=icon)
u = sys.argv[0] + '?mode=EMPTY'
xbmcplugin.addDirectoryItem(h, u, i, False)
#-- generate list of seasons
for s in season_list:
i = xbmcgui.ListItem(s['comment'],
iconImage=mi.img,
thumbnailImage=mi.img)
u = sys.argv[0] + '?mode=SERIAL'
#-- filter parameters
u += '&name=%s' % urllib.quote_plus(s['comment'])
u += '&url=%s' % urllib.quote_plus(par.url)
u += '&genre=%s' % urllib.quote_plus(par.genre)
u += '&genre_name=%s' % urllib.quote_plus(par.genre_name)
u += '&playlist=%s' % urllib.quote_plus(pl_url)
u += '&is_season=%s' % urllib.quote_plus('*')
i.setInfo(type='video',
infoLabels={
'title': mi.title,
'cast': mi.actors.split(','),
'year': int(mi.year[:4]),
'director': mi.director,
'plot': mi.text,
'genre': mi.genre.split(',')
})
i.setProperty('fanart_image', mi.img)
xbmcplugin.addDirectoryItem(h, u, i, True)
else:
# -- mane of season
name = '[COLOR FFFFF000]' + mi.title + '[/COLOR]'
if len(season_list) > 0:
name += ' [COLOR FF00FFF0]( ' + par.name + ' )[/COLOR]'
i = xbmcgui.ListItem(name, path='', thumbnailImage=icon)
u = sys.argv[0] + '?mode=EMPTY'
xbmcplugin.addDirectoryItem(h, u, i, False)
# -- get list of season parts
s_url = ''
s_num = 0
#---------------------------
if len(season_list) == 0:
sname = '-'
else:
sname = par.name
pl_url = par.playlist
playlist = Get_PlayList(pl_url, season=sname, mode='e')
for rec in playlist:
name = rec['comment']
s_url = rec['file']
s_num += 1
i = xbmcgui.ListItem(name,
path=urllib.unquote(s_url),
thumbnailImage=mi.img) # iconImage=mi.img
u = sys.argv[0] + '?mode=PLAY'
u += '&url=%s' % urllib.quote_plus(s_url)
u += '&name=%s' % urllib.quote_plus(name)
u += '&img=%s' % urllib.quote_plus(mi.img)
u += '&playlist=%s' % urllib.quote_plus(pl_url)
u += '&is_season=%s' % urllib.quote_plus(sname)
i.setInfo(type='video',
infoLabels={
'title': mi.title,
'cast': mi.actors.split(','),
'year': int(mi.year),
'director': mi.director,
'plot': mi.text,
'genre': mi.genre.split(',')
})
i.setProperty('fanart_image', mi.img)
#i.setProperty('IsPlayable', 'true')
xbmcplugin.addDirectoryItem(h, u, i, False)
xbmcplugin.endOfDirectory(h)
def readFile(params):
http = GET(params['href'])
#print 'http'+str(http)
if http == None: return False
beautifulSoup = BeautifulSoup(http)
content = beautifulSoup.find('param', attrs={'name': 'flashvars'})
#print content
findfile=str(content)
#print 'findfile'+findfile
pat=re.compile('le=.+"', re.S)
pat_pl=re.compile('pl=.+"', re.S)
pat_st=re.compile('st=.+"', re.S)
mfil = pat.findall(findfile)
pfil = pat_pl.findall(findfile)
stfile = pat_st.findall(findfile)
#print 'pfil'+pfil
flname=None
if mfil:
#print 'mfile30:'+mfil[0][3:-1]
flname=mfil[0][3:-1]
#flname=xppod.Decode(mfil[0][3:-1])
#print 'flname:'+flname
if pfil:
#print pfil[0][3:-1]
#flname=xppod.Decode(pfil[0][3:-1])
#print 'mfile30:'+pfil[0][3:-1]
flname=pfil[0][3:-1]
if stfile:
#print pfil[0][3:-1]
#flname=xppod.Decode(pfil[0][3:-1])
#print 'mfile30:'+stfile[0][3:-1]
flname=stfile[0][3:-1]
#print 'flname:'+flname
if mfil:
#print 'play file ' + mfil[0]
try:
li = xbmcgui.ListItem(params['title'], addon_icon, thumbnailImage = params['src'])
except:
li = xbmcgui.ListItem(params['title'], addon_icon, thumbnailImage = addon_icon)
li.setProperty('IsPlayable', 'true')
#print 'mfil0: '+xppod.Decode(lurl.split('=')[1])
uri = construct_request({
'func': 'play',
'file': flname
})
#print 'uri for addDir: '+uri
xbmcplugin.addDirectoryItem(hos, uri, li, False)
elif pfil:
#print 'playlist in ' + lurl.split('=')[1]
http=flname
#print 'after xppod: '+str(http)
http = GET(http)
#print 'http pl='+str(http)
f=http.find('{')
f1=0
f1=http.rfind('}]}]}{');
#print 'http' + http
try:
http= xppod.Decode(str(http).strip())
except:
pat=re.compile('[\w\d=.,+]+', re.S)
http = pat.findall(http)[0]
#print 'http after xpod:' + str(http.encode('utf-8'))
try:
jsdata=json.loads(str(http),'iso-8859-1')
except:
jsdata=json.loads(http)
has_sesons=False
#print 'json data:' + str(jsdata)
playlist = jsdata['playlist']
#print 'playlist' + str(playlist.encode('utf-8'))
for file in playlist:
#print 'file: '+str(file.encode('utf-8'))
tt= 'aaa'
tt=tt.encode("latin-1","ignore")
l=''
try:
li = xbmcgui.ListItem(tt, addon_icon, thumbnailImage = params['src'])
li.setProperty('IsPlayable', 'true')
uri = construct_request({
'func': 'play',
'file': file['file']
})
#print 'uri for addDir: '+ str(uri)
xbmcplugin.addDirectoryItem(hos, uri, li, False)
except: pass
try:
for t in file['playlist']:
#print t
li = xbmcgui.ListItem(t['comment'].encode("latin-1","ignore"), addon_icon, thumbnailImage = params['src'])
li.setProperty('IsPlayable', 'true')
uri = construct_request({
'func': 'play',
'file': t['file']
})
#print 'uri for addDir: '+ str(uri)
has_sesons=True
xbmcplugin.addDirectoryItem(hos, uri, li, False)
if has_sesons==False:
li = xbmcgui.ListItem(file['comment'].encode("latin-1","ignore"), addon_icon, thumbnailImage = params['src'])
li.setProperty('IsPlayable', 'true')
uri = construct_request({
'func': 'play',
'file': file['file']
})
#print 'uri for addDir: '+ str(uri)
xbmcplugin.addDirectoryItem(hos, uri, li, False)
except: pass
else:
#print 'stfile'
#print 'playlist in ' + lurl.split('=')[1]
http=flname
#print 'http: '+str(http)
if http == None: return False
http = GET(http)
#print 'http pl='+str(http).strip()
#print 'http2' + http
try:
http= xppod.Decode(str(http).strip())
#print 'http after xpod:' + str(http.encode('utf-8'))
except:
pat=re.compile('[\w\d=.,+]+', re.S)
http = pat.findall(http)[0]
try:
jsdata=json.loads(str(http),'iso-8859-1')
except:
jsdata=json.loads(http)
has_sesons=False
#print 'json data:' + str(jsdata)
if 'pl' in jsdata:
playlist = jsdata['pl'].replace('\'','"')
playlist = json.loads(playlist, 'utf-8')
playlist = playlist['playlist']
for file in playlist:
if 'file' in file:
try:
#print 'file: '+str(file['file'])
tt= file['comment'].encode('latin-1',"ignore"),
l=''
li = xbmcgui.ListItem(tt, addon_icon, thumbnailImage = params['src'])
li.setProperty('IsPlayable', 'true')
uri = construct_request({
'func': 'play',
'file': file['file']
})
#print 'uri for addDir: '+ str(uri)
xbmcplugin.addDirectoryItem(hos, uri, li, False)
except: pass
else:
try:
for t in file['playlist']:
#print t
if 'file' in t:
li = xbmcgui.ListItem(t['comment'].encode('latin-1',"ignore"), addon_icon, thumbnailImage = params['src'])
li.setProperty('IsPlayable', 'true')
uri = construct_request({
'func': 'play',
'file': t['file']
})
#print 'uri for addDir: '+ str(uri)
has_sesons=True
xbmcplugin.addDirectoryItem(hos, uri, li, False)
else:
for t2 in t['playlist']:
#print t2
li = xbmcgui.ListItem(t2['comment'].encode('latin-1',"ignore"), addon_icon, thumbnailImage = params['src'])
li.setProperty('IsPlayable', 'true')
uri = construct_request({
'func': 'play',
'file': t2['file']
})
#print 'uri for addDir: '+ str(uri)
has_sesons=True
xbmcplugin.addDirectoryItem(hos, uri, li, False)
if has_sesons==False:
li = xbmcgui.ListItem(t['comment'].encode('latin-1',"ignore"), addon_icon, thumbnailImage = params['src'])
li.setProperty('IsPlayable', 'true')
uri = construct_request({
'func': 'play',
'file': t['file']
})
#print 'uri for addDir: '+ str(uri)
xbmcplugin.addDirectoryItem(hos, uri, li, False)
if has_sesons==False:
li = xbmcgui.ListItem(file['comment'].encode('latin-1',"ignore"), addon_icon, thumbnailImage = params['src'])
li.setProperty('IsPlayable', 'true')
uri = construct_request({
'func': 'play',
'file': file['file']
})
#print 'uri for addDir: '+ str(uri)
xbmcplugin.addDirectoryItem(hos, uri, li, False)
except: pass
else:
li = xbmcgui.ListItem(params['title'], addon_icon, thumbnailImage = params['src'])
li.setProperty('IsPlayable', 'true')
uri = construct_request({
'func': 'play',
'file': jsdata['file']
})
#print 'uri for addDir: '+ str(uri)
xbmcplugin.addDirectoryItem(hos, uri, li, False)
xbmcplugin.endOfDirectory(hos)
