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 __metodo_2(self, id, startTime, endTime):
'''
Segundo Método implementado:
TK2 - Pass de "N":
==================
force_http -> 1
id -> /url/url/url.mp4
sec -> encode(serverTime;id;startTime;endTime)
'''
printt(u"[INFO] Probando Método 2")
AES = aes.AES()
tokenizer = "/tokenizer/tk2.php"
passwd = "xo85kT+QHz3fRMcHNXp9cA"
server_time = self.__descHTML(self.URL_TIME).strip()
toEncode = server_time+";"+id+";"+startTime+";"+endTime
data = AES.encrypt(toEncode, passwd, 256)
post_args = {
'force_http' : '1',
'sec' : data,
'id' : id
}
url = self.__post(post_args, tokenizer)
if url is None: return None
else: return url
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).
'''
# 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).
'''
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 __modoNormal(self):
'''return URL y NAME de los vídeos normales de Canal SUR'''
printt(u"[INFO] Vídeo Normal")
htmlStream = self.__descHTML(self._URL_recibida)
url = "http://www.canalsur.es" + htmlStream.split("flashvars=\"file=")[1].split("&")[0]
ext = "." + url.split(".")[-1]
name = htmlStream.split("<title>")[1].split("<")[0] + 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 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 __alacarta(self):
'''return URL y NAME de los vídeos de A la carta de Canal SUR'''
printt(u"[INFO] A la carta")
xmlStream = self.__descHTML(self.__descHTML(self._URL_recibida).split("_url_xml_datos=")[1].split("\"")[0])
url = xmlStream.split("<url>")[1].split("<")[0]
ext = "." + url.split(".")[-1]
name = xmlStream.split("<title><![CDATA[")[1].split("]")[0] + 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) # .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 __rtvvRadio(self, htmlStream, sep):
'''
Dada una URL de la radio de RTVV devuelve la URL y el NOMBRE de descarga del audio
'''
printt(u"[INFO] Modo Audios de Ràdio")
url = self.URL_RTVV + htmlStream.split(sep)[1].split("\"")[0]
ext = "." + url.split(".")[-1]
name = htmlStream.split("class=\"title\"><strong>")[1].split("<")[0] + ext
return [url, name]
def __btvnoticies(self):
'''
return Nombre y URL de un vídeo de BTV Notícies
'''
printt(u"[INFO] BTV Notícies")
htmlStream = self.__descHTML(self._URL_recibida)
url = htmlStream.split("flashvars.post_guid = \"")[1].split("\"")[0]
name = htmlStream.split("<h2>")[1].split("<")[0]
name += ".flv"
return [url, name]
def __catradio(self):
'''Procesa los audios de catradio'''
# Primero nos quedamos con el id
audioID = self._URL_recibida.split("/")[4]
printt(u"[INFO] Audio ID:", audioID)
IDsplit = "insertNewItem(\'" + audioID + "\'"
# Nos quedamos con su identificacion
streamID = self.__descHTML(self._URL_recibida).split(IDsplit)[1].split(">")[0]
name = streamID.split(",")[1] + ".mp3"
url = "http://" + streamID.split("http://")[1].split("\'")[0]
return [url, name]
def __alacarta(self):
'''
return Nombre y URL de un vídeos de televisión a la carta de BTV
'''
printt(u"[INFO] A la Carta")
htmlStream = self.__descHTML(self._URL_recibida)
url = htmlStream.split("videoBTV.playlist.add(\"")[1].split("\"")[0]
name = htmlStream.split("<div id=\"titol\">")[1].split("</p>")[0].split("<h3>")[1]
name = name.replace("</h3><p>", "-")
name += ".wmv"
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.
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 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 __metodo_3(self, id, startTime, endTime):
'''
Tercer método implementado:
TK3 - Pass de "M":
==================
force_http -> 1
hash -> encode(serverTime;id;startTime;endTime)
id -> /url/url/url.mp4
startTime -> 0
endTime -> 0
'''
printt(u"[INFO] Probando Método 3")
AES = aes.AES()
tokenizer = "/tokenizer/tk3.php"
passwd = "xo85kT+QHz3fRMcHMXp9cA"
server_time = self.__descHTML(self.URL_TIME).strip()
toEncode = server_time+";"+id+";"+startTime+";"+endTime
data = AES.encrypt(toEncode, passwd, 256)
post_args = {
#'force_http' : '1',
'hash' : data,
'id' : id,
'startTime' : '0',
'endTime': '0'}
data = self.__post(post_args, tokenizer)
if data is None:
return None
else:
#print "DATA:", data
if data.find("<stream>") != -1: # FIXME: Este comandono funciona
R = data.split("<stream>")[1].split("</stream>")[0]
A = "\""+ "/".join(data.split("/")[4:]).split("</stream>")[0] +"\""
F = "\""+ "WIN 11,1,102,55" +"\""
W = "\""+ "http://static1.tele-cinco.net/comun/swf/playerMitele.swf" +"\""
P = "\""+ self._URL_recibida +"\""
Y = "\""+ "mp4:" + data.split("</file>")[0].split("mp4:")[1] +"\""
url = [R, "-a", A, "-f", F, "-W", W, "-p", P, "-y", Y]
else:
try:
url = data.split("<url><file>")[1].split("</file></url>")[0].replace("&", "&")
except IndexError:
url = data.split("<file geoblocked=\"true\">")[1].split("</file></url>")[0].replace("&", "&")
return url
def __modoNormalVariasPartes(self, streamHTML):
url2down = []
name = []
# Delimitamos la parte del carrusel (funcionará para todos??)
streamHTML = streamHTML.split("<a title=\"Video Anterior\"")[1].split("<a title=\"Video Siguiente\"")[0]
partes = len(streamHTML.split("<img title="))-1
streamPARTES = streamHTML.split("<img title=")[1:]
printt(u"[INFO] Número de partes:", str(partes))
#print streamPARTES
for i in streamPARTES:
xmlURL = self.URL_DE_ANTENA3 + i.split("rel=\"/")[1].split("\"")[0]
streamXML = self.__descXML(xmlURL)
url2down.append(self.URL_DE_DESCARGA + streamXML.split("<archivo><![CDATA[")[1].split("]")[0])
ext = streamXML.split("<archivo><![CDATA[")[1].split("]")[0].split('.')[-1]
name.append(i.split("\"")[1].split("\"")[0] + '.' + ext)
print "[INFO] URLs :", url2down
print "[INFO] Nombres :", name
return [url2down, name]
def __modoF1(self, streamHTML):
'''
<param value="_urlData=http://www.antena3.com/gestorf1/swf/player_hitos/xml/data.xml&_image=http://www.antena3.com/gestorf1/pictures/361/361/malasia-portada_crop1.png&_id_list=1405&_promo1=http://www.smartadserver.com/call/pubx/15272/241149/4654/S/&_promo2=http://www.smartadserver.com/call/pubx/15272/241148/4654/S/" name="flashVars">
'''
streamHTML = self.__get8stream(self._URL_recibida)
# Qué vídeo:
streamVids = streamHTML.split("<ul class=\"a3_gp_visor_menu\">")[1].split("</ul>")[0].replace("\t", "")
streamVids = streamVids.split("<li>")[1:]
printt(u"[???] Qué quieres descargar: ")
b = 0
for i in streamVids:
b += 1
printt(u"\t%d) %s" % (b, i.split(">")[1].split("<")[0].capitalize()))
opc = False
while opc is False:
opc = raw_input("[(%d a %d) >>>] " % (1, b))
if opc.isdigit():
opc = int(opc)
if opc < 1 or opc > b:
opc = False
else:
opc = False
streamVid = streamVids[opc-1]
streamVidUrl = self.URL_DE_ANTENA3 + streamVid.split("href=\"")[1].split("\"")[0]
# Vamos a por el vídeo
streamHTML = self.__descHTML(streamVidUrl)
url2down = []
name = []
id_list = streamHTML.split("_id_list=")[1].split("&")[0]
#printt(u"[DEBUG] url2down", str(id_list))
listxml = self.__descXML(self.URL_DE_F1 + id_list + "_playlist.xml")
listxml = listxml.split("<video>")[1:]
for i in listxml:
url2down.append(i.split("<url>")[1].split("<")[0])
ext = "." + url2down[-1].split(".")[-1]
name.append(i.split("<title>")[1].split("<")[0] + ext)
return [url2down, name]
def __aCarta(self):
"""
return URL (mms) y NAME
"""
printt(u"[INFO] Á Carta (tvg)")
urlStream = self.__descHTML(self._URL_recibida)
urlframeiParte = urlStream.split('<frame src="')[1].split('"')[0]
urlframei = self.URL_CRTVG + "reproductor/" + urlframeiParte
urlframei = urlframei.replace("&", "&").replace(" ", "%20")
frameiStream = self.__descHTML(urlframei)
frameVideo = frameiStream.split('<frame src="')[1].split('"')[0]
urlframeVideo = self.URL_CRTVG + "reproductor/" + frameVideo
urlframeVideo = urlframeVideo.replace("&", "&").replace(" ", "%20")
frameVideoStream = self.__descHTML(urlframeVideo)
asxFile = frameVideoStream.split('<PARAM NAME="URL" value="')[1].split('"')[0]
printt(u"[INFO] ASX File:", asxFile)
asxStream = self.__descHTML(asxFile)
name = asxStream.split("<TITLE>")[1].split("<")[0] + ".wmv"
url = asxStream.split('<ENTRY><REF HREF="')[1].split('"')[0]
return [url, name]
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).
'''
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:
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).
'''
# 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 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).
'''
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.
'''
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).
'''
# 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/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("") != -1:
printt(u"[INFO] Audios de catradio")
url, name = self.__catradio()
if name:
name = formatearNombre(name)
return [url, name]
