python类info()的实例源码

def delete_repo(self):
        """Deletes repo
        """
        logger.info('delete', path=self.paths['repo_path'], track=self.track)
        helpers.delete_path(self.paths['repo_path'])

def run_command(self, ecommand, host):
        """Run single stored command"""

        command = ecommand['command']

        # Check to see if host can run command
        if not command.can_host_use(host):
            if not command.suppress_limit_to_hosts_warnings:
                logger.warn("Invalid host for command",
                            command=command.name,
                            hostname=host.hostname,
                            module=COMMAND_MODULE_INIT,
                            allowed_hosts=command.limit_to_hosts)
            return False

        # Call root is already taken applied in get_cmd
        ssh_run = SshRun(host.hostname, host.ssh_hostname, "",
                         helpers.get_function_name(), False)

        logger.info("SSH Started",
                    state=0,
                    hostname=host.hostname,
                    command=command.name,
                    module=COMMAND_MODULE_CUSTOM)

        results = ssh_run.run_single(self.get_cmd(ecommand))

        ssh_run.close_ssh_channel()

        _log_rc(results,
                "SSH Finished",
                state=1,
                auth=command.use_auth,
                app_binary=command.use_app_binary,
                hostname=host.hostname,
                command=command.name,
                cmd=self.get_cmd_clean(ecommand),
                output=results,
                module=COMMAND_MODULE_CUSTOM)
        return True

def loads(*args, **kwargs):

    try:
        #logger.info("tvalacarta.core.jsontools loads Probando json incluido en el interprete")
        import json
        return to_utf8(json.loads(*args, **kwargs))
    except ImportError:
        pass
    except:
       logger.info(traceback.format_exc())

    try:
        logger.info("tvalacarta.core.jsontools loads Probando simplejson incluido en el interprete")
        import simplejson as json
        return to_utf8(json.loads(*args, **kwargs))
    except ImportError:
        pass
    except:
       logger.info(traceback.format_exc())

    try:
        logger.info("tvalacarta.core.jsontools loads Probando simplejson en el directorio lib")
        from lib import simplejson as json
        return to_utf8(json.loads(*args, **kwargs))
    except ImportError:
        pass
    except:
       logger.info(traceback.format_exc())

def dumps(*args, **kwargs):

    try:
        #logger.info("tvalacarta.core.jsontools loads Probando json incluido en el interprete")
        import json
        return json.dumps(*args, **kwargs)
    except ImportError:
        pass
    except:
        logger.info(traceback.format_exc())

    try:
        logger.info("tvalacarta.core.jsontools loads Probando simplejson incluido en el interprete")
        import simplejson as json
        return json.dumps(*args, **kwargs)
    except ImportError:
        pass
    except:
        logger.info(traceback.format_exc())

    try:
        logger.info("tvalacarta.core.jsontools loads Probando simplejson en el directorio lib")
        from lib import simplejson as json
        return json.dumps(*args, **kwargs)
    except ImportError:
        pass
    except:
        logger.info(traceback.format_exc())

def load_json(data):
    #logger.info("core.jsontools.load_json Probando simplejson en directorio lib")

    try:
        #logger.info("tvalacarta.core.jsontools.load_json Probando simplejson en directorio lib")
        from lib import simplejson
        json_data = simplejson.loads(data, object_hook= to_utf8)
        logger.info("tvalacarta.core.jsontools.load_json -> "+repr(json_data))
        return json_data
    except:
        logger.info(traceback.format_exc())

        try:
            logger.info("tvalacarta.core.jsontools.load_json Probando simplejson incluido en el interprete")
            import simplejson
            json_data = simplejson.loads(data, object_hook=to_utf8)
            logger.info("tvalacarta.core.jsontools.load_json -> "+repr(json_data))
            return json_data
        except:
            logger.info(traceback.format_exc())

            try:
                logger.info("tvalacarta.core.jsontools.load_json Probando json incluido en el interprete")
                import json
                json_data = json.loads(data, object_hook=to_utf8)
                logger.info("tvalacarta.core.jsontools.load_json -> "+repr(json_data))
                return json_data
            except:
                logger.info(traceback.format_exc())

                try:
                    logger.info("tvalacarta.core.jsontools.load_json Probando JSON de Plex")
                    json_data = JSON.ObjectFromString(data, encoding="utf-8")
                    logger.info("tvalacarta.core.jsontools.load_json -> "+repr(json_data))
                    return json_data
                except:
                    logger.info(traceback.format_exc())

    logger.info("tvalacarta.core.jsontools.load_json No se ha encontrado un parser de JSON valido")
    logger.info("tvalacarta.core.jsontools.load_json -> (nada)")
    return ""

def xmlTojson(path_xml):
    '''Lee un fichero xml y retorna un diccionario json

    Parametros:
    path_xml (str) -- Ruta completa al archivo XML que se desea leer.

    Retorna:
    Si el argumento path_xml no señala a un archivo XML valido retorna un diccionario vacio. 
    En caso cortrario retorna un diccionario construido a partir de los campos del archivo XML.

    '''

    import os
    ret ={}
    try:
        if os.path.exists(path_xml):
            infile = open( path_xml , "rb" )
            data = infile.read()
            infile.close()
            ret = Xml2Json(data).result
    except:
        import traceback
        logger.info("tvalacarta.core.jsontools xmlTojson ERROR al leer el fichero y/o crear el json")
        logger.info("tvalacarta.core.jsontools "+traceback.format_exc())

    return ret

def downloadtitle(url,title):
    logger.info("tvalacarta.core.downloadtools downloadtitle: title="+title+" url="+url )

    fullpath = getfilefromtitle(url,title)
    return downloadfile(url,fullpath)

def GetTitleFromFile(title):
    # Imprime en el log lo que va a descartar
    logger.info("tvalacarta.core.downloadtools GetTitleFromFile: titulo="+title )
    #logger.info("tvalacarta.core.downloadtools downloadtitle: title="+urllib.quote_plus( title ))
    plataforma = config.get_system_platform();
    logger.info("tvalacarta.core.downloadtools GetTitleFromFile: plataforma="+plataforma)

    #nombrefichero = xbmc.makeLegalFilename(title + url[-4:])
    if plataforma=="xbox":
        nombrefichero = title[:38] + title[-4:]
        nombrefichero = limpia_nombre_excepto_1(nombrefichero)
    else:
        nombrefichero = title
    return nombrefichero

def extract(self, file, dir):
        logger.info("file=%s" % file)
        logger.info("dir=%s" % dir)

        if not dir.endswith(':') and not os.path.exists(dir):
            os.mkdir(dir)

        zf = zipfile.ZipFile(file)
        self._createstructure(file, dir)
        num_files = len(zf.namelist())

        for name in zf.namelist():
            logger.info("name=%s" % name)
            if not name.endswith('/'):
                logger.info("no es un directorio")
                try:
                    (path,filename) = os.path.split(os.path.join(dir, name))
                    logger.info("path=%s" % path)
                    logger.info("name=%s" % name)
                    os.makedirs( path )
                except:
                    pass
                outfilename = os.path.join(dir, name)
                logger.info("outfilename=%s" % outfilename)
                try:
                    outfile = open(outfilename, 'wb')
                    outfile.write(zf.read(name))
                except:
                    logger.info("Error en fichero "+name)

def update(item):
    # Descarga el ZIP
    logger.info("tvalacarta.core.updater update")
    remotefilename = REMOTE_FILE+item.version+".zip"
    localfilename = LOCAL_FILE+item.version+".zip"
    logger.info("tvalacarta.core.updater remotefilename=%s" % remotefilename)
    logger.info("tvalacarta.core.updater localfilename=%s" % localfilename)
    logger.info("tvalacarta.core.updater descarga fichero...")
    inicio = time.clock()

    #urllib.urlretrieve(remotefilename,localfilename)
    from core import downloadtools
    downloadtools.downloadfile(remotefilename, localfilename, continuar=False)

    fin = time.clock()
    logger.info("tvalacarta.core.updater Descargado en %d segundos " % (fin-inicio+1))

    # Lo descomprime
    logger.info("tvalacarta.core.updater descomprime fichero...")
    import ziptools
    unzipper = ziptools.ziptools()
    destpathname = DESTINATION_FOLDER
    logger.info("tvalacarta.core.updater destpathname=%s" % destpathname)
    unzipper.extract(localfilename,destpathname)

    # Borra el zip descargado
    logger.info("tvalacarta.core.updater borra fichero...")
    os.remove(localfilename)
    logger.info("tvalacarta.core.updater ...fichero borrado")

def get_channel_remote_url(channel_name):

    _remote_channel_url_ = "https://raw.githubusercontent.com/tvalacarta/tvalacarta/master/python/main-classic/"

    if channel_name <> "channelselector":
        _remote_channel_url_+= "channels/"

    remote_channel_url = _remote_channel_url_+channel_name+".py"
    remote_version_url = _remote_channel_url_+channel_name+".xml" 

    logger.info("tvalacarta.core.updater remote_channel_url="+remote_channel_url)
    logger.info("tvalacarta.core.updater remote_version_url="+remote_version_url)

    return remote_channel_url , remote_version_url

def cachePage2(url,headers):

    logger.info("Descargando " + url)
    inicio = time.clock()
    req = urllib2.Request(url)
    for header in headers:
        logger.info(header[0]+":"+header[1])
        req.add_header(header[0], header[1])

    try:
        response = urllib2.urlopen(req)
    except:
        req = urllib2.Request(url.replace(" ","%20"))
        for header in headers:
            logger.info(header[0]+":"+header[1])
            req.add_header(header[0], header[1])
        response = urllib2.urlopen(req)
    data=response.read()
    response.close()
    fin = time.clock()
    logger.info("Descargado en %d segundos " % (fin-inicio+1))

    '''
        outfile = open(localFileName,"w")
        outfile.write(data)
        outfile.flush()
        outfile.close()
        logger.info("Grabado a " + localFileName)
    '''
    return data

def cachePagePost(url,post):

    logger.info("Descargando " + url)
    inicio = time.clock()
    req = urllib2.Request(url,post)
    req.add_header('User-Agent', 'Mozilla/5.0 (Windows; U; Windows NT 5.1; en-GB; rv:1.9.0.3) Gecko/2008092417 Firefox/3.0.3')

    try:
        response = urllib2.urlopen(req)
    except:
        req = urllib2.Request(url.replace(" ","%20"),post)
        req.add_header('User-Agent', 'Mozilla/5.0 (Windows; U; Windows NT 5.1; en-GB; rv:1.9.0.3) Gecko/2008092417 Firefox/3.0.3')
        response = urllib2.urlopen(req)
    data=response.read()
    response.close()
    fin = time.clock()
    logger.info("Descargado en %d segundos " % (fin-inicio+1))

    '''
        outfile = open(localFileName,"w")
        outfile.write(data)
        outfile.flush()
        outfile.close()
        logger.info("Grabado a " + localFileName)
    '''
    return data

def set_ok(self, cookie, request):
        #logger.info("set_ok Cookie "+repr(cookie)+" request "+repr(request))
        #cookie.discard = False
        #cookie.
        devuelve = cookielib.DefaultCookiePolicy.set_ok(self, cookie, request)
        #logger.info("set_ok "+repr(devuelve))
        return devuelve

def return_ok(self, cookie, request):
        #logger.info("return_ok Cookie "+repr(cookie)+" request "+repr(request))
        #cookie.discard = False
        devuelve = cookielib.DefaultCookiePolicy.return_ok(self, cookie, request)
        #logger.info("return_ok "+repr(devuelve))
        return devuelve

def domain_return_ok(self, domain, request):
        #logger.info("domain_return_ok domain "+repr(domain)+" request "+repr(request))
        devuelve = cookielib.DefaultCookiePolicy.domain_return_ok(self, domain, request)
        #logger.info("domain_return_ok "+repr(devuelve))
        return devuelve

def printMatches(matches):
    i = 0
    for match in matches:
        logger.info("[scrapertools.py] %d %s" % (i , match))
        i = i + 1

def get_season_and_episode(title):
    logger.info("get_season_and_episode('"+title+"')")

    patron ="(\d+)[x|X](\d+)"
    matches = re.compile(patron).findall(title)
    logger.info(str(matches))
    filename=matches[0][0]+"x"+matches[0][1]

    logger.info("get_season_and_episode('"+title+"') -> "+filename)

    return filename

def update(total,errores=0, nuevos=0, serie="No indicada"):
    """Pide Resumen de actualizacin. Adems pregunta y actualiza la Biblioteca

    nuevos: Nmero de episodios actualizados. Se muestra como resumen en la ventana 
            de confirmacin.
    total:  Nmero de episodios Totales en la Biblioteca. Se muestra como resumen 
            en la ventana de confirmacin.
    Erores: Nmero de episodios que no se pudo aadir (generalmente por caracteres 
            no vlidos en el nombre del archivo o por problemas de permisos.
    """

    if nuevos == 1:
        texto = 'Se ha aadido 1 episodio a la Biblioteca (%d en total)' % (total,)
    else:
        texto = 'Se han aadido %d episodios a la Biblioteca (%d en total)' % (nuevos,total)
    advertencia = xbmcgui.Dialog()

    # Pedir confirmacin para actualizar la biblioteca
    if nuevos > 0:
        if errores == 0:
            actualizar = advertencia.yesno('pelisalacarta' , texto ,'Deseas que actualice ahora la Biblioteca?')
        else:  # Si hubo errores muestra una lnea adicional en la pregunta de actualizar biblioteca
            if errores == 1:
                texto2 = '(No se pudo aadir 1 episodio)'
            else:
                texto2 = '(No se pudieron aadir '+str(errores)+' episodios)'
            actualizar = advertencia.yesno('pelisalacarta' , texto , texto2 , 'Deseas que actualice ahora la Biblioteca?')
    else: #No hay episodios nuevos -> no actualizar
        if errores == 0:
            texto2 = ""
        elif errores == 1:
            texto2 = '(No se pudo aadir 1 episodio)'
        else:
            texto2 = '(No se pudieron aadir '+str(errores)+' episodios)'
        advertencia.ok('pelisalacarta',texto,texto2)
        actualizar = False

    if actualizar:
        xbmc.executebuiltin('UpdateLibrary(video)')

    logger.info ('[Library update] Serie: "%s". Total: %d, Erroneos: %d, Nuevos: %d' %(serie, total, errores, nuevos))

def fixStrm (file):
    logger.info("[library.py] fixStrm file: "+file)
    url = LeeStrm (file)
    if len(url)==0:
        return False
    args = url.split('?',1)
    url2 = '%s?%s' % (sys.argv[ 0 ],args [1])
    logger.info ("[library.py] fixStrm new url: "+url2)
    return SaveStrm (file,url2)