コード例 #1
0
def showXXX():
    params = ParameterHandler()
    oGui = cGui()
    __createMainMenuEntry(oGui, 'Alle Pornos', 661)
    #im Moment können keine Clips abgespielt werden da die Cliphoster nicht aufgelöst werden können
    #__createMainMenuEntry(oGui, 'Clips', 669, sSecurityValue)
       
    oGuiElement = cGuiElement()
    oGuiElement.setSiteName(SITE_IDENTIFIER)
    oGuiElement.setFunction('displaySearch')
    oGuiElement.setTitle('Suche XXX Streams')
    params.setParam('searchType', '530')
    oGui.addFolder(oGuiElement, params)
    
    __createMainMenuEntry(oGui, 'Amateure', '661&prefixid=Amateure1')
    __createMainMenuEntry(oGui, 'Anal', '661&prefixid=Anal')
    __createMainMenuEntry(oGui, 'Asia', '661&prefixid=Asia')
    __createMainMenuEntry(oGui, 'Black', '661&prefixid=Ebony')
    __createMainMenuEntry(oGui, 'B*****b', '661&prefixid=B*****b')
    __createMainMenuEntry(oGui, 'Deutsch', '661&prefixid=Deutsch')
    __createMainMenuEntry(oGui, 'Fetish', '661&prefixid=Fetish')
    __createMainMenuEntry(oGui, 'Große Brüste', '661&prefixid=GrosseBrueste')
    __createMainMenuEntry(oGui, 'Gruppensex', '661&prefixid=Gruppensex')
    __createMainMenuEntry(oGui, 'Gay', '661&prefixid=Gay')
    __createMainMenuEntry(oGui, 'Hardcore', '661&prefixid=Hardcore')
    __createMainMenuEntry(oGui, 'International', '661&prefixid=International')
    __createMainMenuEntry(oGui, 'Lesben', '661&prefixid=Lesben')
    __createMainMenuEntry(oGui, 'Masturbation', '661&prefixid=Masturbation')
    __createMainMenuEntry(oGui, 'Teens', '661&prefixid=Teens')
    oGui.setEndOfDirectory()
コード例 #2
0
def __getAllSeasons(sUrl):
    oGui = cGui()
    oRequest = cRequestHandler(sUrl)
    sHtmlContent = oRequest.request()

    sPattern = '<SELECT name="season".*?>(.*?)</SELECT>'
    oParser = cParser()
    
    aResult = oParser.parse(sHtmlContent, sPattern)
    if (aResult[0] == True):
        sPattern = '<OPTION value="(\d+)".*?>([^<]+)</OPTION>'
        aResult = oParser.parse(sHtmlContent,sPattern)
        if (aResult[0] == True):
            for aEntry in aResult[1]:
                oGuiElement = cGuiElement()
                oGuiElement.setSiteName(SITE_IDENTIFIER)
                oGuiElement.setFunction('showAllEpisodes')

                sTitle = aEntry[1].strip()
                oGuiElement.setTitle(sTitle)

                oOutputParameterHandler = ParameterHandler()
                oOutputParameterHandler.setParam('sUrl', sUrl)
                oOutputParameterHandler.setParam('season', aEntry[0])
                
                oGui.addFolder(oGuiElement, oOutputParameterHandler)
    oGui.setView('seasons')
    oGui.setEndOfDirectory()
コード例 #3
0
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)
コード例 #4
0
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()
コード例 #5
0
def showSeries():    
    oGui = cGui()  
    oParams = ParameterHandler()  
    
    sUrl = URL_SERIES
    oRequestHandler = cRequestHandler(sUrl)
    sHtmlContent = oRequestHandler.request();
    sChar = oParams.getValue('char')
    if sChar: sChar = sChar.lower()

    series = json.loads(sHtmlContent)
    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
     
        guiElement = cGuiElement(sTitle, SITE_IDENTIFIER, 'showSeasons')
        guiElement.setMediaType('tvshow')
        guiElement.setThumbnail(URL_COVER % serie["id"])        
        oParams.addParams({'siteUrl' : URL_SERIES + '/' + str(serie["id"]), 'Title' : sTitle})
        oGui.addFolder(guiElement, oParams, iTotal = total)

    oGui.setView('tvshows')
    oGui.setEndOfDirectory()
コード例 #6
0
def __writeLog(sLog, cLogLevel):
    params = ParameterHandler()
    if params.exist('site'):
        site = params.getValue('site')
        print "\t[xStream] ->%s: %s" %(site,sLog)
    else:
        print "\t[xStream] %s" % sLog
コード例 #7
0
ファイル: seriesever_net.py プロジェクト: Shinoby1992/xstream
def showFrontPage():
    oParams = ParameterHandler()
    sPattern = '<div class="box-container">.*?<a href="(.*?)".*?Staffel (.*?) Episode (.*?)".*?src="(http://seriesever.net/uploads/posters/thumb/.*?)".*?alt="(.*?)"'

    # request
    sHtmlContent = __getHtmlContent(URL_MAIN)
    # parse content
    oParser = cParser()
    aResult = oParser.parse(sHtmlContent, sPattern)

    oGui = cGui()
    if (aResult[0] == True):
        for link, season, episode, img, title in aResult[1]:
            guiElement = cGuiElement('%s: Season %s - Episode %s' % (title, season, episode), SITE_IDENTIFIER, 'showHosters')
            guiElement.setMediaType('episode')
            guiElement.setSeason(season)

            # 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(episode):
                guiElement.setEpisode(episode)

            guiElement.setTVShowTitle(title)
            guiElement.setThumbnail(img)

            oParams.setParam('sUrl', link)
            oGui.addFolder(guiElement, oParams, bIsFolder=False)

    oGui.setView('episodes')
    oGui.setEndOfDirectory()
コード例 #8
0
def _parseMovieList(url): 
    oGui = cGui()  
    params = ParameterHandler()    
    oRequestHandler = cRequestHandler(url)
    sHtmlContent = oRequestHandler.request()
    # parse movie entries
    pattern = 'class="tabel-topasd".*?<a href="([^"]+)"><img src="([^"]+)" title="([^"]+)".*?<span.*?>([^<>]+)</span>.*?title="([^"]+)"/>'
    oParser = cParser()
    aResult = oParser.parse(sHtmlContent, pattern)
    if not aResult[0]:
        return
    total = len(aResult[1]) # Anzahl der Treffer
    for link, img, title, plot, qual in aResult[1]:
        titleParts = title.split('(') # Titel von Jahr trennen
        movieTitle = titleParts[0].strip().decode('iso-8859-1').encode('utf-8') # encoding anpassen wegen Umlauten
           
        guiElement = cGuiElement(movieTitle, SITE_IDENTIFIER, 'getHosters')
        guiElement.setThumbnail(img) #Cover als Thumbnail setzen
        guiElement.setDescription(plot.decode('iso-8859-1')) # Filmbeschreibung setzen, decode wegen Umlauten
        if len(titleParts)>1:
            tag = titleParts[-1].replace(')','')
            if tag.isdigit() and len(tag)==4:
                guiElement.setYear(tag)
        guiElement.setMediaType('movie')
        if '720p' in qual: # erst mal unwichtig
            guiElement._sQuality = 720
        elif '1080p' in qual:
            guiElement._sQuality = 1080
            
        params.setParam('siteUrl',link)
        oGui.addFolder(guiElement, params, bIsFolder = False, iTotal = total)
    oGui.setView('movies') #diese Liste unterliegt den automatisch ViewSettings für Filmlisten 
    oGui.setEndOfDirectory()
コード例 #9
0
def showSearchEntries(entryUrl=False, sGui=False):
    oGui = sGui if sGui else cGui()
    params = ParameterHandler()
    if not entryUrl:
        entryUrl = params.getValue("sUrl")
    sHtmlContent = cRequestHandler(entryUrl).request()
    pattern = (
        'class="short">.*?href="([^"]+)"[^>]class="title">([^<(]+)[^>]([^")]+).*?<img[^>]src="([^"]+)".*?>([^<]+)</p>'
    )
    aResult = cParser().parse(sHtmlContent, pattern)
    if not aResult[0]:
        if not sGui:
            oGui.showInfo("xStream", "Es wurde kein Eintrag gefunden")
        return
    total = len(aResult[1])
    util = cUtil()
    for sEntryUrl, sName, sYear, sThumbnail, sDescription in aResult[1]:
        oGuiElement = cGuiElement(util.unescape(sName.decode("utf-8")).encode("utf-8"), SITE_IDENTIFIER, "showHosters")
        oGuiElement.setThumbnail(URL_MAIN + sThumbnail)
        oGuiElement.setDescription(util.unescape(sDescription.decode("utf-8")).encode("utf-8"))
        oGuiElement.setYear(sYear)
        oGuiElement.setMediaType("movie")
        params.setParam("entryUrl", sEntryUrl)
        oGui.addFolder(oGuiElement, params, False, total)
    return
コード例 #10
0
def showGenres():
    oGui = cGui()
    params = ParameterHandler()
    for key in sorted(URL_GENRES_LIST):
        params.setParam("sUrl", (URL_MAIN + URL_GENRES_LIST[key]))
        oGui.addFolder(cGuiElement(key, SITE_IDENTIFIER, "showEntries"), params)
    oGui.setEndOfDirectory()
コード例 #11
0
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
コード例 #12
0
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
コード例 #13
0
ファイル: ddl_me.py プロジェクト: Shinoby1992/xstream
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
コード例 #14
0
    def _getInfoAndResolve(self, siteResult):
        import urlresolver
        oGui = cGui()
        params = ParameterHandler()
        # get data
        data = {}
        mediaUrl = params.getValue('sMediaUrl')
        fileName = params.getValue('MovieTitle')
        if not fileName:
            fileName = params.getValue('Title')
        if not fileName: #only temporary
            fileName = params.getValue('sMovieTitle')
        if not fileName:
            fileName = params.getValue('title')

        data['title'] = fileName
        data['season'] = params.getValue('season')
        data['episode'] = params.getValue('episode')
        data['showTitle'] = params.getValue('TVShowTitle')
        data['thumb'] = params.getValue('thumb')
        # resolve
        if siteResult:
            mediaUrl = siteResult['streamUrl']
            logger.info('resolve: ' + mediaUrl)
            if siteResult['resolved']:
                link = mediaUrl
            else:
                link = urlresolver.resolve(mediaUrl)
        elif mediaUrl:
            logger.info('resolve: ' + mediaUrl)
            link = urlresolver.resolve(mediaUrl)
        else:
            oGui.showError('xStream', 'kein Hosterlink übergeben', 5)
            return False
        #resolver response
        if hasattr(link, 'msg'):
            msg = link.msg
        else: msg = False
        if link != False and not msg:
            data['link'] = link
            return data
        # error during resolving
        if not msg:
            msg = 'Stream nicht mehr verfügbar oder Link fehlerhaft'
            oGui.showError('xStream',str(msg),7)
        if hasattr(link, 'code'):
            logger.info(str(msg) +' UnresolveableCode: '+ str(link.code))
        else:
            logger.info(str(msg) +' UnresolveableCode: - ')
        '''
            UnresolveableCode
            0: Unknown Error
            1: The url was resolved, but the file has been permanantly
                removed
            2: The file is temporarily unavailable for example due to
                planned site maintenance
            3. There was an error contacting the site for example a
                connection attempt timed out
        '''
        return False
コード例 #15
0
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()
コード例 #16
0
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
コード例 #17
0
ファイル: seriesever_net.py プロジェクト: Shinoby1992/xstream
def showSeasons():
    logger.info('load showSeasons')
    oParams = ParameterHandler()
    sTitle = oParams.getValue('Title')
    sPattern = '<a href="#season-(.*?)" data-parent=".*?>(.*?)</a>'

    # request
    sHtmlContent = __getHtmlContent()
    # parse content
    oParser = cParser()
    aResult = oParser.parse(sHtmlContent, sPattern)

    oGui = cGui()
    if aResult[0]:
        for sId, seasonNum in aResult[1]:
            guiElement = cGuiElement('%s - Staffel %s' % (sTitle, seasonNum), SITE_IDENTIFIER, 'showEpisodes')
            guiElement.setMediaType('season')
            guiElement.setSeason(seasonNum)
            guiElement.setTVShowTitle(sTitle)

            oParams.setParam('Season', seasonNum)
            oGui.addFolder(guiElement, oParams)

    oGui.setView('seasons')
    oGui.setEndOfDirectory()
コード例 #18
0
def _cinema(oGui):
    sPattern = '<div class="Opt leftOpt Headlne"><a title="(.*?)" href="(.*?)">.*?src="(.*?)".*?class="Descriptor">(.*?)</div.*?/lng/([0-9]+).png".*?IMDb:</b> (.*?) /'
    oParams = ParameterHandler()
    sSecurityValue = oParams.getValue('securityCookie')
    sHtmlContent = __getHtmlContent(URL_CINEMA_PAGE, sSecurityValue)
    # parse content
    oParser = cParser()
    aResult = oParser.parse(sHtmlContent, sPattern)
    # iterate result and create GuiElements
    if not aResult[0]: return
    total = len(aResult[1])
    for aEntry in aResult[1]:
        sMovieTitle = aEntry[0]
        lang = __createLanguage(aEntry[4])
        rating = aEntry[5]
        oGuiElement = cGuiElement()
        oGuiElement.setSiteName(SITE_IDENTIFIER)
        oGuiElement.setFunction('parseMovieEntrySite')
        oGuiElement.setLanguage(lang)
        oGuiElement.setTitle(sMovieTitle)
        oGuiElement.setDescription(aEntry[3])
        oGuiElement.setMediaType('movie')
        oGuiElement.setThumbnail(URL_MAIN + str(aEntry[2]))
        oGuiElement.addItemValue('rating', rating)
        oParams.setParam('sUrl', URL_MAIN + str(aEntry[1]))
        oGui.addFolder(oGuiElement, oParams, bIsFolder=False, iTotal=total)
コード例 #19
0
ファイル: seriesever_net.py プロジェクト: Shinoby1992/xstream
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()
コード例 #20
0
def showHosters():
    params= ParameterHandler()
    oRequestHandler = cRequestHandler(params.getValue('entryUrl'))
    sHtmlContent = oRequestHandler.request()
    pattern = '<div class="inner" style="display:none;">'
    pattern += '.*?<a target="_blank" href="([^"]+)">'
    aResult = cParser().parse(sHtmlContent, pattern)
    if not aResult[0]:
        return
    hosters = []
    idx = 0
    previousName = ''
    for sUrl in aResult[1]:
        hoster = dict()
        hoster['link'] = sUrl
        hname = 'Unknown Hoster'
        try:
            hname = getHosterName(hoster['link'])
        except:
            pass
        if hname == 'linkcrypt.ws':
            resolveLinkcrypt(sUrl, hosters)
            continue
        if previousName != hname:
            idx = 1
        previousName = hname
        hname = "Part %d - %s" % (idx, hname)
        idx += 1

        hoster['name'] = previousName
        hoster['displayedName'] = hname
        hosters.append(hoster)
    if hosters:
        hosters.append('getHosterUrl')
    return hosters
コード例 #21
0
def _cinema(oGui):
    sPattern = '<div class="Opt leftOpt Headlne"><a title="(.*?)" href="(.*?)">.*?src="(.*?)".*?class="Descriptor">(.*?)</div.*?/lng/([0-9]+).png".*?IMDb:</b> (.*?) /'
    oParams = ParameterHandler()
    sSecurityValue = oParams.getValue('securityCookie')
    sHtmlContent = __getHtmlContent(URL_CINEMA_PAGE, sSecurityValue)
    # parse content
    oParser = cParser()
    aResult = oParser.parse(sHtmlContent, sPattern)
    # iterate result and create GuiElements
    if (aResult[0] == True):
        total = len(aResult[1])
        for aEntry in aResult[1]:
            sMovieTitle = aEntry[0]
            lang = aEntry[4]
            rating = aEntry[5]
            oGuiElement = cGuiElement()
            oGuiElement.setSiteName(SITE_IDENTIFIER)
            oGuiElement.setFunction('parseMovieEntrySite')
            oGuiElement.setTitle(__createTitleWithLanguage(lang, sMovieTitle))
            oGuiElement.setDescription(aEntry[3])
            oGuiElement.setMediaType('movie')
            oGuiElement.setThumbnail(aEntry[2])
            oGuiElement.addItemValue('rating',rating)
            #if META:
            #    oMetaget = metahandlers.MetaData()
            #    meta = oMetaget.get_meta('movie', sMovieTitle)
            #    oGuiElement.setItemValues(meta)
            #    oGuiElement.setThumbnail(meta['cover_url'])
            #    oGuiElement.setFanart(meta['backdrop_url'])
            #    oParams.setParam('imdbID', meta['imdb_id'])

            oParams.setParam('sUrl', URL_MAIN + str(aEntry[1]))
            oGui.addFolder(oGuiElement, oParams, bIsFolder = False, iTotal = total)
コード例 #22
0
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
コード例 #23
0
ファイル: hoster.py プロジェクト: badwog1/kodi-repo-gaymods
    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
コード例 #24
0
def __writeLog(sLog, cLogLevel):
    params = ParameterHandler()
    if params.exist('site'):
        site = params.getValue('site')
        print "\t[PLUGIN] xStream->" + site + ": " + str(sLog)
    else:
        print "\t[PLUGIN] xStream: " + str(sLog)
コード例 #25
0
ファイル: seriesever_net.py プロジェクト: Shinoby1992/xstream
def showSeries(sUrl=False):
    logger.info('load showSeries')
    oParams = ParameterHandler()

    if not sUrl:
        sUrl = oParams.getValue('sUrl')

    sPagePattern = '<a href="' + sUrl + '(\d+).html">'

    # request
    sHtmlContent = __getHtmlContent(sUrl)
    # parse content
    oParser = cParser()
    aResult = oParser.parse(sHtmlContent, sPagePattern)

    pages = 1
    if aResult[0]:
        if representsInt(aResult[1][-1]):
            pages = aResult[1][-1]

    oGui = cGui()

    # because sometimes 2 pages have the same content
    dupeCheck = []
    for x in range(1, int(pages) + 1):
        dupeCheck = showSeriesPage(oGui, sUrl, x, dupeCheck)

    oGui.setView('tvshows')
    oGui.setEndOfDirectory()
コード例 #26
0
def __getMovies(oGui, sHtmlContent):
    oParams = ParameterHandler()
    sBlockPattern = '<div class="moviefilm">.*?href="(.*?)"(.*?)src="(.*?)".*?alt="(.*?)"'

    # parse content
    oParser = cParser()
    aResult = oParser.parse(sHtmlContent, sBlockPattern)
    unescape = cUtil().unescape
    if aResult[0]:
        for link, span, img, title in aResult[1]:
            title = unescape(title.decode('utf-8')).encode('utf-8')
            # TODO: Looking for span isn't the best way, but the only difference I found
            if "span" not in span:
                if __isSeriesEverAvaiable():
                    url = __getSELink(link)

                    if url:
                        guiElement = cGuiElement(title, SERIESEVER_IDENTIFIER, 'showMovie')
                        guiElement.setMediaType('movie')
                        guiElement.setThumbnail(img)
                        oParams.addParams({'sUrl': url})
                        oGui.addFolder(guiElement, oParams)
            else:
                guiElement = cGuiElement(title, SITE_IDENTIFIER, 'showHosters')
                guiElement.setMediaType('movie')
                guiElement.setThumbnail(img)
                oParams.addParams({'sUrl': link, 'Title': title})
                oGui.addFolder(guiElement, oParams, bIsFolder=False)
コード例 #27
0
def showGenre():
    oGui = cGui()

    oInputParameterHandler = ParameterHandler()
    if (oInputParameterHandler.exist(PARAM_URL_KEY)):
        sUrl = oInputParameterHandler.getValue(PARAM_URL_KEY)

        oRequest = cRequestHandler(sUrl)
        sHtmlContent = oRequest.request()

        sPattern = '<li><a href="([^"]+)" title="Alle[^"]+">([^<]+)<span>'

        oParser = cParser()
        aResult = oParser.parse(sHtmlContent, sPattern)
        if (aResult[0] == True):
            for aEntry in aResult[1]:
                sUrl = aEntry[0]
                sUrl = URL_MAIN + sUrl
                sTitle = aEntry[1].strip()

                oGuiElement = cGuiElement()
                oGuiElement.setSiteName(SITE_IDENTIFIER)
                oGuiElement.setFunction('showMovies')
                oGuiElement.setTitle(sTitle)

                oOutputParameterHandler = ParameterHandler()
                oOutputParameterHandler.setParam(PARAM_URL_KEY, sUrl)
                oOutputParameterHandler.setParam(PARAM_ROOTURL_KEY, sUrl)
                oOutputParameterHandler.setParam(PARAM_PAGE_KEY,1)
                oGui.addFolder(oGuiElement, oOutputParameterHandler)

    oGui.setEndOfDirectory()
コード例 #28
0
ファイル: kkiste_to.py プロジェクト: Shinoby1992/xstream
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
コード例 #29
0
def _search(oGui, sSearchString):
    searchUrl = URL_MAIN + 'livesearch.php?q='
    
    oRequest = cRequestHandler(searchUrl + sSearchString)
    content = oRequest.request()
    searchPattern = "<table.*?<a href='([^']+)'.*?<img src='([^']+)'.*?>([^<>']+)</a>"
    oParser = cParser()
    aResult = oParser.parse(content, searchPattern)
    if not aResult[0]:
        return
    ###### parse entries
    params = ParameterHandler()
    function = 'getHosters'
    iTotal = len(aResult[1])
    for link, img, title in aResult[1]:
        sLabel = title.split('(')
        sTitle = sLabel[0].strip()
        sNextUrl = link
        params.setParam('siteUrl',sNextUrl)
        oGuiElement = cGuiElement(sTitle, SITE_IDENTIFIER, function)
        oGuiElement.setThumbnail(img)
        #oGuiElement.setMediaType('movie')
        if len(sLabel)>1:
            year = sLabel[-1].replace(')','')
            oGuiElement.setYear(year)
        if 'site=Movies' in link:
            oGuiElement.setMediaType('movie')
            oGui.addFolder(oGuiElement, params, bIsFolder = False, iTotal = iTotal)
        else:
            continue
コード例 #30
0
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()
コード例 #31
0
def showHosters():
    params = ParameterHandler()
    if params.getValue('isTvshow') == 'True':
        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:
        sUrl = params.getValue('entryUrl')
        sHtmlContent = cRequestHandler(sUrl).request()

    if not sHtmlContent:
        return []

    pattern = '<a[^>]*href="([^"]+)"[^>]*><img[^>]*class="([s|h]d+)linkbutton"'
    isMatch, aResult = cParser.parse(sHtmlContent, pattern)

    hosters = []
    if not isMatch:
        return hosters

    for sUrl, sQuali in aResult:
        hoster = {}
        if not 'nurhdfilm' in sUrl.lower():
            hoster['link'] = sUrl
            hoster['name'] = cParser.urlparse(sUrl)
            hoster['displayedName'] = '%s %s' % (hoster['name'], sQuali.upper())
            hoster['quality'] = QUALITY_ENUM[sQuali.upper()]
            hosters.append(hoster)
    if hosters:
        hosters.append('getHosterUrl')
    return hosters
コード例 #32
0
def showGenre():
    oGui = cGui()
    params = ParameterHandler()
    entryUrl = params.getValue('sUrl')
    valueType = params.getValue('valueType')

    sHtmlContent = cRequestHandler(entryUrl).request()
    pattern = 'href="(?:\.\.\/)*(%s[^"]+)">([^<]+)<\/a><\/li>' % valueType
    isMatch, aResult = cParser.parse(sHtmlContent, pattern)

    if not isMatch:
        return

    for sID, sName in aResult:
        params.setParam('sUrl', entryUrl + sID)
        oGui.addFolder(cGuiElement(sName, SITE_IDENTIFIER, 'showEntries'), params)
    oGui.setEndOfDirectory()
コード例 #33
0
def showFeaturedSeries():
    params = ParameterHandler()
    if (params.exist('sUrl')):
        sUrl = params.getValue('sUrl')

        oRequest = cRequestHandler(sUrl)
        sHtmlContent = oRequest.request()

        sPattern = '<div id="maincontenttvshow">(.*?)<BR><BR>'
        aResult = cParser().parse(sHtmlContent, sPattern)
        if aResult[0] == True:
            sPattern = '<div style="float:left"><a href="([^"]+)"><img src="([^"]+)" border=0.*?title="([^"]+)"></a>.*?<img src="/img/(.*?).png"'
            sHtmlContent = aResult[1][0]
            aResult = cParser().parse(sHtmlContent, sPattern)
            if aResult[0] == True:
                oGui = cGui()
                for aEntry in aResult[1]:
                    newUrl = str(aEntry[0]).strip()
                    if not (newUrl.startswith('http')):
                        newUrl = URL_MAIN + '/' + newUrl
                    sThumbnail = aEntry[1]
                    sMovieTitle = aEntry[2].strip().replace('\t', '')
                    oGuiElement = cGuiElement()
                    oGuiElement.setSiteName(SITE_IDENTIFIER)
                    oGuiElement.setFunction('showAllSeasons')
                    oGuiElement.setTitle(sMovieTitle)
                    oGuiElement.setThumbnail(
                        sThumbnail.replace('https', 'http'))
                    oGuiElement.setLanguage(__getLanguage(aEntry[3]))
                    oGuiElement.setMediaType('tvshow')
                    oOutputParameterHandler = ParameterHandler()
                    oOutputParameterHandler.setParam('sUrl', newUrl)

                    oGui.addFolder(oGuiElement, oOutputParameterHandler)
                oGui.setView('tvshows')
                oGui.setEndOfDirectory()
コード例 #34
0
ファイル: foxx_to.py プロジェクト: x1125/plugin.video.xstream
def showEpisodes():
    oGui = cGui()
    params = ParameterHandler()
    sTVShowTitle = params.getValue('sName')
    entryUrl = params.getValue('entryUrl')
    sSeasonNr = params.getValue('sSeasonNr')
    sThumbnail = params.getValue('sThumbnail')
    sHtmlContent = cRequestHandler(entryUrl).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="([^"]+)"[^>]*>([^<]+)'
    isMatch, aResult = cParser.parse(sContainer, pattern)

    if not isMatch:
        oGui.showInfo('xStream', 'Es wurde kein Eintrag gefunden')
        return

    total = len(aResult)
    for sUrl, sEpisodeNr in aResult:
        if sUrl.startswith('//'):
            sUrl = 'https:' + sUrl
        oGuiElement = cGuiElement(sEpisodeNr, SITE_IDENTIFIER, 'showHosters')
        oGuiElement.setTVShowTitle(sTVShowTitle)
        oGuiElement.setSeason(sSeasonNr)
        oGuiElement.setThumbnail(sThumbnail)
        oGuiElement.setFanart(sThumbnail)
        oGuiElement.setMediaType('episode')
        params.setParam('entryUrl', sUrl.strip())
        oGui.addFolder(oGuiElement, params, False, total)
    oGui.setView('episodes')
    oGui.setEndOfDirectory()
コード例 #35
0
def showEntries(entryUrl=False, sGui=False):
    oGui = sGui if sGui else cGui()
    params = ParameterHandler()
    if not entryUrl: entryUrl = params.getValue('sUrl')

    oRequestHandler = cRequestHandler(entryUrl, ignoreErrors=(sGui is not False))
    oRequestHandler.addHeaderEntry('Referer', entryUrl)
    sHtmlContent = oRequestHandler.request()

    parser = cParser()
    pattern = '<li[^>]*>\s*'  # container start
    pattern += "<a[^>]*href='[^>]*-(\d+).[^>]*'[^>]*>.*?"  # entryId
    pattern += "<img[^>]*src='([^']*)'[^>]*>.*?</a>.*?"  # thumbnail
    pattern += '<a[^>]*title="([^"]*)"[^>]*>([^<]*)</a>.*?'  # desc, title
    pattern += '<p>(\d+)</p>.*?'  # year
    pattern += '</li[^>]*>'  # container end
    isMatch, aResult = parser.parse(sHtmlContent, pattern)

    if not isMatch:
        if not sGui: oGui.showInfo('xStream', 'Es wurde kein Eintrag gefunden')
        return

    total = len(aResult)
    for sEntryId, sThumbnail, sDesc, sName, sYear in aResult:
        if sDesc.startswith(sName):
            sDesc = sDesc[len(sName) + 3:].strip()

        oGuiElement = cGuiElement(sName, SITE_IDENTIFIER, 'showHosters')
        oGuiElement.setThumbnail(sThumbnail)
        oGuiElement.setDescription(sDesc)
        oGuiElement.setYear(sYear)
        params.setParam('sUrl', URL_Hoster % sEntryId)
        oGui.addFolder(oGuiElement, params, False, total)

    if not sGui:
        isMatchNextPage, sNextUrl = parser.parseSingleResult(sHtmlContent, '</strong>.*?<a[^>]*href="([^"]+)"[^>]*>\d+')
        if isMatchNextPage:
            params.setParam('sUrl', URL_MAIN + cUtil.unescape(sNextUrl))
            oGui.addNextPage(SITE_IDENTIFIER, 'showEntries', params)

        oGui.setEndOfDirectory()
コード例 #36
0
def showValueList():
    oGui = cGui()
    params = ParameterHandler()
    entryUrl = params.getValue('sUrl')
    valueType = params.getValue('valueType')

    sHtmlContent = cRequestHandler(entryUrl).request()
    pattern = '<input[^>]*name="%s[[]]"[^>]*value="(.*?)"[^>]*>(.*?)</' % valueType
    aResult = cParser().parse(sHtmlContent, pattern)

    if not aResult[0]:
        return

    for sID, sName in aResult[1]:
        params.setParam('sUrl',entryUrl + '&' + valueType +'[]=' + sID)
        oGui.addFolder(cGuiElement(sName.strip(), SITE_IDENTIFIER, 'showEntries'), params)  
    oGui.setEndOfDirectory()
コード例 #37
0
def __displayItems(oGui, sHtmlContent):
    # Test if a cookie was set, else define the default empty one
    oParams = ParameterHandler()

    # 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)
コード例 #38
0
def showGenre():
    oGui = cGui()
    params = ParameterHandler()
    oRequestHandler = cRequestHandler(params.getValue('sUrl'))
    sHtmlContent = oRequestHandler.request()
    # Get the URL
    pattern = '<a[^>]*?class="CatInf"[^>]*?href="(.*?)"[^>]*?>.*?'
     # Get the entry count
    pattern += '<div[^>]*?class="CatNumInf"[^>]*?>(\d+)</div>.*?'
    # Get the genre name
    pattern += '<div[^>]*?class="CatNameInf"[^>]*?>([^<>]+)</div>'
    aResult = cParser().parse(sHtmlContent, pattern)
    if not aResult[0]:
        return
    for sUrl, sNum, sName in aResult[1]:
        if not sUrl or not sNum or not sName: return
        oGuiElement = cGuiElement("%s (%d)" %(sName, int(sNum)), SITE_IDENTIFIER, 'showEntries')
        params.setParam('sUrl', sUrl)
        params.setParam('mediaTypePageId', 1)
        oGui.addFolder(oGuiElement, params)
    oGui.setEndOfDirectory()
コード例 #39
0
def showGenre():
    oGui = cGui()
    params = ParameterHandler()
    oRequestHandler = cRequestHandler(params.getValue('sUrl'))
    sHtmlContent = oRequestHandler.request()
    pattern = '<a[^>]*?class="CatInf"[^>]*?href="([^"]+).*?'  # Link
    pattern += '<div[^>]*?class="CatNumInf">(\d+).*?'  # count
    pattern += '<div[^>]*?class="CatNameInf">([^<]+)'  # Name
    isMatch, aResult = cParser.parse(sHtmlContent, pattern)

    if not isMatch:
        oGui.showInfo('xStream', 'Es wurde kein Eintrag gefunden')
        return

    for sUrl, sCount, sName in aResult:
        params.setParam('sUrl', sUrl)
        params.setParam('PageId', 1)
        oGui.addFolder(
            cGuiElement("%s (%d)" % (sName, int(sCount)), SITE_IDENTIFIER,
                        'showEntries'), params)
    oGui.setEndOfDirectory()
コード例 #40
0
def showEntries(entryUrl=False, sGui=False):
    oGui = sGui if sGui else cGui()
    params = ParameterHandler()
    if not entryUrl: entryUrl = params.getValue('sUrl')
    oRequest = cRequestHandler(entryUrl)
    if 'serien/' in entryUrl:
        contentType = 'episodes'
        mediaType = 'episode'
    else:
        contentType = 'movies'
        mediaType = 'movie'

    sHtmlContent = oRequest.request()
    # Grab the link and title
    pattern = '<a[^>]*href="([^"]*)"[^>]*title="([^"]*)"[^>]*>[^<]*'
    # Grab the thumbnail
    pattern += '<img[^>]*src=["\']([^"\']*)["\'][^>]*class="cover-opacity"[^>]*>'
    aResult = cParser().parse(sHtmlContent, pattern)
    if not aResult[0]: return
    for sUrl, sName, sThumbnail in aResult[1]:
        oGuiElement = cGuiElement(sName, SITE_IDENTIFIER, 'showHosters')
        oGuiElement.setMediaType(mediaType)
        if mediaType == 'episode':
            res = re.search('S(\d{2})E(\d{2})', sName)
            if res:
                oGuiElement.setEpisode(res.group(1))
                oGuiElement.setSeason(res.group(2))
        oGuiElement.setThumbnail(__checkUrl(sThumbnail))
        params.setParam('entryUrl', __checkUrl(sUrl))
        oGui.addFolder(oGuiElement, params, bIsFolder=False)
    #check next page
    pattern = '<a[^>]*class="[^"]*pageing[^"]*"[^>]*'
    pattern += 'href=["\']([^"\']*)["\'][^>]*>[ ]*vorw'
    aResult = cParser().parse(sHtmlContent, pattern)
    if aResult[0] and aResult[1][0]:
        params.setParam('sUrl', aResult[1][0])
        oGui.addNextPage(SITE_IDENTIFIER, 'showEntries', params)
    if not sGui:
        oGui.setView(contentType)
        oGui.setEndOfDirectory()
コード例 #41
0
def showHosters():
    sUrl = ParameterHandler().getValue('entryUrl')
    sHtmlContent = cRequestHandler(sUrl).request()
    pattern = '<iframe[^>]src="([^"]+)'
    isMatch, aResult = cParser().parse(sHtmlContent, pattern)
    hosters = []
    if isMatch:
        for sUrl in aResult:
            if 'vio.to' in sUrl:
                oRequest = cRequestHandler('http:' + sUrl)
                oRequest.addHeaderEntry('Referer', sUrl)
                sHtmlContent = oRequest.request()
                pattern = "url:[^>]'([^']+)"
                isMatch, aResult = cParser().parse(sHtmlContent, pattern)
                for sUrl in aResult:
                    hoster = {'link': sUrl, 'name': Qualy(sUrl)}
                    hosters.append(hoster)
        else:
            hoster = {'link': sUrl, 'name': cParser().urlparse(sUrl)}
            hosters.append(hoster)
    if hosters:
        hosters.append('getHosterUrl')
    return hosters
コード例 #42
0
def _webtv_resolver(url):
    oParams = ParameterHandler()
    sHtmlContent = cRequestHandler(url).request()

    if 'web.tv' in url:
        aResult = cParser().parse(sHtmlContent, '"sources.*?src.."(.*?)"}]')
    if 'publicvideohost.org' in url:
        pattern = '(?:file|source)+?:.?(?:"|'
        pattern += "')(.*?.flv+)(?:"
        pattern += '"|' + "')"
        aResult = cParser().parse(sHtmlContent, pattern)
        #(?:file|source)+?:.?(?:"|')(.*?.[a-zA-Z0-9]{2,3}+)(?:"|')
    if 'uploadkadeh.com' in url:
        aResult = cParser().parse(sHtmlContent,
                                  'player_code.*?video\|([^\|]+)')
    if 'cloudvideo.tv' in url:
        aResult = cParser().parse(sHtmlContent, 'source..*?"(.+?)"')

    for sUrl in aResult[1]:
        if sUrl:
            return sUrl
        else:
            xbmcgui.Dialog().ok("Fehler", 'Error 666: ' + sUrl)
コード例 #43
0
def showHosters():
    sUrl = ParameterHandler().getValue('entryUrl')
    sHtmlContent = cRequestHandler(sUrl).request()
    pattern = 'class="PartChange"[^>]data-id="([\d]+).*?data-controlid="([\d]+)">.*?alt="([^"]+)'
    isMatch, aResult = cParser().parse(sHtmlContent, pattern)
    result, sHoster = cParser().parseSingleResult(sHtmlContent, '".PartChange".*?url:[^>]"([^"]+)')
    result, token = cParser().parseSingleResult(sHtmlContent, "_token':'([^']+)")

    hosters = []
    if isMatch:
        for ID, controlid, sName in aResult:
            request = cRequestHandler(sHoster)
            request.addParameters('_token', token)
            request.addParameters('PartID', ID)
            request.addParameters('ControlID', controlid)
            request.setRequestType(1)
            sHtmlContent = request.request()
            result, link = cParser().parseSingleResult(sHtmlContent, 'src="([^"]+)')
            hoster = {'link': link, 'name': sName}
            hosters.append(hoster)
    if hosters:
        hosters.append('getHosterUrl')
    return hosters
コード例 #44
0
def showEpisodes():
    oGui = cGui()
    params = ParameterHandler()
    sThumbnail = params.getValue('sThumbnail')
    sSeason = params.getValue('sSeason')
    news_id = params.getValue('news_id')
    sTVShowTitle = params.getValue('sName')

    oRequest = cRequestHandler(URL_EPISODE)
    oRequest.addParameters('news_id', news_id)
    oRequest.addParameters('season', sSeason)
    oRequest.setRequestType(1)
    sHtmlContent = oRequest.request()

    if not sHtmlContent:
        return

    data = json.loads(sHtmlContent)
    if "options" in data:
        sHtmlContent = data["options"]

    pattern = '<option[^>]*value="(\d+)"[^>]*>([^<]+(\d+))\s*</option>'
    isMatch, aResult = cParser.parse(sHtmlContent, pattern)

    if not isMatch:
        return

    total = len(aResult)
    for seriesId, sName, Episodenr in aResult:
        oGuiElement = cGuiElement(sName, SITE_IDENTIFIER, 'getHosters')
        oGuiElement.setTVShowTitle(sTVShowTitle)
        oGuiElement.setSeason(sSeason)
        oGuiElement.setEpisode(Episodenr)
        oGuiElement.setThumbnail(sThumbnail)
        oGuiElement.setMediaType('episode')
        params.setParam('seriesId', seriesId)
        oGui.addFolder(oGuiElement, params, False, total)

    oGui.setView('episodes')
    oGui.setEndOfDirectory()
コード例 #45
0
def showLinks(sUrl=False, sName=False):
    oGui = cGui()
    params = ParameterHandler()
    sUrl = sUrl if sUrl else params.getValue('sUrl')
    sName = sName if sName else params.getValue('sName')
    oRequest = cRequestHandler(sUrl)
    sHtmlContent = oRequest.request()
    pattern = 'var hdfilme6 = (.*?);'
    aResult = cParser().parse(sHtmlContent, pattern)
    if not aResult[0] or not aResult[1][0]: return

    for aEntry in json.loads(aResult[1][0]):
        if 'file' not in aEntry or 'label' not in aEntry: continue
        sLabel = sName + ' - ' + aEntry['label'].encode('utf-8')
        oGuiElement = cGuiElement(sLabel, SITE_IDENTIFIER, 'play')
        params.setParam('url', aEntry['file'])
        oGui.addFolder(oGuiElement, params, False)
    oGui.setEndOfDirectory()
コード例 #46
0
def showHosters():
    oParams = ParameterHandler()
    sTitle = oParams.getValue('Title')
    seriesId = oParams.getValue('seriesID')
    season = oParams.getValue('Season')
    episode = oParams.getValue('EpisodeNr')

    data = _getJsonContent("series/%s/%s/%s" % (seriesId, season, episode))
    hosters = []
    for link in data['links']:
        hoster = dict()
        hoster['link'] = URL_MAIN + 'watch/' + link['id']
        hoster['name'] = link['hoster']
        hoster['displayedName'] = link['hoster']
        hosters.append(hoster)
    if hosters:
        hosters.append('getHosterUrl')
    return hosters
コード例 #47
0
def showGenresList(entryUrl=False):
    oGui = cGui()
    params = ParameterHandler()
    if not entryUrl: entryUrl = params.getValue('sUrl')
    valueType = params.getValue('valueType')
    sHtmlContent = cRequestHandler(entryUrl).request()
    pattern = '<li>[^<]*<a[^>]*href="([^"]+%s-online[^"]+)"[^>]*><strong>([^<]+)</strong>' % valueType
    isMatch, aResult = cParser.parse(sHtmlContent, pattern)

    if not isMatch:
        oGui.showInfo('streamon', 'Es wurde kein Eintrag gefunden')
        return

    for sUrl, sName in aResult:
        params.setParam('sUrl', sUrl)
        oGui.addFolder(cGuiElement(sName, SITE_IDENTIFIER, 'showEntries'),
                       params)
    oGui.setEndOfDirectory()
コード例 #48
0
def showHosters():
    sUrl = ParameterHandler().getValue('entryUrl')
    sHtmlContent = cRequestHandler(sUrl).request()
    pattern = 'src="([^"]+)"[^>]*frameborder'
    aResult = cParser().parse(sHtmlContent, pattern)
    hosters = []
    for hUrl in aResult[1]:
        if not hUrl.startswith('http'):
            hUrl = 'https:' + hUrl
        if 'view.php' in hUrl:
            oRequest = cRequestHandler(hUrl)
            oRequest.addHeaderEntry('Referer', hUrl)
            sHtmlContent = oRequest.request()
            aResult = cParser().parse(sHtmlContent, "jbdaskgs[^>]=[^>]'([^']+)")
            cf = cCFScrape.createUrl(sUrl, oRequest)
            for sUrl in aResult[1]:
                import base64
                sUrl = base64.b64decode(sUrl)
                isMatch, aResult = cParser.parse(sUrl, '"file":"([^"]+).*?label":"([^"]+)')
                for sUrl, sQuality in aResult:
                    if 'google' in sUrl:
                        hoster = {'link': sUrl, 'name': sQuality, 'quality': QUALITY_ENUM[sQuality]}
                    else:
                        hoster = {'link': sUrl + cf, 'name': sQuality, 'quality': QUALITY_ENUM[sQuality]}
                    hosters.append(hoster)
        if 'wp-embed.php' in hUrl:
            oRequest = cRequestHandler(hUrl)
            oRequest.addHeaderEntry('Referer', hUrl)
            sHtmlContent = oRequest.request()
            aResult = cParser.parse(sHtmlContent, '<iframe[^>]src="([^"]+)')
            for sUrl in aResult[1]:
                isMatch, hname = cParser().parseSingleResult(sUrl, '^(?:https?://)?(?:[^@\n]+@)?([^:/\n]+)')
                hoster = {'link': sUrl, 'name': hname}
                hosters.append(hoster)
    if hosters:
        hosters.append('getHosterUrl')
    return hosters
コード例 #49
0
ファイル: streamkiste_tv.py プロジェクト: vbprofi/kodi-repo
def showEntries(entryUrl=False, sGui=False):
    oGui = sGui if sGui else cGui()
    params = ParameterHandler()
    if not entryUrl: entryUrl = params.getValue('sUrl')

    sHtmlContent = cRequestHandler(entryUrl,
                                   ignoreErrors=(sGui is not False)).request()
    pattern = '<div[^>]*class="movie-preview[^"]*"[^>]*>.*?'  # container start
    pattern += '<img[^>]*src="([^"]*)"[^>]*>.*?'  # sThumbnail
    pattern += '<a[^>]*href="([^"]+)"[^>]*>([^<]+)</a>.*?'  # url / name
    pattern += '<span[^>]*class="movie-release">(\d+)</span>.*?'  # year
    pattern += '<p[^>]*class="story">([^<]+)</p>.*?'  # desc
    pattern += '(?:</div>\s*){4}'  # container end
    isMatch, aResult = cParser.parse(sHtmlContent, pattern)

    if not isMatch:
        if not sGui: oGui.showInfo('xStream', 'Es wurde kein Eintrag gefunden')
        return

    total = len(aResult)
    for sThumbnail, sUrl, sName, sYear, sDesc in aResult:
        sThumbnail = re.sub('-\d+x\d+\.', '.', sThumbnail)
        oGuiElement = cGuiElement(sName, SITE_IDENTIFIER, 'showHosters')
        oGuiElement.setMediaType('movie')
        oGuiElement.setThumbnail(sThumbnail)
        oGuiElement.setDescription(sDesc)
        oGuiElement.setYear(sYear)
        params.setParam('entryUrl', sUrl)
        oGui.addFolder(oGuiElement, params, False, total)

    if not sGui:
        isMatchNextPage, sNextUrl = cParser.parseSingleResult(
            sHtmlContent, '<link[^>]*rel="next"[^>]*href="([^"]+)"')
        if isMatchNextPage:
            params.setParam('sUrl', sNextUrl)
            oGui.addNextPage(SITE_IDENTIFIER, 'showEntries', params)

        oGui.setView('movies')
        oGui.setEndOfDirectory()
コード例 #50
0
def showEntries(entryUrl=False, sGui=False):
    oGui = sGui if sGui else cGui()
    params = ParameterHandler()
    if not entryUrl: entryUrl = params.getValue('sUrl')
    isShowAdult = showAdult()
    sJson = cRequestHandler(entryUrl, ignoreErrors=(sGui is not False)).request()

    if not sJson:
        if not sGui: oGui.showError('streamon', 'Fehler beim Laden der Daten.')
        return

    aJson = json.loads(sJson)

    if not 'posts' in aJson or len(aJson['posts']) == 0:
        if not sGui: oGui.showInfo('streamon', 'Es wurde kein Eintrag gefunden')
        return

    total = len(aJson['posts'])
    for item in aJson["posts"]:
        try:
            FSK = ','.join(item['custom_fields']['FSK'])
            if not isShowAdult and '18' in FSK.lower():
                continue
            oGuiElement = cGuiElement(item['title'].encode('utf-8', 'ignore'), SITE_IDENTIFIER, 'getHosterUrl')
            oGuiElement.setThumbnail(item['thumbnail'].encode('utf-8', 'ignore'))
            sFanart = ','.join(item['custom_fields']['featured_img_all'])
            oGuiElement.setFanart(sFanart.encode('utf-8', 'ignore'))
            sYahr = ','.join(item['custom_fields']['Jahr'])
            oGuiElement.setYear(sYahr)
            oGuiElement.setDescription(item['content'])
            Youtube = ','.join(item['custom_fields']['Youtube_Delivery_Id'])
            Streaming = ','.join(item['custom_fields']['Streaming'])
            params.setParam('Youtube', Youtube)
            params.setParam('Streaming', Streaming)
            oGui.addFolder(oGuiElement, params, False, total)
        except:
            pass
    if not sGui:
        oGui.setEndOfDirectory()
コード例 #51
0
def showEntries(entryUrl=False, sGui=False):
    oGui = sGui if sGui else cGui()
    params = ParameterHandler()
    if not entryUrl: entryUrl = params.getValue('sUrl')
    sHtmlContent = cRequestHandler(entryUrl).request()
    pattern = '<table[^>]*class="eBlock"[^>]*>.*?'
    pattern += '<a[^>]*href="([^"]*)"[^>]*>(.*?)</a>.*?'  # url / title
    pattern += '<img[^>]*src="([^"]*)"[^>]*>.*?'  # img
    pattern += '(?:<fieldset[^>]*>.*?Jahr:</b>\s+(\d+).*?</fieldset>.*?)?'  # year (opt)
    pattern += '</table>'
    aResult = cParser().parse(sHtmlContent, pattern)

    if aResult[0] and aResult[1][0]:
        total = len(aResult[1])
        util = cUtil()
        for sUrl, sName, sThumbnail, sJahr in aResult[1]:
            oGuiElement = cGuiElement(
                util.unescape(sName.decode('utf-8')).encode('utf-8'),
                SITE_IDENTIFIER, 'showHosters')
            oGuiElement.setSiteName(SITE_IDENTIFIER)
            oGuiElement.setThumbnail(
                sThumbnail if sThumbnail.startswith("http") else 'http:' +
                sThumbnail)
            oGuiElement.setMediaType('movie')
            oGuiElement.setYear(sJahr)
            params.setParam(
                'entryUrl',
                sUrl if sUrl.startswith("http") else URL_MAIN + sUrl)
            oGui.addFolder(oGuiElement, params, False, total)

    pattern = '<a[^>]*class="swchItem"[^>]*href="([^"]+)"[^>]*><span>&raquo;</span>'
    aResult = cParser().parse(sHtmlContent, pattern)
    if aResult[0] and aResult[1][0]:
        params.setParam('sUrl', URL_MAIN + aResult[1][0])
        oGui.addNextPage(SITE_IDENTIFIER, 'showEntries', params)

    if not sGui:
        oGui.setView('movies')
        oGui.setEndOfDirectory()
コード例 #52
0
def showEntries(entryUrl=False, sGui=False):
    oGui = sGui if sGui else cGui()
    params = ParameterHandler()
    if not entryUrl: entryUrl = params.getValue('sUrl')

    oRequestHandler = cRequestHandler(entryUrl,
                                      ignoreErrors=(sGui is not False))
    oRequestHandler.addHeaderEntry('Referer', entryUrl)
    sHtmlContent = oRequestHandler.request()

    parser = cParser()
    pattern = '<li[^>]*title="(.*?)\((:?\d+)?\).*?(:?\s+-\s+(:?[^"]+))?"[^>]*>.*?'  # name / year / desc
    pattern += "<a[^>]*href='[^>]*-(\d+).[^>]*'[^>]*>.*?"  # url
    pattern += "<img[^>]*src='([^']*)'[^>]*>.*?"  # img
    pattern += "</li>"  # title
    isMatch, aResult = parser.parse(sHtmlContent, pattern)

    if not isMatch:
        if not sGui: oGui.showInfo('xStream', 'Es wurde kein Eintrag gefunden')
        return

    total = len(aResult)
    for sName, sYear, sUglyDesc, sDesc, sUrl, sThumbnail in aResult:
        oGuiElement = cGuiElement(sName, SITE_IDENTIFIER, 'showHosters')
        oGuiElement.setThumbnail(sThumbnail)
        oGuiElement.setDescription(cUtil().unescape(
            sDesc.decode('utf-8')).encode('utf-8'))
        oGuiElement.setYear(sYear)
        params.setParam('sUrl', URL_Hoster % sUrl)
        oGui.addFolder(oGuiElement, params, False, total)

    isMatchNextPage, sNextUrl = parser.parseSingleResult(
        sHtmlContent, '</strong>.*?<a[^>]*href="([^"]+)"[^>]*>\d+')
    if isMatchNextPage:
        params.setParam('sUrl', URL_MAIN + cUtil().unescape(sNextUrl))
        oGui.addNextPage(SITE_IDENTIFIER, 'showEntries', params)

    if not sGui:
        oGui.setEndOfDirectory()
コード例 #53
0
def showEntries(entryUrl = False, sGui = False):
    oGui = sGui if sGui else cGui()
    params = ParameterHandler()
    if not entryUrl: entryUrl = params.getValue('sUrl')
	
    sHtmlContent = cRequestHandler(entryUrl).request()
    parser = cParser()
    aResult = parser.parse(sHtmlContent, '<h2[^>]*class="maintitle">(.*?)<center') # filter main content if needed
    if aResult[0]:
        sHtmlContent = aResult[1][0]

    pattern = '<div[^>]*class="thumbnail">.*?' # container
    pattern += '<a[^>]*href="([^"]*)"[^>]*title="([^"]*)"[^>]*>.*?' # linke / title
    pattern += '<img[^>]*src="([^"]*)"' # image
    aResult = parser.parse(sHtmlContent, pattern)

    if not aResult[0]:
        if not sGui: oGui.showInfo('xStream','Es wurde kein Eintrag gefunden')
        return
    util = cUtil()
    total = len (aResult[1])
    for sEntryUrl, sName, sThumbnail in aResult[1]:
        if "stream" not in sEntryUrl: continue
        oGuiElement = cGuiElement(util.unescape(sName.decode('utf-8')).encode('utf-8'), SITE_IDENTIFIER, 'showHosters')
        oGuiElement.setThumbnail(sThumbnail)
        oGuiElement.setMediaType('movie')
        params.setParam('entryUrl', sEntryUrl)
        oGui.addFolder(oGuiElement, params, False, total)

    pattern = '<a[^>]*class="nextpostslink"[^>]*href="([^"]+)"'
    aResult = parser.parse(sHtmlContent, pattern)
    if aResult[0] and aResult[1][0]:
        params.setParam('sUrl', aResult[1][0])
        oGui.addNextPage(SITE_IDENTIFIER, 'showEntries', params)

    if not sGui:
        oGui.setView('movies')
        oGui.setEndOfDirectory()
        return
コード例 #54
0
ファイル: ddl_me.py プロジェクト: x1125/plugin.video.xstream
def showEpisodes():
    oGui = cGui()
    params = ParameterHandler()
    iSeason = int(params.getValue('season'))
    sThumbnail = params.getValue('sThumbnail')
    url = params.getValue('entryUrl')
    sHtmlContent = cRequestHandler(url).request()
    aResult = cParser().parse(sHtmlContent, "var[ ]subcats[ ]=[ ](.*?);")
    if not aResult[0] or not aResult[1][0]:
        return
    episodes = {}
    data = json.loads(aResult[1][0])
    for key, value in data.items():
        SeasonsNr = int(value['info']['staffel'])
        if SeasonsNr != iSeason:
            continue
        episodeNr = int(value['info']['nr'])
        if episodeNr not in episodes.keys():
            episodes.update({episodeNr: key})

    isMatchDesc, sDesc = cParser.parseSingleResult(
        sHtmlContent, '<img[^>]class.*?>(.*?)<br><br>')

    for sEpisodeNr, sEpisodesID in episodes.items():
        oGuiElement = cGuiElement()
        epiName = data[sEpisodesID]['info']['name'].encode('utf-8')
        epiName = epiName.split("»")[0].strip()
        oGuiElement = cGuiElement(
            str(sEpisodeNr) + " - " + epiName, SITE_IDENTIFIER, 'showHosters')
        oGuiElement.setEpisode(sEpisodeNr)
        oGuiElement.setMediaType('episode')
        if sDesc:
            oGuiElement.setDescription(sDesc)
        oGuiElement.setThumbnail(sThumbnail)
        oGuiElement.setFanart(sThumbnail)
        params.setParam('sJsonID', sEpisodesID)
        oGui.addFolder(oGuiElement, params, bIsFolder=False)
    oGui.setView('episodes')
    oGui.setEndOfDirectory()
コード例 #55
0
def showHosters():
    sUrl = ParameterHandler().getValue('entryUrl')
    sHtmlContent = cRequestHandler(sUrl).request()

    isMatch, aResult = cParser().parse(
        sHtmlContent,
        '<a[^>]*data-href="([^"]+)"[^>]*>.*?<span>([^<]*)<\/span>')
    if not isMatch:
        return []

    hosters = []
    for sUrls, sName in aResult:
        urls = sUrls.split(',')
        for idx, sLink in enumerate(sUrls.split(',')):
            hoster = {}
            hoster['name'] = sName
            hoster['link'] = sLink
            hoster['displayedName'] = '%s - Mirror %s' % (sName, idx + 1)
            hosters.append(hoster)

    if hosters:
        hosters.append('getHosterUrl')

    return hosters
コード例 #56
0
def getHosterUrl(sUrl=False):
    username = cConfig().getSetting('serienstream.user')
    password = cConfig().getSetting('serienstream.pass')

    oRequestHandler = cRequestHandler(URL_LOGIN, caching=False)
    oRequestHandler.addHeaderEntry('X-Requested-With', 'XMLHttpRequest')
    oRequestHandler.addResponse('email', username)
    oRequestHandler.addResponse('password', password)
    oRequestHandler.request()

    if not sUrl.startswith('http'):
        refUrl = ParameterHandler().getValue('sUrl')
        oRequest = cRequestHandler(URL_MAIN + sUrl, caching=False)
        oRequest.addHeaderEntry("Referer", refUrl)
        oRequest.addHeaderEntry('X-Requested-With', 'XMLHttpRequest')
        oRequest.request()
        sUrl = oRequest.getRealUrl()

    results = []
    result = {}
    result['streamUrl'] = sUrl
    result['resolved'] = False
    results.append(result)
    return results
コード例 #57
0
def showHosters():
    sUrl = ParameterHandler().getValue('entryUrl')
    sHtmlContent = cRequestHandler(sUrl).request()
    pattern = 'src="([^"]+)"[^>]*frameborder'
    isMatch, aResult = cParser().parse(sHtmlContent, pattern)
    hosters = []
    if isMatch:
        for hUrl in aResult:
            if 'view.php' in hUrl:
                sHtmlContent = cRequestHandler(hUrl).request()
                isMatch, aResult = cParser().parse(
                    sHtmlContent, "jbdaskgs[^>]=[^>]'([^']+)")
                for sUrl in aResult:
                    sUrl = base64.b64decode(sUrl)
                    isMatch, aResult = cParser.parse(
                        sUrl, '"file":"([^"]+).*?label":"([^"]+)')
                    for sUrl, sQuality in aResult:
                        hoster = {
                            'link': sUrl,
                            'name': sQuality,
                            'quality': QUALITY_ENUM[sQuality]
                        }
                        hosters.append(hoster)
            if 'wp-embed.php' in hUrl:
                oRequest = cRequestHandler(hUrl)
                sHtmlContent = oRequest.request()
                aResult = cParser.parse(sHtmlContent,
                                        '<iframe[^>]src="([^"]+)')
                for sUrl in aResult[1]:
                    isMatch, hname = cParser().parseSingleResult(
                        sUrl, '^(?:https?://)?(?:[^@\n]+@)?([^:/\n]+)')
                    hoster = {'link': sUrl, 'name': hname}
                    hosters.append(hoster)
    if hosters:
        hosters.append('getHosterUrl')
    return hosters
コード例 #58
0
def showHosters():
    sUrl = ParameterHandler().getValue('entryUrl')
    sHtmlContent = cRequestHandler(sUrl).request()
    pattern = '<v-flex>[^>]*<v-btn.*?</v-flex>'
    isMatch, sHtmlContainer = cParser.parse(sHtmlContent, pattern)
    pattern = '<meta name="csrf-token" content="([^"]+)">'
    isMatch, token = cParser.parseSingleResult(sHtmlContent, pattern)
    hosters = []
    for a in sHtmlContainer:
        pattern = 'x">([^<]+)</v-btn>'
        isMatch, sQuality = cParser.parseSingleResult(a, pattern)
        pattern = "recaptcha[^>]'([^']+)', '([^']+)', '([^']+).*?"
        pattern += '">.*?>([^<]+)'
        isMatch, aResult = cParser().parse(a, pattern)
        for e, h, sLang, sName in aResult:
            link = getLinks(sUrl, e, h, token, sLang)
            hoster = {
                'link': link,
                'name': sName.strip() + ' ' + sQuality.strip()
            }
            hosters.append(hoster)
    if hosters:
        hosters.append('getHosterUrl')
    return hosters
コード例 #59
0
def play():
    params = ParameterHandler()
    if (params.exist('sUrl') and params.exist('sTitle')):
        sUrl = params.getValue('sUrl')
        sTitle = params.getValue('sTitle')
        print sUrl
        oRequest = cRequestHandler(sUrl)
        sHtmlContent = oRequest.request()

        sPattern = ': "([^\."]+\.flv)"'
        oParser = cParser()
        aResult = oParser.parse(sHtmlContent, sPattern)
        if (aResult[0] == True):
            sStreamUrl = URL_GET_STREAM + str(aResult[1][0])+'?autostart=true'           
            result = {}
            result['streamUrl'] = sStreamUrl
            result['resolved'] = True
            return result
    return False
コード例 #60
0
def load():
    # Logger-Eintrag
    logger.info("Load %s" % SITE_NAME)

    # GUI-Element erzeugen
    oGui = cGui()

    # ParameterHandler erzeugen
    params = ParameterHandler()

    # Einträge anlegen
    params.setParam('sUrl', URL_MOVIES)
    oGui.addFolder(cGuiElement('Filme', SITE_IDENTIFIER, 'showContentMenu'), params)
    params.setParam('sUrl', URL_SHOWS)
    oGui.addFolder(cGuiElement('Serien', SITE_IDENTIFIER, 'showContentMenu'), params)
    oGui.addFolder(cGuiElement('Suche', SITE_IDENTIFIER, 'showSearch'))

    # Liste abschließen
    oGui.setEndOfDirectory()