Python Utiles.formatearNombre方法代码示例

# 需要导入模块: import Utiles [as 别名]
# 或者: from Utiles import formatearNombre [as 别名]
 def __modoNormal(self):
     self.info(u"[INFO] Vídeo Normal")
     html = Descargar.get(self.url).decode('iso-8859-1').encode('utf8')
     url = html.split("flashvars=\"file=")[1].split("&")[0]
     ext = "." + url.split(".")[-1]
     tit = html.split("<title>")[1].split("<")[0]
     name = tit + ext
     name = Utiles.formatearNombre(name)
     try:
         desc = html.split("<div class=\"bloqEntradillaEnNoticia\">")[1].split("<p>")[1].split("</p>")[0].strip().decode('string-escape')
     except:
         desc = u"Vídeo de Canal Sur".encode("utf8")
     try: img = self.URL_CANALSUR + Utiles.recortar(html, "image=", "\"")
     except: img = None
     return {"exito" : True,
             "num_videos" : 1,
             "mensaje"   : u"URL obtenido correctamente",
             "videos":[{
                     "url_video" : [url],
                     "url_img"   : img if img is not None else None,
                     "filename"  : [name] if name is not None else None,
                     "tipo"      : "http",
                     "partes"    : 1,
                     "rtmpd_cmd" : None,
                     "menco_cmd" : None,
                     "url_publi" : None,
                     "otros"     : None,
                     "mensaje"   : None
                     }],
             "titulos": [tit] if tit is not None else None,
             "descs": [desc] if desc is not None else None
             }

# 需要导入模块: import Utiles [as 别名]
# 或者: from Utiles import formatearNombre [as 别名]
    def getInfo(self):
        html = Descargar.get(self.url)

        m_xml_url = re.search(r"\.xml='(.+?)'", html)
        if m_xml_url is None:
            return {"exito": False, "mensaje": "No se encontró información del video"}

        xml_url = self.URL_DISNEY_CHANNEL + m_xml_url.group(1)
        chapter_xml = Descargar.get(xml_url)
        doc = xml.etree.ElementTree.fromstring(chapter_xml)

        base_http_url = doc.find("./url/urlHttpVideo").text
        video_info = doc.find("./multimedias/multimedia")
        img = self.URL_DISNEY_CHANNEL + "/" + video_info.find("./archivoMultimediaMaxi/archivo").text
        titulo = video_info.find("./nombre").text.encode('utf8')
        serie = video_info.find("./seccion").text
        desc = video_info.find("./descripcion").text.encode('utf8')

        parts_urls = []
        filenames = []
        parts = list(doc.findall("./multimedias/multimedia"))
        parts += list(doc.findall("./multimedias/relacionados/multimedia"))
        for (i, part) in enumerate(parts, 1):
            self.debug(unicode(part))
            part_url = base_http_url + part.find("./archivoMultimedia/archivo").text
            ext = part_url.rpartition('.')[2]
            try:
                filename = "%s-%s %s.%s" % (titulo, i, serie, ext)
            except:
                filename = "Video-Disney-Chanel_%s.%s" % (i, ext)
            filename_clean = Utiles.formatearNombre(filename)
            parts_urls.append(part_url)
            filenames.append(filename_clean)

        return {"exito" : True,
                "num_videos" : 1,
                "mensaje"   : u"URL obtenido correctamente",
                "videos":[{
                        "url_video" : parts_urls,
                        "url_img"   : img,
                        "filename"  : filenames,
                        "tipo"      : "http",
                        "partes"    : len(parts_urls),
                        "rtmpd_cmd" : None,
                        "menco_cmd" : None,
                        "url_publi" : None,
                        "otros"     : None,
                        "mensaje"   : None
                        }],
                "titulos":[titulo],
                "descs": [desc],
                }

# 需要导入模块: import Utiles [as 别名]
# 或者: from Utiles import formatearNombre [as 别名]
    def normalNuevoMultiple(self, xmls):
        ret = {
            "exito": True,
            "num_videos": 0,
            "mensaje": u"URLs obtenido correctamente",
            "videos": [],
            "titulos": [],
            "descs": [],
        }
        cont = 0
        for xml_ in xmls:
            video = {
                "url_video": [],
                "url_img": None,
                "filename": [],
                "tipo": "http",
                "partes": 0,
                "rtmpd_cmd": None,
                "menco_cmd": None,
                "url_publi": None,
                "otros": None,
                "mensaje": None,
            }

            sxml = Descargar.get(xml_)
            xmltree = xml.etree.ElementTree.fromstring(sxml)

            url_desc = xmltree.find("./media/asset/files/videoSource").text.encode("utf8")
            url_img = xmltree.find("./media/asset/files/background").text.encode("utf8")

            ret["num_videos"] += 1
            ret["titulos"].append(xmltree.find("./media/asset/info/art/name").text.encode("utf8"))
            ret["descs"].append(xmltree.find("./media/asset/info/art/description").text.encode("utf8"))

            video["url_video"].append(url_desc)
            video["url_img"] = url_img
            # print cont, ":", ret["titulos"][cont]
            video["filename"].append(Utiles.formatearNombre(ret["titulos"][cont]) + ".mp4")
            video["partes"] = 1
            ret["videos"].append(video)

            cont += 1

        return ret

# 需要导入模块: import Utiles [as 别名]
# 或者: from Utiles import formatearNombre [as 别名]
    def __newPlus(self, html):
        self.debug(u"Nuevo método PLUS [Febrero 2014]")

        charset = re.findall('\<meta http\-equiv\=\"Content\-Type\" content\=\"text\/html\; charset\=(.*)\" \/\>',html)[0]
        html = html.decode(charset).encode("utf8")

        mp4s = re.findall('source.*src=\"(.*)\".*type=\"video\/mp4\"', html)
        try: # Título laterl en rosa
            title = re.findall('h2.*class=\"title\">(.*)<\/h2>',html.split("<video")[1])[0].replace("<strong>", "").replace("</strong>","")
        except: # Título de "Estás viendo"..
            title = re.findall('titulo=(.*?)\"',html)[0]
        try: # Descripción en lateral
            desc = re.findall('h2.*class=\"title\">.*<\/h2>.*<p>(.*)</p>.*</div>.*<!-- .video_entry -->',html.split("<video")[1],re.S)[0]
        except: # Descripción debajo del vídeo
            desc = re.findall('div.*class\=\"desc_play_video\".*\<p>(.*?)<\/p>.*<\/div>',html,re.S)[0]
        img = ("%s%s") % (self.URL_PLUS, re.findall('video.*poster=\"(.+?)\"',html)[0].replace("&amp;", "&"))
        try: name = Utiles.formatearNombre(title)+'.mp4'
        except: name = u"VideoCanalPlus.mp4".encode("utf8")

        # Otra manera (parece que no siepre disponible para algunos 'xref=' ...):
        #xref = re.findall('xref=(.*)',self.url)[0]
        #urlInfo = "http://canalplus.es/servicios/player/mm_se_top.html?xref=%s&view=playlist" % (xref)
        #info = Descargar.get(urlInfo)
        #doc = xml.etree.ElementTree.fromstring(info) ## Parsear XML

        return {"exito" : True,
                "num_videos" : 1,
                "mensaje"   : u"URL obtenido correctamente",
                "videos":[{
                        "url_video" : [mp4s[-1]], #De momento nos quedamos la última url, supuestamente la de mayor calidad
                        "url_img"   : img if img is not None else None,
                        "filename"  : [name] if name is not None else None,
                        "tipo"      : "http",
                        "partes"    : 1,
                        "rtmpd_cmd" : None,
                        "menco_cmd" : None,
                        "url_publi" : None,
                        "otros"     : None,
                        "mensaje"   : None
                        }],
                "titulos": [title] if title is not None else None,
                "descs": [desc] if desc is not None else None
                }

# 需要导入模块: import Utiles [as 别名]
# 或者: from Utiles import formatearNombre [as 别名]
    def normalMultiple(self, xmls):
        ret = {
            "exito": True,
            "num_videos": 0,
            "mensaje": u"URLs obtenido correctamente",
            "videos": [],
            "titulos": [],
            "descs": [],
        }
        cont = 0
        for xml in xmls:
            video = {
                "url_video": [],
                "url_img": None,
                "filename": [],
                "tipo": "http",
                "partes": 0,
                "rtmpd_cmd": None,
                "menco_cmd": None,
                "url_publi": None,
                "otros": None,
                "mensaje": None,
            }

            sxml = Descargar.get(xml)
            url_desc = self.__getUrlDescarga(sxml)
            url_img = re.findall("<urlImg><!\[CDATA\[(.*)\]\]></urlImg>", sxml)[0]

            ret["num_videos"] += 1
            ret["titulos"].append(re.findall("<nombre><!\[CDATA\[(.*)\]\]></nombre>", sxml)[0])
            ret["descs"].append(re.findall("<descripcion><!\[CDATA\[(.*)\]\]></descripcion>", sxml)[0])

            video["url_video"].append(url_desc + re.findall("<archivo><!\[CDATA\[(.*\.mp4)\]\]></archivo>", sxml)[0])
            video["url_img"] = url_img + re.findall("<archivo><!\[CDATA\[(.*\.jpg)\]\]></archivo>", sxml)[0]
            # print cont, ":", ret["titulos"][cont]
            video["filename"].append(Utiles.formatearNombre(ret["titulos"][cont]))
            video["partes"] = 1
            ret["videos"].append(video)

            cont += 1

        return ret

# 需要导入模块: import Utiles [as 别名]
# 或者: from Utiles import formatearNombre [as 别名]

#.........这里部分代码省略.........
                xmls = ["/".join(self.url.split("/")[:3]) + i for i in xmls]
                return self.normalMultiple(xmls)

            #####################################################################################
            if streamHTML.find(".seoURL='") != -1:  # Url directamente en HTML
                self.debug(u"Vídeo con SEO URL")
                img = self.URL_DE_ANTENA3 + streamHTML.split(".poster='/")[1].split("'")[0]
                url2down, name = self.__modoNormalConURL(streamHTML)
            elif streamHTML.find("a3_gp_visor_player") != -1:
                self.log(u"[INFO] Vídeo de Fórmula 1")
                return self.__modoF1(streamHTML)  # return directamente aquí (varios videos)
            else:  # No está la url en el hmtl (buscar por varias partes)
                if streamHTML.find('<div class="visor">') != -1:  # Más de 1 parte # Quizas mejor "carrusel"?
                    return self.__modoNormalVariasPartes(streamHTML)  # return directamente aquí (varios videos)
                    # url2down, name = self.__modoNormalVariasPartes(streamHTML)
                else:  # Solo una parte
                    url2down, name = self.__modoNormalUnaParte(streamHTML)

        desc = None
        try:
            desc = Utiles.recortar(streamHTML, '<meta property="og:description" content="', '"').strip()
        except:
            try:
                desc = Utiles.recortar(streamHTML, '<meta name="description" content="', '" />').strip()
            except:
                desc = None

        # if type(url2down) == list:
        #    for i in url2down:
        #        if i.find("geobloqueo") != -1:
        #            self.log(u"[!!!] El vídeo \"" + i + "\" no se puedo descargar (geobloqueado)")
        #            url2down.remove(i)
        #            # TODO: Borrar también su nombre correspondiente
        #
        #    # Comprobar si todas las partes están geobloqueadas (no quedan elementos en la lista):
        #    if len(url2down) == 0:
        #        raise Error.GeneralPyspainTVsError("Grupo Antena 3. Todo el contenido Geobloqueado.")
        # else:
        #    if url2down.find("geobloqueo") != -1:
        #        raise Error.GeneralPyspainTVsError("Grupo Antena 3. Todo el contenido Geobloqueado.")
        if type(name) == list:
            try:
                tit_vid = name[0].split(".")[0]
                tit_vid = tit_vid.replace("_" + tit_vid.split("_")[1], "")
            except:
                try:
                    tit_vid = (
                        Utiles.recortar(streamHTML, "<title>", "</title>")
                        .replace("ANTENA 3 TV", "")
                        .replace("-", "")
                        .strip()
                    )
                except:
                    tit_vid = "Vídeo de Grupo Antena 3"
            for i in name:
                b = Utiles.formatearNombre(i)
                name[name.index(i)] = b
        else:
            try:
                tit_vid = name.split(".")[0].replace("_" + name.split("_")[1], "")
                tit_vid = tit_vid.replace("_" + tit_vid.split("_")[1], "")
            except:
                try:
                    tit_vid = (
                        Utiles.recortar(streamHTML, "<title>", "</title>")
                        .replace("ANTENA 3 TV", "")
                        .replace("-", "")
                        .strip()
                    )
                except:
                    tit_vid = "Vídeo de Grupo Antena 3"
            name = Utiles.formatearNombre(name)

        # try:
        #    tit_vid = Utiles.recortar(streamHTML, "<title>", "</title>").replace("ANTENA 3 TV", "").replace("-", "").strip()
        # except:
        #    tit_vid = "Vídeo de Grupo Antena 3"
        tit_vid = tit_vid.replace("TV VIDEOS ONLINE", "").strip()

        return {
            "exito": True,
            "num_videos": 1,
            "mensaje": u"URL obtenido correctamente",
            "videos": [
                {
                    "url_video": [url2down] if type(url2down) != list else url2down,
                    "url_img": img if img is not None else None,
                    "filename": [name] if type(name) != list else name,
                    "tipo": "http",
                    "partes": 1 if type(url2down) != list else len(url2down),
                    "rtmpd_cmd": None,
                    "menco_cmd": None,
                    "url_publi": None,
                    "otros": None,
                    "mensaje": None,
                }
            ],
            "titulos": [tit_vid] if tit_vid is not None else None,
            "descs": [desc] if desc is not None else None,
        }

# 需要导入模块: import Utiles [as 别名]
# 或者: from Utiles import formatearNombre [as 别名]
    def __modoF1(self, streamHTML):  # TODO: ¡¡¡Acabar esta función para devolver todos los videos y sus partes!!!
        """
           <param value="_urlData=http://www.antena3.com/gestorf1/swf/player_hitos/xml/data.xml&_image=http://www.antena3.com/gestorf1/pictures/361/361/malasia-portada_crop1.png&_id_list=1405&_promo1=http://www.smartadserver.com/call/pubx/15272/241149/4654/S/&_promo2=http://www.smartadserver.com/call/pubx/15272/241148/4654/S/" name="flashVars">
        """
        streamHTML = Descargar.getHtmlUtf8(self.url)
        # Qué vídeo:
        streamVids = streamHTML.split('<ul class="a3_gp_visor_menu">')[1].split("</ul>")[0].replace("\t", "")
        streamVids = streamVids.split("<li>")[1:]

        desc = None
        try:
            desc = Utiles.recortar(streamHTML, '<meta property="og:description" content="', '"').strip()
        except:
            desc = None

        # self.debug(streamVids)
        ret = {
            "exito": True,
            "num_videos": 0,
            "mensaje": u"URLs obtenido correctamente",
            "videos": [],
            "titulos": [],
            "descs": [],
        }

        v = -1
        for i in streamVids:  # todos los vídeos con todas sus partes
            video = {
                "url_video": [],
                "url_img": None,
                "filename": [],
                "tipo": "http",
                "partes": 0,
                "rtmpd_cmd": None,
                "menco_cmd": None,
                "url_publi": None,
                "otros": None,
                "mensaje": None,
            }
            v += 1
            streamVid = streamVids[v]
            streamVidUrl = self.URL_DE_ANTENA3 + streamVid.split('href="')[1].split('"')[0]
            self.debug(u"URL Video: " + streamVidUrl)
            streamHTML = Descargar.getHtml(streamVidUrl)

            # Partes
            id_list = streamHTML.split("_id_list=")[1].split("&")[0]
            listXMLurl = self.URL_DE_F1 + id_list + "_playlist.xml"
            self.debug(u"URL XML list: " + listXMLurl)
            listxml = Descargar.getHtml(listXMLurl)
            video["url_img"] = listxml.split("<picture>")[1].split("</picture>")[0].strip()
            listxml = listxml.split("<video>")[1:]
            # print listxml
            for b in listxml:
                video["partes"] += 1
                # video["mensaje"] = unicode(i.split(">")[1].split("<")[0].capitalize())
                endurl = b.split("<url>")[1].split("<")[0]
                # video["url_video"].append(endurl.replace(endurl.split("mp_")[0],"http://desprogresiva.antena3.com/"))
                video["url_video"].append(endurl.replace(endurl.split("mp_")[0], self.URL_DE_DESCARGA_LA_SEXTA))
                ext = "." + video["url_video"][-1].split(".")[-1]
                tit = b.split("<title>")[1].split("<")[0] + ext
                tit = Utiles.formatearNombre(tit)
                video["filename"].append(tit)

            ret["titulos"].append(unicode(i.split(">")[1].split("<")[0].capitalize()).encode("utf8"))
            ret["videos"].append(video)
            ret["num_videos"] += 1
            ret["descs"].append(unicode(desc).encode("utf8"))

        return ret

# 需要导入模块: import Utiles [as 别名]
# 或者: from Utiles import formatearNombre [as 别名]
 def getInfo(self):
     '''
         Devuelve toda la información asociada a la URL recibida, de la siguiente forma:
         {
          "exito"     : bool,  <-- True (si se han obtenido videos)
          "num_video" : int,   <-- Número de vídeos obtenidos
          "mensaje"   : u"" ,  <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False])
          "videos"    :  [{
                         "url_video" : [],   <-- Url de descarga de vídeo
                         "url_img"   : "",   <-- Url de la miniatura del video
                         "filename"  : [],   <-- Nombre de las partes para guardar en disco
                         "tipo"      : "",   <-- http, rtmp[e,..], mms, ...
                         "partes"    : int,  <-- Número de partes que tiene el vídeo
                         "rtmpd_cmd" : [],   <-- Comando rtmpdump (si tipo == rtmp) sino None
                         "menco_cmd" : [],   <-- Comando mencoder (Si tipo == rtmp) sino None
                         "url_publi" : "",   <-- Url del vídeo de publicidad asociado al vídeo
                         "otros"     : [],   <-- Lista donde se pueden pasar cosas opcionales
                         "mensaje"   : ""    <-- Mensajes de la API
                         }], <-- Debe ser una lista de tamaño "num_videos"
          "titulos"   : [u""], <-- Titulos de los videos
          "descs"     : [u""] <-- Descripción de cada vídeo
         }
         
         Los valores que no se rellenen, deberán devolver None.
         La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente:
         {
         "exito": False,
         "mensaje": "No se pudo descargar el video"  
         }
         
         "videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None)
         "url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None)
     '''
     url_img = None
     streamHTML = Descargar.getHtml(self.url).decode('string-escape')
     if streamHTML.find("CUAVID") != -1:
         self.debug(u"CUAVID")
         ContentID = streamHTML.split("imageContentId: \'")[1].split("\'")[0]
         streamJSON = Descargar.getHtml(self.URL_SOURCES + ContentID)
         url2down = streamJSON.split("\"src\":\"")[1].split("\"")[0].replace("\/", "/")
         name = streamJSON.split("\"wrpContent\":\"")[1].split("\"")[0] + ".mp4"
     elif streamHTML.find("MDS.embedObj(video") != -1: # Este parece ser el único método a 16/10/2012 (pero dejo los demás..)
         self.debug(u"MDS.embedObj")
         contentID = streamHTML.split("MDS.embedObj(video, \"")[1].split("\"")[0]
         clippingID = streamHTML.split("imageClippingId: \'")[1].split("\'")[0]
         imageContentID = streamHTML.split("imageContentId: \'")[1].split("\'")[0]
         self.debug("URL Json: "+self.URL_JSON + "contentId=" + contentID + "&clippingId=" + clippingID + "&imageContentId=" + imageContentID)
         streamJSON = Descargar.getHtml( self.URL_JSON +
                                         "contentId=" + contentID +
                                          "&clippingId=" + clippingID +
                                          "&imageContentId=" + imageContentID
                                          )
         
         #streamJSON = dict(streamJSON)
         #url2down = streamJSON["sources"][0]["src"]
         url2down = streamJSON.split("({\"sources\":[{\"src\":\"")[1].split("\"")[0].replace("\/", "/")
         name = streamHTML.split("<title>")[1].split("<")[0]
         name += "." + url2down.split(".")[-1].split("?")[0]
         url_img = streamJSON.split("\"poster\":\"")[1].split("\"")[0].replace("\/", "/")
     elif streamHTML.find("src_iframe:") != -1:
         self.info(u"[INFO] Vídeo Común")
         name = streamHTML.split("<title>")[1].split("<")[0]
         urlComunes = self.URL_CUATRO + streamHTML.split("src_iframe:")[1].replace(" ", "").split("\'")[1].split("\'")[0]
         streamComunes = Descargar.getHtml(urlComunes)
         url2down = streamComunes.split("document.write(\'<video id=")[1].split("src=\"")[1].split("\"")[0]
         ext= "." + url2down.split(".")[-1]
         name += ext
     else:
         raise Error.GeneralPyspainTVsError("Cuatro.com: No se encuentra contenido")
     
     
     tit_vid = None
     if name:
         name = name.replace("Ver vídeo online","")
         tit_vid = name.split(".")[0]
         name = Utiles.formatearNombre(name)
     
     desc = None        
     try:
         desc = Utiles.recortar(streamHTML, "<h3 class=\"subtitle\">", "<").strip()
     except:
         desc = tit_vid if tit_vid is not None else None
 
     return {"exito" : True,
             "num_videos" : 1,
             "mensaje"   : u"URL obtenido correctamente",
             "videos":[{
                     "url_video" : [url2down],
                     "url_img"   : url_img if url_img is not None else None,
                     "filename"  : [name] if name is not None else None,
                     "tipo"      : "http",
                     "partes"    : 1,
                     "rtmpd_cmd" : None,
                     "menco_cmd" : None,
                     "url_publi" : None,
                     "otros"     : None,
                     "mensaje"   : None
                     }],
             "titulos": [tit_vid] if tit_vid is not None else None,
             "descs": [desc] if desc is not None else None
#.........这里部分代码省略.........

# 需要导入模块: import Utiles [as 别名]
# 或者: from Utiles import formatearNombre [as 别名]
        startTime = "0" if streamXML.find('<link start="') == -1 else streamXML.split('<link start="')[1].split('"')[0]
        endTime = "0" if streamXML.find('end="') == -1 else streamXML.split('end="')[1].split('"')[0]
        self.debug(u"startTime: %s\n[DEBUG] endTime: %s" % (startTime, endTime))

        # Dejo el que era el método 3
        url = self.__getUrl2down(ID, startTime, endTime)
        if url is None:
            raise Error.GeneralPyspainTVsError("mitele.es: No funciona el procedimiento.")

        # Obtener nombre:
        if type(url) == str:
            name = streamHTML.split("<title>")[1].split("<")[0] + "." + url.split(".")[-1].split("?")[0]
        else:  # De momento: suponemos que son mp4.
            name = streamHTML.split("<title>")[1].split("<")[0] + ".mp4"
        if name:
            name = Utiles.formatearNombre(name)

        name = name.replace("VERPROGRAMAS", "").replace("Veronline", "")
        name = name.replace("VERSERIES", "").replace("Veronline", "")
        tit_vid = tit_vid.replace("VER PROGRAMAS", "").replace("Ver online", "")
        tit_vid = tit_vid.replace("VER SERIES", "").replace("Ver online", "")

        desc = None
        try:
            desc = Utiles.descriptionFormat(Utiles.recortar(htmlBackup, '"post_content":"', '"').strip())
        except:
            desc = tit_vid if tit_vid is not None else None

        return {
            "exito": True,
            "num_videos": 1,

# 需要导入模块: import Utiles [as 别名]
# 或者: from Utiles import formatearNombre [as 别名]

#.........这里部分代码省略.........
        intermediate_cyphertext = ""
        increment = 1
        text_index = 0
        while text_index < len(cyphertext):
            text_index = text_index + increment
            try: intermediate_cyphertext = intermediate_cyphertext + cyphertext[text_index-1]
            except: pass
            increment = increment + 1
            if increment == 5: increment = 1

        plaintext = ""
        key_index = 0
        increment = 4
        while key_index < len(key):
            key_index = key_index + 1
            text_index = int(key[key_index-1]) * 10
            key_index = key_index + increment
            try: text_index = text_index + int(key[key_index-1])
            except: pass
            text_index = text_index + 1
            increment = increment + 1
            if increment == 5: increment = 1
            plaintext = plaintext + intermediate_cyphertext[text_index-1]
            #try: plaintext = plaintext + intermediate_cyphertext[text_index-1]
            #except: pass

        urlVideo = plaintext
        if urlVideo != "":
            if not urlVideo.endswith(".mp4"): urlVideo = urlVideo.replace(urlVideo.split(".mp4")[1], "")
            url_video = urlVideo.replace("www.rtve.es", "media5.rtve.es")
            
            titulo = sourceHTML.split("<title>")[1].split("</")[0].replace("RTVE.es", "").replace("-", "").strip()
            filename = titulo + ".mp4"
            filename = Utiles.formatearNombre(filename)

            url_img = sourceHTML.split("\"thumbnail\" content=\"")[1].split("\"")[0]
        else:
            raise Error.GeneralPyspainTVsError("No se pudo encontrar el enlace de descarga")

        #TEMP FIX:
        #url_video = url_video.replace(url_video.split(".")[1], url_video.split(".")[1][:3])

        # -- Método 24 Mayo 2013 FIN
        
        desc = None
        try: #obtener descripción del video
            desc = Utiles.recortar(sourceHTML, "<meta itemprop=\"description\" content=\"", "\"").strip()
        except:
            try:
                desc = Utiles.recortar(sourceHTML, "<meta property=\"og:description\" content=\"", "\"").strip()
            except:
                try:
                    desc = Utiles.recortar(sourceHTML, "<meta name=\"description\" content=\"", "\"").strip()
                except:
                    desc = u"Vídeos de Televión Española"
        
        # Comprobar si existe calidad FLV
        url_flv = url_video.replace("mp4", "flv")
        if Descargar.isReachableHead(url_flv):
            msgCalidad = u'''Este vídeo dispone de dos calidades. 
            Para los vídeos de RTVE, la mejor suele ser la que se presenta en formato FLV. 
            En los vídeos con más tiempo puede que el audio al principio no esté bien sincronizado 
            con el audio. Este problema será menos grave en el formato FLV llegándose incluso a 
            sincronizar totalmente pasados unos segundos.'''.encode('utf8')

            return {"exito" : True,

# 需要导入模块: import Utiles [as 别名]
# 或者: from Utiles import formatearNombre [as 别名]

#.........这里部分代码省略.........
            url2down = Descargar.getHtml(ask4token)
            name = streamHTML.split("var title = \'")[1].split("\'")[0] + ".mp4"
        elif self.url.find("videoURL=") != -1: # Forma con el ID en la URL (nueva??)
            videoID = self.url.split("videoURL=")[1]
            ask4token = self.URL_ASK4TOKEN + videoID[-3:] + "/" + videoID + ".mp4"
            self.debug(u"[+] Pidiendo nuevo token")
            url2down = Descargar.getHtml(ask4token)
            # Obtner nombre:
            xmlURL = "http://estaticos.telecinco.es/xml/Video/Video_" + videoID + ".xml"
            streamXML = Descargar.getHtml(xmlURL)
            name = streamXML.split("<![CDATA[")[1].split("]")[0] + ".mp4"
        elif streamHTML.find("MDS.embedObj(video") != -1:
            contentID = streamHTML.split("MDS.embedObj(video, \"")[1].split("\"")[0]
            try: clippingID = streamHTML.split("imageClippingId: \'")[1].split("\'")[0] # try por que en la API no funcionaba oO
            except: clippingID = "1.jpg"
            try: imageContentID = streamHTML.split("imageContentId: \'")[1].split("\'")[0] # try por problemas com la API oO
            except: imageContentID = streamHTML.split("MDS.embedObj(video, \"")[1].split("\"")[0]
            self.debug(u"URL JSON: " + self.URL_JSON + "contentId=" + contentID + "&clippingId=" + clippingID + "&imageContentId=" + imageContentID)
            streamJSON = Descargar.getHtml(self.URL_JSON +
                                         "contentId=" + contentID +
                                         "&clippingId=" + clippingID +
                                         "&imageContentId=" + imageContentID
                                         )
            url2down = streamJSON.split("({\"sources\":[{\"src\":\"")[1].split("\"")[0].replace("\/", "/")
            name = streamHTML.split("<title>")[1].split("<")[0]
            name += "." + url2down.split(".")[-1].split("?")[0]
            url_img = streamJSON.split("\"poster\":\"")[1].split("\"")[0].replace("\/", "/")
        elif streamHTML.find("MSV.embedData") != -1:
            #rx=re.compile(r"MSV\.embedData\[(.*)\]", re.MULTILINE|re.DOTALL)
            rx=re.compile(r'/mdsvideo/popup\.html\?(.*)"')
            videos = rx.findall(streamHTML)
            if not videos: Error.GeneralPyspainTVsError("Telecinco.es. No se encuentra contenido.")
            ret =   {
                    "exito" : True,
                    "num_videos" : len(videos),
                    "mensaje"   : u"URL obtenido correctamente",
                    "videos": [],
                    "titulos": [],
                    "descs": []
                    }
            for js in videos:
                vid = {
                "url_video" : None,
                "url_img"   : None,
                "filename"  : [],
                "tipo"      : "http",
                "partes"    : 1,
                "rtmpd_cmd" : None,
                "menco_cmd" : None,
                "url_publi" : None,
                "otros"     : None,
                "mensaje"   : None
                }
                stream = Descargar.getHtmlUtf8(self.URL_JSON + js + "&imageContentId=" + Utiles.recortar(js, 'contentId=', '&'))
                info = json.loads(stream[1:-1])
                vid['url_video'] = [info['sources'][0]['src']]
                vid['url_img'] = info['poster']
                try: vid['filename'].append(Utiles.formatearNombre(info['nielsen']['title']+'.mp4'))
                except: vid['filename'].append('VideosDeTelecinco.mp4')
                ret['videos'].append(vid)
                ret['titulos'].append(unicode(info['nielsen']['title']).encode('utf8').replace('"','').replace("'",""))
                ret['descs'].append(u'Cat.: %s. Subcat.: %s. %s'.encode('utf8') % (info['nielsen']['category'].encode('utf8'),info['nielsen']['subcategory'].encode('utf8'),info['nielsen']['title'].encode('utf8')))
            return ret      
        else:
            Error.GeneralPyspainTVsError("Telecinco.es. No se encuentra contenido.")
        

        tit_vid = None
        if name != None:
            name = name.replace("Ver vídeo online","")
            tit_vid = name.split(".")[0]
            name = Utiles.formatearNombre(name)
        
        desc = None        
        try:
            desc = Utiles.recortar(streamHTML, "<h3 class=\"subtitle\">", "<").strip()
        except:
            desc = tit_vid if tit_vid is not None else None
        
        #TIT FIX:
        tit_vid = tit_vid.replace('"','').replace("'","")

        return {"exito" : True,
                "num_videos" : 1,
                "mensaje"   : u"URL obtenido correctamente",
                "videos":[{
                        "url_video" : [url2down],
                        "url_img"   : url_img if url_img is not None else None,
                        "filename"  : [name] if name is not None else None,
                        "tipo"      : "http",
                        "partes"    : 1,
                        "rtmpd_cmd" : None,
                        "menco_cmd" : None,
                        "url_publi" : None,
                        "otros"     : None,
                        "mensaje"   : None
                        }],
                "titulos": [tit_vid] if tit_vid is not None else None,
                "descs": [desc] if desc is not None else None
                }

# 需要导入模块: import Utiles [as 别名]
# 或者: from Utiles import formatearNombre [as 别名]
    def getInfo(self):
        '''
            Devuelve toda la información asociada a la URL recibida, de la siguiente forma:
            {
             "exito"     : bool,  <-- True (si se han obtenido videos)
             "num_video" : int,   <-- Número de vídeos obtenidos
             "mensaje"   : u"" ,  <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False])
             "videos"    :  [{
                            "url_video" : [],   <-- Url de descarga de vídeo
                            "url_img"   : "",   <-- Url de la miniatura del video
                            "filename"  : [],   <-- Nombre de las partes para guardar en disco
                            "tipo"      : "",   <-- http, rtmp[e,..], mms, ...
                            "partes"    : int,  <-- Número de partes que tiene el vídeo
                            "rtmpd_cmd" : [],   <-- Comando rtmpdump (si tipo == rtmp) sino None
                            "menco_cmd" : [],   <-- Comando mencoder (Si tipo == rtmp) sino None
                            "url_publi" : "",   <-- Url del vídeo de publicidad asociado al vídeo
                            "otros"     : [],   <-- Lista donde se pueden pasar cosas opcionales
                            "mensaje"   : ""    <-- Mensajes de la API
                            }], <-- Debe ser una lista de tamaño "num_videos"
             "titulos"   : [u""], <-- Titulos de los videos
             "descs"     : [u""] <-- Descripción de cada vídeo
            }
            
            Los valores que no se rellenen, deberán devolver None.
            La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente:
            {
            "exito": False,
            "mensaje": "No se pudo descargar el video"  
            }
            
            "videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None)
            "url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None)
        '''
        
        html = self.gethtml()
        
        # CREO que ya no hay vídeos desde RTMP, como no encuentro no puedo comprobar
#        if html.find("&videoId=") != -1:
#            videoID = html.split("&videoId=")[1].split("\'")[0]
#            self.info(u"[INFO] Video ID:", videoID)
#            streamStreams = Descargar.get(self.URL_STREAMS_START + videoID + self.URL_STREAMS_END)
#            streamStreams = streamStreams.replace(" ", "").replace("\n", "")
#            videos = streamStreams.split("{")[1:]
#            self.info(u"[INFO] Se han detectado varios tipos de calidad:")
#            b = 0
#            for i in videos:
#                self.info(u"\t[%4d] %s" % (b, i.split("\"quality\":\"")[1].split("\"")[0]))
#                b += 1
#            # Presentar menú para elegir vídeo:
#            self.info(u"[-->] Introduce el número del tipo vídeo que quieres descargar (Ctrl+C para cancelar): ")
#            while True:
#                try:
#                    ID = int(raw_input())
#                except ValueError:
#                    self.info(u"[!!!] Parece que no has introducido un número. Prueba otra vez:")
#                    continue
#                    
#                if ID < 0 or ID > len(videos)-1:
#                    self.info(u"[!!!] No existe el vídeo con número [%4d] Prueba otra vez:" % ID)
#                    continue
#                else:
#                    break
#            
#            url = videos[ID].split("\"url\":\"")[1].split("\"")[0]
#            ext = "." + url.split("?")[0].split(".")[-1]
#            name = (html.split("<title>")[1].split("<")[0]).strip()
#            name += ext
        if html.find("NicePlayer.js?") != -1 or html.find("nicePlayer.js?") != -1:
            try:
                urlJS = html.split("NicePlayer.js?")[0].split("\"")[-1] + \
                "NicePlayer.js?" + html.split("NicePlayer.js?")[1].split("\"")[0]
            except IndexError:
                try:
                    urlJS = html.split("nicePlayer.js?")[0].split("\"")[-1] + \
                    "nicePlayer.js?" + html.split("nicePlayer.js?")[1].split("\"")[0]
                except:
                    raise Error.GeneralPyspainTVsError(u"No se encustra contenido")
            except:
                raise Error.GeneralPyspainTVsError(u"No se encustra contenido")
            streamJS = Descargar.get(urlJS)
            try: url = streamJS.split("var fileHtml5 = \"")[1].split("\"")[0]
            except:
                try: url = self.URL_RTMP + streamJS.split("var fileFlash = \"")[1].split("\"")[0]
                except: raise Error.GeneralPyspainTVsError(u"No se encuentra contenido")     
            name = html.split("<title>")[1].split("<")[0].strip()
            name += Utiles.formatearNombre("." + url.split(".")[-1])
            try: img = streamJS.split("var image = \"")[1].split("\"")[0]
            except: img = None
            try: tit = Utiles.recortar(html, "<title>", "</title>")#.encode('utf8')
            except: tit = u"Vídeo de Radio Televisión de Castilla y Leon".encode('utf8')
            try: desc = Utiles.recortar(html, "<meta name=\"Description\" content=\"", "\"").decode('string-escape').strip().encode('utf8')
            except: desc = u"Vídeo de Radio Televisión de Castilla y Leon".encode('utf8')
        elif html.find("<embed src=\"http://www.youtube.com") != -1:
            raise Error.GeneralPyspainTVsError(u"El vídeo de la página es de YouTube. Encontrarás muchas formas de descargarlo ;)")
        else:
            raise Error.GeneralPyspainTVsError(u"No se encuentra contenido")
            
        
        return {"exito" : True,
                "num_videos" : 1,
#.........这里部分代码省略.........

# 需要导入模块: import Utiles [as 别名]
# 或者: from Utiles import formatearNombre [as 别名]
 def getInfo(self):
     '''
         Devuelve toda la información asociada a la URL recibida, de la siguiente forma:
         {
          "exito"     : bool,  <-- True (si se han obtenido videos)
          "num_video" : int,   <-- Número de vídeos obtenidos
          "mensaje"   : u"" ,  <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False])
          "videos"    :  [{
                         "url_video" : [],   <-- Url de descarga de vídeo
                         "url_img"   : "",   <-- Url de la miniatura del video
                         "filename"  : [],   <-- Nombre de las partes para guardar en disco
                         "tipo"      : "",   <-- http, rtmp[e,..], mms, ...
                         "partes"    : int,  <-- Número de partes que tiene el vídeo
                         "rtmpd_cmd" : [],   <-- Comando rtmpdump (si tipo == rtmp) sino None
                         "menco_cmd" : [],   <-- Comando mencoder (Si tipo == rtmp) sino None
                         "url_publi" : "",   <-- Url del vídeo de publicidad asociado al vídeo
                         "otros"     : [],   <-- Lista donde se pueden pasar cosas opcionales
                         "mensaje"   : ""    <-- Mensajes de la API
                         }], <-- Debe ser una lista de tamaño "num_videos"
          "titulos"   : [u""], <-- Titulos de los videos
          "descs"     : [u""] <-- Descripción de cada vídeo
         }
         
         Los valores que no se rellenen, deberán devolver None.
         La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente:
         {
         "exito": False,
         "mensaje": "No se pudo descargar el video"  
         }
         
         "videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None)
         "url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None)
     '''
     img = None
     # print "[+] Procesando descarga"
     streamHTML = Descargar.getHtml(self.url)
     if self.url.find(".com/videos/") != -1: # Modo Salón
         img = self.URL_DE_ANTENA3 + Utiles.qe(streamHTML).split("player_capitulo.poster=\'/")[1].split("\'")[0]
         url2down, name = self.__modoSalon(streamHTML)
     else: # Otro vídeos (No modo salón)
         self.log(u"[INFO] Vídeo normal (no Modo Salón)")
         if streamHTML.find(".seoURL='") != -1: # Url directamente en HTML
             img = self.URL_DE_ANTENA3 + streamHTML.split(".poster=\'/")[1].split("\'")[0]
             url2down, name = self.__modoNormalConURL(streamHTML)
         elif streamHTML.find("a3_gp_visor_player") != -1:
             self.log(u"[INFO] Vídeo de Fórmula 1")
             return self.__modoF1(streamHTML) # return directamente aquí
         else: # No está la url en el hmtl (buscar por varias partes)
             if streamHTML.find("<div class=\"visor\">") != -1: # Más de 1 parte # Quizas mejor "carrusel"?
                 url2down, name = self.__modoNormalVariasPartes(streamHTML)
             else: # Solo una parte
                 url2down, name = self.__modoNormalUnaParte(streamHTML)
     
     desc = None        
     try:
         desc = Utiles.recortar(streamHTML, "<meta property=\"og:description\" content=\"", "\"").strip()
     except:
         try:
             desc = Utiles.recortar(streamHTML, "<meta name=\"description\" content=\"", "\" />").strip()
         except:   
             desc = None
     
     #if type(url2down) == list:
     #    for i in url2down:
     #        if i.find("geobloqueo") != -1:
     #            self.log(u"[!!!] El vídeo \"" + i + "\" no se puedo descargar (geobloqueado)")
     #            url2down.remove(i)
     #            # TODO: Borrar también su nombre correspondiente
     #        
     #    # Comprobar si todas las partes están geobloqueadas (no quedan elementos en la lista):
     #    if len(url2down) == 0:
     #        raise Error.GeneralPyspainTVsError("Grupo Antena 3. Todo el contenido Geobloqueado.")
     #else:
     #    if url2down.find("geobloqueo") != -1:
     #        raise Error.GeneralPyspainTVsError("Grupo Antena 3. Todo el contenido Geobloqueado.")
     if type(name) == list:
         tit_vid = name[0].split(".")[0]
         for i in name:
             b = Utiles.formatearNombre(i)
             name[name.index(i)] = b
     else:
         tit_vid = name.split(".")[0]
         name = Utiles.formatearNombre(name)
     
     return {"exito" : True,
             "num_videos" : 1,
             "mensaje"   : u"URL obtenido correctamente",
             "videos":[{
                     "url_video" : [url2down] if type(url2down) != list else url2down,
                     "url_img"   : img if img is not None else None,
                     "filename"  : [name] if type(name) != list else name,
                     "tipo"      : "http",
                     "partes"    : 1 if type(url2down) != list else len(url2down),
                     "rtmpd_cmd" : None,
                     "menco_cmd" : None,
                     "url_publi" : None,
                     "otros"     : None,
                     "mensaje"   : u"URL obtenida correctamente" if type(url2down) != list else u"URLs obtenida correctamente"
                     }],
             "titulos": [tit_vid] if tit_vid is not None else None,
#.........这里部分代码省略.........

# 需要导入模块: import Utiles [as 别名]
# 或者: from Utiles import formatearNombre [as 别名]
    def getInfo(self):
        '''
            Devuelve toda la información asociada a la URL recibida, de la siguiente forma:
            {
             "exito"     : bool,  <-- True (si se han obtenido videos)
             "num_video" : int,   <-- Número de vídeos obtenidos
             "mensaje"   : u"" ,  <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False])
             "videos"    :  [{
                            "url_video" : [],   <-- Url de descarga de vídeo
                            "url_img"   : "",   <-- Url de la miniatura del video
                            "filename"  : [],   <-- Nombre de las partes para guardar en disco
                            "tipo"      : "",   <-- http, rtmp[e,..], mms, ...
                            "partes"    : int,  <-- Número de partes que tiene el vídeo
                            "rtmpd_cmd" : [],   <-- Comando rtmpdump (si tipo == rtmp) sino None
                            "menco_cmd" : [],   <-- Comando mencoder (Si tipo == rtmp) sino None
                            "url_publi" : "",   <-- Url del vídeo de publicidad asociado al vídeo
                            "otros"     : [],   <-- Lista donde se pueden pasar cosas opcionales
                            "mensaje"   : ""    <-- Mensajes de la API
                            }], <-- Debe ser una lista de tamaño "num_videos"
             "titulos"   : [u""], <-- Titulos de los videos
             "descs"     : [u""] <-- Descripción de cada vídeo
            }
            
            Los valores que no se rellenen, deberán devolver None.
            La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente:
            {
            "exito": False,
            "mensaje": "No se pudo descargar el video"  
            }
            
            "videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None)
            "url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None)
        '''
        
        if self.url.find("tv-a-la-carta/") != -1 or self.url.find("http://alacarta.canalextremadura.es/tv") != -1 \
                                                        or self.url.find("canalextremadura.es/alacarta/tv/") != -1:
            self.info(u"[INFO] TV a la carta")
            html = html2 = Descargar.get(self.url).decode('utf8').encode('utf8')
            html = html.replace(" ", "")
            if html.find("crea_video_hd(") != -1:
                urlFLV = html.split("crea_video_hd(\"")[1].split("\"")[0]
                streamFLV = Descargar.get(urlFLV)
                url = "http://" + streamFLV.split("http://")[1]
                ext = "." + url.split(".")[-1].split("?")[0]
            elif html.find("file:'") != -1:
                try:
                    url = html.split("\'file\':\'")[1].split("\'")[0] #Modo nomal nuevo
                except: #Modo normal antiguo
                    url = html.split("streamer:\'")[1].split("\'")[0] + html.split("file:\'")[1].split("\'")[0]
                ext = "." + url.split(".")[-1]
            elif html.split("if(isiPad)") != -1: #HTTP para iPad
                url = html.split("<video")[1].split(".mp4")[0].split("\"")[-1] + ".mp4"
                ext = ".mp4"
            elif html.find("rel=\"rtmp://") != -1: #RTMP en alacarta
                url = "rtmp://" + html.split("rel=\"rtmp://")[1].split("\"")[0].replace("#", "")
                url = url.split(".mp4")[0] + ".mp4"
                ext = ".mp4"
                name = html.split("<title>")[1].split("<")[0] + ext
                if name: name = Utiles.formatearNombre(name)
                
                try: img = self.URL_CANAL_EXTREMADURA + Utiles.recortar(html2, "poster=\"", "\"")
                except: img = None
                try: tit = Utiles.recortar(html2, "<title>", "</title>").replace("Canal Extremadura", "").replace("|","").strip()#.encode('utf8')
                except: tit = u"Vídeo de Canal Extremadura".encode('utf8')
                try: desc = Utiles.recortar(html2, "<div class=\"descripcion\">", "</div>").strip()#.ecnode('utf8')
                except: desc = u"Vídeo de Canal Extremadura".encode('utf8')
                else:
                    if type(desc) is str:
                        if desc == "": desc = u"Vídeo de Canal Extremadura".encode('utf8')
                    elif type(desc) is unicode:
                        if desc == u"": desc = u"Vídeo de Canal Extremadura".encode('utf8')
                
                rtmpd_cmd = u"rtmpdump -r "+url+" -o "+name
                
                return {"exito" : True,
                        "num_videos" : 1,
                        "mensaje"   : u"URL obtenido correctamente",
                        "videos":[{
                                "url_video" : [url],
                                "url_img"   : img if img is not None else None,
                                "filename"  : [name] if name is not None else None,
                                "tipo"      : "rtmp",
                                "partes"    : 1,
                                "rtmpd_cmd" : [rtmpd_cmd],
                                "menco_cmd" : None,
                                "url_publi" : None,
                                "otros"     : None,
                                "mensaje"   : None
                                }],
                        "titulos": [tit] if tit is not None else None,
                        "descs": [desc] if desc is not None else None
                        } 
            else:
                raise Error.GeneralPyspainTVsError(u"No se encuentra el contenido audiovisual")
            name = html.split("<title>")[1].split("<")[0] + ext
        #TODO: Dar soporte a la radio, por ahora no    
#        elif self.url.find("radio-a-la-carta/") != -1 or self.url.find("http://alacarta.canalextremadura.es/radio") != -1 \
#                                                    or self.url.find("canalextremadura.es/alacarta/radio/") != -1:
#            self.info(u"[INFO] Radio A la Carta")
#            html = Descargar.get(self.url).replace(" ", "")
#.........这里部分代码省略.........

# 需要导入模块: import Utiles [as 别名]
# 或者: from Utiles import formatearNombre [as 别名]

#.........这里部分代码省略.........
            try:
                ID = html.split("flashvars.videoid =")[1].split(";")[0].strip()
            except:
                raise Error.GeneralPyspainTVsError(u"Error al recuperar el vídeo. ¿Es la URL correcta?")
        if ID is None:
            raise Error.GeneralPyspainTVsError(u"No se encuentra vídeo en la página")
        
        self.debug(u"ID: ", ID)
            
        
#        # 3cat24.cat:
#        if self.url.find("3cat24.cat/video/") != -1:
#            self.info(u"[INFO] Vídeos de 3cat24")
#            videoID = self.url.split("/")[-1]
#            url, name = self.__3cat24(nuevoID=videoID)
#        elif self.url.find("3cat24.cat/") != -1 or self.url.find("324.cat") != -1: # de 3cat24 pero no directamente el vídeo
#            self.info(u"[INFO] 3cat24 (otros vídeos)")
#            html = Descargar.get(self.url)
#            videoID = html.split("flashvars.videoid =")[1].split(";")[0].strip()
#            url, name = self.__3cat24(nuevoID=videoID)
#        elif self.url.find("tv3.cat/videos") != -1: # Gracis a Carlesm ;)
#            self.info(u"[INFO] Vídeos de TV3")
#            videoID = self.url.split("/")[-2]
#            if not videoID.isdigit(): videoID = self.url.split("/")[-1]
#            url, name = self.__3cat24(nuevoID=videoID)
#        elif self.url.find("tv3.cat/3alacarta") != -1: # Sirve la misma función de 3cat24 (con nuevoID)
#            self.info(u"[INFO] Vídeos de 3alacarta")
#            videoID = self.url.split("/")[-1]
#            if not videoID.isdigit(): videoID = self.url.split("/")[-2] #HTML5
#            url, name = self.__3cat24(nuevoID=videoID)
#        elif self.url.find("3xl.cat/videos") != -1:
#            self.info(u"[INFO] Vídeos de 3XL")
#            videoID = self.url.split("/")[-2]
#            url, name = self.__3cat24(nuevoID=videoID)
#        elif self.url.find("catradio.cat") != -1:
#            raise Error.GeneralPyspainTVsError(u"Los audios aún no están soportados. Lo estarán muy pronto ;)")
#            #self.info(u"[INFO] Audios de catradio")
#            #url, name = self.__catradio()
        
        #Buscar URL vídeo #FIXME: ERROR de Forbiden que da de vez en cuando
        headers = {
        'User-Agent':'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.7; rv:19.0) Gecko/20121211 Firefox/19.0',
        'Accept':'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
        'Accept-Language':'es-ES,es;q=0.8,en-US;q=0.5,en;q=0.3',
        'Accept-Encodign':'gzip, deflate'
        }
        
        tok = [
               self.URL_TOKEN_START + ID + self.URL_TOKEN_END,
               self.URL_TOKEN_START + ID + self.URL_TOKEN_END2,
               self.URL_TOKEN_NUEVO + ID,
               self.URL_TOKEN_NUEVO2 + ID
               ]
        
        xmlUrl = None
        for t in tok:
            try: xmlUrl = Descargar.get(t)
            except: continue
            if xmlUrl.find("<error>") != -1 or xmlUrl.find("<code>33</code>") != -1:
                xmlUrl = None
                continue
            else:
                break
        if xmlUrl is None:
            raise Error.GeneralPyspainTVsError(u"No se ha podido obtener los enlaces. Prueba dentro de 5 minutos.")
        
        self.debug(u"TOKEN Utilizdo: "+t)
        url = "rtmp://" + xmlUrl.split("rtmp://")[1].split("<")[0]
        urlReplace = "http://mp4-medium-dwn-es.media.tv3.cat/" if url.find("mp4-es") != -1 else "http://mp4-medium-dwn.media.tv3.cat/"
        url = url.replace(url.split("mp4:")[0]+"mp4:", urlReplace).replace(url.split(".mp4")[1],"")             
        
        #Buscar información con URL_INFO_VIDEO        
        info = Descargar.get(self.URL_INFO_VIDEO + ID, header=headers)
        try: img = Utiles.recortar(info, "<imgsrc>", "</imgsrc>").strip()
        except: img = None
        try: tit = Utiles.recortar(info, "<title>", "</title>").strip().decode('iso-8859-1').encode('utf8')
        except: tit = u"Vídeo de Televisió de Catalunya".encode('utf8')
        try: desc = Utiles.recortar(info, "<desc>", "</desc>").strip().decode('iso-8859-1').encode('utf8')
        except: desc = u"Vídeo de Televisió de Catalunya".encode('utf8')
        try: name = Utiles.formatearNombre(tit+".mp4")
        except: name = "VideoTV3.mp4"
        
        return {"exito" : True,
                "num_videos" : 1,
                "mensaje"   : u"URL obtenido correctamente",
                "videos":[{
                        "url_video" : [url],
                        "url_img"   : img if img is not None else None,
                        "filename"  : [name] if name is not None else None,
                        "tipo"      : "http",
                        "partes"    : 1,
                        "rtmpd_cmd" : None,
                        "menco_cmd" : None,
                        "url_publi" : None,
                        "otros"     : None,
                        "mensaje"   : None
                        }],
                "titulos": [tit] if tit is not None else None,
                "descs": [desc] if desc is not None else None
                }