Python logger.error函数代码示例

def _parseMedia(sUrl,sRootUrl,iPage,sPattern, oGui):
    logger.error("parse %s with pattern %s" % (sUrl, sPattern))

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

    _parseMovie(sHtmlContent,sUrl,sRootUrl,iPage,sPattern,oGui)

    def __callRequest(self):
        cookieJar = mechanize.LWPCookieJar()
        try: #TODO ohne try evtl.
            cookieJar.load(self._cookiePath, self.__bIgnoreDiscard, self.__bIgnoreExpired)
        except Exception as e:
            logger.info(e)
        sParameters = urllib.urlencode(self.__aParameters)

        opener = mechanize.build_opener(SmartRedirectHandler,
                                        mechanize.HTTPEquivProcessor,
                                        mechanize.HTTPRefreshProcessor)
        if (len(sParameters) > 0):
            oRequest = mechanize.Request(self.__sUrl, sParameters)
        else:
            oRequest = mechanize.Request(self.__sUrl)

        for aHeader in self.__aHeaderEntries:                
                for sHeaderKey, sHeaderValue in aHeader.items():
                    oRequest.add_header(sHeaderKey, sHeaderValue)
        cookieJar.add_cookie_header(oRequest)
        
        if self.caching and self.cacheTime > 0:
            sContent = self.readCache(self.getRequestUri())
            if sContent:
                return sContent
        try:
            oResponse = opener.open(oRequest,timeout = 60)             
        except mechanize.HTTPError, e:
            if not self.ignoreErrors:
                xbmcgui.Dialog().ok('xStream','Fehler beim Abrufen der Url:',self.__sUrl, str(e))
                logger.error("HTTPError "+str(e)+" Url: "+self.__sUrl)
                return ''
            else:
                oResponse = e                 

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 __decodeHash(sHash):
    sHash = sHash.replace("!BeF", "R")
    sHash = sHash.replace("@jkp", "Ax")
    try:
        url = base64.b64decode(sHash)
        return url
    except:
        logger.error("Invalid Base64: %s" % sHash)

 def __importPlugin(self, fileName):
     pluginData = {}
     try:
         plugin = __import__(fileName, globals(), locals())
         pluginData['name'] = plugin.SITE_NAME                       
     except Exception, e:
         logger.error("Can't import plugin: %s :%s" % (fileName, e))
         return False

def __createMenuEntry(oGui, sFunction, sLabel, dOutputParameter):
    oParams = ParameterHandler()

    # Create all paramters out of lOuputParameter
    try:
        for param, value in dOutputParameter.items():
            oParams.setParam(param, value)
    except Exception, e:
        logger.error("Can't add parameter to menu entry with label: %s: %s" % (sLabel, e))

 def __getPluginDB(self):
     if not os.path.exists(self.pluginDBFile):
         return dict()
     file = open(self.pluginDBFile, 'r')
     try:
         data = json.load(file)
     except ValueError:
         logger.error("pluginDB seems corrupt, creating new one")
         data = dict()
     file.close()
     return data

def __getSecurityCookieValue():
    oRequestHandler = cRequestHandler(URL_NEWS, False)
    oRequestHandler.removeNewLines(False)
    oRequestHandler.removeBreakLines(False)
    sHtmlContent = oRequestHandler.request()
    sPattern = "var hash=\[(.*?)\]"
    oParser = cParser()
    aResult = oParser.parse(sHtmlContent, sPattern)
    if aResult[0] == False:
        logger.error("Can't find script file for cookie")
    result = jsunprotect.jsunprotect(sHtmlContent)
    if not result:
        logger.error("Not protected or Deactivator not found")
        return False
    else:
        logger.info(result)
        oRequestHandler = cRequestHandler(URL_MAIN+'/?'+result, False)
        oRequestHandler.addHeaderEntry('Referer', URL_MAIN)
        #oRequestHandler.addHeaderEntry('Accept', '*/*')
        oRequestHandler.addHeaderEntry('Host', domain)
        oRequestHandler.request()
        return False
    for aEntry in aResult[1][0].split(","):
        sScriptFile = URL_MAIN +'/'+ str(aEntry).replace("'","").strip()
        sScriptFile.replace(" ","")

        logger.info("scriptfile: %s" % sScriptFile)
        oRequestHandler = cRequestHandler(sScriptFile)
        oRequestHandler.addHeaderEntry('Referer', URL_MAIN)
        oRequestHandler.addHeaderEntry('Accept', '*/*')
        oRequestHandler.addHeaderEntry('Host', domain)
        sHtmlContent = oRequestHandler.request()

    sPattern = "escape\(hsh \+ \"([^\"]+)\"\)"
    oParser = cParser()
    aResult = oParser.parse(sHtmlContent, sPattern)

    if not aResult[0]:
        logger.info("No hash value found for the cookie")
        return False

    sHash = aResult[1][0]

    sHash = sHashSnippet + sHash
    sSecurityCookieValue = "sitechrx=" + str(sHash) + ";Path=/"

    oRequestHandler = cRequestHandler(URL_MAIN)
    oRequestHandler.addHeaderEntry("Cookie", sSecurityCookieValue)
    oRequestHandler.request()

    logger.info("Token: %s" % sSecurityCookieValue)

    return sSecurityCookieValue

def _getSiteKey():
    sHtmlContent = _getRequestHandler(URL_MAIN, True).request()
    pattern = '<script [^>]*src="([^"]*basic.min.js[^"]*)"[^>]*></script[>].*?'
    aResult = cParser().parse(sHtmlContent, pattern)
    if aResult[0]:
        sHtmlContent = _getRequestHandler(aResult[1][0], True).request()
        aResult = cParser().parse(sHtmlContent, "'sitekey':'(.*?)'")
        if aResult[0]:
            return aResult[1][0]
        else:
            logger.error("error while getting sitekey: sitekey not found in basic.min.js")
    else:
        logger.error("error while getting sitekey: basic.min.js not found")

def __getHtmlContent(sUrl=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')
    # Make the request
    oRequest = cRequestHandler(sUrl)
    oRequest.addHeaderEntry('Referer', URL_MAIN)
    oRequest.addHeaderEntry('Accept', '*/*')

    return oRequest.request()

def __displayItems(oGui, sHtmlContent):
    # Test if a cookie was set, else define the default empty one
    sSecurityValue = False
    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)

def __getHtmlContent(sUrl=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')
    # Make the request
    oRequest = cRequestHandler(sUrl)
    oRequest.addHeaderEntry('User-Agent', 'Mozilla/5.0 (X11; Linux i686) AppleWebKit/535.1 (KHTML, like Gecko) Chrome/13.0.782.99 Safari/535.1')
    oRequest.addHeaderEntry('Referer', URL_MAIN)
    oRequest.addHeaderEntry('Accept', '*/*')

    return oRequest.request()

def showHosters():
    logger.info('load showHosters')
    oParams = ParameterHandler()
    hosters = []
    try:
        sHtmlContent = __getHtmlContent()
        video_id = re.findall('var video_id.*?(\d+)', sHtmlContent)[0]
        # 720p seems to be the best on this site, even if 1080p is avaible for selection, only the 720p stream2k links contain a 1080p stream
        part_name = '720p'
        parts = re.findall('class="changePart" data-part="(.*?)">', sHtmlContent)
        if len(parts) == 1:
            part_name = parts[0]

        if oParams.exist('from_moviesever') and len(parts) == 2:
            part_name = parts[1]

        app = re.findall('<script src="(%sassets/js/app.js.*?)"></script>' % URL_MAIN, sHtmlContent)

        domain_list = []
        #try:
        #    domain_list = __get_domain_list(app, domain_list)
        #except:
        #    logger.info('Could not get domain list')
        #if not domain_list:
        #    domain_list = ['se1.seriesever.net', 'se2.seriesever.net']
        #import random
        #random.shuffle(domain_list)

        json_data = __getVideoPage(video_id, part_name, '0')

        try:
            part_count = json_data['part_count']
        except:
            part_count = 0

        hosters = parseHosterResponse(json_data, hosters)

        if part_count > 1:
            for i in range(1, part_count):
                json_data = __getVideoPage(video_id, part_name, str(i))
                hosters = parseHosterResponse(json_data, hosters)

        hosters.sort()

    except Exception, e:
        logger.error(e)

def __getOldurl(sLink):
    sHtmlContent = __getHtmlContent(sLink)
    url = re.findall('url="(.*?)"', sHtmlContent)

    if len(url) == 0:
        url = re.findall('src="(.*?)"', sHtmlContent)
        if len(url) == 0:
            logger.error("Unknown Response: %s" % sHtmlContent)
        else:
            if "play/se.php" in url[0]:
                sHtmlContent = __getHtmlContent(url[0])
                sHash = re.findall('link:"(.*?)"', sHtmlContent)[0]
                return __decodeHash(sHash)
            else:
                logger.error("Unknown url: %s" % url)
    else:
        return url[0]

def parseHosterResponse(json_data, hosters):
    if (json_data['part']['source'] != 'url') and (json_data['part']['source'] != 'other'):
        logger.error("Unknown data: %s" % json_data['part']['source'])
        return

    code = None
    try:
        code = json_data['part']['code']
    except:
        pass

    if code:
        hoster = dict()

        if json_data['part']['source'] == 'url':
            if "http" not in code:
                hoster['link'] = __decodeHash(code)
            else:
                hoster['link'] = code
        elif json_data['part']['source'] == 'other':
            link1 = re.findall('src="(http.*?)"', code)[0]

            if "/play/old/seframer.php" in link1:
                hoster['link'] = urllib.unquote(__getOldurl(link1))
            else:
                hoster['link'] = link1

        hname = 'Unknown Hoster'
        try:
            hname = re.compile('^(?:https?:\/\/)?(?:www\.)?(?:[^@\n][email protected])?([^:\/\n]+)', flags=re.I | re.M).findall(hoster['link'])
        except Exception, e:
            logger.error(e)

        hoster['name'] = hname[0]
        hoster['link'] = hoster['link']

        hosters.append(hoster)