def __modoSalonNuevo(self, streamXML):
'''Nuevos vídeos con extensión .m4v'''
printt(u"[INFO] Nuevos vídeos en formato f4v")
if streamXML.find("000.f4v"):
url2down1 = self.URL_DE_DESCARGA + streamXML.split("<archivo><![CDATA[")[1].split("]")[0]
else:
url2down1 = self.URL_DE_DESCARGA + \
streamXML.split("<archivo><![CDATA[")[1].split("001.f4v]]></archivo>")[0] + "000.f4v"
try: # Descargar entero
urllib2.urlopen(url2down1)
url2down = url2down1
name = streamXML.split("<nombre><![CDATA[")[1].split("]]>")[0] + ".f4v"
except urllib2.HTTPError: # Descargar por partes:
printt(u"[!!!] No se puede descargar el vídeo en un archivo (000.m4v)")
printt(u"[INFO] El vídeo se descargará por partes")
parts = re.findall("\<archivo\>\<\!\[CDATA\[.*\.f4v\]\]\>\<\/archivo\>", streamXML)
if parts:
name1 = streamXML.split("<nombre><![CDATA[")[1].split("]]>")[0]
url2down = []
name = []
for i in parts:
url2down.append(self.URL_DE_DESCARGA + i.split("<archivo><![CDATA[")[1].split("]]></archivo>")[0])
name.append(name1 + "_" + i.split("]")[0].split("/")[-1])
else:
salir(u"[!!!] ERROR: No se encuentran las partes del vídeo")
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 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).
'''
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 name:
name = formatearNombre(name)
return [url, name]
def __playCuatro(self):
'''return url y name pertenecientes a los vídeos de Play Cuatro'''
streamHTML = self.__descHTML(self._URL_recibida).replace(" ", "")
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("playerPageURL:\'")[1].split("\'")[0].split("/")[-1] + 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).
'''
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).
'''
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)
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).
'''
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 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 __3cat24(self, nuevoID=None):
'''
Procesa los vídeos de 3cat24 si no se le pasa un nuevo ID.
Si se le apsa ID puede que sea de 3cat24 o un vídeo a alacarta (si el ID es de alacarta)
'''
id = self._URL_recibida.split("/")[-1] if nuevoID is None else nuevoID
streamHTML = self.__descHTML(self.URL_TOKEN_START + id + self.URL_TOKEN_END)
if streamHTML.find("<error>") != -1:
salir(u"[!!!] Error al capturar el vídeo")
name = streamHTML.split("<media videoname=\"")[1].split("\"")[0] + ".mp4"
url = "rtmp://" + streamHTML.split("rtmp://")[1].split("<")[0]
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 __aGalegaInfo(self):
"""
return url (mms) y nombre de los vídeos de A galega info de crtgv
"""
# Creo que lo más recomendable es pedir el código javascript
# de las WWW de debajo del vídeo
printt(u"[INFO] A galega info")
printt(u'El vídeo que intentas descargar pertenece a la sección "A galega Info".')
printt(u"Para asegurar que se baja el vídeo deseado, haz click con el ratón a las WWW")
printt(u"que aparecen debajo del vídeo (a la izquierda).")
printt(u"Copia todo el contenido y pégalo aquí")
try:
javascript = raw_input("Pegua aquí: ")
except KeyboardInterrupt, e:
salir(u"\nKeyboardInterrupt: Ciao!")
def __getHtmlUrlFromAlacarta(self):
'''
Dada una URL de A la Carta de RTVV devuelve su URL normal
'''
id = self._URL_recibida.split("/")[-1]
if id.find("#") == -1 or self._URL_recibida.endswith("rtvv.es/va/noualacarta/") or \
self._URL_recibida.endswith("rtvv.es/va/noualacarta"):
salir(u"[ERROR] Página general de \"A la Carta\". Introducir url específica")
id = id.replace("#", "")
printt(u"[INFO] ID:", id)
frameIDsplit = "<li class=\"scr-item contentId_" + id + "\">"
printt(u"[INFO] Separador:", frameIDsplit)
frameID = self.__descHTML(self._URL_recibida).split(frameIDsplit)[1].split("</li>")[0]
htmlURL = self.URL_RTVV + frameID.split("<a href=\"")[1].split("\"")[0]
return htmlURL
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 descargarVideo(self):
'''
Procesa la descarga del vídeo llamanda a la función download de pyaxel para la mayoría de los
vídeos en GNU/Linux y Mac OS X. Para sistemas win32, se llama a descargarVideoWindows() y tanto para
GNU/Linux como para Mac OS X y Windows cuando el protocolo es mms:// se utiliza libmms (por ahora Windows no)
y cuando el protocolo es rtmp:// se utiliza el binario rtmpdump que el cliente debe tener instalado.
'''
# Utilizar el binario de rtmpdump si el protocolo es rtmp://
if type(self._URL) != list and self._URL.startswith("rtmp://"):
printt(u"")
printt(u"DESCARGAR:")
printt(u"----------------------------------------------------------------")
printt(u"[ URL DE DESCARGA FINAL ]", self._URL)
printt(u"[ DESTINO ]", self.outputName)
printt(u"\n[INFO] Presiona \"Ctrl + C\" para cancelar\n")
rtmpdump = "rtmpdump -o \"" + self.outputName + "\" -r \"" + self._URL + "\""
rtmpdump_resume = "rtmpdump --resume -o \"" + self.outputName + "\" -r \"" + self._URL + "\""
rtmpdump_win = "rtmpdump.exe -o \"" + self.outputName + "\" -r \"" + self._URL + "\""
rtmpdump_resume_win = "rtmpdump.exe --resume -o \"" + self.outputName + "\" -r \"" + self._URL + "\""
try:
if path.isfile(self.outputName):
printt(u"Se ha encontrado una descarga parcial anterior, se continúa...\n")
printt(u"\nLanzando rtmpdump...\n")
if sys.platform == "win32":
system(rtmpdump_resume_win)
else:
system(rtmpdump_resume)
else:
printt(u"\nLanzando rtmpdump...\n")
if sys.platform == "win32":
system(rtmpdump_win)
else:
system(rtmpdump)
except OSError, e:
printt(u"[!!!] ERROR. No se encuenta rtmpdump:", e)
except KeyboardInterrupt:
salir(u"Bye!")
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 descargar(self):
'''
Recoge una url la descarga y lo devuelve
Pensado para descargar streams HTML y XML
'''
if self._URL.find("http://") == -1:
self._URL = "http://" + self._URL
try:
# TVG necesita headers:
if self._URL.find("crtvg.es/") != -1:
request = urllib2.Request(self._URL, None, self.std_headers)
f = urllib2.urlopen(request)
stream = f.read()
f.close()
return stream
elif self._URL == PdtVersion.URL_VERSION: # Si lo que se descarga es VERSION (convertir a utf-8)
f = urllib2.urlopen(self._URL)
Reader = codecs.getreader("utf-8")
fh = Reader(f)
stream = fh.read()
return stream
else:
f = urllib2.urlopen(self._URL)
stream = f.read()
f.close()
return stream
except Exception, e:
if self._URL.find("rtve.es") != -1: # No salir (para identificar si es a la carta o no)
return -1
elif self._URL == PdtVersion.URL_VERSION:
return -1
else:
printt(u"[!!!] ERROR al descargar:", e)
salir(u"")
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 __modoSalon(self, streamHTML):
printt(u"[INFO] Modo Salón")
if streamHTML.find("so.addVariable(\"xml\"") != -1:
streamXML = \
self.__descXML(self.URL_DE_ANTENA3 + streamHTML.split("so.addVariable(\"xml\",\"")[1].split("\"")[0])
elif streamHTML.find("player_capitulo.xml='") != -1:
streamXML = \
self.__descXML(self.URL_DE_ANTENA3 + streamHTML.split("player_capitulo.xml='")[1].split("'")[0])
else:
salir(u"[!!!] ERROR No se encuentra el XML")
# Comprobar aquí si se puede descargar 000.mp4:
if streamXML.find(".mp4") != -1:
url2down1 = self.URL_DE_DESCARGA + \
streamXML.split("<archivo><![CDATA[")[1].split("001.mp4]]></archivo>")[0] + "000.mp4"
elif streamXML.find(".f4v") != -1:
[url2down, name] = self.__modoSalonNuevo(streamXML)
return [url2down, name]
else:
salir(u"[!!!] ERROR: No se encuentra vídeos mp4 o f4v")
try: # Descargar entero
urllib2.urlopen(url2down1)
url2down = url2down1
name = streamXML.split("<nombre><![CDATA[")[1].split("]]>")[0] + ".mp4"
except urllib2.HTTPError: # Descargar por partes:
printt(u"[!!!] No se puede descargar el vídeo en un archivo (000.mp4)")
printt(u"[INFO] El vídeo se descargará por partes")
parts = re.findall("\<archivo\>\<\!\[CDATA\[.*\.mp4\]\]\>\<\/archivo\>", streamXML)
if parts:
name1 = streamXML.split("<nombre><![CDATA[")[1].split("]]>")[0]
url2down = []
name = []
for i in parts:
url2down.append(self.URL_DE_DESCARGA + i.split("<archivo><![CDATA[")[1].split("]]></archivo>")[0])
name.append(name1 + "_" + i.split("]")[0].split("/")[-1])
else:
salir(u"[!!!] ERROR: No se encuentran las partes del vídeo")
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 streamHTML.find("_urlVideo=") != -1: # Vídeo en un sola parte
codURL = streamHTML.split("_urlVideo=")[1].split("&")[0]
url = self.__showURL(codURL)
url = url.replace(" ", "%20")
#print url
url = url.replace("/mp4:", "/")
url = url.replace("/flv:", "/")
url = url.replace("/_definst_/", "/")
url = url.replace("/manifest.f4m", "")
url = url.replace("http://lasextavod-f.akamaihd.net/z/", "rtmp://vod.lasexta.com/vod/")
name = streamHTML.split("<title>")[1].split("<")[0]
if url.find("?start=") != -1: ext="." + url.split("?start=")[0].split(".")[-1]
else: ext= "." + url.split(".")[-1]
name += ext
elif streamHTML.find("_url_list=") != -1: # Vídeo en varias partes
name1 = streamHTML.split("<title>")[1].split("<")[0]
codURL1 = streamHTML.split("_url_list=")[1].split("&")[0]
url1 = self.__showURL(codURL1)
streamHTML = self.__descHTML(url1)
codURL2 = []
urls = streamHTML.strip().split("<title>")[1:]
for i in urls:
if i.find("<urlHD>"):
opc = None
while (opc != 's' and opc != 'n'):
opc = raw_input("[???] Se descarga en HD. Prefieres SD (s/n): ")
opc = False if opc == 's' else True
break
for i in urls:
#name2.append(i.split("<")[0])
if i.find("<urlHD>") != -1:
if opc:
codURL2.append(i.split("<urlHD>")[1].split("<")[0])
else:
codURL2.append(i.split("<url>")[1].split("<")[0])
else:
codURL2.append(i.split("<url>")[1].split("<")[0])
url = []
name = []
b = 1
for i in codURL2:
#if i.find("rtmp://") != -1:
# tmp = i
#else:
# tmp = self.__showURL(i)
tmp = i
try:
tmp = self.__showURL(i)
except:
pass
tmp = tmp.replace("/mp4:", "/")
tmp = tmp.replace("/flv:", "/")
tmp = tmp.replace("/_definst_/", "/")
tmp = tmp.replace("/manifest.f4m", "")
tmp = tmp.replace("http://lasextavod-f.akamaihd.net/z/", "rtmp://vod.lasexta.com/vod/")
url.append(tmp)
if tmp.find("?start=") != -1: ext="." + tmp.split("?start=")[0].split(".")[-1]
else: ext= "." + tmp.split(".")[-1]
name.append(name1 + "_part0" + str(b) + ext)
b += 1
del b
elif streamHTML.find("_id_list=") != -1:
id = streamHTML.split("_id_list=")[1].split("&")[0]
sPlayList = self.__descHTML(self.URL_PLAYLIST + id)
partes = sPlayList.split("<video>")[1:]
url = []
name = []
for i in partes:
tmpURL = i.split("<url>")[1].split("<")[0]
ext = "." + tmpURL.split(".")[-1]
tmpURL = tmpURL.replace("/mp4:", "/")
tmpURL = tmpURL.replace("/flv:", "/")
tmpURL = tmpURL.replace("/_definst_/", "/")
tmpURL = tmpURL.replace("/manifest.f4m", "")
tmpURL = tmpURL.replace("http://lasextavod-f.akamaihd.net/z/", "rtmp://vod.lasexta.com/vod/")
url.append(tmpURL)
name.append(i.split("<title>")[1].split("<")[0].capitalize() + ext)
else:
salir(u"[!!!] ERROR: No se ha encontrado el vídeo")
# Cambiar a HTTP y ver si existe el vídeo:
# En listas se presupone que si funciona la primera parte funcionan todas..
tmp = url[0] if type(url) is list else url
tmp = tmp.replace("rtmp://vod.lasexta.com/vod/", "http://descarga.lasexta.com/")
try:
urllib2.urlopen(tmp)
except urllib2.HTTPError, e:
pass
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]
def descargarVideoWindows(self, nombre=None):
'''
Procesa la descarga del vídeo llamanda a la función download de pyaxel para la mayoría de los
vídeos en GNU/Linux y Mac OS X. Para sistemas win32, se llama a descargarVideoWindows() y tanto para
GNU/Linux como para Mac OS X y Windows cuando el protocolo es mms:// se utiliza libmms (por ahora Windows no)
y cuando el protocolo es rtmp:// se utiliza el binario rtmpdump que el user debe tener instalado.
'''
url = self._URL
name = nombre if nombre != None else self._URL.split('/')[-1]
printt(u"")
printt(u"DESCARGAR:")
printt(u"----------------------------------------------------------------")
if type(self._URL) == list:
b=1
for i in self._URL:
printt(u"[ URL DE DESCARGA FINAL ] [Parte %d] %s" % (b, i))
b += 1
else:
printt(u"[ URL DE DESCARGA FINAL ]", self._URL)
printt(u"[INFO] Presiona \"Ctrl + C\" para cancelar")
printt(u"")
def estadodescarga(bloque, tamano_bloque, tamano_total):
'''
función reporthook que representa en pantalla información mientras
se realiza la descarga
'''
# En Megas
try:
cant_descargada = ((bloque * tamano_bloque) / 1024.00) / 1024.00
tamano_total = (tamano_total / 1024.00) / 1024.00
porcentaje = cant_descargada / (tamano_total / 100.00)
if porcentaje > 100.00:
porcentaje = 100.00
except ZeroDivisionError:
pass
#print "[DEBUG] Error de divisiñon entre cero"
# TODO: Agregar velocidad de descarga al progreso
sys.stdout.write("\r[Descargando]: [ %.2f MiB / %.2f MiB ]\t\t[ %.1f%% ]" \
% (cant_descargada, tamano_total, porcentaje))
#######
if type(self._URL) == list:
printt(u"[?] Quieres descargar todas las partes? [s/n]:")
opc = ""
while opc != "s" and opc != "n":
opc = raw_input()
if opc is not "s" or opc is not "n":
printt(u"[!!!] [s/n]")
if opc is "s":
for i in range(0, len(self._URL)):
printt(u"[Descargando %d parte]" % (int(i) + 1))
printt(u"[Destino]", name[i])
try:
urllib.urlretrieve(url[i], name[i], reporthook=estadodescarga)
print ""
#except KeyboardInterrupt:
# sys.exit("\nCiao!")
except:
pass
print "\n"
elif opc is "n":
printt(u"\n[?] Qué partes quieres descargar?")
printt(u"[INFO] Puedes introducir varias partes separadas por comas")
ERROR = True
while ERROR is True:
ERROR = False
printt(u"[INFO] Partes:")
b = 1
for i in range(0, len(self._URL)):
printt(u"[Parte %s] %s" % (str(b), self._URL[i]))
b += 1
del b
printt(u"[?] --> ")
partes = raw_input()
partes = partes.split(",")
for i in partes:
if not i.isdigit():
printt(u"[!!!] ERROR. No se reconoce la parte \"%s\"" % i)
ERROR = True
break
if int(i) < 1 or int(i) > len(self._URL):
printt(u"[!!!] ERROR. La parte \"%s\" no existe" % int(i))
ERROR = True
break
printt(u"[OK] Se descargarán las partes")
for i in partes:
printt(u"[Descargando %d parte]" % (int(i)))
printt(u"[Destino]", name[int(i)-1])
try:
urllib.urlretrieve(url[int(i)-1], name[int(i)-1], reporthook=estadodescarga)
print ""
#except KeyboardInterrupt:
# sys.exit("\nCiao!")
except:
pass
print "\n"
else:
try:
printt(u"[Destino]", name)
urllib.urlretrieve(url, name, reporthook=estadodescarga)
print ""
except KeyboardInterrupt:
salir("\nCiao!")
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("_urlVideo=") != -1: # Vídeo en un sola parte
codURL = streamHTML.split("_urlVideo=")[1].split("&")[0]
url = self.__showURL(codURL)
name = streamHTML.split("<title>")[1].split("<")[0]
if url.find("?start=") != -1: ext="." + url.split("?start=")[0].split(".")[-1]
else: ext= "." + url.split(".")[-1]
name += ext
elif streamHTML.find("_url_list=") != -1: # Vídeo en varias partes
name1 = streamHTML.split("<title>")[1].split("<")[0]
codURL1 = streamHTML.split("_url_list=")[1].split("&")[0]
url1 = self.__showURL(codURL1)
streamHTML = self.__descHTML(url1)
codURL2 = []
urls = streamHTML.strip().split("<title>")[1:]
for i in urls:
#name2.append(i.split("<")[0])
codURL2.append(i.split("<url>")[1].split("<")[0])
url = []
name = []
b = 1
for i in codURL2:
tmp = self.__showURL(i)
url.append(tmp)
if tmp.find("?start=") != -1: ext="." + tmp.split("?start=")[0].split(".")[-1]
else: ext= "." + tmp.split(".")[-1]
name.append(name1 + "_part0" + str(b) + ext)
b += 1
del b
elif streamHTML.find("_id_list=") != -1:
id = streamHTML.split("_id_list=")[1].split("&")[0]
sPlayList = self.__descHTML(self.URL_PLAYLIST + id)
partes = sPlayList.split("<video>")[1:]
url = []
name = []
for i in partes:
tmpURL = i.split("<url>")[1].split("<")[0]
ext = "." + tmpURL.split(".")[-1]
if tmpURL.find("/mp4:") != -1: tmpURL = tmpURL.replace("/mp4:", "/")
if tmpURL.find("/flv:") != -1: tmpURL = tmpURL.replace("/flv:", "/")
url.append(tmpURL)
name.append(i.split("<title>")[1].split("<")[0].capitalize() + ext)
else:
salir(u"[!!!] ERROR: No se ha encontrado el vídeo")
if type(name) is list:
for i in name:
b = formatearNombre(i)
name[name.index(i)] = b
else:
name = formatearNombre(name)
return [url, name]
printt(u"Se ha encontrado una descarga parcial anterior, se continúa...\n")
printt(u"\nLanzando rtmpdump...\n")
if sys.platform == "win32":
system(rtmpdump_resume_win)
else:
system(rtmpdump_resume)
else:
printt(u"\nLanzando rtmpdump...\n")
if sys.platform == "win32":
system(rtmpdump_win)
else:
system(rtmpdump)
except OSError, e:
printt(u"[!!!] ERROR. No se encuenta rtmpdump:", e)
except KeyboardInterrupt:
salir(u"Bye!")
print "\n"
elif opc is "n":
printt(u"\n[?] Qué partes quieres descargar?")
printt(u"[INFO] Puedes introducir varias partes separadas por comas")
ERROR = True
while ERROR is True:
ERROR = False
printt(u"[INFO] Partes:")
b = 1
for i in range(0, len(self._URL)):
printt(u"[Parte %s] %s" % (str(b), self._URL[i]))
b += 1
del b
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 __init__(self, url=None):
self._outputName = None
self._URL = url
if self._URL == None:
salir(u"ERROR: No se puede descargar la url")
