Python Utiles类代码示例

    def atresplayer_mobile(self):
        #stream = self.__get(self.url)
        stream = Descargar.get(self.url)
        episode = re.findall('episode="(.*)">', stream)[0]
        header = {"Accept":"application/json"}
        j = json.loads(Descargar.getHtmlHeaders("http://servicios.atresplayer.com/episode/get?episodePk="+episode, header=header))

        if j['type'] == "REGISTER":
            url = Utiles.url_fix(self.__getApiMobileUrl2(episode))
            #self.debug(unicode(url))
            #jj = json.loads(Descargar.getHtmlHeaders(Utiles.url_fix(url)))
            try:
                #url2down = jj['resultDes']
                url2down = url
            except:
                raise Error.GeneralPyspainTVsError(unicode(jj['resultDes']))
        elif j['type'] == "FREE": # TEMP FIX
            url = Utiles.url_fix(self.__getApiMobileUrl2(episode))
            try:
                url2down = url
            except:
                raise Error.GeneralPyspainTVsError(unicode(jj['resultDes']))
        else:
            url = Utiles.url_fix(self.__getApiMobileUrl(episode).replace("https://", "http://"))
            self.debug(unicode(url))
            #jj = json.loads(self.__get(Utiles.url_fix(url)))
            jj = json.loads(Descargar.get(Utiles.url_fix(url)))
            try:
                url2down = jj['resultObject']['es']
            except:
                raise Error.GeneralPyspainTVsError(unicode(jj['resultDes']))

            if url2down is None:
                raise Error.GeneralPyspainTVsError(u"[Atresplayer] No se han podido obtener enlaces para URL proporcionada")

            

        title = u"%s %s".encode('utf-8') % (j['titleSection'].encode('utf-8'), j['titleDetail'].encode('utf-8'))
        desc = unicode(j['seoDescription']).encode('utf-8')
        name = u"VideoAtresPlayer.mp4"
        img = j['urlImage'].replace(".jpg", "06.jpg")

        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": [title] if title is not None else None,
                "descs": [desc] if desc is not None else None
                }

 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
             }

 def __ClanTV(self, html, ID):
     self.info(u"[INFO] Vídeo de Clan")
     logging.debug("entro en clan")
     buscar = self.__getSerieName(self.url)
     logging.debug(buscar)
     if buscar is None:
         #html = Descargar.get(self.url)
         buscar = "/".join(self.url.split("/")[6:9])
         logging.debug(buscar)
         if not buscar.startswith("videos") and not buscar.endswith("todos"):
             try:
                 serie = Utiles.recortar(self.url, "/videos/", "/todos/")
                 logging.debug(serie)
             except: #http://www.rtve.es/infantil/videos-juegos/#/videos/suckers/todos/suckers-ventosas/1605449 ó */
                 Surl = self.url.split("/")
                 if Surl[-1] == "": buscar = Surl[-3]
                 if Surl[-1].isdigit(): buscar = Surl[-2]
                 else:
                     raise Error.GeneralPyspainTVsError(u"Error al encontrar la serie. Por favor reporta el error")
             else:
                 buscar = "/videos/"+serie+"/todos/"
                 logging.debug(buscar)
         buscar = str(buscar)
     self.debug(u"Serie:", buscar)
     logging.debug("final: "+ buscar)
     #Ir a la página de descripción de vídeos de Clan
     try:
         dataURL = "http://www.rtve.es/infantil/components/"+html.split(buscar)[0].split("<a rel=\"")[-1].split("\"")[0]+"/videos.xml.inc"
     except Exception, e:
         logging.debug(e.__str__())

    def atresplayer_mobile(self):
        #stream = self.__get(self.url)
        stream = Descargar.get(self.url)
        episode = re.findall('episode="(.*)">', stream)[0]
        header = {"Accept":"application/json"}
        j = json.loads(Descargar.getHtmlHeaders(self.URL_EPISODE_INFO+episode, header=header))

        url = Utiles.url_fix(self.__getApiMobileUrl(episode).replace("https://", "http://"))
        self.debug(unicode(url))
        #jj = json.loads(self.__get(Utiles.url_fix(url)))
        jj = json.loads(Descargar.get(Utiles.url_fix(url)))
        try:
            url2down = jj['resultObject']['es']
        except:
            raise Error.GeneralPyspainTVsError(unicode(jj['resultDes']))

        if url2down is None:
            raise Error.GeneralPyspainTVsError(u"[Atresplayer] No se han podido obtener enlaces para URL proporcionada")

        title = u"%s %s".encode('utf-8') % (j['titleSection'].encode('utf-8'), j['titleDetail'].encode('utf-8'))
        desc = unicode(j['seoDescription']).encode('utf-8')
        urlparsed = urlparse.urlparse(self.url)
        pathsplit = urlparsed.path.split('/')
        del pathsplit[:3]
        name = u'_'.join(pathsplit)
        name = name.replace('.html','.mp4')
        img = j['urlImage'].replace(".jpg", "06.jpg")

        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": [title] if title is not None else None,
                "descs": [desc] if desc is not None else None
                }

    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],
                }

 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()
     
     if html.find("'file'") == -1:
         urlXML = self.URL_GET_XML+Utiles.recortar(html, "var idvideo = '", "'")
     else:
         urlXML = self.URL_HIST_CARTA+Utiles.unescape(Utiles.recortar(html, "'file': '", "'"))        
     
     import logging
     logging.debug(self.PROXY_PYDOWNTV+Utiles.escape(urlXML))
     logging.debug(self.PROXY_PYDOWNTV+Utiles.escape(urlXML))
     xml = Descargar.get(urlXML)
     if xml.find("vohWwiQliW") != -1: # GEOLOCALIZADO
         logging.debug("GEO")
         xml = Descargar.get(self.PROXY_PYDOWNTV+Utiles.escape(urlXML))
         if xml.find("vohWwiQliW") != -1:
             logging.debug("GEO2")
             try:
                 xml = Descargar.get(self.PROXY_PYDOWNTV+Utiles.escape(urlXML))
             except Exception, e:
                 raise Error.GeneralPyspainTVsError(e.__str__())

    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

    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
                }

    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

 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
#.........这里部分代码省略.........

#.........这里部分代码省略.........
            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
                }

 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)
 
 try:
     tit_vid = name = htmlBackup.split("<div class=\"Destacado-text\">")[1].split("<h2>")[1].split("</h2>")[0]
     name = Utiles.formatearNombre(name + ".mp4")
 except:   
     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", "").replace("|", "").strip()
 
 desc = None        
 try:
     desc = htmlBackup.split("<div class=\"Destacado-text\">")[1].split("<p class=\"text\">")[1].split("</p>")[0]
     #desc = Utiles.descriptionFormat(Utiles.recortar(htmlBackup, "\"post_content\":\"", "\"").strip())
 except:

 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,
#.........这里部分代码省略.........

 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)
     '''
     
     # Comprobar si es de radio primero:
     firstHtmlCheck = Descargar.get(self.url)
     separador = "this.element.jPlayer(\"setFile\", \""
     if firstHtmlCheck.find(separador) != -1 and firstHtmlCheck.find(".mp3") != -1:
         raise Error.GeneralPyspainTVsError(u"No soportamos la radio por ahora. Pronto estará disponible.")
         url, name = self.__rtvvRadio(firstHtmlCheck, separador)
         if name:
             name = Utiles.formatearNombre(name)
         return [url, name]
     # FIN Ràdio
     
     # Ahora Vídeos
     html = None
     if self.url.find("rtvv.es/va/noualacarta") != -1 or self.url.find("rtvv.es/es/noualacarta") != -1:
         self.info(u"[INFO] A la Carta")
         htmlURL, cap = self.__getHtmlUrlFromAlacarta()
         html = Descargar.get(htmlURL)
         xmlURL = self.URL_RTVV + html.split("file: \"")[1].split("\"")[0]
     else:
         self.info(u"[INFO] Vídeo Normal")
         xmlURL = self.URL_RTVV + Descargar.get(self.url).split("file: \"")[1].split("\"")[0]
     
         
     self.info(u"[INFO] URL de XML:", xmlURL)
     xmlStream = Descargar.get(xmlURL)
     url = xmlStream.split("<media:content url=\"")[1].split("\"")[0]
     ext = "." + url.split(".")[-1]
     # Acotar a <item></item> para coger el <title> del <item>
     item = xmlStream.split("<item>")[1].split("</item>")[0]
     name = item.split("<title><![CDATA[")[1].split("]")[0] + ext
     
     html = self.gethtml() if html is None else html
     try: img = Utiles.recortar(xmlStream, "<media:thumbnail url=\"", "\"")
     except: img = None
     try:
         if cap is not None:
             tit = html.split("<div class=\"title\">")[1].split("<h2>")[1].split("</h2>")[0] + " ( "+cap+" ) "
         else:
             tit = html.split("<div class=\"title\">")[1].split("<h2>")[1].split("</h2>")[0]
     except: tit = u"Vídeo de Radiotelevisión Valenciana".encode('utf8')
     try: name = Utiles.formatearNombre(tit+".mp4")
     except: name = "VideoRTVV.mp4"
     try: desc = Utiles.recortar(html, "<div class=\"tx\">", "</div>")
     except: desc = u"Vídeo de Radiotelevisión Valenciana".encode('utf8')
     
     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
             }

 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)
     '''
     
     # Diferenciar entre vídeos "á carta" y vídeos de "agalegainfo":
     streamHTML = Descargar.get(self.url).decode('string-escape')
     tit_vid = Utiles.descriptionFormat(streamHTML.split("title: \"")[1].split("\"")[0])
     htmlBackup = streamHTML
     streamHTML = streamHTML.replace(" ", "").replace("\t", "").replace("\n", "")
     
     if self.url.find("a-carta") != -1:
         self.info(u"[INFO] Modo \"Á Carta\"")
     else:
         self.info(u"[INFO] Vídeo Normal (No \"Á Carta\")")
     
     rtmp = streamHTML.split("rtmp:{")[1]
     s = rtmp.split("url:\"")[1].split("\"")[0]
     r = rtmp.split("netConnectionUrl:\"")[1].split("\"")[0]
     a = r.split("/")[-1]
     video = rtmp.split("clip:{")[1]
     y = video.split("url:\"")[1].split("\"")[0]
     name = video.split("title:\"")[1].split("\"")[0] + "." + y.split(".")[-1]
     img = streamHTML.split("backgroundImage:\"url(")[1].split(")")[0]
     url = r
             
     if name:
         name = Utiles.formatearNombre(name)
     rtmpd_cmd = "rtmpdump -v -r "+url+" -y "+y+" -s "+s+" -a "+a+" -o "+name
     
     desc = None        
     try: #FIXME: Pillar más que solo el primer párrafo
         desc = "".join(htmlBackup.split("<p style=\"text-align: justify;\">")[1:]).split("</div>")[0].strip().decode('string-escape')
         #desc = Utiles.recortar(htmlBackup, "<p style=\"text-align: justify;\">", "</div>").strip().decode('string-escape')
     except:
         desc = tit_vid if tit_vid is not None else None
     if desc ==  None: desc = u"Vídeo de Televisión de Galicia".encode("utf8")
     
     return {"exito" : True,
             "num_videos" : 1,
             "mensaje"   : u"URL obtenida 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_vid] if tit_vid is not None else None,
             "descs": [desc] if desc is not None else None
             }