def parseMovieEntrySite():
oParams = ParameterHandler()
sSecurityValue = oParams.getValue('securityCookie')
if (oParams.exist('sUrl')):
sUrl = oParams.getValue('sUrl')
# get movieEntrySite content
sHtmlContent = __getHtmlContent(sUrl, sSecurityValue)
sMovieTitle = __createMovieTitle(sHtmlContent)
bIsSerie = __isSerie(sHtmlContent)
if (bIsSerie):
oGui = cGui()
aSeriesItems = parseSerieSite(sHtmlContent)
if (len(aSeriesItems) > 0):
imdbID = oParams.getValue('imdbID')
for item in aSeriesItems:
oGuiElement = cGuiElement(item['title'], SITE_IDENTIFIER, 'showHosters')
sShowTitle = sMovieTitle.split('(')[0].split('*')[0]
oGuiElement.setMediaType('episode')
oParams.addParams({'sUrl':item['url'], 'episode':item['episode'], 'season':item['season'], 'TvShowTitle':sShowTitle})
oGui.addFolder(oGuiElement, oParams, bIsFolder = False, iTotal = len(aSeriesItems))
oGui.setView('episodes')
oGui.setEndOfDirectory()
else:
result = showHosters(sHtmlContent, sMovieTitle)
return result
def showEpisodes():
oGui = cGui()
oParams = ParameterHandler()
sSecurityValue = oParams.getValue('securityCookie')
sUrl = oParams.getValue('sUrl')
seasonNum = oParams.getValue('Season')
sHtmlContent = __getHtmlContent(sUrl, sSecurityValue)
sMovieTitle = __createMovieTitle(sHtmlContent)
result = cParser().parse(sHtmlContent, '<div class="Grahpics">.*?<img src="([^"]+)"')
thumbnail = URL_MAIN + str(result[1][0]) if result[0] else False
aSeriesItems = parseSerieEpisodes(sHtmlContent, seasonNum)
if not aSeriesItems[0]: return
for item in aSeriesItems:
oGuiElement = cGuiElement(item['title'], SITE_IDENTIFIER, 'showHosters')
sShowTitle = sMovieTitle.split('(')[0].split('*')[0]
oGuiElement.setThumbnail(thumbnail)
oGuiElement.setMediaType('episode')
oGuiElement.setSeason(item['season'])
oGuiElement.setEpisode(item['episode'])
oGuiElement.setTVShowTitle(sShowTitle)
oParams.addParams({'sUrl': item['url'], 'episode': item['episode'], 'season': item['season']})
oGui.addFolder(oGuiElement, oParams, bIsFolder=False, iTotal=len(aSeriesItems))
oGui.setView('episodes')
oGui.setEndOfDirectory()
def showHostersSeries():
params = ParameterHandler()
if params.exist("sUrl") and params.exist("sMovieTitle"):
sUrl = params.getValue("sUrl")
sMovieTitle = params.getValue("sMovieTitle")
sHtmlContent = cRequestHandler(sUrl).request()
sPattern = '<tr id="tablemoviesindex2".*?<a href="([^"]+)".*? width="16">([^<]+)<'
aResult = cParser().parse(sHtmlContent.replace("\\", ""), sPattern)
if aResult[0] == True:
hosters = []
previousName = ""
iMatches = 2
for aEntry in aResult[1]:
sHoster = aEntry[1].strip()
hoster = {}
hoster["name"] = sHoster
hoster["link"] = URL_MAIN + "/" + aEntry[0]
if hoster["name"] == previousName:
hoster["displayedName"] = hoster["name"] + " (" + str(iMatches) + ")"
iMatches += 1
else:
previousName = hoster["name"]
iMatches = 2
hosters.append(hoster)
hosters.append("showHoster")
return hosters
def showHostersSeries():
oInputParameterHandler = ParameterHandler()
if (oInputParameterHandler.exist('sUrl') and oInputParameterHandler.exist('sMovieTitle')):
sUrl = oInputParameterHandler.getValue('sUrl')
sMovieTitle = oInputParameterHandler.getValue('sMovieTitle')
sHtmlContent = cRequestHandler(sUrl).request()
sPattern = '<tr id="tablemoviesindex2".*?<a href="([^"]+)".*? width="16">([^<]+)<'
aResult = cParser().parse(sHtmlContent.replace('\\',''), sPattern)
if (aResult[0] == True):
hosters = []
previousName = ''
iMatches = 2
for aEntry in aResult[1]:
sHoster = aEntry[1].strip()
hoster = {}
hoster['name'] = sHoster
hoster['link'] = URL_MAIN + aEntry[0]
if hoster['name'] == previousName:
hoster['displayedName'] = hoster['name'] + ' ('+str(iMatches)+')'
iMatches += 1
else:
previousName = hoster['name']
iMatches = 2
hosters.append(hoster)
hosters.append('showHoster')
return hosters
def __getHtmlContent(sUrl = None, sSecurityValue=None):
params = ParameterHandler()
# Test if a url is available and set it
if sUrl is None and not params.exist('siteUrl'):
logger.info("There is no url we can request.")
return False
else:
if sUrl is None:
sUrl = params.getValue('siteUrl')
# Test if a security value is available
if sSecurityValue is None:
if params.exist('securityCookie'):
sSecurityValue = params.getValue('securityCookie')
else :
sSecurityValue = ''
# Make the request
oRequest = cRequestHandler(sUrl)
#oRequest.addHeaderEntry('Cookie', sSecurityValue)
#oRequest.addHeaderEntry('Accept', '*/*')
#oRequest.addHeaderEntry('Host', 'gstream.to')
return oRequest.request()
def showEpisodes():
oGui = cGui()
oParams = ParameterHandler()
sSeason = oParams.getValue('season')
sMovieTitle = oParams.getValue('sMovieTitle')
sMovie = oParams.getValue(PARAM_MOVIESEGMENT_KEY).replace(".html","/")
sUrl = URL_SERIES_EPISODEURL + sMovie
oRequest = cRequestHandler(sUrl)
#oRequest.setHeaderEntry("Accept","application/json, text/javascript, */*; q=0.01")
oRequest.addParameters("season",sSeason)
oRequest.addHeaderEntry("X-Requested-With","XMLHttpRequest")
oRequest.addHeaderEntry('Referer', sUrl)
oRequest.addHeaderEntry('Accept', '*/*')
oRequest.addHeaderEntry('Host', SITE_NAME.lower())
sHtmlContent = oRequest.request()
aData = sorted(loads(sHtmlContent)['episodes'])
for aEntry in aData:
logger.info(aEntry['episode'])
oGuiElement = cGuiElement()
oGuiElement.setFunction('_playEpisode')
oGuiElement.setSiteName(SITE_IDENTIFIER)
oGuiElement.setTitle(sMovieTitle + '- S'+sSeason+'E'+str(aEntry['episode']))
oOutputParameterHandler = ParameterHandler()
oOutputParameterHandler.setParam('link',aEntry['link'])
oOutputParameterHandler.setParam('season',sSeason)
oOutputParameterHandler.setParam('episode',aEntry['episode'])
oOutputParameterHandler.setParam('sMovieTitle',sMovieTitle)
oOutputParameterHandler.setParam(PARAM_URL_KEY,"http://www.ecostream.tv/stream/"+aEntry['link']+".html")
oGui.addFolder(oGuiElement, oOutputParameterHandler, bIsFolder=False, iTotal = len(aData))
oGui.setView('episodes')
oGui.setEndOfDirectory()
def showCharacters():
logger.info('load showCharacters')
oGui = cGui()
oParams = ParameterHandler()
sSecurityValue = oParams.getValue('securityCookie')
if oParams.exist('sUrl') and oParams.exist('page') and oParams.exist('mediaType'):
siteUrl = oParams.getValue('sUrl')
# iPage = oParams.getValue('page')
# sMediaType = oParams.getValue('mediaType')
# request
sHtmlContent = __getHtmlContent(siteUrl, sSecurityValue)
# parse content
sPattern = 'class="LetterMode.*?>([^>]+)</a>'
oParser = cParser()
aResult = oParser.parse(sHtmlContent, sPattern)
if aResult[0]:
for aEntry in aResult[1]:
oGuiElement = cGuiElement(aEntry, SITE_IDENTIFIER, 'ajaxCall')
# oOutputParameterHandler = ParameterHandler()
oParams.setParam('character', aEntry[0])
# oOutputParameterHandler.addParameter('page', iPage)
# oOutputParameterHandler.addParameter('mediaType', sMediaType)
# oOutputParameterHandler.addParameter('securityCookie', sSecurityValue)
if oParams.exist('mediaTypePageId'):
sMediaTypePageId = oParams.getValue('mediaTypePageId')
oParams.setParam('mediaTypePageId', sMediaTypePageId)
oGui.addFolder(oGuiElement, oParams)
oGui.setEndOfDirectory()
def showEpisodes():
oGui = cGui()
params = ParameterHandler()
entryUrl = params.getValue('entryUrl')
sTVShowTitle = params.getValue('TVShowTitle')
sThumbnail = params.getValue('sThumbnail')
sSeason = params.getValue('season')
sHtmlContent = cRequestHandler(entryUrl).request()
pattern = '<h\d+>[^"]*Staffel %s Episode (\d+)[^"]*</h\d+>' % sSeason
aResult = cParser().parse(sHtmlContent, pattern)
total = len (aResult)
for sEpisode in sorted(aResult[1], key=lambda k: k) :
oGuiElement = cGuiElement(sTVShowTitle + " - Folge " + sEpisode, SITE_IDENTIFIER, 'showHosters')
oGuiElement.setMediaType('episode')
oGuiElement.setTVShowTitle(sTVShowTitle)
oGuiElement.setSeason(sSeason)
oGuiElement.setEpisode(sEpisode)
oGuiElement.setThumbnail(sThumbnail)
oGui.addFolder(oGuiElement, params, False, total)
oGui.setView('episodes')
oGui.setEndOfDirectory()
def showMovies():
oGui = cGui()
oParams = ParameterHandler()
if (oParams.exist(PARAM_URL_KEY)):
sUrl = oParams.getValue(PARAM_URL_KEY)
sRootUrl = sUrl
iPage = 1
if (oParams.exist(PARAM_PAGE_KEY)):
iPage = oParams.getValue(PARAM_PAGE_KEY)
sRootUrl = oParams.getValue(PARAM_ROOTURL_KEY)
if (sRootUrl.startswith(URL_MOVIES_ALL) |
sRootUrl.startswith(URL_SEARCH)):
sPattern = PATTERN_LIST
elif (sRootUrl.startswith(URL_CURRENT_MOVIES) |
sRootUrl.startswith(URL_NEW_MOVIES) |
sRootUrl.startswith(URL_MAIN)):
sPattern = PATTERN_DIVBOX
else:
oGui.showError('Error','wrong root url')
return
_parseMedia(sUrl,sRootUrl,iPage,sPattern, oGui)
else:
oGui.showError('Error','wrong page count')
return
else:
oGui.showError('Error','No request url found')
oGui.setEndOfDirectory()
def showHosters():
# ParameterHandler erzeugen
params = ParameterHandler()
# URL Anpassen um die Stream und nicht die Infos zu bekommen
entryUrl = params.getValue('entryUrl').replace("-info","-stream")
# Seite abrufen
sHtmlContent = cRequestHandler(entryUrl).request()
# Prüfen ob Episoden gefunden werden
pattern = '<a[^>]*episode="([^"]*)"[^>]*href="([^"]*)"[^>]*>'
aResult = cParser().parse(sHtmlContent, pattern)
# Prüfen ob Einträge vorliegen
if not aResult[0]:
return
# Ermitteln ob es sich um eine Serie handelt
isTvshowEntry = params.getValue('isTvshow')
# Falls Episoden gefunden worden => Episodenauswahl vorschalten
if isTvshowEntry == 'True':
showEpisodes(aResult[1], params)
else:
return getHosters(entryUrl)
def parseMovieEntrySite():
oParams = ParameterHandler()
sSecurityValue = oParams.getValue('securityCookie')
if oParams.exist('sUrl'):
sUrl = oParams.getValue('sUrl')
# get movieEntrySite content
sHtmlContent = __getHtmlContent(sUrl, sSecurityValue)
sMovieTitle = __createMovieTitle(sHtmlContent)
# get thumbnail
result = cParser().parse(sHtmlContent, '<div class="Grahpics">.*?<img src="([^"]+)"')
thumbnail = URL_MAIN + str(result[1][0]) if result[0] else False
bIsSerie = __isSerie(sHtmlContent)
if bIsSerie:
oGui = cGui()
aSeriesItems = parseSerieSite(sHtmlContent)
if not aSeriesItems[0]: return
total = len(aSeriesItems)
for aEntry in aSeriesItems[1]:
seasonNum = str(aEntry)
guiElement = cGuiElement('%s - Staffel %s' % (sMovieTitle, seasonNum), SITE_IDENTIFIER, 'showEpisodes')
guiElement.setMediaType('season')
guiElement.setSeason(seasonNum)
guiElement.setTVShowTitle(sMovieTitle)
oParams.setParam('Season', seasonNum)
if thumbnail:
guiElement.setThumbnail(thumbnail)
oGui.addFolder(guiElement, oParams, iTotal=total)
oGui.setView('seasons')
oGui.setEndOfDirectory()
else:
logger.info('Movie')
result = showHosters(sHtmlContent, sMovieTitle)
return result
def __getHtmlContent(sUrl = None, sSecurityValue = None):
oParams = ParameterHandler()
# Test if a url is available and set it
if sUrl is None and not oParams.exist('sUrl'):
logger.error("There is no url we can request.")
return False
else:
if sUrl is None:
sUrl = oParams.getValue('sUrl')
# Test if a security value is available
if sSecurityValue is None:
if oParams.exist("securityCookie"):
sSecurityValue = oParams.getValue("securityCookie")
if not sSecurityValue:
sSecurityValue = ''
# preferred language
sPrefLang = __getPreferredLanguage()
# Make the request
oRequest = cRequestHandler(sUrl)
oRequest.addHeaderEntry('Cookie', sPrefLang+sSecurityValue+'ListDisplayYears=Always;')
oRequest.addHeaderEntry('Referer', URL_MAIN)
oRequest.addHeaderEntry('Accept', '*/*')
oRequest.addHeaderEntry('Host', domain)
return oRequest.request()
def showHosters():
params = ParameterHandler()
sHtmlContent = cRequestHandler(params.getValue('entryUrl')).request()
aResult = cParser().parse(sHtmlContent, "var[ ]subcats[ ]=[ ](.*?);")
if not aResult[0]: return []
hosters = []
data = json.loads(aResult[1][0])
sJsonID = params.getValue('sJsonID')
if not sJsonID:
sJsonID = data.keys()[0]
partCount = 1 # fallback for series (because they get no MultiParts)
if '1' in data[sJsonID]:
partCount = int(data[sJsonID]['1'])
for jHoster in data[sJsonID]['links']:
for jHosterEntry in data[sJsonID]['links'][jHoster]:
if jHosterEntry[5] != 'stream': continue
hoster = {}
if partCount > 1:
hoster['displayedName'] = jHoster + ' - Part ' + jHosterEntry[0]
hoster['link'] = jHosterEntry[3]
hoster['name'] = jHoster
hosters.append(hoster)
if len(hosters) > 0:
hosters.append('getHosterUrl')
return hosters
def showHosters():
params = ParameterHandler()
imdbID = params.getValue('itemID')
lang = params.getValue('lang')
if not imdbID or not lang: return
hosters = []
for sLang in re.compile('(\w+)-').findall(lang):
oResponse = _getJSonResponse(URL_LINKS, {'ID':imdbID,'lang':sLang} )
if 'links' not in oResponse or len(oResponse['links']) == 0:
return
for aEntry in oResponse['links']:
hoster = dict()
if oResponse['links'][aEntry][0].upper() in QUALITY_ENUM:
hoster['quality'] = QUALITY_ENUM[oResponse['links'][aEntry][0]]
hoster['link'] = URL_OUT % oResponse['links'][aEntry][1]
hoster['name'] = aEntry
hoster['displayedName'] = '%s (%s) - Quality: %s' % (aEntry, sLang, oResponse['links'][aEntry][0])
hosters.append(hoster)
if hosters:
hosters = sorted(hosters, key=lambda k: k['name']) #sort by hostername
hosters.append('play')
return hosters
def sendToPyLoad(self, siteResult = False):
from resources.lib.handler.pyLoadHandler import cPyLoadHandler
import urlresolver
params = ParameterHandler()
sMediaUrl = params.getValue('sMediaUrl')
sFileName = params.getValue('MovieTitle')
if not sFileName:
sFileName = params.getValue('Title')
if not sFileName: #nur vorrübergehend
sFileName = params.getValue('sMovieTitle')
if not sFileName:
sFileName = params.getValue('title')
if siteResult:
sMediaUrl = siteResult['streamUrl']
if siteResult['resolved']:
sLink = sMediaUrl
else:
sLink = urlresolver.resolve(sMediaUrl)
else:
sLink = urlresolver.resolve(sMediaUrl)
try:
msg = sLink.msg
except:
msg = False
if sLink != False and not msg:
logger.info('download with pyLoad: ' + sMediaUrl)
cPyLoadHandler().sendToPyLoad(sFileName,sLink)
return True
else:
cGui().showError('xStream', str(msg), 5)
return False
def showSeries():
oGui = cGui()
oParams = ParameterHandler()
sChar = oParams.getValue('char')
if sChar: sChar = sChar.lower()
series = _getJsonContent("series")
total = len(series)
for serie in series:
sTitle = serie["series"].encode('utf-8')
if sChar:
if sChar == '#':
if sTitle[0].isalpha(): continue
elif sTitle[0].lower() != sChar: continue
if oParams.getValue('specific') == 'Season':
guiElement = cGuiElement(sTitle, SITE_IDENTIFIER, 'randomSeason')
else:
guiElement = cGuiElement(sTitle, SITE_IDENTIFIER, 'showSeasons')
guiElement.setMediaType('tvshow')
guiElement.setThumbnail(URL_COVER % serie["id"])
# Load series description by iteration through the REST-Api (slow)
#sDesc = _getJsonContent("series/%d/1" % int(serie['id']))
#guiElement.setDescription(sDesc['series']['description'].encode('utf-8'))
#sStart = str(sDesc['series']['start'])
#if sStart != 'None':
# guiElement.setYear(int(sDesc['series']['start']))
oParams.addParams({'seriesID' : str(serie["id"]), 'Title' : sTitle})
oGui.addFolder(guiElement, oParams, iTotal = total)
oGui.setView('tvshows')
oGui.setEndOfDirectory()
def showHosters():
oInputParameterHandler = ParameterHandler()
sMovieTitle = oInputParameterHandler.getValue('sMovieTitle')
sUrl = oInputParameterHandler.getValue(PARAM_URL_KEY)
sHtmlContent = cRequestHandler(sUrl).request()
sPattern = 'data-det="([^"]+)"'
aResult = cParser().parse(sHtmlContent, sPattern)
results = []
if not aResult[0]: return results
# can't handle without changes to requestHandler
import mechanize, json
request = mechanize.Request("http://kkiste.to/xhr/link", aResult[1][0])
request.add_header('User-Agent', 'Mozilla/5.0 (Windows; U; Windows NT 5.1; de-DE; rv:1.9.0.3) Gecko/2008092417 Firefox/3.0.3')
request.add_header("X-Requested-With","XMLHttpRequest")
request.add_header('Referer', sUrl)
request.add_header('Accept', '*/*')
request.add_header('Host', SITE_NAME.lower())
request.add_header('Content-Length',len(aResult[1][0]))
request.add_header('Content-Type','text/plain')
resp = mechanize.urlopen(request)
sHtmlContent = resp.read()
try: items = json.loads(sHtmlContent)
except: return results
# multipart stream
for i, item in enumerate(items) :
result = {}
result['streamUrl'] = 'http://www.ecostream.tv/stream/'+item
result['resolved'] = False
result['title'] = sMovieTitle + ' part ' +str(i)
results.append(result)
return results
def download(self, siteResult = False):
from resources.lib.download import cDownload
import urlresolver
#oGui = cGui()
params = ParameterHandler()
sMediaUrl = params.getValue('sMediaUrl')
sFileName = params.getValue('sFileName')
sFileName = params.getValue('sMovieTitle')
if siteResult:
sMediaUrl = siteResult['streamUrl']
if siteResult['resolved']:
sLink = sMediaUrl
else:
sLink = urlresolver.resolve(sMediaUrl)
else:
sLink = urlresolver.resolve(sMediaUrl)
logger.info('call download: ' + sMediaUrl)
logger.info('file link: ' + str(sLink))
if self.dialog:
self.dialog.close()
if (sLink != False):
oDownload = cDownload()
oDownload.download(sLink, 'Stream')
else:
#cGui().showError('Download', 'File deleted or Link could not be resolved', 5);
return False
return True
def showEpisodes():
oGui = cGui()
oParams = ParameterHandler()
sShowTitle = oParams.getValue('Title')
seriesId = oParams.getValue('seriesID')
sImdb = oParams.getValue('imdbID')
sSeason = oParams.getValue('Season')
logger.info("%s: show episodes of '%s' season '%s' " % (SITE_NAME, sShowTitle, sSeason))
data = _getJsonContent("series/%s/%s" % (seriesId, sSeason))
total = len(data['epi'])
for episode in data['epi']:
title = "%d - " % int(episode['epi'])
if episode['german']:
title += episode['german'].encode('utf-8')
else:
title += episode['english'].encode('utf-8')
guiElement = cGuiElement(title, SITE_IDENTIFIER, 'showHosters')
guiElement.setMediaType('episode')
guiElement.setSeason(data['season'])
guiElement.setEpisode(episode['epi'])
guiElement.setTVShowTitle(sShowTitle)
guiElement.setThumbnail(URL_COVER % data["series"]["id"])
oParams.setParam('EpisodeNr', episode['epi'])
oGui.addFolder(guiElement, oParams, bIsFolder = False, iTotal = total)
oGui.setView('episodes')
oGui.setEndOfDirectory()
def showSeasons():
oGui = cGui()
params = ParameterHandler()
sTitle = params.getValue('Title')
seriesId = params.getValue('seriesID')
sImdb = params.getValue('imdbID')
logger.info("%s: show seasons of '%s' " % (SITE_NAME, sTitle))
sHtmlContent = _getContent("series/%s/1" % seriesId)
data = json.loads(sHtmlContent)
total = int(data["series"]["seasons"])
for i in range(1,total+1):
seasonNum = str(i)
guiElement = cGuiElement('%s - Staffel %s' %(sTitle,seasonNum), SITE_IDENTIFIER, 'showEpisodes')
guiElement.setMediaType('season')
guiElement.setSeason(seasonNum)
guiElement.setTVShowTitle(sTitle)
params.setParam('Season', seasonNum)
guiElement.setThumbnail(URL_COVER % data["series"]["id"])
oGui.addFolder(guiElement, params, iTotal = total)
oGui.setView('seasons')
oGui.setEndOfDirectory()
def showEpisodes():
logger.info('load showEpisodes')
oParams = ParameterHandler()
sTitle = oParams.getValue('Title')
sSeason = oParams.getValue('Season')
sPattern = 'class="list-group-item".*?<span itemprop="name">Staffel ' + sSeason + ' Episode(?:[\s]*)(.*?)</span>.*?<a class="episode-name" href="(.*?)" title="(.*?)"'
# request
sHtmlContent = __getHtmlContent()
# parse content
oParser = cParser()
aResult = oParser.parse(sHtmlContent, sPattern)
oGui = cGui()
if (aResult[0] == True):
for eNr, link, title in aResult[1]:
guiElement = cGuiElement('Episode %s - %s' % (eNr, title), SITE_IDENTIFIER, 'showHosters')
guiElement.setMediaType('episode')
guiElement.setSeason(sSeason)
# Special fix for non-int episode numbers (like Attack on Titan 13.5)
# Can't even check this on thetvdb.com, because AOT 13.5 for example is Season 0 Episode 1
# May I can use "<airsbefore_episode>" and "<airsbefore_season>" for metadata
if representsInt(eNr):
guiElement.setEpisode(eNr)
guiElement.setTVShowTitle(sTitle)
oParams.setParam('sUrl', link)
oGui.addFolder(guiElement, oParams, bIsFolder=False)
oGui.setView('episodes')
oGui.setEndOfDirectory()
def getHosters():
oParams = ParameterHandler()
sChannelUrl = oParams.getValue('channelUrl')
sChannelName = oParams.getValue('channelName')
logger.info('get stream url for URL: ' + sChannelUrl)
oRequestHandler = cRequestHandler(sChannelUrl)
oRequestHandler.addHeaderEntry('Referer', URL_MAIN)
sHtmlContent = oRequestHandler.request();
hosters = []
sPattern = "'file': '(.*?)',"
oParser = cParser()
aResult = oParser.parse(sHtmlContent, sPattern)
if aResult[0]:
sUrl = str(aResult[1])[2:-2]
logger.info('load channel ' + sChannelName + ' with url ' + sUrl)
hoster = {}
hoster['link'] = sUrl
hoster['name'] = 'streamcloud' # dummy
hosters.append(hoster)
hosters.append('getHosterUrl')
return hosters
def showSeasons():
oGui = cGui()
params = ParameterHandler()
sTitle = params.getValue('Title')
seriesId = params.getValue('seriesID')
sImdb = params.getValue('imdbID')
logger.info("%s: show seasons of '%s' " % (SITE_NAME, sTitle))
data = _getJsonContent("series/%s/1" % seriesId)
rangeStart = not int(data["series"]["movies"])
total = int(data["series"]["seasons"])
for i in range(rangeStart, total + 1):
seasonNum = str(i)
if i is 0:
seasonTitle = 'Film(e)'
dialogType = 'showCinemaMovies'
else:
seasonTitle = '%s - Staffel %s' %(sTitle, seasonNum)
if params.getValue('specific') == 'Episode':
dialogType = 'randomEpisode'
else:
dialogType = 'showEpisodes'
guiElement = cGuiElement(seasonTitle, SITE_IDENTIFIER, dialogType)
guiElement.setMediaType('season')
guiElement.setSeason(seasonNum)
guiElement.setTVShowTitle(sTitle)
params.setParam('Season', seasonNum)
guiElement.setThumbnail(URL_COVER % data["series"]["id"])
oGui.addFolder(guiElement, params, iTotal = total)
oGui.setView('seasons')
oGui.setEndOfDirectory()
def showEpisodes():
oGui = cGui()
oParams = ParameterHandler()
sShowTitle = oParams.getValue('Title')
sUrl = oParams.getValue('siteUrl')
sImdb = oParams.getValue('imdbID')
sSeason = oParams.getValue('Season')
logger.info("%s: show episodes of '%s' season '%s' " % (SITE_NAME, sShowTitle, sSeason))
oRequestHandler = cRequestHandler(sUrl+"/"+sSeason)
sHtmlContent = oRequestHandler.request();
data = json.loads(sHtmlContent)
total = len(data['epi'])
for episode in data['epi']:
if episode['german']:
title = episode['german'].encode('utf-8')
else:
title = episode['english'].encode('utf-8')
guiElement = cGuiElement(str(episode['epi'])+" - "+title, SITE_IDENTIFIER, 'showHosters')
guiElement.setMediaType('episode')
guiElement.setSeason(data['season'])
guiElement.setEpisode(episode['epi'])
guiElement.setTVShowTitle(sShowTitle)
guiElement.setThumbnail(URL_COVER % data["series"]["id"])
#oParams.setParam('EpisodeNr', episode['epi'])
oParams.setParam('siteUrl',sUrl+"/"+sSeason+"/"+episode['epi'])
oGui.addFolder(guiElement, oParams, bIsFolder = False, iTotal = total)
oGui.setView('episodes')
oGui.setEndOfDirectory()
def randomSeason():
oGui = cGui()
oParams = ParameterHandler()
if oParams.getValue('specific') == 'Season' and not oParams.getValue('seriesID'):
showSeries()
return
data = _getJsonContent("series/%s/1" % oParams.getValue('seriesID'))
seasons = int(data["series"]["seasons"])+1
randomSeason = random.randrange(1, seasons, 1)
seasonNum = str(randomSeason)
seasonTitle = '%s - Staffel %s' % (oParams.getValue('Title'), seasonNum)
dialogType = 'showEpisodes'
guiElement = cGuiElement(seasonTitle, SITE_IDENTIFIER, dialogType)
guiElement.setMediaType('season')
guiElement.setSeason(seasonNum)
guiElement.setTVShowTitle(oParams.getValue('Title'))
oParams.setParam('Season', seasonNum)
guiElement.setThumbnail(URL_COVER % data["series"]["id"])
oGui.addFolder(guiElement, oParams, iTotal=1)
oGui.setEndOfDirectory()
def parseMovieEntrySite():
oParams = ParameterHandler()
sSecurityValue = oParams.getValue('securityCookie')
if (oParams.exist('sUrl')):
sUrl = oParams.getValue('sUrl')
# get movieEntrySite content
sHtmlContent = __getHtmlContent(sUrl, sSecurityValue)
sMovieTitle = __createMovieTitle(sHtmlContent)
bIsSerie = __isSerie(sHtmlContent)
if (bIsSerie):
oGui = cGui()
aSeriesItems = parseSerieSite(sHtmlContent)
if (len(aSeriesItems) > 0):
imdbID = oParams.getValue('imdbID')
for item in aSeriesItems:
oGuiElement = cGuiElement(item['title'], SITE_IDENTIFIER, 'showHosters')
sShowTitle = sMovieTitle.split('(')[0].split('*')[0]
oGuiElement.setMediaType('episode')
#if META and imdbID:
# oMetaget = metahandlers.MetaData()
# meta = oMetaget.get_episode_meta(sShowTitle, imdbID, item['season'], item['episode'])
# meta['TVShowTitle'] = sShowTitle
# oGuiElement.setItemValues(meta)
# oGuiElement.setThumbnail(meta['cover_url'])
# oGuiElement.setFanart(meta['backdrop_url'])
# oGuiElement.setTitle('%s %s' % (item['title'], meta['title'].encode('utf-8')))
oParams.addParams({'sUrl':item['url'], 'episode':item['episode'], 'season':item['season'], 'TvShowTitle':sShowTitle})
oGui.addFolder(oGuiElement, oParams, bIsFolder = False, iTotal = len(aSeriesItems))
oGui.setView('episodes')
oGui.setEndOfDirectory()
else:
result = showHosters(sHtmlContent, sMovieTitle)
return result
def showHosters():
#oGui = cGui()
oParams= ParameterHandler()
sTitle = oParams.getValue('Title')
sUrl = oParams.getValue('siteUrl')
oRequestHandler = cRequestHandler(sUrl)
sHtmlContent = oRequestHandler.request()
#if not META:
# __createInfo(oGui, sHtmlContent, sTitle)
sPattern = '<h3>Hoster dieser Episode(.*?)</ul>'
oParser = cParser()
aResult = oParser.parse(sHtmlContent, sPattern)
if (aResult[0] == True):
hosters = []
sHtmlContent = aResult[1][0]
sPattern = 'href="([^"]+)">.*?class="icon ([^"]+)"></span> ([^<]+?)</a>'
oParser = cParser()
aResult = oParser.parse(sHtmlContent, sPattern)
if (aResult[0] == True):
for aEntry in aResult[1]:
hoster = dict()
hoster['link'] = URL_MAIN + '/' + str(aEntry[0])
hoster['name'] = str(aEntry[2]).split(' - Teil')[0]
hoster['displayedName'] = str(aEntry[2])
hosters.append(hoster)
hosters.append('getHosterUrl')
return hosters
def showEpisodes():
oGui = cGui()
params = ParameterHandler()
sHtmlContent = _getRequestHandler(params.getValue('entryUrl')).request()
pattern = "<a[^>]*href=['\"]#streams_episodes_%d_(\d+)['\"][^>]*>.*?" % int(params.getValue('iReleaseId')) # EpisodeId
pattern += "<strong>(\d+)</strong>(.*?)</span>" # Episode-Nr / Name
aResult = cParser().parse(sHtmlContent, pattern)
if not aResult[0] or not aResult[1][0]:
oGui.showInfo('xStream','Es wurde kein Eintrag gefunden')
return
sThumbnail = params.getValue('sThumbnail')
sName = params.getValue('sName')
total = len(aResult[1])
for sEpisodeId, sNumber, sEpisodName in aResult[1]:
oGuiElement = cGuiElement(str(int(sNumber)) + " - " + sEpisodName, SITE_IDENTIFIER, 'showHosters')
oGuiElement.setTVShowTitle(sName)
oGuiElement.setMediaType('episode')
oGuiElement.setEpisode(int(sNumber))
oGuiElement.setThumbnail(sThumbnail)
params.setParam('iEpisodeId', int(sEpisodeId))
oGui.addFolder(oGuiElement, params, False, total)
oGui.setView('episodes')
oGui.setEndOfDirectory()
def parseMovieSimpleList():
oGui = cGui()
params = ParameterHandler()
oParser = cParser()
if (params.exist('iPage')):
iPage = params.getValue('iPage')
else:
iPage = 1
if (params.exist('sUrl')):
sUrl = params.getValue('sUrl')
logger.info(sUrl)
if (sUrl.find('tvshows-season-') != -1):
sPattern = '<TR>\s*<TD.*?id="tdmovies".*?<a href="([^"]+)">(.*?)\s*</a>.*?<img border=0 src="http://[^/]+/img/([^"]+)".*?</TR>'
if params.exist('sLanguageToken'):
sLanguageToken = params.getValue('sLanguageToken')
oRequest = cRequestHandler(sUrl)
sHtmlContent = oRequest.request()
aResult = oParser.parse(sHtmlContent, sPattern)
if aResult[0] == True:
for aEntry in aResult[1]:
sUrl = str(aEntry[0]).strip()
if not (sUrl.startswith('http')):
sUrl = URL_MAIN +'/'+ sUrl
if aEntry[2] == sLanguageToken:
break
oRequest = cRequestHandler(sUrl)
sHtmlContent = oRequest.request()
aResult = oParser.parse(sHtmlContent, sPattern)
if aResult[0] == True:
for aEntry in aResult[1]:
sUrl = str(aEntry[0]).strip()
if not (sUrl.startswith('http')):
sUrl = URL_MAIN +'/'+ sUrl
if aEntry[2] == sLanguageToken:
break
else:
oRequest = cRequestHandler(sUrl)
sHtmlContent = oRequest.request()
aResult = oParser.parse(sHtmlContent, sPattern)
if aResult[0] == True:
sUrl = str(aResult[1][0][0]).strip()
if not (sUrl.startswith('http')):
sUrl = URL_MAIN + sUrl
oRequest = cRequestHandler(sUrl)
sHtmlContent = oRequest.request()
aResult = oParser.parse(sHtmlContent, sPattern)
if aResult[0] == True:
sUrl = str(aResult[1][0][0]).strip()
if not (sUrl.startswith('http')):
sUrl = URL_MAIN +'/'+ sUrl
__getAllSeasons(sUrl)
else:
__parseMovieSimpleList(sUrl, iPage, oGui)
oGui.setView('movies')
oGui.setEndOfDirectory()
def parseMovieResultSite():
oGui = cGui()
params = ParameterHandler()
if (params.exist('siteUrl')):
siteUrl = params.getValue('siteUrl')
normalySiteUrl = params.getValue('normalySiteUrl')
iPage = params.getValue('iPage')
__parseMovieResultSite(oGui, siteUrl, normalySiteUrl, iPage)
oGui.setEndOfDirectory()
def showHosters():
params = ParameterHandler()
if (params.exist('sUrl') and params.exist('sMovieTitle')):
sUrl = params.getValue('sUrl')
sMovieTitle = params.getValue('sMovieTitle')
sHtmlContent = cRequestHandler(sUrl).request()
sPattern = '<tr id="tablemoviesindex2">.*?<a href="([^"]+)">([^<]+)<.*?alt="(.*?) .*?width="16">.*?</a>.*?smileys/([1-9]).gif"'
aResult = cParser().parse(sHtmlContent.replace('\\', ''), sPattern)
if (aResult[0] == True):
hosters = []
for aEntry in aResult[1]:
sHoster = aEntry[2].strip()
hoster = {}
hoster['name'] = sHoster
hoster['link'] = URL_MAIN + '/' + aEntry[0]
hoster['displayedName'] = aEntry[
1] + ' - ' + sHoster + ' - Quality: ' + aEntry[3]
hoster['quality'] = aEntry[3]
hoster['date'] = aEntry[1].strip()
hosters.append(hoster)
hosters.append('showHoster')
return hosters
def showHosters():
oParams = ParameterHandler()
seriesId = oParams.getValue('seriesID')
season = oParams.getValue('Season')
episode = oParams.getValue('EpisodeNr')
data = _getJsonContent("series/%s/%s/%s" % (seriesId, season, episode))
if not data:
return []
hosters = []
for link in data['links']:
hoster = dict()
hoster['link'] = URL_MAIN + 'watch/' + link['id']
hoster['name'] = link['hoster']
if hoster['name'] == "OpenLoadHD":
hoster['name'] = "OpenLoad"
hoster['displayedName'] = link['hoster']
hosters.append(hoster)
if hosters:
hosters.append('getHosterUrl')
return hosters
def showEntries(entryUrl=False, sGui=False):
oGui = sGui if sGui else cGui()
params = ParameterHandler()
if not entryUrl: entryUrl = params.getValue('sUrl')
oRequest = cRequestHandler(entryUrl, ignoreErrors=(sGui is not False))
sHtmlContent = oRequest.request()
pattern = '<div[^>]*class="poster">.*?img[^>]src="([^"]+)"[^>]alt="([^"]+).*?(.*?)<a[^>]href="([^"]+).*?<span>([\d]+)</span>.*?<div[^>]class="texto">([^"]+)</div>'
isMatch, aResult = cParser.parse(sHtmlContent, pattern)
if not isMatch:
if not sGui: oGui.showInfo('xStream', 'Es wurde kein Eintrag gefunden')
return
cf = cRequestHandler.createUrl(entryUrl, oRequest)
total = len(aResult)
for sThumbnail, sName, sDummy, sUrl, sYear, sDesc in aResult:
isTvshow = True if "serie" in sUrl else False
sThumbnail = sThumbnail + cf
if sThumbnail.startswith('//'):
sThumbnail = 'https:' + sThumbnail
if sUrl.startswith('//'):
sUrl = 'https:' + sUrl
oGuiElement = cGuiElement(sName, SITE_IDENTIFIER,
'showSeasons' if isTvshow else 'showHosters')
oGuiElement.setMediaType('tvshow' if isTvshow else 'movie')
oGuiElement.setThumbnail(sThumbnail)
oGuiElement.setFanart(sThumbnail)
if 'German' in sDummy:
oGuiElement.setLanguage('Deutsch')
if 'English' in sDummy:
oGuiElement.setLanguage('Englisch')
oGuiElement.setYear(sYear)
oGuiElement.setDescription(sDesc)
params.setParam('entryUrl', sUrl)
params.setParam('sName', sName)
params.setParam('sThumbnail', sThumbnail)
params.setParam('sDesc', sDesc)
oGui.addFolder(oGuiElement, params, isTvshow, total)
if not sGui:
pattern = '"next"[^>]*href="([^"]+)'
isMatchNextPage, sNextUrl = cParser.parseSingleResult(
sHtmlContent, pattern)
if isMatchNextPage:
if sNextUrl.startswith('//'):
sNextUrl = 'https:' + sNextUrl
params.setParam('sUrl', sNextUrl)
oGui.addNextPage(SITE_IDENTIFIER, 'showEntries', params)
oGui.setView('tvshows' if 'serie' in sUrl else 'movies')
oGui.setEndOfDirectory()
def play(sUrl=False):
# ParameterHandler erzeugen
oParams = ParameterHandler()
# URL ermitteln falls nicht übergeben
if not sUrl: sUrl = oParams.getValue('url')
# Array mit einem Eintrag für Hosterliste erzeugen (sprich direkt abspielen)
results = []
result = {'streamUrl': sUrl, 'resolved': True}
results.append(result)
# Ergebniss zurückliefern
return results
def showValueList():
oGui = cGui()
params = ParameterHandler()
entryUrl = params.getValue('sUrl')
valueType = params.getValue('valueType')
sHtmlContent = cRequestHandler(entryUrl).request()
sPattern = '<select[^>]*name="%s\[\]"[^>]*>(.*?)</select>' % valueType # container#
logger.info("sPattern %s" % sPattern)
isMatch, strContainer = cParser.parseSingleResult(sHtmlContent, sPattern)
if isMatch:
sPattern = '<option[^>]*value="(.*?)"[^>]*>(.*?)</option>' # container
isMatch, aResult = cParser.parse(strContainer, sPattern)
if not isMatch:
return
for sID, sName in aResult:
params.setParam('sUrl', entryUrl + '&' + valueType + '[]=' + sID)
oGui.addFolder(
cGuiElement(sName.strip(), SITE_IDENTIFIER, 'showEntries'), params)
oGui.setEndOfDirectory()
def showCinemaMovies():
oGui = cGui()
oParams = ParameterHandler()
sShowTitle = oParams.getValue('Title')
seriesId = oParams.getValue('seriesID')
sImdb = oParams.getValue('imdbID')
data = _getJsonContent("series/%s/0" % (seriesId))
total = len(data['epi'])
for movie in data['epi']:
if movie['german']:
title = movie['german'].encode('utf-8')
else:
title = movie['english'].encode('utf-8')
guiElement = cGuiElement(title, SITE_IDENTIFIER, 'showHosters')
guiElement.setMediaType('movie')
guiElement.setTitle(title)
guiElement.setThumbnail(URL_COVER % data["series"]["id"])
oParams.setParam('EpisodeNr', movie['epi'])
oGui.addFolder(guiElement, oParams, bIsFolder=False, iTotal=total)
oGui.setView('movie')
oGui.setEndOfDirectory()
def showHosters():
oParams = ParameterHandler()
sUrl = oParams.getValue('entryUrl')
sHtmlContent = __getContent(sUrl)
sPattern = '<a[^>]*class="link_a"[^>]*href="([^"]+).*?domain=([^"]+).*?</td><td>([^<]+)</td><td>([^<]+)</td><td>'
aResult = cParser().parse(sHtmlContent, sPattern)
hosters = []
for sUrl, sName, sQuali, sLang in aResult[1]:
if not 'filecrypt' in sName:
hoster = {'link': sUrl, 'name': sName}
hosters.append(hoster)
if hosters:
hosters.append('getHosterUrl')
return hosters
def showHosters():
oParams = ParameterHandler()
sUrl = oParams.getValue('entryUrl')
sHtmlContent = cRequestHandler(sUrl).request()
sPattern = 'src=[^>]"([^"]+)"\s'
aResult = cParser().parse(sHtmlContent, sPattern)
hosters = []
if aResult[1]:
for sUrl in aResult[1]:
hoster = {'link': sUrl, 'name': sUrl}
hosters.append(hoster)
if hosters:
hosters.append('getHosterUrl')
return hosters
def showGenre():
oGui = cGui()
params = ParameterHandler()
entryUrl = params.getValue('sUrl')
sHtmlContent = cRequestHandler(entryUrl).request()
pattern = "text: '([^']+)', value: '([^']+)"
isMatch, aResult = cParser.parse(sHtmlContent, pattern)
if not isMatch:
oGui.showInfo('xStream', 'Es wurde kein Eintrag gefunden')
return
for sName, sID in aResult:
params.setParam('sUrl', entryUrl + '&genre[]=' + sID)
oGui.addFolder(cGuiElement(sName, SITE_IDENTIFIER, 'showEntries'), params)
oGui.setEndOfDirectory()
def __getHtmlContent(sUrl=None, ignoreErrors=False):
parms = ParameterHandler()
if sUrl is None and not parms.exist('sUrl'):
logger.error("There is no url we can request.")
return False
elif sUrl is None:
sUrl = parms.getValue('sUrl')
sPrefLang = __getPreferredLanguage()
oRequest = cRequestHandler(sUrl, ignoreErrors=ignoreErrors)
oRequest.addHeaderEntry('Cookie', sPrefLang + 'ListDisplayYears=Always;')
oRequest.addHeaderEntry('Referer', URL_MAIN)
oRequest.addHeaderEntry('Accept', '*/*')
oRequest.addHeaderEntry('Host', domain)
return oRequest.request()
def getHosterUrl(sUrl=False):
oParams = ParameterHandler()
logger.info(oParams.getAllParameters())
if not sUrl:
sUrl = oParams.getValue('url')
results = []
result = {}
result['streamUrl'] = sUrl
result['resolved'] = False
results.append(result)
return results
def searchRequest(dictFilter=False, sGui=False):
oGui = sGui if sGui else cGui()
params = ParameterHandler()
dictFilter = {}
for (prop, val) in SEARCH_DICT.items():
parmVal = params.getValue(prop)
parmVal = ast.literal_eval(
parmVal
) if prop == 'year[]' and parmVal else parmVal # yes a bit ugly
dictFilter[prop] = parmVal if parmVal else val
params.setParam(prop, dictFilter[prop])
oResponse = _getJSonResponse(URL_SEARCH, dictFilter, (sGui is not False))
if 'entries' not in oResponse or len(oResponse['entries']) == 0:
if not sGui: oGui.showInfo('xStream', 'Es wurde kein Eintrag gefunden')
return
sLanguage = _getPrefLanguage()
total = len(oResponse['entries'])
for aEntry in oResponse['entries']:
aLang = re.compile('(\w+)-').findall(aEntry['language'])
if sLanguage and sLanguage not in aLang:
continue
elif sLanguage:
aLang = [sLanguage]
oGuiElement = cGuiElement()
oGuiElement.setSiteName(SITE_IDENTIFIER)
oGuiElement.setFunction('showHosters')
oGuiElement.setTitle(aEntry['title'].encode('utf-8'))
oGuiElement.setMediaType('movie')
oGuiElement.setThumbnail(URL_PROTOCOL + aEntry['cover'])
oGuiElement.setYear(aEntry['year'])
oGuiElement.setLanguage(', '.join(map(str, aLang)))
if oGui.isMetaOn:
oGuiElement.addItemValue('imdb_id', 'tt' + aEntry['imdb'])
oOutParms = ParameterHandler()
oOutParms.setParam('itemID', aEntry['imdb'])
oOutParms.setParam('lang', aEntry['language'])
oGui.addFolder(oGuiElement, oOutParms, False, total, True)
if int(oResponse['current']) < int(oResponse['pages']):
params.setParam('page', int(oResponse['current']) + 1)
oGui.addNextPage(SITE_IDENTIFIER, 'searchRequest', params)
if not sGui:
oGui.setView('movies')
oGui.setEndOfDirectory()
def showHosters():
oParams = ParameterHandler()
id = oParams.getValue('id')
sHtmlContent = cRequestHandler(URL_HOSTER % id + S0VZ).request()
pattern = '(http[^"]+)'
isMatch, aResult = cParser().parse(sHtmlContent, pattern)
hosters = []
for sUrl in aResult:
hname = cParser.urlparse(sUrl)
hoster = {'link': sUrl, 'name': hname}
hosters.append(hoster)
if hosters:
hosters.append('getHosterUrl')
return hosters
def showValue():
oGui = cGui()
params = ParameterHandler()
sUrl = params.getValue('sUrl')
sHtmlContent = cRequestHandler(sUrl).request()
isMatch, sContainer = cParser.parseSingleResult(
sHtmlContent,
'<ul[^>]*class="%s"[^>]*>(.*?)<\/ul>' % params.getValue('sCont'))
if isMatch:
isMatch, aResult = cParser.parse(
sContainer,
'<li>\s*<a[^>]*href="([^"]*)"[^>]*>(.*?)<\/a>\s*<\/li>')
if not isMatch:
oGui.showInfo('xStream', 'Es wurde kein Eintrag gefunden')
return
for sUrl, sName in aResult:
sUrl = sUrl if sUrl.startswith('http') else URL_MAIN + sUrl
params.setParam('sUrl', sUrl)
oGui.addFolder(
cGuiElement(sName.strip(), SITE_IDENTIFIER, 'showEntries'), params)
oGui.setEndOfDirectory()
def getHosters():
hosters = []
params = ParameterHandler()
if (params.exist('movieUrl') and params.exist('sMovieTitle')):
sSiteUrl = params.getValue('movieUrl')
sMovieTitle = params.getValue('sMovieTitle')
sHtmlContent = __getHtmlContent(sUrl = sSiteUrl)
sPattern = 'id="ame_noshow_post.*?<a href="([^"]+)" title="[^"]+" target="_blank">([^<]+)</a>'
aResult = cParser().parse(sHtmlContent, sPattern)
if aResult[0] == True:
for aEntry in aResult[1]:
sUrl = aEntry[0]
# extract hoster domainname
if 'gstream.to/secure/' in sUrl :
sHoster = sUrl.split('secure/')[-1].split('/')[0].split('.')[-2]
else:
sHoster = sUrl.split('//')[-1].split('/')[0].split('.')[-2]
hoster = {}
hoster['link'] = sUrl
hoster['name'] = sHoster
hosters.append(hoster)
hosters.append('getHosterUrl')
return hosters
def showSearchEntries(entryUrl=False, sGui=False, sSearchText=False):
oGui = sGui if sGui else cGui()
params = ParameterHandler()
if not entryUrl: entryUrl = params.getValue('sUrl')
oRequest = cRequestHandler(entryUrl)
sHtmlContent = oRequest.request()
pattern = '-2">.*?href="([^"]+).*?src="([^"]+).*?alt="([^"]+).*?year">([\d]+)(.*?)(?:<div[^>]class="contenido"><p>([^<]+)?)'
isMatch, aResult = cParser.parse(sHtmlContent, pattern)
if not isMatch:
if not sGui: oGui.showInfo('xStream', 'Es wurde kein Eintrag gefunden')
return
cf = cRequestHandler.createUrl(entryUrl, oRequest)
total = len(aResult)
for sUrl, sThumbnail, sName, sYear, sDummy, sDesc in aResult:
if sSearchText and not cParser().search(sSearchText, sName):
continue
if sThumbnail and not sThumbnail.startswith('http'):
sThumbnail = 'https:' + sThumbnail
sThumbnail = sThumbnail + cf
if sUrl.startswith('//'):
sUrl = 'https:' + sUrl
isTvshow = True if "serie" in sUrl else False
oGuiElement = cGuiElement(sName, SITE_IDENTIFIER,
'showSeasons' if isTvshow else 'showHosters')
oGuiElement.setMediaType('tvshow' if isTvshow else 'movie')
oGuiElement.setThumbnail(sThumbnail)
oGuiElement.setFanart(sThumbnail)
oGuiElement.setYear(sYear)
if 'de.png' in sDummy:
oGuiElement.setLanguage('Deutsch')
if 'en.png' in sDummy:
oGuiElement.setLanguage('Englisch')
oGuiElement.setDescription(sDesc)
params.setParam('entryUrl', sUrl)
params.setParam('sName', sName)
params.setParam('sThumbnail', sThumbnail)
params.setParam('sDesc', sDesc)
oGui.addFolder(oGuiElement, params, isTvshow, total)
if not sGui:
pattern = "span[^>]*class=[^>]*current[^>]*>.*?</span><a[^>]*href='([^']+)"
isMatchNextPage, sNextUrl = cParser.parseSingleResult(
sHtmlContent, pattern)
if isMatchNextPage:
if sNextUrl.startswith('//'):
sNextUrl = 'https:' + sNextUrl
params.setParam('sUrl', sNextUrl)
oGui.addNextPage(SITE_IDENTIFIER, 'showSearchEntries', params)
oGui.setEndOfDirectory()
def showHosters():
oParams = ParameterHandler()
oRequest = cRequestHandler(URL_REQUEST)
oRequest.addParameters('mID', oParams.getValue('id'))
oRequest.addParameters('raw', 'true')
oRequest.addParameters('language', oParams.getValue('lang'))
if oParams.getValue('season'):
oRequest.addParameters('season', oParams.getValue('season'))
oRequest.addParameters('episode', oParams.getValue('episode'))
sHtmlContent = oRequest.request()
if not sHtmlContent:
return []
jContent = json.loads(sHtmlContent)
if not jContent[1]:
return []
hosters = []
for ohoster in jContent[1].items():
sName = ohoster[1]['name']
for links in ohoster[1]['links']:
hoster = dict()
hoster['link'] = links['URL']
hoster['name'] = sName
if links['quality'] in QUALITY_ENUM:
hoster['displayedName'] = '[%s] %s' % (QUALITY_ENUM[links['quality']], sName)
hoster['quality'] = links['quality']
hosters.append(hoster)
if hosters:
hosters.append('getHosterUrl')
return hosters
def showEpisodes():
oGui = cGui()
params = ParameterHandler()
sUrl = params.getValue('entryUrl')
sThumbnail = params.getValue("Thumbnail")
sSeason = params.getValue('season')
sShowName = params.getValue('TVShowTitle')
sHtmlContent = cRequestHandler(sUrl).request()
sPattern = '<a[^>]*href="#(s%se(\d+))"[^>]*>(.*?)</a>' % sSeason
isMatch, aResult = cParser().parse(sHtmlContent, sPattern)
if not isMatch:
oGui.showInfo('streamon', 'Es wurde kein Eintrag gefunden')
return
result, imdb = cParser().parseSingleResult(sHtmlContent,
'IMDB\s?=\s?\'(\d+)')
total = len(aResult)
for sEpisodeUrl, sEpisodeNr, sEpisodeTitle in aResult:
res = re.search('%s (.*)' % sEpisodeNr, sEpisodeTitle)
if res:
sEpisodeTitle = '%s - %s' % (sEpisodeNr, res.group(1))
oGuiElement = cGuiElement(sEpisodeTitle, SITE_IDENTIFIER,
"showHosters")
oGuiElement.setThumbnail(sThumbnail)
oGuiElement.setFanart(sThumbnail)
oGuiElement.setTVShowTitle(sShowName)
oGuiElement.setEpisode(sEpisodeNr)
oGuiElement.setSeason(sSeason)
oGuiElement.setMediaType('episode')
params.setParam('entryUrl', sUrl)
params.setParam('val', sEpisodeUrl)
params.setParam('IMDB', imdb)
oGui.addFolder(oGuiElement, params, False, total)
oGui.setView('episodes')
oGui.setEndOfDirectory()
def showEpisodes():
oGui = cGui()
params = ParameterHandler()
sTVShowTitle = params.getValue('TVShowTitle')
entryUrl = params.getValue('entryUrl')
sSeasonNr = params.getValue('sSeasonNr')
oRequest = cRequestHandler(entryUrl)
sHtmlContent = oRequest.request()
pattern = '<span[^>]*class="se-t[^"]*">%s</span>.*?<ul[^>]*class="episodios"[^>]*>(.*?)</ul>' % sSeasonNr
isMatch, sContainer = cParser.parseSingleResult(sHtmlContent, pattern)
if not isMatch:
oGui.showInfo('xStream', 'Es wurde kein Eintrag gefunden')
return
pattern = '<a[^>]*href="([^"]+)"[^>]*>\s*<img src="([^"]+).*?<div[^>]*class="numerando">[^-]*-\s*(\d+)\s*?</div>.*?<a[^>]*>([^<]*)</a>'
isMatch, aResult = cParser.parse(sContainer, pattern)
if not isMatch:
oGui.showInfo('xStream', 'Es wurde kein Eintrag gefunden')
return
total = len(aResult)
for sUrl, sThumbnail, sEpisodeNr, sName in aResult:
oGuiElement = cGuiElement("%s - %s" % (sEpisodeNr, sName.strip()), SITE_IDENTIFIER, 'showHosters')
oGuiElement.setTVShowTitle(sTVShowTitle)
oGuiElement.setSeason(sSeasonNr)
oGuiElement.setEpisode(sEpisodeNr)
sThumbnail = re.sub('-\d+x\d+\.', '.', sThumbnail)
oGuiElement.setThumbnail(sThumbnail)
oGuiElement.setMediaType('episode')
if sUrl and not sUrl.startswith('http'):
sUrl = URL_MAIN + sUrl
params.setParam('entryUrl', sUrl.strip())
oGui.addFolder(oGuiElement, params, False, total)
oGui.setView('seasons')
oGui.setEndOfDirectory()
def showSeasons():
oGui = cGui()
params = ParameterHandler()
sTitle = params.getValue('Title')
seriesId = params.getValue('seriesID')
logger.info("%s: show seasons of '%s' " % (SITE_NAME, sTitle))
data = _getJsonContent("series/%s/1" % seriesId)
if not data:
oGui.showInfo('xStream', 'Es wurde kein Eintrag gefunden')
return
rangeStart = not int(data["series"]["movies"])
total = int(data["series"]["seasons"])
for i in range(rangeStart, total + 1):
seasonNum = str(i)
if i is 0:
seasonTitle = 'Film(e)'
dialogType = 'showCinemaMovies'
else:
seasonTitle = '%s - Staffel %s' % (sTitle, seasonNum)
if params.getValue('specific') == 'Episode':
dialogType = 'randomEpisode'
else:
dialogType = 'showEpisodes'
guiElement = cGuiElement(seasonTitle, SITE_IDENTIFIER, dialogType)
guiElement.setMediaType('season')
guiElement.setSeason(seasonNum)
guiElement.setTVShowTitle(sTitle)
guiElement.setDescription(data["series"]["description"])
guiElement.setThumbnail(URL_COVER % data["series"]["id"])
params.setParam('Season', seasonNum)
oGui.addFolder(guiElement, params, iTotal=total)
oGui.setView('seasons')
oGui.setEndOfDirectory()
def showReleases():
oGui = cGui()
params = ParameterHandler()
sHtmlContent = _getRequestHandler(params.getValue('entryUrl'), True).request()
pattern = "<a[^>]*href=['\"]#stream_(\d+)['\"][^>]*>.*?</i>(.*?)" # releaseId / Name (opt)
pattern += "(?:<i[^>]*class=['\"].*?flag-(\w+)['\"][^>]*>.*?)?" # main-lang (opt)
pattern += "(?:[|]\s<i[^>]*class=['\"].*?flag-(\w+)['\"][^>]*>.*?)?</li>" # suptitle-lang (opt)
aResult = cParser().parse(sHtmlContent, pattern)
if not aResult[0] or not aResult[1][0]:
oGui.showInfo('xStream','Es wurde kein Eintrag gefunden')
return
sThumbnail = params.getValue('sThumbnail')
sName = params.getValue('sName')
total = len(aResult[1])
for sReleaseId, sReleaseName, sLang, sSubLang in aResult[1]:
aStreams = cParser().parse(sHtmlContent, "id=['\"]streams_episodes_%s_\d['\"]" % sReleaseId)
if not aStreams[0] or not aStreams[1][0]: # skip empty releases
continue
sReleaseName = sReleaseName.strip()
if sLang and sSubLang:
sReleaseName += " (%s | %s)" % (sLang.upper(),sSubLang.upper())
elif sLang:
sReleaseName += " (%s)" % (sLang.upper())
oGuiElement = cGuiElement(sReleaseName, SITE_IDENTIFIER, 'showHosters')
oGuiElement.setThumbnail(sThumbnail)
params.setParam('iReleaseId', int(sReleaseId))
if len(aStreams[1]) > 1:
oGuiElement.setFunction("showEpisodes")
oGui.addFolder(oGuiElement, params, True, total)
else:
params.setParam('iEpisodeId', 0)
oGui.addFolder(oGuiElement, params, False, total)
oGui.setEndOfDirectory()
def showSeasons():
oGui = cGui()
params = ParameterHandler()
sUrl = params.getValue('entryUrl')
sHtmlContent = cRequestHandler(sUrl).request()
aResult = cParser().parse(sHtmlContent, "var[ ]subcats[ ]=[ ](.*?);")
if not aResult[0] or not aResult[1][0]:
oGui.showInfo('xStream', 'Es wurde kein Eintrag gefunden')
return
data = json.loads(aResult[1][0])
seasons = []
for key, value in data.items():
SeasonsNr = int(value['info']['staffel'])
if SeasonsNr not in seasons:
seasons.append(SeasonsNr)
sThumbnail = params.getValue('sThumbnail')
sName = params.getValue('sName')
seasons = sorted(seasons)
isDesc, sDesc = cParser.parseSingleResult(
sHtmlContent, '<img[^>]class.*?>(.*?)<br><br>')
total = len(seasons)
for iSeason in seasons:
oGuiElement = cGuiElement("Staffel " + str(iSeason), SITE_IDENTIFIER,
'showEpisodes')
oGuiElement.setTVShowTitle(sName)
oGuiElement.setSeason(iSeason)
oGuiElement.setMediaType('season')
if isDesc:
oGuiElement.setDescription(sDesc)
oGuiElement.setThumbnail(sThumbnail)
oGuiElement.setFanart(sThumbnail)
oGui.addFolder(oGuiElement, params, True, total)
oGui.setView('seasons')
oGui.setEndOfDirectory()
def parseMovieEntrySite():
oParams = ParameterHandler()
sSecurityValue = oParams.getValue('securityCookie')
if (oParams.exist('sUrl')):
sUrl = oParams.getValue('sUrl')
# get movieEntrySite content
sHtmlContent = __getHtmlContent(sUrl, sSecurityValue)
sMovieTitle = __createMovieTitle(sHtmlContent)
# get thumbnail
result = cParser().parse(sHtmlContent, '<div class="Grahpics">.*?<img src="([^"]+)"')
thumbnail = ''
if result[0]:
thumbnail = URL_MAIN + str(result[1][0])
bIsSerie = __isSerie(sHtmlContent)
if (bIsSerie):
oGui = cGui()
aSeriesItems = parseSerieSite(sHtmlContent)
if (len(aSeriesItems) > 0):
imdbID = oParams.getValue('imdbID')
for item in aSeriesItems:
oGuiElement = cGuiElement(item['title'], SITE_IDENTIFIER, 'showHosters')
sShowTitle = sMovieTitle.split('(')[0].split('*')[0]
oGuiElement.setThumbnail(thumbnail)
oGuiElement.setMediaType('episode')
oGuiElement.setSeason(item['season'])
oGuiElement.setEpisode(item['episode'])
oGuiElement.setTVShowTitle(sShowTitle)
oParams.addParams({'sUrl':item['url'], 'episode':item['episode'], 'season':item['season']})
oGui.addFolder(oGuiElement, oParams, bIsFolder = False, iTotal = len(aSeriesItems))
oGui.setView('episodes')
oGui.setEndOfDirectory()
else:
logger.info('Movie')
result = showHosters(sHtmlContent, sMovieTitle)
return result
def getHosters(sUrl=False):
if not sUrl:
params = ParameterHandler()
oRequest = cRequestHandler(HOSTER_URL)
oRequest.addHeaderEntry("X-Requested-With", "XMLHttpRequest")
oRequest.setRequestType(1)
oRequest.addParameters('imdbid', params.getValue('imdbid'))
oRequest.addParameters('language', params.getValue('language'))
oRequest.addParameters('season', params.getValue('Season'))
oRequest.addParameters('episode', params.getValue('Episode'))
sHtmlContent = oRequest.request()
else:
sHtmlContent = cRequestHandler(sUrl).request()
if not sHtmlContent:
return []
sPattern = '<a[^>]*href="([^"]+)"[^>]*><img[^>]*class="([s|h]d+)linkbutton"'
isMatch, aResult = cParser.parse(sHtmlContent, sPattern)
hosters = []
if not isMatch:
return hosters
for sUrl, sQuali in aResult:
hoster = {}
if not 'nurhdfilm' in sUrl.lower():
hoster['link'] = sUrl
hoster['name'] = str(urlparse(sUrl).netloc).title()
hoster['displayedName'] = '%s [%s]' % (hoster['name'],
sQuali.upper())
hoster['quality'] = QUALITY_ENUM[sQuali.upper()]
hosters.append(hoster)
if hosters:
hosters.append('getHosterUrl')
return hosters
def showHosters(sHtmlContent='', sTitle=False):
oParams = ParameterHandler()
sSecurityValue = oParams.getValue('securityCookie')
if (sTitle == False):
sTitle = oParams.getValue('title')
if (oParams.exist('sUrl')):
sUrl = oParams.getValue('sUrl')
sHtmlContent = __getHtmlContent(sUrl, sSecurityValue)
sPattern = '<li id="Hoster.*?rel="([^"]+)".*?<div class="Named">(.*?)</div>(.*?)</div></li>'
oParser = cParser()
aResult = oParser.parse(sHtmlContent, sPattern)
hosters = []
if (aResult[0]):
for aEntry in aResult[1]:
sHoster = aEntry[1]
# check for additional mirrors
sPattern = '<b>Mirror</b>: [1-9]/([1-9])<br />'
oParser = cParser()
aResult = oParser.parse(aEntry[2], sPattern)
mirrors = 1
if (aResult[0]):
mirrors = int(aResult[1][0])
for i in range(1, mirrors + 1):
sUrl = URL_MIRROR + urllib.unquote_plus(aEntry[0])
mirrorName = ""
if (mirrors > 1):
mirrorName = " Mirror " + str(i)
sUrl = re.sub(r'Mirror=[1-9]', 'Mirror=' + str(i), sUrl)
hoster = {}
hoster['name'] = sHoster
hoster['link'] = sUrl
hoster['displayedName'] = sHoster + mirrorName
hosters.append(hoster)
hosters.append('getHosterUrlandPlay')
return hosters
def showEpisodes():
oGui = cGui()
params = ParameterHandler()
sUrl = params.getValue('entryUrl')
sThumbnail = params.getValue("sThumbnail")
sSeason = params.getValue('season')
sShowName = params.getValue('TVShowTitle')
sHtmlContent = cRequestHandler(sUrl).request()
pattern = '<div[^>]*class="staffelWrapperLoop[^"]*"[^>]*data-sid="%s">(.*?)</div></li></ul></div>' % sSeason
isMatch, sContainer = cParser.parseSingleResult(sHtmlContent, pattern)
if not isMatch:
oGui.showInfo('xStream', 'Es wurde kein Eintrag gefunden')
return
pattern = '<a[^>]*href="([^"]*)"[^>]*class="getStaffelStream"[^>]*>.*?<small>([^>]*?)</small>'
isMatch, aResult = cParser.parse(sContainer, pattern)
isDesc, sDesc = cParser.parseSingleResult(sHtmlContent,
'"description">([^<]+)')
total = len(aResult)
for sEpisodeUrl, sName in aResult:
oGuiElement = cGuiElement(sName, SITE_IDENTIFIER, "showHosters")
oGuiElement.setThumbnail(sThumbnail)
oGuiElement.setFanart(sThumbnail)
oGuiElement.setTVShowTitle(sShowName)
oGuiElement.setSeason(sSeason)
oGuiElement.setMediaType('episode')
if sEpisodeUrl.startswith('//'):
params.setParam('entryUrl', 'https:' + sEpisodeUrl)
else:
params.setParam('entryUrl', sEpisodeUrl)
if isDesc:
oGuiElement.setDescription(sDesc)
oGui.addFolder(oGuiElement, params, False, total)
oGui.setView('episodes')
oGui.setEndOfDirectory()
def showEpisodes():
oGui = cGui()
params = ParameterHandler()
sThumbnail = params.getValue('sThumbnail')
sTVShowTitle = params.getValue('TVShowTitle')
entryUrl = params.getValue('entryUrl')
sSeasonNr = params.getValue('sSeasonNr')
sHtmlContent = cRequestHandler(entryUrl).request()
pattern = '<span[^>]*>\s*' # container start
pattern += '<a[^>]*href="([^"]+staffel-%s-[^"]+)"[^>]*><b>E(\d+)</b>.([^"]+)</a>.*?' % sSeasonNr # url / epId / name
pattern += '(?:<small[^>]*>([^<]*)</small>.*?)?' # desc
pattern += '</span>' # container end
isMatch, aResult = cParser.parse(sHtmlContent, pattern)
if not isMatch:
oGui.showInfo('xStream', 'Es wurde kein Eintrag gefunden')
return
total = len(aResult)
for sUrl, sEpisodeNr, sName, sDesc in aResult:
if sName and 'episode #' not in sName.lower():
sName = "%s - %s" % (sEpisodeNr, sName.strip())
else:
sName = "Folge %s" % sEpisodeNr
oGuiElement = cGuiElement(sName, SITE_IDENTIFIER, 'showHosters')
oGuiElement.setTVShowTitle(sTVShowTitle)
oGuiElement.setSeason(sSeasonNr)
oGuiElement.setEpisode(sEpisodeNr)
oGuiElement.setThumbnail(sThumbnail)
oGuiElement.setDescription(sDesc)
oGuiElement.setMediaType('episode')
params.setParam('entryUrl', URL_MAIN + sUrl)
oGui.addFolder(oGuiElement, params, False, total)
oGui.setView('episodes')
oGui.setEndOfDirectory()
def showEpisodes():
oGui = cGui()
oParams = ParameterHandler()
sSeason = oParams.getValue('season')
sMovieTitle = oParams.getValue('sMovieTitle')
sMovie = oParams.getValue(PARAM_MOVIESEGMENT_KEY).replace(".html","/")
sUrl = URL_SERIES_EPISODEURL + sMovie
oRequest = cRequestHandler(sUrl)
#oRequest.setHeaderEntry("Accept","application/json, text/javascript, */*; q=0.01")
oRequest.addParameters("season",sSeason)
oRequest.addHeaderEntry("X-Requested-With","XMLHttpRequest")
oRequest.addHeaderEntry('Referer', sUrl)
oRequest.addHeaderEntry('Accept', '*/*')
oRequest.addHeaderEntry('Host', SITE_NAME.lower())
sHtmlContent = oRequest.request()
aData = sorted(loads(sHtmlContent)['episodes'])
for aEntry in aData:
logger.info(aEntry['episode'])
oGuiElement = cGuiElement()
oGuiElement.setFunction('_playEpisode')
oGuiElement.setSiteName(SITE_IDENTIFIER)
oGuiElement.setTitle(sMovieTitle + '- S'+sSeason+'E'+str(aEntry['episode']))
oGuiElement.setMediaType('episode')
oGuiElement.setEpisode(aEntry['episode'])
oOutputParameterHandler = ParameterHandler()
oOutputParameterHandler.setParam('link',aEntry['link'])
oOutputParameterHandler.setParam('season',sSeason)
oOutputParameterHandler.setParam('episode',aEntry['episode'])
oOutputParameterHandler.setParam('sMovieTitle',sMovieTitle)
oOutputParameterHandler.setParam(PARAM_URL_KEY,"http://www.ecostream.tv/stream/"+aEntry['link']+".html")
oGui.addFolder(oGuiElement, oOutputParameterHandler, bIsFolder=False, iTotal = len(aData))
oGui.setView('episodes')
oGui.setEndOfDirectory()
def getHosters(sUrl=False):
# ParameterHandler erzeugen
params = ParameterHandler()
# URL und Name ermitteln falls nicht übergeben
sUrl = sUrl if sUrl else params.getValue('sUrl')
# Seite abrufen
sHtmlContent = cRequestHandler(sUrl).request()
# Servername und Episoden pro Server ermitteln
pattern = "<ul[^>]*class=['\"]list-inline list-film['\"][^>]*>.*?([a-zA-Z0-9_ ]+)</div>(.*?)</ul>"
isMatch, aResult = cParser.parse(sHtmlContent, pattern)
# Hosterliste initialisieren
hosters = []
# Prüfen ob Server ermittelt werden konnte
if isMatch:
# Prüfen ob eine direkte-Episode gewünscht ist
aMatches = re.compile("episode=(\d+)$").findall(sUrl)
# gewünsche Episode ermitteln wenn möglich
sEpisode = "1" if not aMatches else aMatches[0]
# Server-Block durchlaufen
for sServername, sInnerHtml in aResult:
# Alle Links für diesen Server ermitteln
isMatch, aResult = cParser.parse(sInnerHtml, "href=['\"]([^'\"]*)['\"][^>]*>")
# Keine Links gefunden? => weiter machen
if not isMatch:
continue
# Alle Links durchlaufen
for singleUrl in aResult:
# Link auf korrekte Episode prüfen
aMatches = re.compile("episode=(%s)$" % sEpisode).findall(singleUrl)
# Wurde ein Link gefunden? => Einträge zur Gesamtliste hinzufügen
if aMatches:
res = re.search("(\d+)-stream(?:\?episode=(\d+))?", singleUrl, re.I)
if res:
hosters.extend(_getHostFromUrl(res.group(1), res.group(2), sServername))
# Sind Hoster vorhanden? => Nachfolgefunktion ergänzen
if hosters:
hosters.append('play')
return hosters
def __displayItems(oGui, sHtmlContent):
# Test if a cookie was set, else define the default empty one
sSecurityValue = ""
oParams = ParameterHandler()
if oParams.exist("securityCookie"):
sSecurityValue = oParams.getValue("securityCookie")
# The pattern to filter every item of the list
sPattern = '<td class="Icon"><img width="16" height="11" src="/gr/sys/lng/(\d+).png" alt="language"></td>'+\
'.*?title="([^\"]+)".*?<td class="Title">.*?<a href="([^\"]+)" onclick="return false;">([^<]+)</a> <span class="Year">([0-9]+)</span>'
# Parse to get all items of the list
oParser = cParser()
aResult = oParser.parse(sHtmlContent, sPattern)
if not aResult[0]:
logger.error("Could not find an item")
return
# Go throught all items and create a gui element for them.
total = len(aResult[1])
for aEntry in aResult[1]:
sTitle = cUtil().unescape(aEntry[3])
# split title and subtitle language
sTitle, subLang = __checkSubLanguage(sTitle)
# get audio language
sLang = __createLanguage(aEntry[0])
sUrl = URL_MAIN + aEntry[2]
mediaType = ''
if aEntry[1] == 'movie' or aEntry[1] == 'cinema':
mediaType = 'movie'
elif aEntry[1] == 'series':
mediaType = 'series'
else:
mediaType = 'documentation'
oGuiElement = cGuiElement(sTitle, SITE_IDENTIFIER,
'parseMovieEntrySite')
oGuiElement.setLanguage(sLang)
oGuiElement.setSubLanguage(subLang)
oGuiElement.setYear(aEntry[4])
oParams.setParam('sUrl', sUrl)
oParams.setParam('mediaType', mediaType)
if mediaType == 'series':
oGuiElement.setMediaType('tvshow')
oGui.addFolder(oGuiElement, oParams, iTotal=total)
elif mediaType == 'movie':
oGuiElement.setMediaType('movie')
oGui.addFolder(oGuiElement, oParams, bIsFolder=False, iTotal=total)
else:
oGui.addFolder(oGuiElement, oParams, bIsFolder=False, iTotal=total)
