def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' if self._URL_recibida.find("canalsuralacarta.es") != -1: # CSur a la carta: url, name = self.__alacarta() elif self._URL_recibida.find("canalsur.es/") != -1: # Vídeos normales url, name = self.__modoNormal() else: # No debería de suceder nuca salir(u"[!!!] Error inesperado") if type(name) == list: for i in name: b = formatearNombre(i) name[name.index(i)] = b else: name = formatearNombre(name) return [url, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. ''' # print "[+] Procesando descarga" streamHTML = self.__descHTML(self._URL_recibida) if self._URL_recibida.find("antena3.com/videos/") != -1: # Modo Salón url2down, name = self.__modoSalon(streamHTML) else: # Otro vídeos (No modo salón) printt(u"[INFO] Vídeo normal (no Modo Salón)") if streamHTML.find(".seoURL='") != -1: # Url directamente en HTML url2down, name = self.__modoNormalConURL(streamHTML) elif streamHTML.find("a3_gp_visor_player") != -1: url2down, name = self.__modoF1(streamHTML) 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) if type(url2down) == list: for i in url2down: if i.find("geobloqueo") != -1: printt(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: salir(u"[!] No se puede descargar ninguna parte (geobloqueadas)") else: if url2down.find("geobloqueo") != -1: salir(u"[!] El vídeo no se puede descargar (geobloqueado)") if type(name) == list: for i in name: b = formatearNombre(i) name[name.index(i)] = b else: name = formatearNombre(name) return [url2down , name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' streamHTML = self.__descHTML(self._URL_recibida) xmlURL = streamHTML.split("_url_xml_datos:\"")[1].split("\"")[0] streamXML = self.__descHTML(xmlURL) url = streamXML.split("<url>")[1].split("<")[0] ext = "." + url.split(".")[-1] name = streamXML.split("<title><![CDATA[")[1].split("]")[0] + ext if name: name = formatearNombre(name) return [url, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' # Por ahora videos que no sean de Play Cuatro: if self._URL_recibida.find("http://play.cuatro.com/") != -1: printt(u"[INFO] Play Cuatro") url, name = self.__playCuatro() else: printt(u"[INFO] Vídeo Común") streamHTML = self.__descHTML(self._URL_recibida) name = streamHTML.split("<title>")[1].split("<")[0] urlComunes = self.URL_CUATRO + streamHTML.split("src_iframe:")[1].replace(" ", "").split("\'")[1].split("\'")[0] streamComunes = self.__descHTML(urlComunes) url = streamComunes.split("document.write(\'<video id=")[1].split("src=\"")[1].split("\"")[0] ext= "." + url.split(".")[-1] name += ext if name: name = formatearNombre(name) return [url, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' streamHTML = self.__descHTML(self._URL_recibida) if streamHTML.find(".WMV") != -1: name = streamHTML.split("<span id=\"lbltitulo_detalle\">")[1].split("<")[0] url = streamHTML.split("<input type=\"hidden\" id=\"hidden_url\" value=\'")[1].split("\'")[0] ext = "." + url.split(".")[-1].lower() name += ext elif streamHTML.find("youtube") != -1: salir(u"[!!!] No se reconoce el tipo de contenido.\nPuede que el vídeo sea de YouTube??") else: salir(u"[!!!] No se reconoce el tipo de contenido") if name: name = formatearNombre(name) return [url, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' streamHTML = self.__getStream(self._URL_recibida) name = streamHTML.split("<meta name=\"dc.title\" content=\"")[1].split("\"")[0] VideoPlayer = streamHTML.split("<param name=\"@videoPlayer\" value=\"")[1].split("\"")[0] info = self.__get_info(VideoPlayer)['renditions'] big = 0 for video in info: if video['encodingRate'] >= big: big = video['encodingRate'] url = video['defaultURL'] ext = "." + url.split(".")[-1] if name: name = formatearNombre(name) name += ext return [url, name]
def procesarDescarga(self): """ Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). """ # Diferenciar entre videos a la carta y videos de agalegainfo if self._URL_recibida.find("agalegainfo") != -1: # Vídeos de agalegainfo url, name = self.__aGalegaInfo() else: # Aquí son todos "á carta" o tienen más tipos de vídeos?? url, name = self.__aCarta() if name: name = formatearNombre(name) return [url, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' streamHTML = self.__descHTML(self._URL_recibida) if streamHTML.find("<param name=\"movie\"") != -1: printt(u"[INFO] Vídeo") # Delimitar: streamVideo = streamHTML.split("<param name=\"movie\"")[1].split("/>")[0] url = streamVideo.split("file=")[1].split("&")[0] ext = "." + url.split(".")[-1] name = streamHTML.split("<meta name=\"title\" content=\"")[1].split("\"")[0] + ext else: salir(u"[!!!] No se reconoce el tipo de contenido") if name: name = formatearNombre(name) return [url, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' streamHTML = self.__descHTML(self._URL_recibida) name = streamHTML.split("MEDIANAME:unescape(\'")[1].split("\'")[0] ext = streamHTML.split("ORIGVIDEOFORMAT:\'")[1].split("\'")[0] printt(u"[INFO] Vídeo", ext.upper()) ext = "." + ext urlSMIL = streamHTML.split("PATHTOMEDIA:\'")[1].split("\'")[0] streamSMIL = self.__descHTML(urlSMIL) urlBase = streamSMIL.split("base=\"")[1].split("\"")[0] urlSrc = streamSMIL.split("src=\"")[1].split("\"")[0] url = urlBase + urlSrc name += ext if name: name = formatearNombre(name) return [url, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' streamHTML = self.__descHTML(self._URL_recibida) name = streamHTML.split("<title>")[1].split("<")[0] streamHTML = streamHTML.replace(" ", "") if streamHTML.find("playervideo") != -1 and streamHTML.find("playlist") != -1: url = streamHTML.split("playlist")[1].split("url:\'")[1].split("\'")[0] else: url = streamHTML.split("\'clip\':{\'url\':\'")[1].split("\'")[0] name += "." + url.split(".")[-1] if name: name = formatearNombre(name) return [url, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. ''' streamHTML = self.__descHTML(self._URL_recibida).replace("\n", "").replace("\t", "") uri = streamHTML.split("var uri = \"")[1].split("\"")[0] streamXML = self.__descHTML(self.XML_URL + uri) name = streamXML.split("<title>")[1].split("<![CDATA[")[1].split("]]>")[0] name = name.replace("!", "").replace("|","") + ".mp4" #xmlURL = self.PROXY_LINFOX + streamXML.split("<media:content")[1].split("url=\"")[1].split("\"")[0] #Sin Proxy en modo local: xmlURL = streamXML.split("<media:content")[1].split("url=\"")[1].split("\"")[0] streamXML2 = self.__GET(xmlURL) #ulr = streamXML2.split("</rendition>")[-2].split("<src>")[1].split("</src>")[0] url = "rtmp" + streamXML2.split("<src>rtmp")[-1].split("</src>")[0] name = formatearNombre(name) return [url, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' # Dividir si es de a la carta o de btvnocies: if self._URL_recibida.find("btvnoticies.cat") != -1: url, name = self.__btvnoticies() elif self._URL_recibida.find("btv.cat/alacarta/") != -1: url, name = self.__alacarta() else: printt(u"[!!!] No deberías haber visto este ERROR") if name: name = formatearNombre(name) return [url, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' if self._URL_recibida.find("tv-a-la-carta/") != -1 or self._URL_recibida.find("http://alacarta.canalextremadura.es/tv") != -1 or self._URL_recibida.find("canalextremadura.es/alacarta/tv/") != -1: printt(u"[INFO] TV a la carta") streamHTML = self.__descHTML(self._URL_recibida).replace(" ", "") if streamHTML.find("crea_video_hd(") != -1: urlFLV = streamHTML.split("crea_video_hd(\"")[1].split("\"")[0] streamFLV = self.__descHTML(urlFLV) url = "http://" + streamFLV.split("http://")[1] ext = "." + url.split(".")[-1].split("?")[0] elif streamHTML.find("file:'") != -1: try: url = streamHTML.split("\'file\':\'")[1].split("\'")[0] #Modo nomal nuevo except: #Modo normal antiguo url = streamHTML.split("streamer:\'")[1].split("\'")[0] + streamHTML.split("file:\'")[1].split("\'")[0] ext = "." + url.split(".")[-1] elif streamHTML.find("rel=\"rtmp://") != -1: #RTMP en alacarta url = "rtmp://" + streamHTML.split("rel=\"rtmp://")[1].split("\"")[0].replace("#", "") url = url.split(".mp4")[0] + ".mp4" ext = ".mp4" elif streamHTML.split("if(isiPad)") != -1: #HTTP para iPad url = streamHTML.split("<video")[1].split(".mp4")[0].split("\"")[-1] + ".mp4" ext = ".mp4" else: salir(u"[!!!] No se encuentra el vídeo") name = streamHTML.split("<title>")[1].split("<")[0] + ext elif self._URL_recibida.find("radio-a-la-carta/") != -1 or self._URL_recibida.find("http://alacarta.canalextremadura.es/radio") != -1 or self._URL_recibida.find("canalextremadura.es/alacarta/radio/") != -1: printt(u"[INFO] Radio A la Carta") streamHTML = self.__descHTML(self._URL_recibida).replace(" ", "") try: #Modo nuevo url = streamHTML.split("<divclass=\"descargar\">")[1].split("<ahref=\"")[1].split("\"")[0] except: #Modo antiguo url = streamHTML.split("s1.addVariable(\'file\',\'")[1].split("\'")[0] name = streamHTML.split("<title>")[1].split("<")[0] + ".mp3" else: #Modo normal nuevo con nueva url recibida printt(u"[INFO] Modo Genérico") streamHTML = self.__descHTML(self._URL_recibida).replace(" ", "") url = streamHTML.split("\'file\':\'")[1].split("\'")[0] #Modo nomal nuevo ext = "." + url.split(".")[-1] name = streamHTML.split("<title>")[1].split("<")[0] + ext if name: name = formatearNombre(name) return [url, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' streamHTML = self.__descHTML(self._URL_recibida) name = streamHTML.split("<title>")[1].split("<")[0] vID = streamHTML.split("onclick=\"HERRAMIENTAS.playVideo(\'")[1].split("\'")[0] streamJSON = self.__descHTML(self.URL_VCF_JSON_START + vID + self.URL_VLC_JSON_END) playerID = streamJSON.split("name=\\\"playerID\\\" value=\\\"")[1].split("\\")[0] playerKey = streamJSON.split("name=\\\"playerKey\\\" value=\\\"")[1].split("\\")[0] publisherID = streamJSON.split("name=\\\"publisherID\\\" value=\\\"")[1].split("\\")[0] videoID = vID const = "9f8617ac59091bcfd501ae5188e4762ffddb9925" print playerID print playerKey print publisherID print videoID print const data = self.get_data(publisherID, playerID, const, videoID, playerKey)#['renditions'] print data sys.exit() rtmpdata = self.get_data(publisherID, playerID, const, videoID, playerKey)['renditions'] URL = str(rtmpdata[0]['defaultURL']) r = URL.split("&")[0] a = "/".join(r.split("/")[-3:]) C1 = "B:0" C2 = "S:" + "&".join(URL.split("&")[1:]) y = URL.split("&")[1] url = r #print "rtmpdump -r " + r + " -a " + a + " -C " + C1 + " -C " + C2 + " -y " + y + " -o " + name + ".mp4" name += ".mp4" if name: name = formatearNombre(name) return [url, name, "-a", a, "-C", C1, "-C", C2, "-y", y]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' streamHTML = self.__descHTML(self._URL_recibida) if streamHTML.find("&videoId=") != -1: videoID = streamHTML.split("&videoId=")[1].split("\'")[0] printt(u"[INFO] Video ID:", videoID) streamStreams = self.__descHTML(self.URL_STREAMS_START + videoID + self.URL_STREAMS_END) streamStreams = streamStreams.replace(" ", "").replace("\n", "") videos = streamStreams.split("{")[1:] printt(u"[INFO] Se han detectado varios tipos de calidad:") b = 0 for i in videos: printt(u"\t[%4d] %s" % (b, i.split("\"quality\":\"")[1].split("\"")[0])) b += 1 # Presentar menú para elegir vídeo: printt(u"[-->] Introduce el número del tipo vídeo que quieres descargar (Ctrl+C para cancelar): ") while True: try: ID = int(raw_input()) except ValueError: printt(u"[!!!] Parece que no has introducido un número. Prueba otra vez:") continue except KeyboardInterrupt: salir(u"\nBye!") if ID < 0 or ID > len(videos)-1: printt(u"[!!!] No existe el vídeo con número [%4d] Prueba otra vez:" % ID) continue else: break url = videos[ID].split("\"url\":\"")[1].split("\"")[0] ext = "." + url.split("?")[0].split(".")[-1] name = (streamHTML.split("<title>")[1].split("<")[0]).strip() name += ext else: salir(u"[!!!] No se encustra ningún vídeo en la página") if name: name = formatearNombre(name) return [url, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' streamHTML = self.__descHTML(self._URL_recibida) if self._URL_recibida.find("audios/") != -1 or self._URL_recibida.find("audioak/") != -1: printt(u"[INFO] Audio") name = streamHTML.split("<title>")[1].split("<")[0] streamMP3 = streamHTML.split("<a id=\"descargaMp3\"")[1].split(">")[0] url = self.URL_EITB + streamMP3.split("href=\"")[1].split("\"")[0] name += ".mp3" elif self._URL_recibida.find("videos/") != -1 or self._URL_recibida.find("bideoak/") != -1 or self._URL_recibida.find("video/") != -1 : if streamHTML.find("<a id=\"descargaMp4\"") != -1: name = streamHTML.split("<title>")[1].split("<")[0] streamMP4 = streamHTML.split("<a id=\"descargaMp4\"")[1].split(">")[0] url = self.URL_EITB + streamMP4.split("href=\"")[1].split("\"")[0] else: #streamHTML = self.__descHTML(self._URL_recibida) name = self._URL_recibida.split("/")[-1] playerID = streamHTML.split("<param name=\"playerID\" value=\"")[1].split("\"")[0] playerKey = streamHTML.split("<param name=\"playerKey\" value=\"")[1].split("\"")[0] const = "9f8617ac59091bcfd501ae5188e4762ffddb9925" publisherID = "102076681001" videoID = self._URL_recibida.split("/")[-1] rtmpdata = self.get_data(publisherID, playerID, const, videoID, playerKey)['renditions'] URL = str(rtmpdata[0]['defaultURL']) r = URL.split("&")[0] a = "/".join(r.split("/")[-3:]) C1 = "B:0" C2 = "S:" + "&".join(URL.split("&")[1:]) y = URL.split("&")[1] url = r #print "rtmpdump -r " + r + " -a " + a + " -C " + C1 + " -C " + C2 + " -y " + y + " -o " + name + ".mp4" name += ".mp4" else: salir(u"[!!!] No se reconoce el tipo de contenido") if name: name = formatearNombre(name) return [url, name, "-a", a, "-C", C1, "-C", C2, "-y", y]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' # Comprobar si es de radio primero: firstHtmlCheck = self.__descHTML(self._URL_recibida) separador = "this.element.jPlayer(\"setFile\", \"" if firstHtmlCheck.find(separador) != -1 and firstHtmlCheck.find(".mp3") != -1: url, name = self.__rtvvRadio(firstHtmlCheck, separador) if name: name = formatearNombre(name) return [url, name] # FIN Ràdio # Ahora Vídeos if self._URL_recibida.find("rtvv.es/va/noualacarta") != -1: printt(u"[INFO] A la Carta") xmlURL = self.URL_RTVV + self.__descHTML(self.__getHtmlUrlFromAlacarta()).split("file: \"")[1].split("\"")[0] else: printt(u"[INFO] Vídeo Normal") xmlURL = self.URL_RTVV + self.__descHTML(self._URL_recibida).split("file: \"")[1].split("\"")[0] printt(u"[INFO] URL de XML:", xmlURL) xmlStream = self.__descHTML(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 if name: name = formatearNombre(name) return [url, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del audio a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. ''' # 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) audioID = self._URL_recibida.split('/')[-1] if audioID == "": audioID = self._URL_recibida.split('/')[-2] elif audioID.find(".shtml") != -1 or audioID.find(".html") != -1 or \ audioID.find(".html") != -1: audioID = audioID.split('.')[0] printt(u"[INFO] ID del Audio :", audioID) xmlURL = "http://www.rtve.es/swf/data/es/audios/audio/" + audioID[-1] \ + "/" + audioID[-2] + "/" + audioID[-3] \ + "/" + audioID[-4] + "/" + audioID + ".xml" printt(u"[INFO] Url de xml :", xmlURL) #print "[+] Procesando Descarga" sourceXML = self.__descXML(xmlURL) # Ahora la url final del audio puede estar entre las etiquetas <file></file> # o puede que tengamos que dar un rodeo if sourceXML.find("<file>") != -1 and sourceXML.find("</file>"): # Contiene la URL urlAudio = sourceXML.split("<file>")[1].split("</file>")[0] elif sourceXML.find("assetDataId::") != -1: # Dar el rodeo idAsset = sourceXML.split("assetDataId::")[1].split("\"/>")[0] printt(u"[INFO] Nuevo ID Asset :", idAsset) urlXMLasset = "www.rtve.es/scd/CONTENTS/ASSET_DATA_AUDIO/" + idAsset[-1] \ + "/" + idAsset[-2] + "/" + idAsset[-3] \ + "/" + idAsset[-4] + "/ASSET_DATA_AUDIO-" + idAsset + ".xml" printt(u"[INFO] XML URL Asset :", urlXMLasset) sourceAssetXML = self.__descXML(urlXMLasset) urlInSourceAssetXML = sourceAssetXML.split("defaultLocation=\"")[1].split("\"")[0] #print "urllInSourceAssetXML =", urlInSourceAssetXML urlAudio = "http://www.rtve.es/resources/TE_NGVA/mp3/" + urlInSourceAssetXML.split("/mp3/")[1] else: salir(u"[!!!] No se encuentró la URL del Audio") # Nombre con el que se guardará la descarga: extension = '.' + urlAudio.split('.')[-1] name = sourceXML.split("<name>")[1].split("</name")[0] + extension name = formatearNombre(name) return [urlAudio, name]
def procesarDescarga(self): """ Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). """ streamHTML = self.__descHTML(self._URL_recibida) # .replace(" ", "") if streamHTML.find("contentArray[") != -1: printt(u"[INFO] Se han detectado varios vídeos en la página:") # Deleimitar los bloques de vídeos: bloques = streamHTML.split("contentArray[")[1:] # Delimitar en un diccionario los videos: videosSucio = {} for i in bloques: videosSucio[int(i.split("]")[0])] = i.split("=")[1].split(");")[0] # Mostrar el menú en pantalla: for i in videosSucio: printt("\t[%4d] %s" % (i, videosSucio[i].split("'")[1])) # Presentar menú para elegir vídeo: printt(u"[-->] Introduce el número del vídeo que quieres descargar (Ctrl+C para cancelar): ") while True: try: ID = int(raw_input()) except ValueError: printt(u"[!!!] Parece que no has introducido un número. Prueba otra vez:") continue except KeyboardInterrupt: salir(u"\nBye!") if ID < 0 or ID > len(videosSucio) - 1: printt(u"[!!!] No existe el vídeo con número [%4d] Prueba otra vez:" % ID) continue else: break # Consguir el vídeo según el ID: url = videosSucio[ID].split("'")[7] ext = "." + url.split(".")[-1] name = videosSucio[ID].split("'")[1] + ext else: salir(u"[!!!] ERROR: No se han econtrado vídeos en la página") if name: name = formatearNombre(name) return [url, name]
def procesarDescarga(self): streamHTML = self.__descHTML(self._URL_recibida) name = streamHTML.split("<title>")[1].split("<")[0] streamHTML = streamHTML.replace("%3A", ":").replace("%2F", "/").replace(" ", "").replace("\t", "") clip = streamHTML.split("clip:")[1].split("url:\'")[1].split("\'")[0].replace("mp4:", "") server = streamHTML.split("netConnectionUrl:\'")[1].split("\'")[0] url = server + clip name += "." + clip.split(".")[-1] if name: name = formatearNombre(name) return [url, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' # En principio parece que tenemos 4 tipos de vídeos diferentes: A la carta video, a la carta auido, a 3cat24 # 3cat24.cat: if self._URL_recibida.find("3cat24.cat/video/") != -1: printt(u"[INFO] Vídeos de 3cat24") url, name = self.__3cat24() elif self._URL_recibida.find("3cat24.cat/") != -1: # de 3cat24 pero no directamente el vídeo printt(u"[INFO] 3cat24 (otros vídeos)") streamHTML = self.__descHTML(self._URL_recibida) videoID = streamHTML.split("flashvars.videoid =")[1].split(";")[0].strip() url, name = self.__3cat24(nuevoID=videoID) elif self._URL_recibida.find("tv3.cat/videos") != -1: # Gracis a Carlesm ;) printt(u"[INFO] Vídeos de TV3") videoID = self._URL_recibida.split("/")[-2] if not videoID.isdigit(): videoID = self._URL_recibida.split("/")[-1] url, name = self.__3cat24(nuevoID=videoID) elif self._URL_recibida.find("tv3.cat/3alacarta") != -1: # Sirve la misma función de 3cat24 (con nuevoID) printt(u"[INFO] Vídeos de 3alacarta") videoID = self._URL_recibida.split("/")[-1] url, name = self.__3cat24(nuevoID=videoID) elif self._URL_recibida.find("3xl.cat/videos") != -1: printt(u"[INFO] Vídeos de 3XL") videoID = self._URL_recibida.split("/")[-2] url, name = self.__3cat24(nuevoID=videoID) elif self._URL_recibida.find("catradio.cat") != -1: printt(u"[INFO] Audios de catradio") url, name = self.__catradio() if name: name = formatearNombre(name) return [url, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. ''' streamHTML = self.__descHTML(self._URL_recibida) streamVids = streamHTML.split("<iframe src=\"http://www.telecinco.es/")[1:] urls = [self.URL_TELECINCO + i.split("\"")[0] for i in streamVids] url2down = [] name = [] for url in urls: tv5 = Telecinco(url) tmp_url, tmp_name = tv5.procesarDescarga() url2down.append(tmp_url) name.append(tmp_url.split(".mp4")[0].split("/")[-1] + ".mp4") if url2down == list and len(url2down) == 1: url2down = url2down[0] if type(name) == list: for i in name: b = formatearNombre(i) name[name.index(i)] = b if len(name) == 1: name = name[0] else: name = formatearNombre(name) return [url2down, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' streamHTML = self.__descHTML(self._URL_recibida) if self._URL_recibida.find("detail.php?id") != -1: # Aun no es el vídeo if streamHTML.find("ShowPreviewMM(\'") != -1: url = streamHTML.split("ShowPreviewMM(\'")[1].split("\'")[0] name = streamHTML.split("); return false;\">")[1].split("<")[0] elif streamHTML.find("onClick=\"ShowPreviewMM(") != -1: printt(u"[INFO] Buscando ID del vídeo") nuevoID = streamHTML.split("onClick=\"ShowPreviewMM(")[1].split(")")[0] printt(u"[INFO] Vídeo ID:", nuevoID) name = streamHTML.split("); return false;\">")[1].split("<")[0] url, name = self.__paginaDvideo(streamHTML, nuevoID, name) elif streamHTML.find("onClick=\"ShowPreviewMM(") != -1: pass else: salir(u"[!!!] No se reconoce el tipo de contenido") elif self._URL_recibida.find("mm.php?id") != -1: url, name = self.__paginaDvideo(streamHTML) elif streamHTML.find("youtube"): salir(u"[!!!] No se reconoce el tipo de contenido.\nPuede que el vídeo sea de YouTube??") else: salir(u"[!!!] No se reconoce el tipo de contenido") url = url.replace("http://", "mms://") ext = "." + url.split(".")[-1] if name.find(ext) == -1: name += ext.lower() if name: name = formatearNombre(name) return [url, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. ''' streamHTML = self.__descHTML(self._URL_recibida) if streamHTML.find("http://level3/") != -1: # Método antiguo printt(u"[INFO] Método antiguo (mitele)") videoID = streamHTML.split("\'http://level3/")[1].split(".")[0] videoEXT = streamHTML.split("\'http://level3/")[1].split("\'")[0].split(".")[1] videoEXT = "." + videoEXT url2down = self.URL_DESCARGA_TELECINCO + videoID[-1] + "/" + videoID[-2] + "/" + videoID + videoEXT name = None elif streamHTML.find(self.string2split4id[0]) != -1: # Método nuevo newID = streamHTML.split(self.string2split4id[0])[1].split(self.string2split4id[1])[0].split(".")[0] printt(u"[INFO] Nuevo Video ID:", newID) ask4token = self.URL_ASK4TOKEN + newID[-3:] + "/" + newID + ".mp4" printt(u"[+] Pidiendo nuevo token") url2down = self.__descHTML(ask4token) name = streamHTML.split("var title = \'")[1].split("\'")[0] + ".mp4" elif self._URL_recibida.find("videoURL="): # Forma con el ID en la URL (nueva??) videoID = self._URL_recibida.split("videoURL=")[1] ask4token = self.URL_ASK4TOKEN + videoID[-3:] + "/" + videoID + ".mp4" printt(u"[+] Pidiendo nuevo token") url2down = self.__descHTML(ask4token) # Obtner nombre: xmlURL = "http://estaticos.telecinco.es/xml/Video/Video_" + videoID + ".xml" streamXML = self.__descHTML(xmlURL) name = streamXML.split("<![CDATA[")[1].split("]")[0] + ".mp4" else: salir(u"[!!!] No se encuentra URL de descarga") if name != None: name = formatearNombre(name) return [url2down, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' # Esta es realmente la parte importante, la que procesa lo necesario para obtener la url # final de descarga del vídeo. name = None # Procesar el nombre final del vídeos (para guardar en disco) if name: name = formatearNombre(name) return [url, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' streamHTML = self.__descHTML(self._URL_recibida) if self._URL_recibida.find("audios/") != -1 or self._URL_recibida.find("audioak/") != -1: printt(u"[INFO] Audio") name = streamHTML.split("<title>")[1].split("<")[0] streamMP3 = streamHTML.split("<a id=\"descargaMp3\"")[1].split(">")[0] url = self.URL_EITB + streamMP3.split("href=\"")[1].split("\"")[0] name += ".mp3" elif self._URL_recibida.find("videos/") != -1 or self._URL_recibida.find("bideoak/") != -1: printt(u"[INFO] Vídeo de %s" % (self._URL_recibida.split("/")[4])) name = streamHTML.split("<title>")[1].split("<")[0] streamMP4 = streamHTML.split("<a id=\"descargaMp4\"")[1].split(">")[0] url = self.URL_EITB + streamMP4.split("href=\"")[1].split("\"")[0] name += ".mp4" else: salir(u"[!!!] No se reconoce el tipo de contenido") if name: name = formatearNombre(name) return [url, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' if self._URL_recibida.find("tv-a-la-carta/") != -1: printt(u"[INFO] TV a la carta") streamHTML = self.__descHTML(self._URL_recibida).replace(" ", "") urlFLV = streamHTML.split("crea_video_hd(\"")[1].split("\"")[0] streamFLV = self.__descHTML(urlFLV) url = "http://" + streamFLV.split("http://")[1] ext = "." + url.split(".")[-1].split("?")[0] name = streamHTML.split("<title>")[1].split("<")[0] + ext elif self._URL_recibida.find("radio-a-la-carta/") != -1: printt(u"[INFO] Radio A la Carta") streamHTML = self.__descHTML(self._URL_recibida).replace(" ", "") url = streamHTML.split("s1.addVariable(\'file\',\'")[1].split("\'")[0] name = streamHTML.split("<title>")[1].split("<")[0] + ".mp3" else: salir(u"[!!!] No se reconoce el tipo de contenido") if name: name = formatearNombre(name) return [url, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' # Diferenciar entre videos a la carta y videos de agalegainfo streamHTML = self.__descHTML(self._URL_recibida).replace(" ", "").replace("\t", "").replace("\n", "") if self._URL_recibida.find("a-carta") != -1: printt(u"[INFO] Modo \"A Carta\"") else: printt(u"[INFO] Vídeo Normal (No \"A 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] url = r if name: name = formatearNombre(name) return [url, name, "-y", y, "-s", s, "-a", a]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. ''' # 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_recibida.split('/')[-1] if videoID == "": videoID = self._URL_recibida.split('/')[-2] elif videoID.find(".shtml") != -1 or videoID.find(".html") != -1 or \ videoID.find(".html") != -1: videoID = videoID.split('.')[0] # Añadido para vídeos nuevos (periodo de prueba): sourceHTML = self.__descHTML(self._URL_recibida) 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 ######################################################## printt(u"[INFO] ID del Vídeo :", videoID) #Primero probar nuevo método: url = self.__ztnr(videoID) #print "URL:",url if url != "http://www.rtve.es/resources/.mp4" or url != url != "http://www.rtve.es/resources/.flv": name = sourceHTML.split("<title>")[1].split("</")[0] + ".mp4" name = formatearNombre(name) return [url, name] xmlURL = "www.rtve.es/swf/data/es/videos/video/" + videoID[-1] \ + "/" + videoID[-2] + "/" + videoID[-3] \ + "/" + videoID[-4] + "/" + videoID + ".xml" printt(u"[INFO] Url de xml :", xmlURL) # Este bloque o debería de entrar si funciona el bloque de prueba: sourceXML = self.__descXML(xmlURL) if sourceXML == -1: # Comprobar si existe (No es tve a la carta) sourceHTML = self.__descHTML(self._URL_recibida) if sourceHTML.find("<div id=\"video") != -1: id = sourceHTML.split("<div id=\"video")[1].split("\"")[0] elif sourceHTML.find("<div id=\"vid") != -1: id = sourceHTML.split("<div id=\"vid")[1].split("\"")[0] else: salir(u"[!] ERROR al generear el nuevo id") xmlURL = "www.rtve.es/swf/data/es/videos/video/" + id[-1] \ + "/" + id[-2] + "/" + id[-3] \ + "/" + id[-4] + "/" + id + ".xml" sourceXML = self.__descXML(xmlURL) printt(u"[INFO] Nuevo vídeo ID:", id) printt(u"[INFO] Nuevo url de xml:", xmlURL) # Ahora la url final del video puede estar entre las etiquetas <file></file> # o puede que tengamos que dar un rodeo if sourceXML.find("<file>") != -1 and sourceXML.find("</file>") != -1: # Contiene la URL urlVideo = sourceXML.split("<file>")[1].split("</file>")[0] elif sourceXML.find("assetDataId::") != -1: # Dar el rodeo idAsset = sourceXML.split("assetDataId::")[1].split("\"/>")[0] urlXMLasset = "www.rtve.es/scd/CONTENTS/ASSET_DATA_VIDEO/" + idAsset[-1] \ + "/" + idAsset[-2] + "/" + idAsset[-3] \ + "/" + idAsset[-4] + "/ASSET_DATA_VIDEO-" + idAsset + ".xml" sourceAssetXML = self.__descXML(urlXMLasset) try: urlInSourceAssetXML = sourceAssetXML.split("defaultLocation=\"")[1].split("\"")[0] except AttributeError: urlInSourceAssetXML = "retrochapuza" url = self.__getUrlIpad() if url == "ERROR": # Buscar vídeo en A la Carta try: self._URL_recibida = sourceXML.split("<url>")[1].split("<")[0] except: printt(u"[!!!] No he encontrado el vídeo :(") salir(u"") url = self.__getUrlIpad() sourceHTML = self.__descHTML(url) urlVideo = "http://www.rtve.es" + sourceHTML.split(".mp4")[0].split("urlContent=")[1] + ".mp4" # Probar esta url (obtener nueva url, necesario para el script!!): u = urllib2.urlopen(urlVideo) meta = u.info() file_size = int(meta.getheaders("Content-Length")[0]) if file_size == 0: urlVideo = meta.getheaders("Location")[0] u.close() #print "urllInSourceAssetXML =", urlInSourceAssetXML # Es flv o mp4? if urlInSourceAssetXML.find("/flv/") != -1: urlVideo = "http://www.rtve.es/resources/TE_NGVA/flv/" \ + urlInSourceAssetXML.split("/flv/")[1] elif urlInSourceAssetXML.find("/mp4/") != -1: urlVideo = "http://www.rtve.es/resources/TE_NGVA/mp4/" \ + urlInSourceAssetXML.split("/mp4/")[1] elif urlInSourceAssetXML == "retrochapuza": pass else: salir(u"Vídeo no encontrado") else: salir(u"No se encuentra la URL del vídeo") # Nombre con el que se guardará la descarga: extension = '.' + urlVideo.split('.')[-1] name = sourceXML.split("<name>")[1].split("</name")[0] + extension name = formatearNombre(name) return [urlVideo, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. ''' # 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_recibida.split('/')[-1] if videoID == "": videoID = self._URL_recibida.split('/')[-2] elif videoID.find(".shtml") != -1 or videoID.find(".html") != -1 or \ videoID.find(".html") != -1: videoID = videoID.split('.')[0] printt(u"[INFO] ID del Vídeo :", videoID) xmlURL = "www.rtve.es/swf/data/es/videos/video/" + videoID[-1] \ + "/" + videoID[-2] + "/" + videoID[-3] \ + "/" + videoID[-4] + "/" + videoID + ".xml" printt(u"[INFO] Url de xml :", xmlURL) #print "[+] Procesando Descarga" sourceXML = self.__descXML(xmlURL) if sourceXML == -1: # Comprobar si existe (No es tve a la carta) sourceHTML = self.__descHTML(self._URL_recibida) if sourceHTML.find("<div id=\"video") != -1: id = sourceHTML.split("<div id=\"video")[1].split("\"")[0] elif sourceHTML.find("<div id=\"vid") != -1: id = sourceHTML.split("<div id=\"vid")[1].split("\"")[0] else: salir(u"[!] ERROR al generear el nuevo id") xmlURL = "www.rtve.es/swf/data/es/videos/video/" + id[-1] \ + "/" + id[-2] + "/" + id[-3] \ + "/" + id[-4] + "/" + id + ".xml" sourceXML = self.__descXML(xmlURL) printt(u"[INFO] Nuevo vídeo ID:", id) printt(u"[INFO] Nuevo url de xml:", xmlURL) # Ahora la url final del video puede estar entre las etiquetas <file></file> # o puede que tengamos que dar un rodeo if sourceXML.find("<file>") != -1 and sourceXML.find("</file>"): # Contiene la URL urlVideo = sourceXML.split("<file>")[1].split("</file>")[0] elif sourceXML.find("assetDataId::") != -1: # Dar el rodeo idAsset = sourceXML.split("assetDataId::")[1].split("\"/>")[0] urlXMLasset = "www.rtve.es/scd/CONTENTS/ASSET_DATA_VIDEO/" + idAsset[-1] \ + "/" + idAsset[-2] + "/" + idAsset[-3] \ + "/" + idAsset[-4] + "/ASSET_DATA_VIDEO-" + idAsset + ".xml" sourceAssetXML = self.__descXML(urlXMLasset) urlInSourceAssetXML = sourceAssetXML.split("defaultLocation=\"")[1].split("\"")[0] #print "urllInSourceAssetXML =", urlInSourceAssetXML # Es flv o mp4? if urlInSourceAssetXML.find("/flv/") != -1: urlVideo = "http://www.rtve.es/resources/TE_NGVA/flv/" \ + urlInSourceAssetXML.split("/flv/")[1] elif urlInSourceAssetXML.find("/mp4/") != -1: urlVideo = "http://www.rtve.es/resources/TE_NGVA/mp4/" \ + urlInSourceAssetXML.split("/mp4/")[1] else: salir(u"Vídeo no encontrado") else: salir(u"No se encuentra la URL del vídeo") # Nombre con el que se guardará la descarga: extension = '.' + urlVideo.split('.')[-1] name = sourceXML.split("<name>")[1].split("</name")[0] + extension name = formatearNombre(name) return [urlVideo, name]