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]
