Python Utiles.recortar方法代码示例

# 需要导入模块: import Utiles [as 别名]
# 或者: from Utiles import recortar [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()
     
     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__())

# 需要导入模块: import Utiles [as 别名]
# 或者: from Utiles import recortar [as 别名]
 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__())

# 需要导入模块: import Utiles [as 别名]
# 或者: from Utiles import recortar [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 recortar [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)
        '''
        #TODO: Cuida con las paginas que tiene más de un vídeo. De momento funciona porque es el primer video que aparece!
        
        # Primero: nos quedamos con le id dependiendo si el user metio la url con
        # una barra (/) final o no y si tiene extensión (no es alacarta)
        videoID = self.url.split('/')[-1]
        if videoID == "":
            videoID = self.url.split('/')[-2]
        elif videoID.find(".shtml") != -1 or videoID.find(".html") != -1 or \
            videoID.find(".html") != -1:
            videoID = videoID.split('.')[0]
        
        self.debug(u"ID del vídeo en url = " + videoID)
        
        # Añadido para vídeos nuevos (periodo de prueba):
        sourceHTML = Descargar.getHtml(self.url)
        videoID_comp = None
        if sourceHTML.find("flashcontentId:\'videoplayer") != -1:
            videoID_comp = sourceHTML.split("flashcontentId:\'videoplayer")[1].split("\'")[0]
            if videoID_comp != videoID: videoID = videoID_comp
        if sourceHTML.find("<div id=\"video") != -1:
            videoID_comp = sourceHTML.split("<div id=\"video")[1].split("\"")[0]
            if videoID_comp != videoID: videoID = videoID_comp
        ########################################################
        
        self.debug(u"ID del vídeo en HTML = " + videoID_comp if videoID_comp else "No ID en HTML")
        self.log(u"[INFO] ID del Vídeo :", videoID)

        # -- Método 1 Octubre 2012:
        self.debug(u"Probando método de 1 de uno de Octubre de 2012")
        url = "http://www.rtve.es/ztnr/consumer/xl/video/alta/" + videoID + "_es_292525252525111"
        self.debug(url)
        
        user_agent="Mozilla"
        opener = urllib2.build_opener(NoRedirectHandler())
        urllib2.install_opener(opener)
        headers = { 'User-Agent' : user_agent }
        req = urllib2.Request(url, None, headers)
        u = urllib2.urlopen(req)
        try:
            urlVideo = u.info().getheaders("Location")[0]
        except:
            raise Error.GeneralPyspainTVsError("No se encuentra Location")
        u.close()
        if urlVideo != "":
            url_video = urlVideo.replace("www.rtve.es", "media5.rtve.es")
            titulo = sourceHTML.split("<title>")[1].split("</")[0]
            filename = titulo + ".mp4"
            filename = Utiles.formatearNombre(filename)
            #sourceHTML = sourceHTML.split("<div id=\"video")[1].split("flashvars")[0] # Me quedo solo con la parte del vídeo principal
            url_img = sourceHTML.split("\"thumbnail\" content=\"")[1].split("\"")[0]
        else:
            raise Error.GeneralPyspainTVsError("No se pudo encontrar el enlace de descarga")
        # -- Método 1 Octubre 2012 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 = None
                
        
#.........这里部分代码省略.........

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

#.........这里部分代码省略.........
                 for node in xmltree.findall("./preset"):
                     if node.attrib.get('type') == "Alta":
                         for url in node.findall("./response/url"):
                             if url.attrib.get('provider') == "AKAMAI_STR-1030":
                                 urlVideo = url.text
             except:
                 urlVideo = re.findall("<url.*>(.*)</url>", xmldata)[0]



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

            try: url_img = sourceHTML.split("\"thumbnail\" content=\"")[1].split("\"")[0]
            except:
                try: url_img = re.findall('<link.*rel\=\"image_src\".*href\=\"(.*)\"' , sourceHTML)[0]
                except: url_img = re.findall('<meta.*name\=\"RTVE\.thumb_video\".*content\=\"(.*)\"',sourceHTML)[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,
                    "num_videos" : 2,
                    "mensaje"   : u"URL obtenido correctamente",
                    "videos":[{
                            "url_video" : [url_video],
                            "url_img"   : url_img,
                            "filename"  : [filename],
                            "tipo"      : "http",
                            "partes"    : 1,
                            "rtmpd_cmd" : None,
                            "menco_cmd" : None,
                            "url_publi" : None,
                            "otros"     : "MP4",
                            "mensaje"   : msgCalidad

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

#.........这里部分代码省略.........
             url = streamHTML.split("html5")[1].split("\'file\':\'")[1].split("\'")[0]
         except:
             url = streamHTML.split("html5")[0].split("\'file\':\'")[1].split("\'")[0]
     else:
         # Cuantas partes son:
         try: 
             partes = int(streamHTML.split("&partes=")[1].split("&")[0])
         except IndexError: # No existe "&partes"
             partes = 1
         
         if partes == 1:
             videoID = streamHTML.split("<param value=\"video1=")[1].split("&")[0]
             if videoID.find("http://") != -1:
                 url = videoID
                 name = streamHTML.split("data-text=\"")[1].split("\"")[0].strip() + "." + url.split(".")[-1]
             else:
                 # Probar entre TOKEN nuevo y antiguo por reproductor:
                 repro = streamHTML.split("<param value=\"player/")[1].split("\"")[0]
                 if repro == "reproductorVideoOnDemmand-mp4-rtpa.swf": # Antiguo
                     streamINFO = self.__descHTML(self.TOKEN_ARCHIVO + videoID)
                     url = "http://" + streamINFO.split("http://")[1]
                 else: # Reproductor nuevo: "reproductorVideoOnDemmand.swf"
                     streamINFO = self.__descHTML(self.TOKEN + videoID + "_1")
                     streamINFO = self.__descHTML(streamINFO.split("&url=")[1])
                     url = "http://" + streamINFO.split("http://")[1]
                 name = streamHTML.split("<div id=\"sobreElVideo\">")[1].split("<h3>")[1].split("</h3>")[0]
                 if name == "":
                     name = streamHTML.split("<title>")[1].split("</title>")[0] + ".mp4"
                 else: name + ".mp4"
         else:
             # Recordar que hay videos que ponen varias partes en las que realmente solo existe una:
             videoID = streamHTML.split("<param value=\"video1=")[1].split("&")[0]
             url = []
             name = []
             for i in range(1, partes+1):
                 streamINFO = self.__descHTML(self.TOKEN + videoID + "_" + str(i))
                 streamINFO = self.__descHTML(streamINFO.split("&url=")[1])
                 
                 tmp_url = "http://" + streamINFO.split("http://")[1]
                 tmp_name = streamHTML.split("<div id=\"sobreElVideo\">")[1].split("<h3>")[1].split("</h3>")[0] +"_part" + str(i)
                 if tmp_name == "":
                     tmp_name = streamHTML.split("<title>")[1].split("</title>")[0] + "_part" + str(i) + ".mp4"
                 else: tmp_name + ".mp4"
                 
                 if Descargar.isReachable(tmp_url):
                     url.append(tmp_url)
                     name.appen(tmp_name)
                     continue
                 else:
                     break
                 
     try: #imagen del vídeo
         img = self.URL_RTPA + Utiles.recortar(htmlBackup, "\'image\': \'", "\'")
     except:
         img = None
     
     desc = None 
     try: # Descripción del vídeo
         desc = htmlBackup.split("<div class=\"overview\">")[1].split("<div>")[1].split("</div>")[0].strip()
     except:
         desc = u"Vídeo de la web de Radio Televisión del Principado de Asturias"
     else:
         if desc is not None and desc == "":
             desc = u"Vídeo de la web de Radio Televisión del Principado de Asturias"
     
     tit_vid = None
     try: #Título del vídeo
         tit_vid = htmlBackup.split("<div id=\"sobreElVideo\">")[1].split("<h3>")[1].split("</h3>")[0]
     except:
         tit_vid = None
     else:
         if tit_vid is not None and tit_vid == "":
             tit_vid = u"Vídeo de la web de Radio Televisión del Principado de Asturias"
     
     if type(name) == list:
         for i in name:
             b = Utiles.formatearNombre(i)
             name[name.index(i)] = b
     else:
         name = Utiles.formatearNombre(name)
     
     return {"exito" : True,
             "num_videos" : 1,
             "mensaje"   : u"URL obtenida correctamente",
             "videos":[{
                     "url_video" : [url] if type(url) != list else url,
                     "url_img"   : img if img is not None else None,
                     "filename"  : [name] if name is not None else None,
                     "tipo"      : "http",
                     "partes"    : partes if partes is not None else 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 recortar [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 recortar [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)
        '''
        
        com = False
        
        html = Descargar.get(self.url)
        html = html.replace("\n", "").replace("\t", "")
        try: #ES
            uri = html.split("var uri = \"")[1].split("\"")[0]
        except: #COM
            com = True
            uri = html.split(".videoUri = \"")[1].split("\"")[0]
        
        #Spain or .com?
        xmlUrl = self.XML_URL + uri if self.url.find(".es") != -1 else self.XML_URL_COM + uri
        self.debug(u"URL XML Info: %s" % xmlUrl)
        xml = Descargar.get(xmlUrl)
        
        name = None
        tit = None
        desc = None
        try: #ES
            name = xml.split("<title>")[1].split("<![CDATA[")[1].split("]]>")[0]
        except: #COM
            xml = xml.decode('iso-8859-1').encode('utf8')
            if xml.find("<item>") != -1:
                name = xml.split("<item>")[1].split("<title>")[1].split("<")[0]
                tit = name
                try: desc = xml.split("<item>")[1].split("<description>")[1].split("<")[0].strip()
                except: desc = u"Vídeo de MTV".encode('utf8')
            else:
                name = xml.split("<title>")[1].split("<")[0]
                tit = name
                try: desc = xml.split("<description>")[1].split("<")[0].strip()
                except: desc = u"Vídeo de MTV".encode('utf8')
        name = name.replace("!", "").replace("|","") + ".mp4"
        name = Utiles.formatearNombre(name)
        
        
        import logging
        
        xmlURL = xml.split("<media:content")[1].split("url=\"")[1].split("\"")[0]
        self.debug(u"URL XML Archivos: %s" % xmlURL)
        xml2 = Descargar.get(xmlURL)
        #ulr = streamXML2.split("</rendition>")[-2].split("<src>")[1].split("</src>")[0]
        url = "rtmp" + xml2.split("<src>rtmp")[-1].split("</src>")[0]
        if url.find("copyright_error.") != -1: # GEO bloqueado!
            logging.debug("GEO Bloqueado")
            logging.debug(self.PROXY_AABILIO+xml.split("<media:content")[1].split("url=\"")[1].split("\"")[0])
            xmlURL = self.PROXY_AABILIO+xml.split("<media:content")[1].split("url=\"")[1].split("\"")[0]
            xml2 = Descargar.get(xmlURL)
            logging.debug(xml2)
            url = "rtmp" + xml2.split("<src>rtmp")[-1].split("</src>")[0]
        
        if com:
            rtmpd_cmd = "rtmpdump -r \'"+url+"\' -o \'"+name+"\' -W \'http://media.mtvnservices.com/player/prime/mediaplayerprime.2.3.6.swf\'"
        else:
            rtmpd_cmd = "rtmpdump -r \'"+url+"\' -o \'"+name+"\'"

        try: img = Utiles.recortar(xml, "<image url=\"", "\"")
        except: img = None
        try: tit = xml.split("<title>")[1].split("<![CDATA[")[1].split("]")[0].strip() if not tit else tit
        except: tit = u"Vídeo de MTV".encode('utf8')
        try: desc = xml.split("<description>")[1].split("<![CDATA[")[1].split("]")[0].strip() if not desc else desc
        except: desc = u"Vídeo de MTV".encode('utf8')
    
        return {"exito" : True,
                "num_videos" : 1,
                "mensaje"   : u"URL obtenido correctamente",
#.........这里部分代码省略.........

# 需要导入模块: import Utiles [as 别名]
# 或者: from Utiles import recortar [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 = Descargar.get(self.url)
     try:
         name = Utiles.recortar(html, "<title>", "</title>")
         html2 = html.replace("%3A", ":").replace("%2F", "/").replace(" ", "").replace("\t", "")
         clip = html2.split("clip:")[1].split("url:\'")[1].split("\'")[0].replace("mp4:", "")
         server = html2.split("netConnectionUrl:\'")[1].split("\'")[0]
         url = server + clip
         name += "." + clip.split(".")[-1]
         img1 = html.split("logo:")[1].split("url:")[1].split("\'")[1].split("\'")[0]
         if img1.find("aragontelevision.es") != -1: img = img1
         else: img = self.URL_ARAGONTV_ALACARTA + img1#html.split("logo:")[1].split("url:")[1].split("\'")[1].split("\'")[0]
         
         try:
             desc = Utiles.recortar(html, "<span class=\"title\">Resumen del vídeo</span>", "</div>").strip().decode('string-escape')
         except:
             desc = u"Vídeo de Aragón Televisión".encode("utf8")
         else:
             try:
                 if type(desc) is unicode:
                     if desc == u"": desc = u"Vídeo de Aragón Televisión".encode("utf8")
                 elif type(desc) is str:
                     if desc == "": desc = u"Vídeo de Aragón Televisión".encode("utf8")
             except:
                 desc = u"Vídeo de Aragón Televisión".encode("utf8")
             
         try:
             tit = Utiles.recortar(html, "<title>", "</title>")
         except:
             tit = u"Vídeo de Aragón Televisón".encode("utf8")
             
         if name: name = Utiles.formatearNombre(name)
         rtmpd_cmd = "rtmpdump -r "+url+" -o "+name
     except:
         raise Error.GeneralPyspainTVsError(u"Error al recuperar el vídeo de Aragon TV")
 
     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
             }

# 需要导入模块: import Utiles [as 别名]
# 或者: from Utiles import recortar [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("atresplayer.com/") != -1:
            return self.atresplayer_mobile()
        elif self.url.find(".com/videos/") != -1:  # Modo Salón
            try:
                img = self.URL_DE_ANTENA3 + Utiles.qe(streamHTML).split("player_capitulo.poster='/")[1].split("'")[0]
            except:
                if streamHTML.find('<div class="premium">') != -1:
                    raise Error.GeneralPyspainTVsError(
                        u"PyDownTV no acepta la descarga de contenidos premium de las cadenas."
                    )
            url2down, name = self.__modoSalon(streamHTML)
        else:  # Otro vídeos (No modo salón)
            self.log(u"[INFO] Vídeo normal (no Modo Salón)")
            # EN PRUEBAS (nuevo modo normal) (17/05/2014)  #######################################
            xmls = re.findall(".*(http.*\/videosnuevosxml\/.*\.xml).*", streamHTML)
            if len(xmls) > 0:
                return self.normalNuevoMultiple(xmls)
            ######################################################################################
            # EN PRUEBAS (solo si hay varios vídeos...)! (23/04/2013) [RETROCOMPATIBLE]: #########
            xmls = re.findall("\.xml='(.*)'", streamHTML)
            if len(xmls) > 1:
                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:
#.........这里部分代码省略.........

# 需要导入模块: import Utiles [as 别名]
# 或者: from Utiles import recortar [as 别名]
        # 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,
            "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": "http",
                    "partes": 1,
                    "rtmpd_cmd": None,

# 需要导入模块: import Utiles [as 别名]
# 或者: from Utiles import recortar [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 = Descargar.getHtmlUtf8Intereconomia(self.url)
        rtmp = False

        try: tit = Utiles.recortar(html, "title: '", "'").encode('utf-8')
        except:
            try: tit = Utiles.recortar(html, "<title>", "</title>").encode('utf-8')
            except:tit = u"Vídeo de Intereconomía".encode('utf8')
        desc = tit
        try: name = Utiles.formatearNombre(tit+".mp4")
        except: name = "VideoIntereconomia.mp4"
        try: img = self.URL_INTER+Utiles.recortar(html, "backgroundImage: 'url(", ")'")
        except: img = None
        try: url = Utiles.url_fix(Utiles.recortar(html, "clip: '", "'"))
        except: 
            try: url = Utiles.url_fix(html.split("playlist:")[1].split("url: '")[1].split("'")[0])
            except:
                try:
                    url = Utiles.url_fix(html.split("clip:")[1].split("url: \'")[1].split("\'")[0])
                    rtmp = True
                except: raise Error.GeneralPyspainTVsError(u"No se ha podido encontrar el vídeo en la página")
 
        if rtmp:
            url = (Utiles.recortar(html, "netConnectionUrl: \'", "\'") + "/" + url).replace("mp4:", "mp4/").replace("mp4%3A", "mp4/")
            rtmpd_cmd = "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
                    }

        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 recortar [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 = Descargar.get(self.url)
     
     try: url = self.URL_VTV + html.split("showPlayer(")[1].split(",")[1].split(",")[0].replace("\"", "").strip() 
     except:
         try:
             url = Utiles.recortar(html, "<meta property=\"og:video\" content=\"", "\"").replace("media.", "")
         except:
             raise Error.GeneralPyspainTVsError("No se pudo obtener la url de descarga")
     
     try: tit = Utiles.recortar(html, "<meta name=\"title\" content=\"", "\"").decode('iso-8859-1').encode('utf8')
     except: tit = u"Vídeo de V Televisión".encode('utf8')
     try: desc = Utiles.recortar(html, "<meta name=\"description\" content=\"", "\"").decode('iso-8859-1').encode('utf8')
     except: desc = tit
     try: img = Utiles.recortar(html, "<meta property=\"og:image\" content=\"", "\"")
     except: img = None
     try: name = Utiles.formatearNombre(tit) + ".mp4"
     except: name = "Video_V_Television.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
             }

# 需要导入模块: import Utiles [as 别名]
# 或者: from Utiles import recortar [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 recortar [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 = Descargar.get(self.url)
     
     rtmp = False
     try: url = html.split("<param name=\"movie\"")[1].split("file=")[1].split("&")[0]
     except:
         try:
             url = Utiles.unescape(Utiles.recortar(html, "value=\"src=", "&"))
             rtmp = True
         except: #TODO: Añadir vídeos de listas
             raise Error.GeneralPyspainTVsError("No se pudo obtener la url de descarga")
     
     try: tit = html.split("<td class=\"contentheading\"")[1].split(">")[1].split("<")[0].decode('iso-8859-1').encode('utf8')
     except:
         try:
             tit = Utiles.recortar(html, "<meta name=\"title\" content=\"", "\"").decode('iso-8859-1').encode('utf8')
         except:
             tit = u"Vídeo de Rias Baixas Televisión".encode('utf8')
     try:
         desc = html.split("<table class=\"contentpaneopen\">")[1].split("</strong>")[1].split("</table>")[0].decode('iso-8859-1').encode('utf8')
         #desc = desc.replace(desc.find("<!-- JW AllVideos"), new)
     except:
         desc = tit
     try:
         if rtmp:
             imgs = html.split("MM_preloadImages('")[1]
             for i in imgs.split("<a href="):
                 if i.find(self.url) != -1:
                     img = self.URL_RB + "/" + i.split("MM_swapImage(")[1].split(",")[2].replace("\'", "").strip()
                     break
                 else: img = None
         else:
             img = html.split("<param name=\"movie\"")[1].split("image=")[1].split("&")[0]
             if Descargar.isReachable(img): pass
             else: img = None
     except: img = None
     try: name = Utiles.formatearNombre(tit) + ".flv"
     except: name = "Video_RiasBaixas.mp4"
 
     if rtmp: rtmpd_cmd = "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"      : "http" if not rtmp else "rtmp",
                     "partes"    : 1,
                     "rtmpd_cmd" : [rtmpd_cmd] if rtmp else 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
             }