def __modoSalon(self, streamHTML):
#TODO: Poner cada Canal su URL, no solo a todos la de antena 3 ;)
self.log(u"[INFO] Modo Salón")
if streamHTML.find("so.addVariable(\"xml\"") != -1:
streamXML = \
Descargar.getHtml(self.URL_DE_ANTENA3 + streamHTML.split("so.addVariable(\"xml\",\"")[1].split("\"")[0])
elif streamHTML.find("player_capitulo.xml='") != -1:
streamXML = \
Descargar.getHtml(self.URL_DE_ANTENA3 + streamHTML.split("player_capitulo.xml='")[1].split("'")[0])
else:
if streamHTML.find("<div class=\"premium\">") != -1:
raise Error.GeneralPyspainTVsError(
u"PyDownTV no acepta la descarga de contenidos premium de las cadenas."
)
raise Error.GeneralPyspainTVsError(
u"Grupo Antena 3. No se encuentra XML.")
self.URL_DE_DESCARGA = self.__getUrlDescarga(streamXML)
# Comprobar aquí si se puede descargar 000.mp4:
if streamXML.find(".mp4") != -1:
tipo = ".mp4"
#url2down1 = self.URL_DE_DESCARGA + \
# streamXML.split("<archivo><![CDATA[")[1].split("001.mp4]]></archivo>")[0] + "000.mp4"
elif streamXML.find(".flv") != -1:
tipo = ".flv"
#url2down1 = self.URL_DE_DESCARGA + \
# streamXML.split("<archivo><![CDATA[")[1].split("001.flv]]></archivo>")[0] + "000.flv"
elif streamXML.find(".f4v") != -1:
[url2down, name] = self.__modoSalonNuevo(streamXML)
return [url2down, name]
else:
raise Error.GeneralPyspainTVsError(
"Grupo Antena 3. No se encuentra mp4, f4v ni flv")
#if Descargar.isReachable(url2down1): # Vídeo completo en una parte
# url2down = url2down1
# name = streamXML.split("<nombre><![CDATA[")[1].split("]]>")[0] + tipo
#else: # Vídeo en varias partes
#self.info(u"[!!!] No se puede encuentra el vídeo en un archivo (000.mp4)")
self.info(u"[INFO] El vídeo consta de varias partes")
parts = re.findall(
"\<archivo\>\<\!\[CDATA\[.*" + tipo + "\]\]\>\<\/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:
raise Error.GeneralPyspainTVsError(
u"Grupo Antena 3. No se encuentra niguna parte de contenido.")
return [url2down, name]
def __modoSalon(self, streamHTML):
# TODO: Poner cada Canal su URL, no solo a todos la de antena 3 ;)
self.log(u"[INFO] Modo Salón")
if streamHTML.find('so.addVariable("xml"') != -1:
streamXML = Descargar.getHtml(
self.URL_DE_ANTENA3 + streamHTML.split('so.addVariable("xml","')[1].split('"')[0]
)
elif streamHTML.find("player_capitulo.xml='") != -1:
streamXML = Descargar.getHtml(
self.URL_DE_ANTENA3 + streamHTML.split("player_capitulo.xml='")[1].split("'")[0]
)
else:
if streamHTML.find('<div class="premium">') != -1:
raise Error.GeneralPyspainTVsError(
u"PyDownTV no acepta la descarga de contenidos premium de las cadenas."
)
raise Error.GeneralPyspainTVsError(u"Grupo Antena 3. No se encuentra XML.")
self.URL_DE_DESCARGA = self.__getUrlDescarga(streamXML)
# Comprobar aquí si se puede descargar 000.mp4:
if streamXML.find(".mp4") != -1:
tipo = ".mp4"
# url2down1 = self.URL_DE_DESCARGA + \
# streamXML.split("<archivo><![CDATA[")[1].split("001.mp4]]></archivo>")[0] + "000.mp4"
elif streamXML.find(".flv") != -1:
tipo = ".flv"
# url2down1 = self.URL_DE_DESCARGA + \
# streamXML.split("<archivo><![CDATA[")[1].split("001.flv]]></archivo>")[0] + "000.flv"
elif streamXML.find(".f4v") != -1:
[url2down, name] = self.__modoSalonNuevo(streamXML)
return [url2down, name]
else:
raise Error.GeneralPyspainTVsError("Grupo Antena 3. No se encuentra mp4, f4v ni flv")
# if Descargar.isReachable(url2down1): # Vídeo completo en una parte
# url2down = url2down1
# name = streamXML.split("<nombre><![CDATA[")[1].split("]]>")[0] + tipo
# else: # Vídeo en varias partes
# self.info(u"[!!!] No se puede encuentra el vídeo en un archivo (000.mp4)")
self.info(u"[INFO] El vídeo consta de varias partes")
parts = re.findall("\<archivo\>\<\!\[CDATA\[.*" + tipo + "\]\]\>\<\/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:
raise Error.GeneralPyspainTVsError(u"Grupo Antena 3. No se encuentra niguna parte de contenido.")
return [url2down, name]
def getInfo(self):
'''
Devuelve toda la información asociada a la URL recibida, de la siguiente forma:
{
"exito" : bool, <-- True (si se han obtenido videos)
"num_video" : int, <-- Número de vídeos obtenidos
"mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False])
"videos" : [{
"url_video" : [], <-- Url de descarga de vídeo
"url_img" : "", <-- Url de la miniatura del video
"filename" : [], <-- Nombre de las partes para guardar en disco
"tipo" : "", <-- http, rtmp[e,..], mms, ...
"partes" : int, <-- Número de partes que tiene el vídeo
"rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None
"menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None
"url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo
"otros" : [], <-- Lista donde se pueden pasar cosas opcionales
"mensaje" : "" <-- Mensajes de la API
}], <-- Debe ser una lista de tamaño "num_videos"
"titulos" : [u""], <-- Titulos de los videos
"descs" : [u""] <-- Descripción de cada vídeo
}
Los valores que no se rellenen, deberán devolver None.
La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente:
{
"exito": False,
"mensaje": "No se pudo descargar el video"
}
"videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None)
"url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None)
'''
tit_vid = None
# Obtener HTML y XML:
try:
streamHTML = htmlBackup = Descargar.getHtml(
self.url).decode('string-escape')
html = streamHTML
tit_vid = streamHTML.split("<title>")[1].split("<")[0]
streamHTML = streamHTML.replace(" ", "")
streamXML = Descargar.getHtml(
streamHTML.split("{\"host\":\"")[1].split("\"")[0].replace(
"\/", "/"))
except Exception, e:
raise Error.GeneralPyspainTVsError(
"mitele.es: No se puede obenter enlaces: " + e.__str__())
def __modoNormalUnaParte(self, streamHTML):
xmlURL = streamHTML.split("A3Player.swf?xml=")[1].split('"')[0]
streamXML = Descargar.getHtml(xmlURL)
self.URL_DE_DESCARGA = self.__getUrlDescarga(streamXML)
url2down = self.URL_DE_DESCARGA + streamXML.split("<archivo><![CDATA[")[1].split("]]></archivo>")[0]
name = streamXML.split("<nombre><![CDATA[")[1].split("]]>")[0] + ".mp4"
return [url2down, name]
def __modoNormalConURL(self, streamHTML):
url2down = streamHTML.split(".seoURL='")[1].split("'")[0]
if not Descargar.isReachable(url2down): # A veces el vídeo de .seoURL da NOT FOUND!
xmlURL = Utiles.recortar(streamHTML, ".xml=\'", "\'")
streamXML = Descargar.getHtml(self.URL_DE_ANTENA3 + xmlURL)
self.URL_DE_DESCARGA = self.__getUrlDescarga(streamXML)
url2down = self.URL_DE_DESCARGA + \
streamXML.split("<archivo><![CDATA[")[1].split("]]></archivo>")[0]
name = streamXML.split("<nombre><![CDATA[")[1].split("]]>")[0] + ".mp4"
return [url2down, name]
url2down = url2down.replace("deslasexta", "desprogresiva")
try: # Parece que a veces aunque en el código aparezca el html, este no existe..
name = Descargar.getHtml(self.URL_DE_ANTENA3 + streamHTML.split(".xml='")[1].split("'")[0]).split("<nombre><![CDATA[")[1].split("]]>")[0] + ".mp4"
except:
name = Utiles.recortar(streamHTML, "<title>", "</title>").replace("ANTENA 3 TV", "").replace("-", "").strip() + ".mp4"
return [url2down, name]
def __modoNormalUnaParte(self, streamHTML):
xmlURL = streamHTML.split("A3Player.swf?xml=")[1].split("\"")[0]
streamXML = Descargar.getHtml(xmlURL)
self.URL_DE_DESCARGA = self.__getUrlDescarga(streamXML)
url2down = self.URL_DE_DESCARGA + \
streamXML.split("<archivo><![CDATA[")[1].split("]]></archivo>")[0]
name = streamXML.split("<nombre><![CDATA[")[1].split("]]>")[0] + ".mp4"
return [url2down, name]
def getInfo(self):
'''
Devuelve toda la información asociada a la URL recibida, de la siguiente forma:
{
"exito" : bool, <-- True (si se han obtenido videos)
"num_video" : int, <-- Número de vídeos obtenidos
"mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False])
"videos" : [{
"url_video" : [], <-- Url de descarga de vídeo
"url_img" : "", <-- Url de la miniatura del video
"filename" : [], <-- Nombre de las partes para guardar en disco
"tipo" : "", <-- http, rtmp[e,..], mms, ...
"partes" : int, <-- Número de partes que tiene el vídeo
"rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None
"menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None
"url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo
"otros" : [], <-- Lista donde se pueden pasar cosas opcionales
"mensaje" : "" <-- Mensajes de la API
}], <-- Debe ser una lista de tamaño "num_videos"
"titulos" : [u""], <-- Titulos de los videos
"descs" : [u""] <-- Descripción de cada vídeo
}
Los valores que no se rellenen, deberán devolver None.
La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente:
{
"exito": False,
"mensaje": "No se pudo descargar el video"
}
"videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None)
"url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None)
'''
tit_vid = None
# Obtener HTML y XML:
try:
streamHTML = htmlBackup = Descargar.getHtml(self.url).decode('string-escape')
html = streamHTML
#streamHTML = htmlBackup = self.toUtf(streamHTML)
tit_vid = streamHTML.split("<title>")[1].split("<")[0]
streamHTML = streamHTML.replace(" ", "")
streamXML = Descargar.getHtml(streamHTML.split("{\"host\":\"")[1].split("\"")[0].replace("\/", "/"))
except Exception, e:
raise Error.GeneralPyspainTVsError("mitele.es: No se puede obenter enlaces: "+e.__str__())
def __modoNormalConURL(self, streamHTML):
url2down = streamHTML.split(".seoURL='")[1].split("'")[0]
if not Descargar.isReachable(
url2down): # A veces el vídeo de .seoURL da NOT FOUND!
xmlURL = Utiles.recortar(streamHTML, ".xml=\'", "\'")
streamXML = Descargar.getHtml(self.URL_DE_ANTENA3 + xmlURL)
self.URL_DE_DESCARGA = self.__getUrlDescarga(streamXML)
url2down = self.URL_DE_DESCARGA + \
streamXML.split("<archivo><![CDATA[")[1].split("]]></archivo>")[0]
name = streamXML.split("<nombre><![CDATA[")[1].split(
"]]>")[0] + ".mp4"
return [url2down, name]
url2down = url2down.replace("deslasexta", "desprogresiva")
try: # Parece que a veces aunque en el código aparezca el html, este no existe..
name = Descargar.getHtml(self.URL_DE_ANTENA3 + streamHTML.split(
".xml='")[1].split("'")[0]).split(
"<nombre><![CDATA[")[1].split("]]>")[0] + ".mp4"
except:
name = Utiles.recortar(streamHTML, "<title>", "</title>").replace(
"ANTENA 3 TV", "").replace("-", "").strip() + ".mp4"
return [url2down, name]
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:]
self.log(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 = Descargar.getHtml(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 getInfo(self):
'''
Devuelve toda la información asociada a la URL recibida, de la siguiente forma:
{
"exito" : bool, <-- True (si se han obtenido videos)
"num_video" : int, <-- Número de vídeos obtenidos
"mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False])
"videos" : [{
"url_video" : [], <-- Url de descarga de vídeo
"url_img" : "", <-- Url de la miniatura del video
"filename" : [], <-- Nombre de las partes para guardar en disco
"tipo" : "", <-- http, rtmp[e,..], mms, ...
"partes" : int, <-- Número de partes que tiene el vídeo
"rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None
"menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None
"url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo
"otros" : [], <-- Lista donde se pueden pasar cosas opcionales
"mensaje" : "" <-- Mensajes de la API
}], <-- Debe ser una lista de tamaño "num_videos"
"titulos" : [u""], <-- Titulos de los videos
"descs" : [u""] <-- Descripción de cada vídeo
}
Los valores que no se rellenen, deberán devolver None.
La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente:
{
"exito": False,
"mensaje": "No se pudo descargar el video"
}
"videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None)
"url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None)
'''
#Ejemplo:
try:
html = Descargar.getHtml(self.url)
html.split("blabla")[0] # Buscar vídeo en html
except Exception, e:
raise Error.GeneralPyspainTVsError("No se encuentra la URL: " + e)
def getInfo(self):
'''
Devuelve toda la información asociada a la URL recibida, de la siguiente forma:
{
"exito" : bool, <-- True (si se han obtenido videos)
"num_video" : int, <-- Número de vídeos obtenidos
"mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False])
"videos" : [{
"url_video" : [], <-- Url de descarga de vídeo
"url_img" : "", <-- Url de la miniatura del video
"filename" : [], <-- Nombre de las partes para guardar en disco
"tipo" : "", <-- http, rtmp[e,..], mms, ...
"partes" : int, <-- Número de partes que tiene el vídeo
"rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None
"menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None
"url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo
"otros" : [], <-- Lista donde se pueden pasar cosas opcionales
"mensaje" : "" <-- Mensajes de la API
}], <-- Debe ser una lista de tamaño "num_videos"
"titulos" : [u""], <-- Titulos de los videos
"descs" : [u""] <-- Descripción de cada vídeo
}
Los valores que no se rellenen, deberán devolver None.
La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente:
{
"exito": False,
"mensaje": "No se pudo descargar el video"
}
"videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None)
"url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None)
'''
#Ejemplo:
try:
html = Descargar.getHtml(self.url)
html.split("blabla")[0] # Buscar vídeo en html
except Exception, e:
raise Error.GeneralPyspainTVsError("No se encuentra la URL: "+e)
def __modoF1(self, streamHTML): # TODO: ¡¡¡Acabar esta función para devolver todos los videos y sus partes!!!
"""
<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 = Descargar.getHtmlUtf8(self.url)
# Qué vídeo:
streamVids = streamHTML.split('<ul class="a3_gp_visor_menu">')[1].split("</ul>")[0].replace("\t", "")
streamVids = streamVids.split("<li>")[1:]
desc = None
try:
desc = Utiles.recortar(streamHTML, '<meta property="og:description" content="', '"').strip()
except:
desc = None
# self.debug(streamVids)
ret = {
"exito": True,
"num_videos": 0,
"mensaje": u"URLs obtenido correctamente",
"videos": [],
"titulos": [],
"descs": [],
}
v = -1
for i in streamVids: # todos los vídeos con todas sus partes
video = {
"url_video": [],
"url_img": None,
"filename": [],
"tipo": "http",
"partes": 0,
"rtmpd_cmd": None,
"menco_cmd": None,
"url_publi": None,
"otros": None,
"mensaje": None,
}
v += 1
streamVid = streamVids[v]
streamVidUrl = self.URL_DE_ANTENA3 + streamVid.split('href="')[1].split('"')[0]
self.debug(u"URL Video: " + streamVidUrl)
streamHTML = Descargar.getHtml(streamVidUrl)
# Partes
id_list = streamHTML.split("_id_list=")[1].split("&")[0]
listXMLurl = self.URL_DE_F1 + id_list + "_playlist.xml"
self.debug(u"URL XML list: " + listXMLurl)
listxml = Descargar.getHtml(listXMLurl)
video["url_img"] = listxml.split("<picture>")[1].split("</picture>")[0].strip()
listxml = listxml.split("<video>")[1:]
# print listxml
for b in listxml:
video["partes"] += 1
# video["mensaje"] = unicode(i.split(">")[1].split("<")[0].capitalize())
endurl = b.split("<url>")[1].split("<")[0]
# video["url_video"].append(endurl.replace(endurl.split("mp_")[0],"http://desprogresiva.antena3.com/"))
video["url_video"].append(endurl.replace(endurl.split("mp_")[0], self.URL_DE_DESCARGA_LA_SEXTA))
ext = "." + video["url_video"][-1].split(".")[-1]
tit = b.split("<title>")[1].split("<")[0] + ext
tit = Utiles.formatearNombre(tit)
video["filename"].append(tit)
ret["titulos"].append(unicode(i.split(">")[1].split("<")[0].capitalize()).encode("utf8"))
ret["videos"].append(video)
ret["num_videos"] += 1
ret["descs"].append(unicode(desc).encode("utf8"))
return ret
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:]
self.log(u"[INFO] Número de partes:", str(partes))
ret = {
"exito": True,
"num_videos": 0,
"mensaje": u"URLs obtenido correctamente",
"videos": [],
"titulos": [],
"descs": [],
}
video = {
"url_video": [],
"url_img": None,
"filename": [],
"tipo": "http",
"partes": 0,
"rtmpd_cmd": None,
"menco_cmd": None,
"url_publi": None,
"otros": None,
"mensaje": None,
}
for i in streamPARTES:
video = {
"url_video": [],
"url_img": None,
"filename": [],
"tipo": "http",
"partes": 0,
"rtmpd_cmd": None,
"menco_cmd": None,
"url_publi": None,
"otros": None,
"mensaje": None,
}
ret["num_videos"] += 1
ret["titulos"].append(i.split('"')[1].split('"')[0])
ret["descs"].append(i.split('"')[1].split('"')[0])
xmlURL = self.URL_DE_ANTENA3 + i.split('rel="/')[1].split('"')[0]
# print xmlURL
streamXML = Descargar.getHtml(xmlURL)
self.URL_DE_DESCARGA = self.__getUrlDescarga(streamXML)
video["url_video"].append(self.URL_DE_DESCARGA + streamXML.split("<archivo><![CDATA[")[1].split("]")[0])
video["url_img"] = (
self.URL_DE_ANTENA3 + "clipping" + streamXML.split("<archivo><![CDATA[clipping")[1].split("]")[0]
)
video["filename"].append(i.split('"')[1].split('"')[0] + ".mp4")
video["partes"] = 1
ret["videos"].append(video)
# 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)
return ret
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:]
self.log(u"[INFO] Número de partes:", str(partes))
ret = {
"exito": True,
"num_videos": 0,
"mensaje": u"URLs obtenido correctamente",
"videos": [],
"titulos": [],
"descs": []
}
video = {
"url_video": [],
"url_img": None,
"filename": [],
"tipo": "http",
"partes": 0,
"rtmpd_cmd": None,
"menco_cmd": None,
"url_publi": None,
"otros": None,
"mensaje": None
}
for i in streamPARTES:
video = {
"url_video": [],
"url_img": None,
"filename": [],
"tipo": "http",
"partes": 0,
"rtmpd_cmd": None,
"menco_cmd": None,
"url_publi": None,
"otros": None,
"mensaje": None
}
ret["num_videos"] += 1
ret["titulos"].append(i.split("\"")[1].split("\"")[0])
ret["descs"].append(i.split("\"")[1].split("\"")[0])
xmlURL = self.URL_DE_ANTENA3 + i.split("rel=\"/")[1].split("\"")[0]
#print xmlURL
streamXML = Descargar.getHtml(xmlURL)
self.URL_DE_DESCARGA = self.__getUrlDescarga(streamXML)
video["url_video"].append(
self.URL_DE_DESCARGA +
streamXML.split("<archivo><![CDATA[")[1].split("]")[0])
video[
"url_img"] = self.URL_DE_ANTENA3 + "clipping" + streamXML.split(
"<archivo><![CDATA[clipping")[1].split("]")[0]
video["filename"].append(i.split("\"")[1].split("\"")[0] + '.mp4')
video["partes"] = 1
ret["videos"].append(video)
#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)
return ret
def __modoF1(
self, streamHTML
): #TODO: ¡¡¡Acabar esta función para devolver todos los videos y sus partes!!!
'''
<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 = Descargar.getHtmlUtf8(self.url)
# Qué vídeo:
streamVids = streamHTML.split(
"<ul class=\"a3_gp_visor_menu\">")[1].split("</ul>")[0].replace(
"\t", "")
streamVids = streamVids.split("<li>")[1:]
desc = None
try:
desc = Utiles.recortar(
streamHTML, "<meta property=\"og:description\" content=\"",
"\"").strip()
except:
desc = None
#self.debug(streamVids)
ret = {
"exito": True,
"num_videos": 0,
"mensaje": u"URLs obtenido correctamente",
"videos": [],
"titulos": [],
"descs": []
}
v = -1
for i in streamVids: #todos los vídeos con todas sus partes
video = {
"url_video": [],
"url_img": None,
"filename": [],
"tipo": "http",
"partes": 0,
"rtmpd_cmd": None,
"menco_cmd": None,
"url_publi": None,
"otros": None,
"mensaje": None
}
v += 1
streamVid = streamVids[v]
streamVidUrl = self.URL_DE_ANTENA3 + streamVid.split(
"href=\"")[1].split("\"")[0]
self.debug(u"URL Video: " + streamVidUrl)
streamHTML = Descargar.getHtml(streamVidUrl)
#Partes
id_list = streamHTML.split("_id_list=")[1].split("&")[0]
listXMLurl = self.URL_DE_F1 + id_list + "_playlist.xml"
self.debug(u"URL XML list: " + listXMLurl)
listxml = Descargar.getHtml(listXMLurl)
video["url_img"] = listxml.split("<picture>")[1].split(
"</picture>")[0].strip()
listxml = listxml.split("<video>")[1:]
#print listxml
for b in listxml:
video["partes"] += 1
#video["mensaje"] = unicode(i.split(">")[1].split("<")[0].capitalize())
endurl = b.split("<url>")[1].split("<")[0]
video["url_video"].append(
endurl.replace(
endurl.split("mp_")[0],
"http://desprogresiva.antena3.com/"))
ext = "." + video["url_video"][-1].split(".")[-1]
tit = b.split("<title>")[1].split("<")[0] + ext
tit = Utiles.formatearNombre(tit)
video["filename"].append(tit)
ret["titulos"].append(
unicode(
i.split(">")[1].split("<")[0].capitalize()).encode('utf8'))
ret["videos"].append(video)
ret["num_videos"] += 1
ret["descs"].append(unicode(desc).encode('utf8'))
return ret
def getInfo(self):
'''
Devuelve toda la información asociada a la URL recibida, de la siguiente forma:
{
"exito" : bool, <-- True (si se han obtenido videos)
"num_video" : int, <-- Número de vídeos obtenidos
"mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False])
"videos" : [{
"url_video" : [], <-- Url de descarga de vídeo
"url_img" : "", <-- Url de la miniatura del video
"filename" : [], <-- Nombre de las partes para guardar en disco
"tipo" : "", <-- http, rtmp[e,..], mms, ...
"partes" : int, <-- Número de partes que tiene el vídeo
"rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None
"menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None
"url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo
"otros" : [], <-- Lista donde se pueden pasar cosas opcionales
"mensaje" : "" <-- Mensajes de la API
}], <-- Debe ser una lista de tamaño "num_videos"
"titulos" : [u""], <-- Titulos de los videos
"descs" : [u""] <-- Descripción de cada vídeo
}
Los valores que no se rellenen, deberán devolver None.
La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente:
{
"exito": False,
"mensaje": "No se pudo descargar el video"
}
"videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None)
"url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None)
'''
url_img = None
streamHTML = Descargar.getHtml(self.url).decode('string-escape')
if streamHTML.find("CUAVID") != -1:
self.debug(u"CUAVID")
ContentID = streamHTML.split("imageContentId: \'")[1].split("\'")[0]
streamJSON = Descargar.getHtml(self.URL_SOURCES + ContentID)
url2down = streamJSON.split("\"src\":\"")[1].split("\"")[0].replace("\/", "/")
name = streamJSON.split("\"wrpContent\":\"")[1].split("\"")[0] + ".mp4"
elif streamHTML.find("MDS.embedObj(video") != -1: # Este parece ser el único método a 16/10/2012 (pero dejo los demás..)
self.debug(u"MDS.embedObj")
contentID = streamHTML.split("MDS.embedObj(video, \"")[1].split("\"")[0]
clippingID = streamHTML.split("imageClippingId: \'")[1].split("\'")[0]
imageContentID = streamHTML.split("imageContentId: \'")[1].split("\'")[0]
self.debug("URL Json: "+self.URL_JSON + "contentId=" + contentID + "&clippingId=" + clippingID + "&imageContentId=" + imageContentID)
streamJSON = Descargar.getHtml( self.URL_JSON +
"contentId=" + contentID +
"&clippingId=" + clippingID +
"&imageContentId=" + imageContentID
)
#streamJSON = dict(streamJSON)
#url2down = streamJSON["sources"][0]["src"]
url2down = streamJSON.split("({\"sources\":[{\"src\":\"")[1].split("\"")[0].replace("\/", "/")
name = streamHTML.split("<title>")[1].split("<")[0]
name += "." + url2down.split(".")[-1].split("?")[0]
url_img = streamJSON.split("\"poster\":\"")[1].split("\"")[0].replace("\/", "/")
elif streamHTML.find("src_iframe:") != -1:
self.info(u"[INFO] Vídeo Común")
name = streamHTML.split("<title>")[1].split("<")[0]
urlComunes = self.URL_CUATRO + streamHTML.split("src_iframe:")[1].replace(" ", "").split("\'")[1].split("\'")[0]
streamComunes = Descargar.getHtml(urlComunes)
url2down = streamComunes.split("document.write(\'<video id=")[1].split("src=\"")[1].split("\"")[0]
ext= "." + url2down.split(".")[-1]
name += ext
elif streamHTML.find("MSV.embedData") != -1:
#rx=re.compile(r"MSV\.embedData\[(.*)\]", re.MULTILINE|re.DOTALL)
rx=re.compile(r'/mdsvideo/popup\.html\?(.*)"')
videos = rx.findall(streamHTML)
if not videos: Error.GeneralPyspainTVsError("Telecinco.es. No se encuentra contenido.")
ret = {
"exito" : True,
"num_videos" : len(videos),
"mensaje" : u"URL obtenido correctamente",
"videos": [],
"titulos": [],
"descs": []
}
for js in videos:
vid = {
"url_video" : None,
"url_img" : None,
"filename" : None,
"tipo" : "http",
"partes" : 1,
"rtmpd_cmd" : None,
"menco_cmd" : None,
"url_publi" : None,
"otros" : None,
"mensaje" : None
}
stream = Descargar.getHtmlUtf8(self.URL_JSON + js + "&imageContentId=" + Utiles.recortar(js, 'contentId=', '&'))
info = json.loads(stream[1:-1])
vid['url_video'] = [info['sources'][0]['src']]
vid['url_img'] = info['poster']
try: vid['filename'] = Utiles.formatearNombre(info['nielsen']['title']+'.mp4')
except: vid['filename'] = 'VideosDeTelecinco.mp4'
ret['videos'].append(vid)
ret['titulos'].append(unicode(info['nielsen']['title']).encode('utf8').replace("\'",""))
ret['descs'].append(u'Cat.: %s. Subcat.: %s. %s'.encode('utf8') % (info['nielsen']['category'].encode('utf8'),info['nielsen']['subcategory'].encode('utf8'),info['nielsen']['title'].encode('utf8')))
return ret
else:
raise Error.GeneralPyspainTVsError("Cuatro.com: No se encuentra contenido")
tit_vid = None
if name:
name = name.replace("Ver vídeo online","")
tit_vid = name.split(".")[0]
name = Utiles.formatearNombre(name)
desc = None
try:
desc = Utiles.recortar(streamHTML, "<h3 class=\"subtitle\">", "<").strip()
except:
desc = tit_vid if tit_vid is not None else None
return {"exito" : True,
"num_videos" : 1,
"mensaje" : u"URL obtenido correctamente",
"videos":[{
"url_video" : [url2down],
"url_img" : url_img if url_img is not None else None,
"filename" : [name] if name is not None else None,
"tipo" : "http",
"partes" : 1,
"rtmpd_cmd" : None,
"menco_cmd" : None,
"url_publi" : None,
"otros" : None,
"mensaje" : None
}],
"titulos": [tit_vid] if tit_vid is not None else None,
"descs": [desc] if desc is not None else None
}
def getInfo(self):
'''
Devuelve toda la información asociada a la URL recibida, de la siguiente forma:
{
"exito" : bool, <-- True (si se han obtenido videos)
"num_video" : int, <-- Número de vídeos obtenidos
"mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False])
"videos" : [{
"url_video" : [], <-- Url de descarga de vídeo
"url_img" : "", <-- Url de la miniatura del video
"filename" : [], <-- Nombre de las partes para guardar en disco
"tipo" : "", <-- http, rtmp[e,..], mms, ...
"partes" : int, <-- Número de partes que tiene el vídeo
"rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None
"menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None
"url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo
"otros" : [], <-- Lista donde se pueden pasar cosas opcionales
"mensaje" : "" <-- Mensajes de la API
}], <-- Debe ser una lista de tamaño "num_videos"
"titulos" : [u""], <-- Titulos de los videos
"descs" : [u""] <-- Descripción de cada vídeo
}
Los valores que no se rellenen, deberán devolver None.
La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente:
{
"exito": False,
"mensaje": "No se pudo descargar el video"
}
"videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None)
"url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None)
'''
url_img = None
streamHTML = Descargar.getHtml(self.url)
if streamHTML.find("http://level3/") != -1: # Método antiguo
self.info(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]
self.info(u"[INFO] Nuevo Video ID:", newID)
ask4token = self.URL_ASK4TOKEN + newID[-3:] + "/" + newID + ".mp4"
self.debug(u"[+] Pidiendo nuevo token")
url2down = Descargar.getHtml(ask4token)
name = streamHTML.split("var title = \'")[1].split("\'")[0] + ".mp4"
elif self.url.find("videoURL=") != -1: # Forma con el ID en la URL (nueva??)
videoID = self.url.split("videoURL=")[1]
ask4token = self.URL_ASK4TOKEN + videoID[-3:] + "/" + videoID + ".mp4"
self.debug(u"[+] Pidiendo nuevo token")
url2down = Descargar.getHtml(ask4token)
# Obtner nombre:
xmlURL = "http://estaticos.telecinco.es/xml/Video/Video_" + videoID + ".xml"
streamXML = Descargar.getHtml(xmlURL)
name = streamXML.split("<![CDATA[")[1].split("]")[0] + ".mp4"
elif streamHTML.find("MDS.embedObj(video") != -1:
contentID = streamHTML.split("MDS.embedObj(video, \"")[1].split("\"")[0]
try: clippingID = streamHTML.split("imageClippingId: \'")[1].split("\'")[0] # try por que en la API no funcionaba oO
except: clippingID = "1.jpg"
try: imageContentID = streamHTML.split("imageContentId: \'")[1].split("\'")[0] # try por problemas com la API oO
except: imageContentID = streamHTML.split("MDS.embedObj(video, \"")[1].split("\"")[0]
self.debug(u"URL JSON: " + self.URL_JSON + "contentId=" + contentID + "&clippingId=" + clippingID + "&imageContentId=" + imageContentID)
streamJSON = Descargar.getHtml(self.URL_JSON +
"contentId=" + contentID +
"&clippingId=" + clippingID +
"&imageContentId=" + imageContentID
)
url2down = streamJSON.split("({\"sources\":[{\"src\":\"")[1].split("\"")[0].replace("\/", "/")
name = streamHTML.split("<title>")[1].split("<")[0]
name += "." + url2down.split(".")[-1].split("?")[0]
url_img = streamJSON.split("\"poster\":\"")[1].split("\"")[0].replace("\/", "/")
elif streamHTML.find("MSV.embedData") != -1:
#rx=re.compile(r"MSV\.embedData\[(.*)\]", re.MULTILINE|re.DOTALL)
rx=re.compile(r'/mdsvideo/popup\.html\?(.*)"')
videos = rx.findall(streamHTML)
if not videos: Error.GeneralPyspainTVsError("Telecinco.es. No se encuentra contenido.")
ret = {
"exito" : True,
"num_videos" : len(videos),
"mensaje" : u"URL obtenido correctamente",
"videos": [],
"titulos": [],
"descs": []
}
for js in videos:
vid = {
"url_video" : None,
"url_img" : None,
"filename" : [],
"tipo" : "http",
"partes" : 1,
"rtmpd_cmd" : None,
"menco_cmd" : None,
"url_publi" : None,
"otros" : None,
"mensaje" : None
}
stream = Descargar.getHtmlUtf8(self.URL_JSON + js + "&imageContentId=" + Utiles.recortar(js, 'contentId=', '&'))
info = json.loads(stream[1:-1])
vid['url_video'] = [info['sources'][0]['src']]
vid['url_img'] = info['poster']
try: vid['filename'].append(Utiles.formatearNombre(info['nielsen']['title']+'.mp4'))
except: vid['filename'].append('VideosDeTelecinco.mp4')
ret['videos'].append(vid)
ret['titulos'].append(unicode(info['nielsen']['title']).encode('utf8').replace('"','').replace("'",""))
ret['descs'].append(u'Cat.: %s. Subcat.: %s. %s'.encode('utf8') % (info['nielsen']['category'].encode('utf8'),info['nielsen']['subcategory'].encode('utf8'),info['nielsen']['title'].encode('utf8')))
return ret
else:
Error.GeneralPyspainTVsError("Telecinco.es. No se encuentra contenido.")
tit_vid = None
if name != None:
name = name.replace("Ver vídeo online","")
tit_vid = name.split(".")[0]
name = Utiles.formatearNombre(name)
desc = None
try:
desc = Utiles.recortar(streamHTML, "<h3 class=\"subtitle\">", "<").strip()
except:
desc = tit_vid if tit_vid is not None else None
#TIT FIX:
tit_vid = tit_vid.replace('"','').replace("'","")
return {"exito" : True,
"num_videos" : 1,
"mensaje" : u"URL obtenido correctamente",
"videos":[{
"url_video" : [url2down],
"url_img" : url_img if url_img is not None else None,
"filename" : [name] if name is not None else None,
"tipo" : "http",
"partes" : 1,
"rtmpd_cmd" : None,
"menco_cmd" : None,
"url_publi" : None,
"otros" : None,
"mensaje" : None
}],
"titulos": [tit_vid] if tit_vid is not None else None,
"descs": [desc] if desc is not None else None
}
def __modoNormalConURL(self, streamHTML):
url2down = streamHTML.split(".seoURL='")[1].split("'")[0]
url2down = url2down.replace("deslasexta", "desprogresiva")
name = Descargar.getHtml(self.URL_DE_ANTENA3 + streamHTML.split(".xml='")[1].split("'")[0]).split("<nombre><![CDATA[")[1].split("]]>")[0] + ".mp4"
return [url2down, name]
def getInfo(self):
'''
Devuelve toda la información asociada a la URL recibida, de la siguiente forma:
{
"exito" : bool, <-- True (si se han obtenido videos)
"num_video" : int, <-- Número de vídeos obtenidos
"mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False])
"videos" : [{
"url_video" : [], <-- Url de descarga de vídeo
"url_img" : "", <-- Url de la miniatura del video
"filename" : [], <-- Nombre de las partes para guardar en disco
"tipo" : "", <-- http, rtmp[e,..], mms, ...
"partes" : int, <-- Número de partes que tiene el vídeo
"rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None
"menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None
"url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo
"otros" : [], <-- Lista donde se pueden pasar cosas opcionales
"mensaje" : "" <-- Mensajes de la API
}], <-- Debe ser una lista de tamaño "num_videos"
"titulos" : [u""], <-- Titulos de los videos
"descs" : [u""] <-- Descripción de cada vídeo
}
Los valores que no se rellenen, deberán devolver None.
La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente:
{
"exito": False,
"mensaje": "No se pudo descargar el video"
}
"videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None)
"url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None)
'''
#TODO: Cuida con las paginas que tiene más de un vídeo. De momento funciona porque es el primer video que aparece!
# Primero: nos quedamos con le id dependiendo si el user metio la url con
# una barra (/) final o no y si tiene extensión (no es alacarta)
logging.debug(self.url)
videoID = self.url.split('/')[-1]
if videoID == "":
videoID = self.url.split('/')[-2]
elif videoID.find(".shtml") != -1 or videoID.find(".html") != -1 or \
videoID.find(".html") != -1:
videoID = videoID.split('.')[0]
if not videoID.isdigit(): videoID = self.getID(self.url)
try:
self.debug(u"ID del vídeo en url = " + videoID)
except:
pass
#if self.url.find("rtve.es/infantil/") != -1: self.url = self.url.replace("/#","") # Vídeos de Clan a veces falla con el ancla
# Añadido para vídeos nuevos (periodo de prueba):
sourceHTML = Descargar.getHtml(self.url).decode('string-escape')
#sourceHTML = self.toUtf(sourceHTML)
videoID_comp = None
if sourceHTML.find("flashcontentId:\'videoplayer") != -1:
videoID_comp = sourceHTML.split(
"flashcontentId:\'videoplayer")[1].split("\'")[0]
if videoID_comp != videoID: videoID = videoID_comp
if sourceHTML.find("<div id=\"video") != -1:
videoID_comp = sourceHTML.split("<div id=\"video")[1].split(
"\"")[0]
if videoID_comp != videoID and videoID_comp.isdigit():
videoID = videoID_comp
########################################################
self.debug(u"ID del vídeo en HTML = " +
videoID_comp if videoID_comp else "No ID en HTML")
self.log(u"[INFO] ID del Vídeo :", videoID)
if videoID is None:
raise Error.GeneralPyspainTVsError(
u"No se encuentra el ID del vídeo")
if self.url.find("rtve.es/infantil/") != -1:
return self.__ClanTV(sourceHTML, videoID)
# -- Método 1 Octubre 2012:
# self.debug(u"Probando método de 1 de uno de Octubre de 2012")
# url = "http://www.rtve.es/ztnr/consumer/xl/video/alta/" + videoID + "_es_292525252525111"
# self.debug(url)
# user_agent="Mozilla"
# opener = urllib2.build_opener(NoRedirectHandler())
# urllib2.install_opener(opener)
# headers = { 'User-Agent' : user_agent }
# req = urllib2.Request(url, None, headers)
# u = urllib2.urlopen(req)
# try:
# urlVideo = u.info().getheaders("Location")[0]
# except:
# raise Error.GeneralPyspainTVsError("No se encuentra Location")
# u.close()
# if urlVideo != "":
# url_video = urlVideo.replace("www.rtve.es", "media5.rtve.es")
# titulo = sourceHTML.split("<title>")[1].split("</")[0].replace("RTVE.es", "").replace("-", "").strip()
# filename = titulo + ".mp4"
# filename = Utiles.formatearNombre(filename)
# #sourceHTML = sourceHTML.split("<div id=\"video")[1].split("flashvars")[0] # Me quedo solo con la parte del vídeo principal
# url_img = sourceHTML.split("\"thumbnail\" content=\"")[1].split("\"")[0]
# else:
# raise Error.GeneralPyspainTVsError("No se pudo encontrar el enlace de descarga")
# -- Método 1 Octubre 2012 FIN
# -- Método 24 Mayo 2013
self.debug(u"Probando método de 24 de uno de Mayo de 2013")
manager = "anubis"
tipo = "videos"
url = "http://www.rtve.es/ztnr/movil/thumbnail/%s/%s/%s.png" % (
manager, tipo, videoID)
self.debug(u"Probando url:", url)
tmp_ = decode(Descargar.get(url))
tmp = re.findall(".*tEXt(.*)#[\x00]*([0-9]*).*", tmp_)[0]
tmp = [n for n in tmp]
cyphertext = tmp[0]
key = tmp[1]
tmp = tmp = [0 for n in range(500)]
# Créditos para: http://sgcg.es/articulos/2012/09/11/nuevos-cambios-en-el-mecanismo-para-descargar-contenido-multimedia-de-rtve-es-2/
intermediate_cyphertext = ""
increment = 1
text_index = 0
while text_index < len(cyphertext):
text_index = text_index + increment
try:
intermediate_cyphertext = intermediate_cyphertext + cyphertext[
text_index - 1]
except:
pass
increment = increment + 1
if increment == 5: increment = 1
plaintext = ""
key_index = 0
increment = 4
while key_index < len(key):
key_index = key_index + 1
text_index = int(key[key_index - 1]) * 10
key_index = key_index + increment
try:
text_index = text_index + int(key[key_index - 1])
except:
pass
text_index = text_index + 1
increment = increment + 1
if increment == 5: increment = 1
try:
plaintext = plaintext + intermediate_cyphertext[text_index - 1]
except:
pass
urlVideo = plaintext
if urlVideo != "":
url_video = urlVideo.replace("www.rtve.es", "media5.rtve.es")
titulo = sourceHTML.split("<title>")[1].split("</")[0].replace(
"RTVE.es", "").replace("-", "").strip()
filename = titulo + ".mp4"
filename = Utiles.formatearNombre(filename)
#sourceHTML = sourceHTML.split("<div id=\"video")[1].split("flashvars")[0] # Me quedo solo con la parte del vídeo principal
url_img = sourceHTML.split("\"thumbnail\" content=\"")[1].split(
"\"")[0]
else:
raise Error.GeneralPyspainTVsError(
"No se pudo encontrar el enlace de descarga")
# -- Método 24 Mayo 2013 FIN
desc = None
try: #obtener descripción del video
desc = Utiles.recortar(
sourceHTML, "<meta itemprop=\"description\" content=\"",
"\"").strip()
except:
try:
desc = Utiles.recortar(
sourceHTML, "<meta property=\"og:description\" content=\"",
"\"").strip()
except:
try:
desc = Utiles.recortar(
sourceHTML, "<meta name=\"description\" content=\"",
"\"").strip()
except:
desc = u"Vídeos de Televión Española"
return {
"exito":
True,
"num_videos":
1,
"mensaje":
u"URL obtenido correctamente",
"videos": [{
"url_video": [url_video],
"url_img": url_img,
"filename": [filename],
"tipo": "http",
"partes": 1,
"rtmpd_cmd": None,
"menco_cmd": None,
"url_publi": None,
"otros": None,
"mensaje": None
}],
"titulos": [titulo],
"descs": [desc] if desc is not None else None
}
def getInfo(self):
'''
Devuelve toda la información asociada a la URL recibida, de la siguiente forma:
{
"exito" : bool, <-- True (si se han obtenido videos)
"num_video" : int, <-- Número de vídeos obtenidos
"mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False])
"videos" : [{
"url_video" : [], <-- Url de descarga de vídeo
"url_img" : "", <-- Url de la miniatura del video
"filename" : [], <-- Nombre de las partes para guardar en disco
"tipo" : "", <-- http, rtmp[e,..], mms, ...
"partes" : int, <-- Número de partes que tiene el vídeo
"rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None
"menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None
"url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo
"otros" : [], <-- Lista donde se pueden pasar cosas opcionales
"mensaje" : "" <-- Mensajes de la API
}], <-- Debe ser una lista de tamaño "num_videos"
"titulos" : [u""], <-- Titulos de los videos
"descs" : [u""] <-- Descripción de cada vídeo
}
Los valores que no se rellenen, deberán devolver None.
La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente:
{
"exito": False,
"mensaje": "No se pudo descargar el video"
}
"videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None)
"url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None)
'''
try: #Tratar de quitar caracteres especiales de las urls que no lo necesitan
self.url = self.url.split("video:")[0] + "video:_" + self.url.split("_")[1]
except:
pass
streamHTML = htmlBackup = Descargar.getHtml(self.url).decode('iso-8859-1').encode('utf8') #rtpa codigicada en iso..
streamHTML = streamHTML.replace("\n", "").replace("\t", "")
partes = None
#método 12/11/2012:
if streamHTML.find("html5") != -1:
partes = 1
name = streamHTML.split("<div id=\"sobreElVideo\">")[1].split("<h3>")[1].split("</h3>")[0] + ".mp4"
streamHTML = streamHTML.replace(" ", "")
try:
url = streamHTML.split("html5")[1].split("\'file\':\'")[1].split("\'")[0]
except:
url = streamHTML.split("html5")[0].split("\'file\':\'")[1].split("\'")[0]
else:
# Cuantas partes son:
try:
partes = int(streamHTML.split("&partes=")[1].split("&")[0])
except IndexError: # No existe "&partes"
partes = 1
if partes == 1:
videoID = streamHTML.split("<param value=\"video1=")[1].split("&")[0]
if videoID.find("http://") != -1:
url = videoID
name = streamHTML.split("data-text=\"")[1].split("\"")[0].strip() + "." + url.split(".")[-1]
else:
# Probar entre TOKEN nuevo y antiguo por reproductor:
repro = streamHTML.split("<param value=\"player/")[1].split("\"")[0]
if repro == "reproductorVideoOnDemmand-mp4-rtpa.swf": # Antiguo
streamINFO = self.__descHTML(self.TOKEN_ARCHIVO + videoID)
url = "http://" + streamINFO.split("http://")[1]
else: # Reproductor nuevo: "reproductorVideoOnDemmand.swf"
streamINFO = self.__descHTML(self.TOKEN + videoID + "_1")
streamINFO = self.__descHTML(streamINFO.split("&url=")[1])
url = "http://" + streamINFO.split("http://")[1]
name = streamHTML.split("<div id=\"sobreElVideo\">")[1].split("<h3>")[1].split("</h3>")[0]
if name == "":
name = streamHTML.split("<title>")[1].split("</title>")[0] + ".mp4"
else: name + ".mp4"
else:
# Recordar que hay videos que ponen varias partes en las que realmente solo existe una:
videoID = streamHTML.split("<param value=\"video1=")[1].split("&")[0]
url = []
name = []
for i in range(1, partes+1):
streamINFO = self.__descHTML(self.TOKEN + videoID + "_" + str(i))
streamINFO = self.__descHTML(streamINFO.split("&url=")[1])
tmp_url = "http://" + streamINFO.split("http://")[1]
tmp_name = streamHTML.split("<div id=\"sobreElVideo\">")[1].split("<h3>")[1].split("</h3>")[0] +"_part" + str(i)
if tmp_name == "":
tmp_name = streamHTML.split("<title>")[1].split("</title>")[0] + "_part" + str(i) + ".mp4"
else: tmp_name + ".mp4"
if Descargar.isReachable(tmp_url):
url.append(tmp_url)
name.appen(tmp_name)
continue
else:
break
try: #imagen del vídeo
img = self.URL_RTPA + Utiles.recortar(htmlBackup, "\'image\': \'", "\'")
except:
img = None
desc = None
try: # Descripción del vídeo
desc = htmlBackup.split("<div class=\"overview\">")[1].split("<div>")[1].split("</div>")[0].strip()
except:
desc = u"Vídeo de la web de Radio Televisión del Principado de Asturias"
else:
if desc is not None and desc == "":
desc = u"Vídeo de la web de Radio Televisión del Principado de Asturias"
tit_vid = None
try: #Título del vídeo
tit_vid = htmlBackup.split("<div id=\"sobreElVideo\">")[1].split("<h3>")[1].split("</h3>")[0]
except:
tit_vid = None
else:
if tit_vid is not None and tit_vid == "":
tit_vid = u"Vídeo de la web de Radio Televisión del Principado de Asturias"
if type(name) == list:
for i in name:
b = Utiles.formatearNombre(i)
name[name.index(i)] = b
else:
name = Utiles.formatearNombre(name)
return {"exito" : True,
"num_videos" : 1,
"mensaje" : u"URL obtenida correctamente",
"videos":[{
"url_video" : [url] if type(url) != list else url,
"url_img" : img if img is not None else None,
"filename" : [name] if name is not None else None,
"tipo" : "http",
"partes" : partes if partes is not None else 1,
"rtmpd_cmd" : None,
"menco_cmd" : None,
"url_publi" : None,
"otros" : None,
"mensaje" : None
}],
"titulos": [tit_vid] if tit_vid is not None else None,
"descs": [desc] if desc is not None else None
}
def getInfo(self):
'''
Devuelve toda la información asociada a la URL recibida, de la siguiente forma:
{
"exito" : bool, <-- True (si se han obtenido videos)
"num_video" : int, <-- Número de vídeos obtenidos
"mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False])
"videos" : [{
"url_video" : [], <-- Url de descarga de vídeo
"url_img" : "", <-- Url de la miniatura del video
"filename" : [], <-- Nombre de las partes para guardar en disco
"tipo" : "", <-- http, rtmp[e,..], mms, ...
"partes" : int, <-- Número de partes que tiene el vídeo
"rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None
"menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None
"url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo
"otros" : [], <-- Lista donde se pueden pasar cosas opcionales
"mensaje" : "" <-- Mensajes de la API
}], <-- Debe ser una lista de tamaño "num_videos"
"titulos" : [u""], <-- Titulos de los videos
"descs" : [u""] <-- Descripción de cada vídeo
}
Los valores que no se rellenen, deberán devolver None.
La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente:
{
"exito": False,
"mensaje": "No se pudo descargar el video"
}
"videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None)
"url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None)
'''
url_img = None
streamHTML = Descargar.getHtml(self.url)
if streamHTML.find("http://level3/") != -1: # Método antiguo
self.info(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]
self.info(u"[INFO] Nuevo Video ID:", newID)
ask4token = self.URL_ASK4TOKEN + newID[-3:] + "/" + newID + ".mp4"
self.debug(u"[+] Pidiendo nuevo token")
url2down = Descargar.getHtml(ask4token)
name = streamHTML.split("var title = \'")[1].split("\'")[0] + ".mp4"
elif self.url.find("videoURL=") != -1: # Forma con el ID en la URL (nueva??)
videoID = self.url.split("videoURL=")[1]
ask4token = self.URL_ASK4TOKEN + videoID[-3:] + "/" + videoID + ".mp4"
self.debug(u"[+] Pidiendo nuevo token")
url2down = Descargar.getHtml(ask4token)
# Obtner nombre:
xmlURL = "http://estaticos.telecinco.es/xml/Video/Video_" + videoID + ".xml"
streamXML = Descargar.getHtml(xmlURL)
name = streamXML.split("<![CDATA[")[1].split("]")[0] + ".mp4"
elif streamHTML.find("MDS.embedObj(video") != -1:
contentID = streamHTML.split("MDS.embedObj(video, \"")[1].split("\"")[0]
clippingID = streamHTML.split("imageClippingId: \'")[1].split("\'")[0]
imageContentID = streamHTML.split("imageContentId: \'")[1].split("\'")[0]
self.debug(u"URL JSON: " + self.URL_JSON + "contentId=" + contentID + "&clippingId=" + clippingID + "&imageContentId=" + imageContentID)
streamJSON = Descargar.getHtml(self.URL_JSON +
"contentId=" + contentID +
"&clippingId=" + clippingID +
"&imageContentId=" + imageContentID
)
#streamJSON = dict(streamJSON)
#url2down = streamJSON["sources"][0]["src"]
url2down = streamJSON.split("({\"sources\":[{\"src\":\"")[1].split("\"")[0].replace("\/", "/")
name = streamHTML.split("<title>")[1].split("<")[0]
name += "." + url2down.split(".")[-1].split("?")[0]
url_img = streamJSON.split("\"poster\":\"")[1].split("\"")[0].replace("\/", "/")
else:
Error.GeneralPyspainTVsError("Telecinco.es. No se encuentra contenido.")
tit_vid = None
if name != None:
name = name.replace("Ver vídeo online","")
tit_vid = name.split(".")[0]
name = Utiles.formatearNombre(name)
desc = None
try:
desc = Utiles.recortar(streamHTML, "<h3 class=\"subtitle\">", "<").strip()
except:
desc = tit_vid if tit_vid is not None else None
return {"exito" : True,
"num_videos" : 1,
"mensaje" : u"URL obtenido correctamente",
"videos":[{
"url_video" : [url2down],
"url_img" : url_img if url_img is not None else None,
"filename" : [name] if name is not None else None,
"tipo" : "http",
"partes" : 1,
"rtmpd_cmd" : None,
"menco_cmd" : None,
"url_publi" : None,
"otros" : None,
"mensaje" : None
}],
"titulos": [tit_vid] if tit_vid is not None else None,
"descs": [desc] if desc is not None else None
}
def getInfo(self):
"""
Devuelve toda la información asociada a la URL recibida, de la siguiente forma:
{
"exito" : bool, <-- True (si se han obtenido videos)
"num_video" : int, <-- Número de vídeos obtenidos
"mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False])
"videos" : [{
"url_video" : [], <-- Url de descarga de vídeo
"url_img" : "", <-- Url de la miniatura del video
"filename" : [], <-- Nombre de las partes para guardar en disco
"tipo" : "", <-- http, rtmp[e,..], mms, ...
"partes" : int, <-- Número de partes que tiene el vídeo
"rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None
"menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None
"url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo
"otros" : [], <-- Lista donde se pueden pasar cosas opcionales
"mensaje" : "" <-- Mensajes de la API
}], <-- Debe ser una lista de tamaño "num_videos"
"titulos" : [u""], <-- Titulos de los videos
"descs" : [u""] <-- Descripción de cada vídeo
}
Los valores que no se rellenen, deberán devolver None.
La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente:
{
"exito": False,
"mensaje": "No se pudo descargar el video"
}
"videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None)
"url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None)
"""
try: # Tratar de quitar caracteres especiales de las urls que no lo necesitan
self.url = self.url.split("video:")[0] + "video:_" + self.url.split("_")[1]
self.debug(u"Adaptar URL: %s" % self.url)
except:
pass
streamHTML = htmlBackup = (
Descargar.getHtml(self.url).decode("iso-8859-1").encode("utf8")
) # rtpa codigicada en iso..
streamHTML = streamHTML.replace("\n", "").replace("\t", "")
partes = None
# método 12/11/2012:
# if streamHTML.find("html5") != -1:
if re.findall("['\"]type['\"]\ *:\ *['\"]html5['\"]", streamHTML):
partes = 1
videoID = re.findall("\:\_(.*)\.", self.url)[0]
url = re.findall("['\"]file['\"]\ *?:\ *?['\"](.*?)['\"]", streamHTML)[0]
info = json.loads(Descargar.getHtmlUtf8(self.RTPA_API_INFO_ENDPOINT + videoID))
try:
name = Utiles.formatearNombre(
"%s (%s).mp4" % (info["VOD"][0]["nombre_programa"], info["VOD"][0]["fecha_emision"])
)
except:
name = u"ProgramaRTPA.mp4"
else:
# Cuantas partes son:
try:
partes = int(streamHTML.split("&partes=")[1].split("&")[0])
except IndexError: # No existe "&partes"
partes = 1
if partes == 1:
videoID = streamHTML.split('<param value="video1=')[1].split("&")[0]
if videoID.find("http://") != -1:
url = videoID
name = streamHTML.split('data-text="')[1].split('"')[0].strip() + "." + url.split(".")[-1]
else:
# Probar entre TOKEN nuevo y antiguo por reproductor:
repro = streamHTML.split('<param value="player/')[1].split('"')[0]
if repro == "reproductorVideoOnDemmand-mp4-rtpa.swf": # Antiguo
streamINFO = self.__descHTML(self.TOKEN_ARCHIVO + videoID)
url = "http://" + streamINFO.split("http://")[1]
else: # Reproductor nuevo: "reproductorVideoOnDemmand.swf"
streamINFO = self.__descHTML(self.TOKEN + videoID + "_1")
streamINFO = self.__descHTML(streamINFO.split("&url=")[1])
url = "http://" + streamINFO.split("http://")[1]
name = streamHTML.split('<div id="sobreElVideo">')[1].split("<h3>")[1].split("</h3>")[0]
if name == "":
name = streamHTML.split("<title>")[1].split("</title>")[0] + ".mp4"
else:
name + ".mp4"
else:
# Recordar que hay videos que ponen varias partes en las que realmente solo existe una:
videoID = streamHTML.split('<param value="video1=')[1].split("&")[0]
url = []
name = []
for i in range(1, partes + 1):
streamINFO = self.__descHTML(self.TOKEN + videoID + "_" + str(i))
streamINFO = self.__descHTML(streamINFO.split("&url=")[1])
tmp_url = "http://" + streamINFO.split("http://")[1]
tmp_name = (
streamHTML.split('<div id="sobreElVideo">')[1].split("<h3>")[1].split("</h3>")[0]
+ "_part"
+ str(i)
)
if tmp_name == "":
tmp_name = streamHTML.split("<title>")[1].split("</title>")[0] + "_part" + str(i) + ".mp4"
else:
tmp_name + ".mp4"
if Descargar.isReachable(tmp_url):
url.append(tmp_url)
name.appen(tmp_name)
continue
else:
break
# FIXME: Gran fixme aquí, arreglar todo esto de desc y de tit_vid
if info:
img = info["VOD"][0]["url_imagen"]
desc = u"%s (%s)" % (info["VOD"][0]["nombre_programa"], info["VOD"][0]["fecha_emision"])
try:
desc = unicode(desc).encode("utf8")
except:
desc = u"Vídeo de la web de Radio Televisión del Principado de Asturias".encode("utf8")
tit_vid = desc
else:
try: # imagen del vídeo
img = self.URL_RTPA + Utiles.recortar(htmlBackup, "'image': '", "'")
except:
img = None
desc = u""
try: # Descripción del vídeo
d = htmlBackup.split('<div class="overview">')[1].split("<div>")[1].split("</div>")[0].strip()
except:
try:
d = htmlBackup.split('<div class="overview">')[1].split("<p>")[1].split("</p>")[0].strip()
except:
pass
try: # desc coding
desc = unicode(d).encode("utf8")
except:
desc = u"Vídeo de la web de Radio Televisión del Principado de Asturias".encode("utf8")
if desc == u"":
desc = u"Vídeo de la web de Radio Televisión del Principado de Asturias".encode("utf8")
tit_vid = u""
try: # Título del vídeo
tit = htmlBackup.split('<div id="sobreElVideo">')[1].split("<h3>")[1].split("</h3>")[0].strip()
except:
try:
tit = (
htmlBackup.split('<div id="sobreElVideo">')[1]
.split('<h4 class="')[1]
.split(">")[1]
.split("<")[0]
.strip()
)
except:
pass
try: # titulo coding
tit = Utiles.tituloFormat(tit)
tit_vid = unicode(tit).encode("utf8")
except:
tit_vid = u"Vídeo de la web de Radio Televisión del Principado de Asturias".encode("utf8")
if tit_vid == u"":
tit_vid = u"Vídeo de la web de Radio Televisión del Principado de Asturias".encode("utf8")
if type(name) == list:
for i in name:
b = Utiles.formatearNombre(i)
name[name.index(i)] = b
else:
name = Utiles.formatearNombre(name)
return {
"exito": True,
"num_videos": 1,
"mensaje": u"URL obtenida correctamente",
"videos": [
{
"url_video": [url] if type(url) != list else url,
"url_img": img if img is not None else None,
"filename": [name] if name is not None else None,
"tipo": "http",
"partes": partes if partes is not None else 1,
"rtmpd_cmd": None,
"menco_cmd": None,
"url_publi": None,
"otros": None,
"mensaje": None,
}
],
"titulos": [tit_vid] if tit_vid is not None else None,
"descs": [desc] if desc is not None else None,
}
def getInfo(self):
"""
Devuelve toda la información asociada a la URL recibida, de la siguiente forma:
{
"exito" : bool, <-- True (si se han obtenido videos)
"num_video" : int, <-- Número de vídeos obtenidos
"mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False])
"videos" : [{
"url_video" : [], <-- Url de descarga de vídeo
"url_img" : "", <-- Url de la miniatura del video
"filename" : [], <-- Nombre de las partes para guardar en disco
"tipo" : "", <-- http, rtmp[e,..], mms, ...
"partes" : int, <-- Número de partes que tiene el vídeo
"rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None
"menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None
"url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo
"otros" : [], <-- Lista donde se pueden pasar cosas opcionales
"mensaje" : "" <-- Mensajes de la API
}], <-- Debe ser una lista de tamaño "num_videos"
"titulos" : [u""], <-- Titulos de los videos
"descs" : [u""] <-- Descripción de cada vídeo
}
Los valores que no se rellenen, deberán devolver None.
La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente:
{
"exito": False,
"mensaje": "No se pudo descargar el video"
}
"videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None)
"url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None)
"""
img = None
# print "[+] Procesando descarga"
streamHTML = Descargar.getHtml(self.url)
if self.url.find("atresplayer.com/") != -1:
return self.atresplayer_mobile()
elif self.url.find(".com/videos/") != -1: # Modo Salón
try:
img = self.URL_DE_ANTENA3 + Utiles.qe(streamHTML).split("player_capitulo.poster='/")[1].split("'")[0]
except:
if streamHTML.find('<div class="premium">') != -1:
raise Error.GeneralPyspainTVsError(
u"PyDownTV no acepta la descarga de contenidos premium de las cadenas."
)
url2down, name = self.__modoSalon(streamHTML)
else: # Otro vídeos (No modo salón)
self.log(u"[INFO] Vídeo normal (no Modo Salón)")
# EN PRUEBAS (nuevo modo normal) (17/05/2014) #######################################
xmls = re.findall(".*(http.*\/videosnuevosxml\/.*\.xml).*", streamHTML)
if len(xmls) > 0:
return self.normalNuevoMultiple(xmls)
######################################################################################
# EN PRUEBAS (solo si hay varios vídeos...)! (23/04/2013) [RETROCOMPATIBLE]: #########
xmls = re.findall("\.xml='(.*)'", streamHTML)
if len(xmls) > 1:
xmls = ["/".join(self.url.split("/")[:3]) + i for i in xmls]
return self.normalMultiple(xmls)
#####################################################################################
if streamHTML.find(".seoURL='") != -1: # Url directamente en HTML
self.debug(u"Vídeo con SEO URL")
img = self.URL_DE_ANTENA3 + streamHTML.split(".poster='/")[1].split("'")[0]
url2down, name = self.__modoNormalConURL(streamHTML)
elif streamHTML.find("a3_gp_visor_player") != -1:
self.log(u"[INFO] Vídeo de Fórmula 1")
return self.__modoF1(streamHTML) # return directamente aquí (varios videos)
else: # No está la url en el hmtl (buscar por varias partes)
if streamHTML.find('<div class="visor">') != -1: # Más de 1 parte # Quizas mejor "carrusel"?
return self.__modoNormalVariasPartes(streamHTML) # return directamente aquí (varios videos)
# url2down, name = self.__modoNormalVariasPartes(streamHTML)
else: # Solo una parte
url2down, name = self.__modoNormalUnaParte(streamHTML)
desc = None
try:
desc = Utiles.recortar(streamHTML, '<meta property="og:description" content="', '"').strip()
except:
try:
desc = Utiles.recortar(streamHTML, '<meta name="description" content="', '" />').strip()
except:
desc = None
# if type(url2down) == list:
# for i in url2down:
# if i.find("geobloqueo") != -1:
# self.log(u"[!!!] El vídeo \"" + i + "\" no se puedo descargar (geobloqueado)")
# url2down.remove(i)
# # TODO: Borrar también su nombre correspondiente
#
# # Comprobar si todas las partes están geobloqueadas (no quedan elementos en la lista):
# if len(url2down) == 0:
# raise Error.GeneralPyspainTVsError("Grupo Antena 3. Todo el contenido Geobloqueado.")
# else:
# if url2down.find("geobloqueo") != -1:
# raise Error.GeneralPyspainTVsError("Grupo Antena 3. Todo el contenido Geobloqueado.")
if type(name) == list:
try:
tit_vid = name[0].split(".")[0]
tit_vid = tit_vid.replace("_" + tit_vid.split("_")[1], "")
except:
try:
tit_vid = (
Utiles.recortar(streamHTML, "<title>", "</title>")
.replace("ANTENA 3 TV", "")
.replace("-", "")
.strip()
)
except:
tit_vid = "Vídeo de Grupo Antena 3"
for i in name:
b = Utiles.formatearNombre(i)
name[name.index(i)] = b
else:
try:
tit_vid = name.split(".")[0].replace("_" + name.split("_")[1], "")
tit_vid = tit_vid.replace("_" + tit_vid.split("_")[1], "")
except:
try:
tit_vid = (
Utiles.recortar(streamHTML, "<title>", "</title>")
.replace("ANTENA 3 TV", "")
.replace("-", "")
.strip()
)
except:
tit_vid = "Vídeo de Grupo Antena 3"
name = Utiles.formatearNombre(name)
# try:
# tit_vid = Utiles.recortar(streamHTML, "<title>", "</title>").replace("ANTENA 3 TV", "").replace("-", "").strip()
# except:
# tit_vid = "Vídeo de Grupo Antena 3"
tit_vid = tit_vid.replace("TV VIDEOS ONLINE", "").strip()
return {
"exito": True,
"num_videos": 1,
"mensaje": u"URL obtenido correctamente",
"videos": [
{
"url_video": [url2down] if type(url2down) != list else url2down,
"url_img": img if img is not None else None,
"filename": [name] if type(name) != list else name,
"tipo": "http",
"partes": 1 if type(url2down) != list else len(url2down),
"rtmpd_cmd": None,
"menco_cmd": None,
"url_publi": None,
"otros": None,
"mensaje": None,
}
],
"titulos": [tit_vid] if tit_vid is not None else None,
"descs": [desc] if desc is not None else None,
}
def getInfo(self):
'''
Devuelve toda la información asociada a la URL recibida, de la siguiente forma:
{
"exito" : bool, <-- True (si se han obtenido videos)
"num_video" : int, <-- Número de vídeos obtenidos
"mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False])
"videos" : [{
"url_video" : [], <-- Url de descarga de vídeo
"url_img" : "", <-- Url de la miniatura del video
"filename" : [], <-- Nombre de las partes para guardar en disco
"tipo" : "", <-- http, rtmp[e,..], mms, ...
"partes" : int, <-- Número de partes que tiene el vídeo
"rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None
"menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None
"url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo
"otros" : [], <-- Lista donde se pueden pasar cosas opcionales
"mensaje" : "" <-- Mensajes de la API
}], <-- Debe ser una lista de tamaño "num_videos"
"titulos" : [u""], <-- Titulos de los videos
"descs" : [u""] <-- Descripción de cada vídeo
}
Los valores que no se rellenen, deberán devolver None.
La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente:
{
"exito": False,
"mensaje": "No se pudo descargar el video"
}
"videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None)
"url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None)
'''
#TODO: Cuida con las paginas que tiene más de un vídeo. De momento funciona porque es el primer video que aparece!
# Primero: nos quedamos con le id dependiendo si el user metio la url con
# una barra (/) final o no y si tiene extensión (no es alacarta)
logging.debug(self.url)
videoID = self.url.split('/')[-1]
if videoID == "":
videoID = self.url.split('/')[-2]
elif videoID.find(".shtml") != -1 or videoID.find(".html") != -1 or \
videoID.find(".html") != -1:
videoID = videoID.split('.')[0]
if not videoID.isdigit(): videoID = self.getID(self.url)
try: self.debug(u"ID del vídeo en url = " + videoID)
except: pass
#if self.url.find("rtve.es/infantil/") != -1: self.url = self.url.replace("/#","") # Vídeos de Clan a veces falla con el ancla
# Añadido para vídeos nuevos (periodo de prueba):
sourceHTML = Descargar.getHtml(self.url).decode('string-escape')
#sourceHTML = self.toUtf(sourceHTML)
videoID_comp = None
if sourceHTML.find("flashcontentId:\'videoplayer") != -1:
videoID_comp = sourceHTML.split("flashcontentId:\'videoplayer")[1].split("\'")[0]
if videoID_comp != videoID: videoID = videoID_comp
if sourceHTML.find("<div id=\"video") != -1:
videoID_comp = sourceHTML.split("<div id=\"video")[1].split("\"")[0]
if videoID_comp != videoID and videoID_comp.isdigit(): videoID = videoID_comp
########################################################
self.debug(u"ID del vídeo en HTML = " + videoID_comp if videoID_comp else "No ID en HTML")
self.log(u"[INFO] ID del Vídeo :", videoID)
if videoID is None: raise Error.GeneralPyspainTVsError(u"No se encuentra el ID del vídeo")
if self.url.find("rtve.es/infantil/") != -1:
return self.__ClanTV(sourceHTML, videoID)
# -- Método 24 Mayo 2013
self.debug(u"Probando método de 24 de uno de Mayo de 2013")
try: manager = re.findall('data-idManager="(.*?)"', sourceHTML)[0]
except:
try: manager = re.findall('idManager="(.*?)"', sourceHTML)[0]
except: manager = "default"
# # Nuevo método (22/02/14) , dejo el actual que todavía funciona
# if sourceHTML.find("themadvideo.com/player/js/MadVideo.js.php") != -1:
# themadvideo_id = re.findall('<iframe.*id\=\"visor(.*)\"' , sourceHTML)[0]
# xmldata = Descargar.get("http://studio.themadvideo.com/api/videos/%s/player_data" % themadvideo_id).decode('utf8')
# xmltree = xml.etree.ElementTree.fromstring(xmldata)
# urlVideo = xmltree.find('./Layout/VideoPlayer/Data/src').text
# url_img = xmltree.find('./Layout/VideoPlayer/Data/Keyframe').text
# titulo = xmltree.find('.').attrib['title']
# try: name = Utiles.formatearNombre(titulo) + ".mp4"
# except: name = "VideoRtve.mp4"
# desc = None
tipo = "videos"
url = "http://www.rtve.es/ztnr/movil/thumbnail/%s/%s/%s.png" % (manager, tipo, videoID)
self.debug(u"Probando url:", url)
try:
tmp_ = decode(Descargar.getHtmlHeaders(url, {"Referer": "http://www.rtve.es"}))
tmp = re.findall(".*tEXt(.*)#[\x00]*([0-9]*).*", tmp_)[0]
tmp = [n for n in tmp]
cyphertext = tmp[0]
key = tmp[1]
tmp = tmp = [0 for n in range(500)]
# Créditos para: http://sgcg.es/articulos/2012/09/11/nuevos-cambios-en-el-mecanismo-para-descargar-contenido-multimedia-de-rtve-es-2/
intermediate_cyphertext = ""
increment = 1
text_index = 0
while text_index < len(cyphertext):
text_index = text_index + increment
try: intermediate_cyphertext = intermediate_cyphertext + cyphertext[text_index-1]
except: pass
increment = increment + 1
if increment == 5: increment = 1
plaintext = ""
key_index = 0
increment = 4
while key_index < len(key):
key_index = key_index + 1
text_index = int(key[key_index-1]) * 10
key_index = key_index + increment
try: text_index = text_index + int(key[key_index-1])
except: pass
text_index = text_index + 1
increment = increment + 1
if increment == 5: increment = 1
plaintext = plaintext + intermediate_cyphertext[text_index-1]
#try: plaintext = plaintext + intermediate_cyphertext[text_index-1]
#except: pass
urlVideo = plaintext
except:
ads = "6037182945"
str1 = "51%s-" % videoID
inverted_str1 = str1[::-1]
s = "".join([ads[int(n)] for n in inverted_str1[1:]])
url = "http://ztnr.rtve.es/ztnr/pub/%s/%s/%s/%s/%s" % (s[0],s[1],s[2],s[3],s)
self.debug(u"Probando url:", url)
xmldata = Descargar.doPOST("www.pydowntv.com", "/utils/cnR2ZV9yYW5kb21fNA/", {"encrypted":Descargar.get(url)})
self.debug(xmldata.replace(xmldata[xmldata.find("</quality>")+10:],""))
try:
xmltree = xml.etree.ElementTree.fromstring(xmldata.replace(xmldata[xmldata.find("</quality>")+10:],""))
for node in xmltree.findall("./preset"):
if node.attrib.get('type') == "Alta":
for url in node.findall("./response/url"):
if url.attrib.get('provider') == "AKAMAI_STR-1030":
urlVideo = url.text
except:
urlVideo = re.findall("<url.*>(.*)</url>", xmldata)[0]
if urlVideo != "":
if not urlVideo.endswith(".mp4"): urlVideo = urlVideo.replace(urlVideo.split(".mp4")[1], "")
url_video = urlVideo.replace("www.rtve.es", "media5.rtve.es").replace("iphonelive","mvod")
titulo = sourceHTML.split("<title>")[1].split("</")[0].replace("RTVE.es", "").replace("-", "").strip()
filename = titulo + ".mp4"
filename = Utiles.formatearNombre(filename)
try: url_img = sourceHTML.split("\"thumbnail\" content=\"")[1].split("\"")[0]
except:
try: url_img = re.findall('<link.*rel\=\"image_src\".*href\=\"(.*)\"' , sourceHTML)[0]
except: url_img = re.findall('<meta.*name\=\"RTVE\.thumb_video\".*content\=\"(.*)\"',sourceHTML)[0]
else:
raise Error.GeneralPyspainTVsError("No se pudo encontrar el enlace de descarga")
#TEMP FIX:
#url_video = url_video.replace(url_video.split(".")[1], url_video.split(".")[1][:3])
# -- Método 24 Mayo 2013 FIN
desc = None
try: #obtener descripción del video
desc = Utiles.recortar(sourceHTML, "<meta itemprop=\"description\" content=\"", "\"").strip()
except:
try:
desc = Utiles.recortar(sourceHTML, "<meta property=\"og:description\" content=\"", "\"").strip()
except:
try:
desc = Utiles.recortar(sourceHTML, "<meta name=\"description\" content=\"", "\"").strip()
except:
desc = u"Vídeos de Televión Española"
# Comprobar si existe calidad FLV
url_flv = url_video.replace("mp4", "flv")
if Descargar.isReachableHead(url_flv):
msgCalidad = u'''Este vídeo dispone de dos calidades.
Para los vídeos de RTVE, la mejor suele ser la que se presenta en formato FLV.
En los vídeos con más tiempo puede que el audio al principio no esté bien sincronizado
con el audio. Este problema será menos grave en el formato FLV llegándose incluso a
sincronizar totalmente pasados unos segundos.'''.encode('utf8')
return {"exito" : True,
"num_videos" : 2,
"mensaje" : u"URL obtenido correctamente",
"videos":[{
"url_video" : [url_video],
"url_img" : url_img,
"filename" : [filename],
"tipo" : "http",
"partes" : 1,
"rtmpd_cmd" : None,
"menco_cmd" : None,
"url_publi" : None,
"otros" : "MP4",
"mensaje" : msgCalidad
},
{
"url_video" : [url_flv],
"url_img" : url_img,
"filename" : [filename.replace(".mp4", ".flv")],
"tipo" : "http",
"partes" : 1,
"rtmpd_cmd" : None,
"menco_cmd" : None,
"url_publi" : None,
"otros" : "FLV",
"mensaje" : msgCalidad
}],
"titulos": [titulo,titulo],
"descs": [desc, desc]
}
else:
return {"exito" : True,
"num_videos" : 1,
"mensaje" : u"URL obtenido correctamente",
"videos":[{
"url_video" : [url_video],
"url_img" : url_img,
"filename" : [filename],
"tipo" : "http",
"partes" : 1,
"rtmpd_cmd" : None,
"menco_cmd" : None,
"url_publi" : None,
"otros" : None,
"mensaje" : None
}],
"titulos": [titulo],
"descs": [desc] if desc is not None else None
}
def getInfo(self):
'''
Devuelve toda la información asociada a la URL recibida, de la siguiente forma:
{
"exito" : bool, <-- True (si se han obtenido videos)
"num_video" : int, <-- Número de vídeos obtenidos
"mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False])
"videos" : [{
"url_video" : [], <-- Url de descarga de vídeo
"url_img" : "", <-- Url de la miniatura del video
"filename" : [], <-- Nombre de las partes para guardar en disco
"tipo" : "", <-- http, rtmp[e,..], mms, ...
"partes" : int, <-- Número de partes que tiene el vídeo
"rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None
"menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None
"url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo
"otros" : [], <-- Lista donde se pueden pasar cosas opcionales
"mensaje" : "" <-- Mensajes de la API
}], <-- Debe ser una lista de tamaño "num_videos"
"titulos" : [u""], <-- Titulos de los videos
"descs" : [u""] <-- Descripción de cada vídeo
}
Los valores que no se rellenen, deberán devolver None.
La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente:
{
"exito": False,
"mensaje": "No se pudo descargar el video"
}
"videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None)
"url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None)
'''
#TODO: Cuida con las paginas que tiene más de un vídeo. De momento funciona porque es el primer video que aparece!
# Primero: nos quedamos con le id dependiendo si el user metio la url con
# una barra (/) final o no y si tiene extensión (no es alacarta)
logging.debug(self.url)
videoID = self.url.split('/')[-1]
if videoID == "":
videoID = self.url.split('/')[-2]
elif videoID.find(".shtml") != -1 or videoID.find(".html") != -1 or \
videoID.find(".html") != -1:
videoID = videoID.split('.')[0]
if not videoID.isdigit(): videoID = self.getID(self.url)
try: self.debug(u"ID del vídeo en url = " + videoID)
except: pass
#if self.url.find("rtve.es/infantil/") != -1: self.url = self.url.replace("/#","") # Vídeos de Clan a veces falla con el ancla
# Añadido para vídeos nuevos (periodo de prueba):
sourceHTML = Descargar.getHtml(self.url).decode('string-escape')
#sourceHTML = self.toUtf(sourceHTML)
videoID_comp = None
if sourceHTML.find("flashcontentId:\'videoplayer") != -1:
videoID_comp = sourceHTML.split("flashcontentId:\'videoplayer")[1].split("\'")[0]
if videoID_comp != videoID: videoID = videoID_comp
if sourceHTML.find("<div id=\"video") != -1:
videoID_comp = sourceHTML.split("<div id=\"video")[1].split("\"")[0]
if videoID_comp != videoID and videoID_comp.isdigit(): videoID = videoID_comp
########################################################
self.debug(u"ID del vídeo en HTML = " + videoID_comp if videoID_comp else "No ID en HTML")
self.log(u"[INFO] ID del Vídeo :", videoID)
if videoID is None: raise Error.GeneralPyspainTVsError(u"No se encuentra el ID del vídeo")
if self.url.find("rtve.es/infantil/") != -1:
return self.__ClanTV(sourceHTML, videoID)
# -- Método 1 Octubre 2012:
# self.debug(u"Probando método de 1 de uno de Octubre de 2012")
# url = "http://www.rtve.es/ztnr/consumer/xl/video/alta/" + videoID + "_es_292525252525111"
# self.debug(url)
# user_agent="Mozilla"
# opener = urllib2.build_opener(NoRedirectHandler())
# urllib2.install_opener(opener)
# headers = { 'User-Agent' : user_agent }
# req = urllib2.Request(url, None, headers)
# u = urllib2.urlopen(req)
# try:
# urlVideo = u.info().getheaders("Location")[0]
# except:
# raise Error.GeneralPyspainTVsError("No se encuentra Location")
# u.close()
# if urlVideo != "":
# url_video = urlVideo.replace("www.rtve.es", "media5.rtve.es")
# titulo = sourceHTML.split("<title>")[1].split("</")[0].replace("RTVE.es", "").replace("-", "").strip()
# filename = titulo + ".mp4"
# filename = Utiles.formatearNombre(filename)
# #sourceHTML = sourceHTML.split("<div id=\"video")[1].split("flashvars")[0] # Me quedo solo con la parte del vídeo principal
# url_img = sourceHTML.split("\"thumbnail\" content=\"")[1].split("\"")[0]
# else:
# raise Error.GeneralPyspainTVsError("No se pudo encontrar el enlace de descarga")
# -- Método 1 Octubre 2012 FIN
# -- Método 24 Mayo 2013
self.debug(u"Probando método de 24 de uno de Mayo de 2013")
manager = re.findall('data-idManager="(.*?)"', sourceHTML)[0] or re.findall('idManager="(.*?)"', sourceHTML)[0] or "default"
tipo = "videos"
url = "http://www.rtve.es/ztnr/movil/thumbnail/%s/%s/%s.png" % (manager, tipo, videoID)
self.debug(u"Probando url:", url)
tmp_ = decode(Descargar.get(url))
tmp = re.findall(".*tEXt(.*)#[\x00]*([0-9]*).*", tmp_)[0]
tmp = [n for n in tmp]
cyphertext = tmp[0]
key = tmp[1]
tmp = tmp = [0 for n in range(500)]
# Créditos para: http://sgcg.es/articulos/2012/09/11/nuevos-cambios-en-el-mecanismo-para-descargar-contenido-multimedia-de-rtve-es-2/
intermediate_cyphertext = ""
increment = 1
text_index = 0
while text_index < len(cyphertext):
text_index = text_index + increment
try: intermediate_cyphertext = intermediate_cyphertext + cyphertext[text_index-1]
except: pass
increment = increment + 1
if increment == 5: increment = 1
plaintext = ""
key_index = 0
increment = 4
while key_index < len(key):
key_index = key_index + 1
text_index = int(key[key_index-1]) * 10
key_index = key_index + increment
try: text_index = text_index + int(key[key_index-1])
except: pass
text_index = text_index + 1
increment = increment + 1
if increment == 5: increment = 1
plaintext = plaintext + intermediate_cyphertext[text_index-1]
#try: plaintext = plaintext + intermediate_cyphertext[text_index-1]
#except: pass
urlVideo = plaintext
if urlVideo != "":
if not urlVideo.endswith(".mp4"): urlVideo = urlVideo.replace(urlVideo.split(".mp4")[1], "")
url_video = urlVideo.replace("www.rtve.es", "media5.rtve.es")
titulo = sourceHTML.split("<title>")[1].split("</")[0].replace("RTVE.es", "").replace("-", "").strip()
filename = titulo + ".mp4"
filename = Utiles.formatearNombre(filename)
url_img = sourceHTML.split("\"thumbnail\" content=\"")[1].split("\"")[0]
else:
raise Error.GeneralPyspainTVsError("No se pudo encontrar el enlace de descarga")
#TEMP FIX:
#url_video = url_video.replace(url_video.split(".")[1], url_video.split(".")[1][:3])
# -- Método 24 Mayo 2013 FIN
desc = None
try: #obtener descripción del video
desc = Utiles.recortar(sourceHTML, "<meta itemprop=\"description\" content=\"", "\"").strip()
except:
try:
desc = Utiles.recortar(sourceHTML, "<meta property=\"og:description\" content=\"", "\"").strip()
except:
try:
desc = Utiles.recortar(sourceHTML, "<meta name=\"description\" content=\"", "\"").strip()
except:
desc = u"Vídeos de Televión Española"
# Comprobar si existe calidad FLV
url_flv = url_video.replace("mp4", "flv")
if Descargar.isReachableHead(url_flv):
msgCalidad = u'''Este vídeo dispone de dos calidades.
Para los vídeos de RTVE, la mejor suele ser la que se presenta en formato FLV.
En los vídeos con más tiempo puede que el audio al principio no esté bien sincronizado
con el audio. Este problema será menos grave en el formato FLV llegándose incluso a
sincronizar totalmente pasados unos segundos.'''.encode('utf8')
return {"exito" : True,
"num_videos" : 2,
"mensaje" : u"URL obtenido correctamente",
"videos":[{
"url_video" : [url_video],
"url_img" : url_img,
"filename" : [filename],
"tipo" : "http",
"partes" : 1,
"rtmpd_cmd" : None,
"menco_cmd" : None,
"url_publi" : None,
"otros" : "MP4",
"mensaje" : msgCalidad
},
{
"url_video" : [url_flv],
"url_img" : url_img,
"filename" : [filename.replace(".mp4", ".flv")],
"tipo" : "http",
"partes" : 1,
"rtmpd_cmd" : None,
"menco_cmd" : None,
"url_publi" : None,
"otros" : "FLV",
"mensaje" : msgCalidad
}],
"titulos": [titulo,titulo],
"descs": [desc, desc]
}
else:
return {"exito" : True,
"num_videos" : 1,
"mensaje" : u"URL obtenido correctamente",
"videos":[{
"url_video" : [url_video],
"url_img" : url_img,
"filename" : [filename],
"tipo" : "http",
"partes" : 1,
"rtmpd_cmd" : None,
"menco_cmd" : None,
"url_publi" : None,
"otros" : None,
"mensaje" : None
}],
"titulos": [titulo],
"descs": [desc] if desc is not None else None
}
def getInfo(self):
'''
Devuelve toda la información asociada a la URL recibida, de la siguiente forma:
{
"exito" : bool, <-- True (si se han obtenido videos)
"num_video" : int, <-- Número de vídeos obtenidos
"mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False])
"videos" : [{
"url_video" : [], <-- Url de descarga de vídeo
"url_img" : "", <-- Url de la miniatura del video
"filename" : [], <-- Nombre de las partes para guardar en disco
"tipo" : "", <-- http, rtmp[e,..], mms, ...
"partes" : int, <-- Número de partes que tiene el vídeo
"rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None
"menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None
"url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo
"otros" : [], <-- Lista donde se pueden pasar cosas opcionales
"mensaje" : "" <-- Mensajes de la API
}], <-- Debe ser una lista de tamaño "num_videos"
"titulos" : [u""], <-- Titulos de los videos
"descs" : [u""] <-- Descripción de cada vídeo
}
Los valores que no se rellenen, deberán devolver None.
La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente:
{
"exito": False,
"mensaje": "No se pudo descargar el video"
}
"videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None)
"url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None)
'''
img = None
# print "[+] Procesando descarga"
streamHTML = Descargar.getHtml(self.url)
if self.url.find(".com/videos/") != -1: # Modo Salón
try:
img = self.URL_DE_ANTENA3 + Utiles.qe(streamHTML).split(
"player_capitulo.poster=\'/")[1].split("\'")[0]
except:
if streamHTML.find("<div class=\"premium\">") != -1:
raise Error.GeneralPyspainTVsError(
u"PyDownTV no acepta la descarga de contenidos premium de las cadenas."
)
url2down, name = self.__modoSalon(streamHTML)
else: # Otro vídeos (No modo salón)
self.log(u"[INFO] Vídeo normal (no Modo Salón)")
# EN PRUEBAS (solo si hay varios vídeos...)! (23/04/2013) [RETROCOMPATIBLE]: #########
xmls = re.findall("\.xml='(.*)'", streamHTML)
if len(xmls) > 1:
xmls = ["/".join(self.url.split("/")[:3]) + i for i in xmls]
return self.normalMultiple(xmls)
#####################################################################################
if streamHTML.find(".seoURL='") != -1: # Url directamente en HTML
self.debug(u"Vídeo con SEO URL")
img = self.URL_DE_ANTENA3 + streamHTML.split(
".poster=\'/")[1].split("\'")[0]
url2down, name = self.__modoNormalConURL(streamHTML)
elif streamHTML.find("a3_gp_visor_player") != -1:
self.log(u"[INFO] Vídeo de Fórmula 1")
return self.__modoF1(
streamHTML) # return directamente aquí (varios videos)
else: # No está la url en el hmtl (buscar por varias partes)
if streamHTML.find(
"<div class=\"visor\">"
) != -1: # Más de 1 parte # Quizas mejor "carrusel"?
return self.__modoNormalVariasPartes(
streamHTML) # return directamente aquí (varios videos)
#url2down, name = self.__modoNormalVariasPartes(streamHTML)
else: # Solo una parte
url2down, name = self.__modoNormalUnaParte(streamHTML)
desc = None
try:
desc = Utiles.recortar(
streamHTML, "<meta property=\"og:description\" content=\"",
"\"").strip()
except:
try:
desc = Utiles.recortar(
streamHTML, "<meta name=\"description\" content=\"",
"\" />").strip()
except:
desc = None
#if type(url2down) == list:
# for i in url2down:
# if i.find("geobloqueo") != -1:
# self.log(u"[!!!] El vídeo \"" + i + "\" no se puedo descargar (geobloqueado)")
# url2down.remove(i)
# # TODO: Borrar también su nombre correspondiente
#
# # Comprobar si todas las partes están geobloqueadas (no quedan elementos en la lista):
# if len(url2down) == 0:
# raise Error.GeneralPyspainTVsError("Grupo Antena 3. Todo el contenido Geobloqueado.")
#else:
# if url2down.find("geobloqueo") != -1:
# raise Error.GeneralPyspainTVsError("Grupo Antena 3. Todo el contenido Geobloqueado.")
if type(name) == list:
try:
tit_vid = name[0].split(".")[0]
tit_vid = tit_vid.replace("_" + tit_vid.split("_")[1], "")
except:
try:
tit_vid = Utiles.recortar(streamHTML, "<title>",
"</title>").replace(
"ANTENA 3 TV",
"").replace("-", "").strip()
except:
tit_vid = "Vídeo de Grupo Antena 3"
for i in name:
b = Utiles.formatearNombre(i)
name[name.index(i)] = b
else:
try:
tit_vid = name.split(".")[0].replace("_" + name.split("_")[1],
"")
tit_vid = tit_vid.replace("_" + tit_vid.split("_")[1], "")
except:
try:
tit_vid = Utiles.recortar(streamHTML, "<title>",
"</title>").replace(
"ANTENA 3 TV",
"").replace("-", "").strip()
except:
tit_vid = "Vídeo de Grupo Antena 3"
name = Utiles.formatearNombre(name)
#try:
# tit_vid = Utiles.recortar(streamHTML, "<title>", "</title>").replace("ANTENA 3 TV", "").replace("-", "").strip()
#except:
# tit_vid = "Vídeo de Grupo Antena 3"
tit_vid = tit_vid.replace("TV VIDEOS ONLINE", "").strip()
return {
"exito":
True,
"num_videos":
1,
"mensaje":
u"URL obtenido correctamente",
"videos": [{
"url_video":
[url2down] if type(url2down) != list else url2down,
"url_img": img if img is not None else None,
"filename": [name] if type(name) != list else name,
"tipo": "http",
"partes": 1 if type(url2down) != list else len(url2down),
"rtmpd_cmd": None,
"menco_cmd": None,
"url_publi": None,
"otros": None,
"mensaje": None
}],
"titulos": [tit_vid] if tit_vid is not None else None,
"descs": [desc] if desc is not None else None
}
def getInfo(self):
'''
Devuelve toda la información asociada a la URL recibida, de la siguiente forma:
{
"exito" : bool, <-- True (si se han obtenido videos)
"num_video" : int, <-- Número de vídeos obtenidos
"mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False])
"videos" : [{
"url_video" : [], <-- Url de descarga de vídeo
"url_img" : "", <-- Url de la miniatura del video
"filename" : [], <-- Nombre de las partes para guardar en disco
"tipo" : "", <-- http, rtmp[e,..], mms, ...
"partes" : int, <-- Número de partes que tiene el vídeo
"rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None
"menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None
"url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo
"otros" : [], <-- Lista donde se pueden pasar cosas opcionales
"mensaje" : "" <-- Mensajes de la API
}], <-- Debe ser una lista de tamaño "num_videos"
"titulos" : [u""], <-- Titulos de los videos
"descs" : [u""] <-- Descripción de cada vídeo
}
Los valores que no se rellenen, deberán devolver None.
La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente:
{
"exito": False,
"mensaje": "No se pudo descargar el video"
}
"videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None)
"url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None)
'''
url_img = None
streamHTML = Descargar.getHtml(self.url).decode('string-escape')
if streamHTML.find("CUAVID") != -1:
self.debug(u"CUAVID")
ContentID = streamHTML.split("imageContentId: \'")[1].split("\'")[0]
streamJSON = Descargar.getHtml(self.URL_SOURCES + ContentID)
url2down = streamJSON.split("\"src\":\"")[1].split("\"")[0].replace("\/", "/")
name = streamJSON.split("\"wrpContent\":\"")[1].split("\"")[0] + ".mp4"
elif streamHTML.find("MDS.embedObj(video") != -1: # Este parece ser el único método a 16/10/2012 (pero dejo los demás..)
self.debug(u"MDS.embedObj")
contentID = streamHTML.split("MDS.embedObj(video, \"")[1].split("\"")[0]
clippingID = streamHTML.split("imageClippingId: \'")[1].split("\'")[0]
imageContentID = streamHTML.split("imageContentId: \'")[1].split("\'")[0]
self.debug("URL Json: "+self.URL_JSON + "contentId=" + contentID + "&clippingId=" + clippingID + "&imageContentId=" + imageContentID)
streamJSON = Descargar.getHtml( self.URL_JSON +
"contentId=" + contentID +
"&clippingId=" + clippingID +
"&imageContentId=" + imageContentID
)
#streamJSON = dict(streamJSON)
#url2down = streamJSON["sources"][0]["src"]
url2down = streamJSON.split("({\"sources\":[{\"src\":\"")[1].split("\"")[0].replace("\/", "/")
name = streamHTML.split("<title>")[1].split("<")[0]
name += "." + url2down.split(".")[-1].split("?")[0]
url_img = streamJSON.split("\"poster\":\"")[1].split("\"")[0].replace("\/", "/")
elif streamHTML.find("src_iframe:") != -1:
self.info(u"[INFO] Vídeo Común")
name = streamHTML.split("<title>")[1].split("<")[0]
urlComunes = self.URL_CUATRO + streamHTML.split("src_iframe:")[1].replace(" ", "").split("\'")[1].split("\'")[0]
streamComunes = Descargar.getHtml(urlComunes)
url2down = streamComunes.split("document.write(\'<video id=")[1].split("src=\"")[1].split("\"")[0]
ext= "." + url2down.split(".")[-1]
name += ext
else:
raise Error.GeneralPyspainTVsError("Cuatro.com: No se encuentra contenido")
tit_vid = None
if name:
name = name.replace("Ver vídeo online","")
tit_vid = name.split(".")[0]
name = Utiles.formatearNombre(name)
desc = None
try:
desc = Utiles.recortar(streamHTML, "<h3 class=\"subtitle\">", "<").strip()
except:
desc = tit_vid if tit_vid is not None else None
return {"exito" : True,
"num_videos" : 1,
"mensaje" : u"URL obtenido correctamente",
"videos":[{
"url_video" : [url2down],
"url_img" : url_img if url_img is not None else None,
"filename" : [name] if name is not None else None,
"tipo" : "http",
"partes" : 1,
"rtmpd_cmd" : None,
"menco_cmd" : None,
"url_publi" : None,
"otros" : None,
"mensaje" : None
}],
"titulos": [tit_vid] if tit_vid is not None else None,
"descs": [desc] if desc is not None else None
}
def getInfo(self):
'''
Devuelve toda la información asociada a la URL recibida, de la siguiente forma:
{
"exito" : bool, <-- True (si se han obtenido videos)
"num_video" : int, <-- Número de vídeos obtenidos
"mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False])
"videos" : [{
"url_video" : [], <-- Url de descarga de vídeo
"url_img" : "", <-- Url de la miniatura del video
"filename" : [], <-- Nombre de las partes para guardar en disco
"tipo" : "", <-- http, rtmp[e,..], mms, ...
"partes" : int, <-- Número de partes que tiene el vídeo
"rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None
"menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None
"url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo
"otros" : [], <-- Lista donde se pueden pasar cosas opcionales
"mensaje" : "" <-- Mensajes de la API
}], <-- Debe ser una lista de tamaño "num_videos"
"titulos" : [u""], <-- Titulos de los videos
"descs" : [u""] <-- Descripción de cada vídeo
}
Los valores que no se rellenen, deberán devolver None.
La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente:
{
"exito": False,
"mensaje": "No se pudo descargar el video"
}
"videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None)
"url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None)
'''
#TODO: Cuida con las paginas que tiene más de un vídeo. De momento funciona porque es el primer video que aparece!
# Primero: nos quedamos con le id dependiendo si el user metio la url con
# una barra (/) final o no y si tiene extensión (no es alacarta)
videoID = self.url.split('/')[-1]
if videoID == "":
videoID = self.url.split('/')[-2]
elif videoID.find(".shtml") != -1 or videoID.find(".html") != -1 or \
videoID.find(".html") != -1:
videoID = videoID.split('.')[0]
self.debug(u"ID del vídeo en url = " + videoID)
# Añadido para vídeos nuevos (periodo de prueba):
sourceHTML = Descargar.getHtml(self.url)
videoID_comp = None
if sourceHTML.find("flashcontentId:\'videoplayer") != -1:
videoID_comp = sourceHTML.split("flashcontentId:\'videoplayer")[1].split("\'")[0]
if videoID_comp != videoID: videoID = videoID_comp
if sourceHTML.find("<div id=\"video") != -1:
videoID_comp = sourceHTML.split("<div id=\"video")[1].split("\"")[0]
if videoID_comp != videoID: videoID = videoID_comp
########################################################
self.debug(u"ID del vídeo en HTML = " + videoID_comp if videoID_comp else "No ID en HTML")
self.log(u"[INFO] ID del Vídeo :", videoID)
# -- Método 1 Octubre 2012:
self.debug(u"Probando método de 1 de uno de Octubre de 2012")
url = "http://www.rtve.es/ztnr/consumer/xl/video/alta/" + videoID + "_es_292525252525111"
self.debug(url)
user_agent="Mozilla"
opener = urllib2.build_opener(NoRedirectHandler())
urllib2.install_opener(opener)
headers = { 'User-Agent' : user_agent }
req = urllib2.Request(url, None, headers)
u = urllib2.urlopen(req)
try:
urlVideo = u.info().getheaders("Location")[0]
except:
raise Error.GeneralPyspainTVsError("No se encuentra Location")
u.close()
if urlVideo != "":
url_video = urlVideo.replace("www.rtve.es", "media5.rtve.es")
titulo = sourceHTML.split("<title>")[1].split("</")[0]
filename = titulo + ".mp4"
filename = Utiles.formatearNombre(filename)
#sourceHTML = sourceHTML.split("<div id=\"video")[1].split("flashvars")[0] # Me quedo solo con la parte del vídeo principal
url_img = sourceHTML.split("\"thumbnail\" content=\"")[1].split("\"")[0]
else:
raise Error.GeneralPyspainTVsError("No se pudo encontrar el enlace de descarga")
# -- Método 1 Octubre 2012 FIN
desc = None
try: #obtener descripción del video
desc = Utiles.recortar(sourceHTML, "<meta itemprop=\"description\" content=\"", "\"").strip()
except:
try:
desc = Utiles.recortar(sourceHTML, "<meta property=\"og:description\" content=\"", "\"").strip()
except:
try:
desc = Utiles.recortar(sourceHTML, "<meta name=\"description\" content=\"", "\"").strip()
except:
desc = None
return {"exito" : True,
"num_videos" : 1,
"mensaje" : u"URL obtenido correctamente",
"videos":[{
"url_video" : [url_video],
"url_img" : url_img,
"filename" : [filename],
"tipo" : "http",
"partes" : 1,
"rtmpd_cmd" : None,
"menco_cmd" : None,
"url_publi" : None,
"otros" : None,
"mensaje" : None
}],
"titulos": [titulo],
"descs": [desc] if desc is not None else None
}
def getInfo(self):
'''
Devuelve toda la información asociada a la URL recibida, de la siguiente forma:
{
"exito" : bool, <-- True (si se han obtenido videos)
"num_video" : int, <-- Número de vídeos obtenidos
"mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False])
"videos" : [{
"url_video" : [], <-- Url de descarga de vídeo
"url_img" : "", <-- Url de la miniatura del video
"filename" : [], <-- Nombre de las partes para guardar en disco
"tipo" : "", <-- http, rtmp[e,..], mms, ...
"partes" : int, <-- Número de partes que tiene el vídeo
"rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None
"menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None
"url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo
"otros" : [], <-- Lista donde se pueden pasar cosas opcionales
"mensaje" : "" <-- Mensajes de la API
}], <-- Debe ser una lista de tamaño "num_videos"
"titulos" : [u""], <-- Titulos de los videos
"descs" : [u""] <-- Descripción de cada vídeo
}
Los valores que no se rellenen, deberán devolver None.
La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente:
{
"exito": False,
"mensaje": "No se pudo descargar el video"
}
"videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None)
"url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None)
'''
img = None
# print "[+] Procesando descarga"
streamHTML = Descargar.getHtml(self.url)
if self.url.find(".com/videos/") != -1: # Modo Salón
img = self.URL_DE_ANTENA3 + Utiles.qe(streamHTML).split("player_capitulo.poster=\'/")[1].split("\'")[0]
url2down, name = self.__modoSalon(streamHTML)
else: # Otro vídeos (No modo salón)
self.log(u"[INFO] Vídeo normal (no Modo Salón)")
if streamHTML.find(".seoURL='") != -1: # Url directamente en HTML
img = self.URL_DE_ANTENA3 + streamHTML.split(".poster=\'/")[1].split("\'")[0]
url2down, name = self.__modoNormalConURL(streamHTML)
elif streamHTML.find("a3_gp_visor_player") != -1:
self.log(u"[INFO] Vídeo de Fórmula 1")
return self.__modoF1(streamHTML) # return directamente aquí
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)
desc = None
try:
desc = Utiles.recortar(streamHTML, "<meta property=\"og:description\" content=\"", "\"").strip()
except:
try:
desc = Utiles.recortar(streamHTML, "<meta name=\"description\" content=\"", "\" />").strip()
except:
desc = None
#if type(url2down) == list:
# for i in url2down:
# if i.find("geobloqueo") != -1:
# self.log(u"[!!!] El vídeo \"" + i + "\" no se puedo descargar (geobloqueado)")
# url2down.remove(i)
# # TODO: Borrar también su nombre correspondiente
#
# # Comprobar si todas las partes están geobloqueadas (no quedan elementos en la lista):
# if len(url2down) == 0:
# raise Error.GeneralPyspainTVsError("Grupo Antena 3. Todo el contenido Geobloqueado.")
#else:
# if url2down.find("geobloqueo") != -1:
# raise Error.GeneralPyspainTVsError("Grupo Antena 3. Todo el contenido Geobloqueado.")
if type(name) == list:
tit_vid = name[0].split(".")[0]
for i in name:
b = Utiles.formatearNombre(i)
name[name.index(i)] = b
else:
tit_vid = name.split(".")[0]
name = Utiles.formatearNombre(name)
return {"exito" : True,
"num_videos" : 1,
"mensaje" : u"URL obtenido correctamente",
"videos":[{
"url_video" : [url2down] if type(url2down) != list else url2down,
"url_img" : img if img is not None else None,
"filename" : [name] if type(name) != list else name,
"tipo" : "http",
"partes" : 1 if type(url2down) != list else len(url2down),
"rtmpd_cmd" : None,
"menco_cmd" : None,
"url_publi" : None,
"otros" : None,
"mensaje" : u"URL obtenida correctamente" if type(url2down) != list else u"URLs obtenida correctamente"
}],
"titulos": [tit_vid] if tit_vid is not None else None,
"descs": [desc] if desc is not None else None
}
def getInfo(self):
'''
Devuelve toda la información asociada a la URL recibida, de la siguiente forma:
{
"exito" : bool, <-- True (si se han obtenido videos)
"num_video" : int, <-- Número de vídeos obtenidos
"mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False])
"videos" : [{
"url_video" : [], <-- Url de descarga de vídeo
"url_img" : "", <-- Url de la miniatura del video
"filename" : [], <-- Nombre de las partes para guardar en disco
"tipo" : "", <-- http, rtmp[e,..], mms, ...
"partes" : int, <-- Número de partes que tiene el vídeo
"rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None
"menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None
"url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo
"otros" : [], <-- Lista donde se pueden pasar cosas opcionales
"mensaje" : "" <-- Mensajes de la API
}], <-- Debe ser una lista de tamaño "num_videos"
"titulos" : [u""], <-- Titulos de los videos
"descs" : [u""] <-- Descripción de cada vídeo
}
Los valores que no se rellenen, deberán devolver None.
La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente:
{
"exito": False,
"mensaje": "No se pudo descargar el video"
}
"videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None)
"url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None)
'''
url_img = None
streamHTML = Descargar.getHtml(self.url)
if streamHTML.find("http://level3/") != -1: # Método antiguo
self.info(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]
self.info(u"[INFO] Nuevo Video ID:", newID)
ask4token = self.URL_ASK4TOKEN + newID[-3:] + "/" + newID + ".mp4"
self.debug(u"[+] Pidiendo nuevo token")
url2down = Descargar.getHtml(ask4token)
name = streamHTML.split("var title = \'")[1].split("\'")[0] + ".mp4"
elif self.url.find("videoURL=") != -1: # Forma con el ID en la URL (nueva??)
videoID = self.url.split("videoURL=")[1]
ask4token = self.URL_ASK4TOKEN + videoID[-3:] + "/" + videoID + ".mp4"
self.debug(u"[+] Pidiendo nuevo token")
url2down = Descargar.getHtml(ask4token)
# Obtner nombre:
xmlURL = "http://estaticos.telecinco.es/xml/Video/Video_" + videoID + ".xml"
streamXML = Descargar.getHtml(xmlURL)
name = streamXML.split("<![CDATA[")[1].split("]")[0] + ".mp4"
elif streamHTML.find("MDS.embedObj(video") != -1:
contentID = streamHTML.split("MDS.embedObj(video, \"")[1].split("\"")[0]
try: clippingID = streamHTML.split("imageClippingId: \'")[1].split("\'")[0] # try por que en la API no funcionaba oO
except: clippingID = "3.jpg"
try: imageContentID = streamHTML.split("imageContentId: \'")[1].split("\'")[0] # try por problemas com la API oO
except: imageContentID = streamHTML.split("MDS.embedObj(video, \"")[1].split("\"")[0]
self.debug(u"URL JSON: " + self.URL_JSON + "contentId=" + contentID + "&clippingId=" + clippingID + "&imageContentId=" + imageContentID)
streamJSON = Descargar.getHtml(self.URL_JSON +
"contentId=" + contentID +
"&clippingId=" + clippingID +
"&imageContentId=" + imageContentID
)
#streamJSON = dict(streamJSON)
#url2down = streamJSON["sources"][0]["src"]
url2down = streamJSON.split("({\"sources\":[{\"src\":\"")[1].split("\"")[0].replace("\/", "/")
name = streamHTML.split("<title>")[1].split("<")[0]
name += "." + url2down.split(".")[-1].split("?")[0]
url_img = streamJSON.split("\"poster\":\"")[1].split("\"")[0].replace("\/", "/")
else:
Error.GeneralPyspainTVsError("Telecinco.es. No se encuentra contenido.")
tit_vid = None
if name != None:
name = name.replace("Ver vídeo online","")
tit_vid = name.split(".")[0]
name = Utiles.formatearNombre(name)
desc = None
try:
desc = Utiles.recortar(streamHTML, "<h3 class=\"subtitle\">", "<").strip()
except:
desc = tit_vid if tit_vid is not None else None
return {"exito" : True,
"num_videos" : 1,
"mensaje" : u"URL obtenido correctamente",
"videos":[{
"url_video" : [url2down],
"url_img" : url_img if url_img is not None else None,
"filename" : [name] if name is not None else None,
"tipo" : "http",
"partes" : 1,
"rtmpd_cmd" : None,
"menco_cmd" : None,
"url_publi" : None,
"otros" : None,
"mensaje" : None
}],
"titulos": [tit_vid] if tit_vid is not None else None,
"descs": [desc] if desc is not None else None
}
def getInfo(self):
'''
Devuelve toda la información asociada a la URL recibida, de la siguiente forma:
{
"exito" : bool, <-- True (si se han obtenido videos)
"num_video" : int, <-- Número de vídeos obtenidos
"mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False])
"videos" : [{
"url_video" : [], <-- Url de descarga de vídeo
"url_img" : "", <-- Url de la miniatura del video
"filename" : [], <-- Nombre de las partes para guardar en disco
"tipo" : "", <-- http, rtmp[e,..], mms, ...
"partes" : int, <-- Número de partes que tiene el vídeo
"rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None
"menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None
"url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo
"otros" : [], <-- Lista donde se pueden pasar cosas opcionales
"mensaje" : "" <-- Mensajes de la API
}], <-- Debe ser una lista de tamaño "num_videos"
"titulos" : [u""], <-- Titulos de los videos
"descs" : [u""] <-- Descripción de cada vídeo
}
Los valores que no se rellenen, deberán devolver None.
La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente:
{
"exito": False,
"mensaje": "No se pudo descargar el video"
}
"videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None)
"url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None)
'''
try: #Tratar de quitar caracteres especiales de las urls que no lo necesitan
self.url = self.url.split(
"video:")[0] + "video:_" + self.url.split("_")[1]
except:
pass
streamHTML = htmlBackup = Descargar.getHtml(
self.url).decode('iso-8859-1').encode(
'utf8') #rtpa codigicada en iso..
streamHTML = streamHTML.replace("\n", "").replace("\t", "")
partes = None
#método 12/11/2012:
if streamHTML.find("html5") != -1:
partes = 1
name = streamHTML.split("<div id=\"sobreElVideo\">")[1].split(
"<h3>")[1].split("</h3>")[0] + ".mp4"
streamHTML = streamHTML.replace(" ", "")
try:
url = streamHTML.split("html5")[1].split(
"\'file\':\'")[1].split("\'")[0]
except:
url = streamHTML.split("html5")[0].split(
"\'file\':\'")[1].split("\'")[0]
else:
# Cuantas partes son:
try:
partes = int(streamHTML.split("&partes=")[1].split("&")[0])
except IndexError: # No existe "&partes"
partes = 1
if partes == 1:
videoID = streamHTML.split("<param value=\"video1=")[1].split(
"&")[0]
if videoID.find("http://") != -1:
url = videoID
name = streamHTML.split("data-text=\"")[1].split(
"\"")[0].strip() + "." + url.split(".")[-1]
else:
# Probar entre TOKEN nuevo y antiguo por reproductor:
repro = streamHTML.split(
"<param value=\"player/")[1].split("\"")[0]
if repro == "reproductorVideoOnDemmand-mp4-rtpa.swf": # Antiguo
streamINFO = self.__descHTML(self.TOKEN_ARCHIVO +
videoID)
url = "http://" + streamINFO.split("http://")[1]
else: # Reproductor nuevo: "reproductorVideoOnDemmand.swf"
streamINFO = self.__descHTML(self.TOKEN + videoID +
"_1")
streamINFO = self.__descHTML(
streamINFO.split("&url=")[1])
url = "http://" + streamINFO.split("http://")[1]
name = streamHTML.split("<div id=\"sobreElVideo\">")[
1].split("<h3>")[1].split("</h3>")[0]
if name == "":
name = streamHTML.split("<title>")[1].split(
"</title>")[0] + ".mp4"
else:
name + ".mp4"
else:
# Recordar que hay videos que ponen varias partes en las que realmente solo existe una:
videoID = streamHTML.split("<param value=\"video1=")[1].split(
"&")[0]
url = []
name = []
for i in range(1, partes + 1):
streamINFO = self.__descHTML(self.TOKEN + videoID + "_" +
str(i))
streamINFO = self.__descHTML(streamINFO.split("&url=")[1])
tmp_url = "http://" + streamINFO.split("http://")[1]
tmp_name = streamHTML.split(
"<div id=\"sobreElVideo\">")[1].split("<h3>")[1].split(
"</h3>")[0] + "_part" + str(i)
if tmp_name == "":
tmp_name = streamHTML.split("<title>")[1].split(
"</title>")[0] + "_part" + str(i) + ".mp4"
else:
tmp_name + ".mp4"
if Descargar.isReachable(tmp_url):
url.append(tmp_url)
name.appen(tmp_name)
continue
else:
break
#FIXME: Gran fixme aquí, arreglat todo esto de desc y de tit_vid
try: #imagen del vídeo
img = self.URL_RTPA + Utiles.recortar(htmlBackup, "\'image\': \'",
"\'")
except:
img = None
desc = u""
try: # Descripción del vídeo
d = htmlBackup.split("<div class=\"overview\">")[1].split(
"<div>")[1].split("</div>")[0].strip()
except:
try:
d = htmlBackup.split("<div class=\"overview\">")[1].split(
"<p>")[1].split("</p>")[0].strip()
except:
pass
try: # desc coding
desc = unicode(d).encode("utf8")
except:
desc = u"Vídeo de la web de Radio Televisión del Principado de Asturias".encode(
"utf8")
if desc == u"":
desc = u"Vídeo de la web de Radio Televisión del Principado de Asturias".encode(
"utf8")
tit_vid = u""
try: #Título del vídeo
tit = htmlBackup.split("<div id=\"sobreElVideo\">")[1].split(
"<h3>")[1].split("</h3>")[0].strip()
except:
try:
tit = htmlBackup.split("<div id=\"sobreElVideo\">")[1].split(
"<h4 class=\"")[1].split(">")[1].split("<")[0].strip()
except:
pass
try: #titulo coding
tit = Utiles.tituloFormat(tit)
tit_vid = unicode(tit).encode("utf8")
except:
tit_vid = u"Vídeo de la web de Radio Televisión del Principado de Asturias".encode(
"utf8")
if tit_vid == u"":
tit_vid = u"Vídeo de la web de Radio Televisión del Principado de Asturias".encode(
"utf8")
if type(name) == list:
for i in name:
b = Utiles.formatearNombre(i)
name[name.index(i)] = b
else:
name = Utiles.formatearNombre(name)
return {
"exito":
True,
"num_videos":
1,
"mensaje":
u"URL obtenida correctamente",
"videos": [{
"url_video": [url] if type(url) != list else url,
"url_img": img if img is not None else None,
"filename": [name] if name is not None else None,
"tipo": "http",
"partes": partes if partes is not None else 1,
"rtmpd_cmd": None,
"menco_cmd": None,
"url_publi": None,
"otros": None,
"mensaje": None
}],
"titulos": [tit_vid] if tit_vid is not None else None,
"descs": [desc] if desc is not None else None
}
def getInfo(self):
'''
Devuelve toda la información asociada a la URL recibida, de la siguiente forma:
{
"exito" : bool, <-- True (si se han obtenido videos)
"num_video" : int, <-- Número de vídeos obtenidos
"mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False])
"videos" : [{
"url_video" : [], <-- Url de descarga de vídeo
"url_img" : "", <-- Url de la miniatura del video
"filename" : [], <-- Nombre de las partes para guardar en disco
"tipo" : "", <-- http, rtmp[e,..], mms, ...
"partes" : int, <-- Número de partes que tiene el vídeo
"rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None
"menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None
"url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo
"otros" : [], <-- Lista donde se pueden pasar cosas opcionales
"mensaje" : "" <-- Mensajes de la API
}], <-- Debe ser una lista de tamaño "num_videos"
"titulos" : [u""], <-- Titulos de los videos
"descs" : [u""] <-- Descripción de cada vídeo
}
Los valores que no se rellenen, deberán devolver None.
La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente:
{
"exito": False,
"mensaje": "No se pudo descargar el video"
}
"videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None)
"url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None)
'''
url_img = None
streamHTML = Descargar.getHtml(self.url)
if streamHTML.find("http://level3/") != -1: # Método antiguo
self.info(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]
self.info(u"[INFO] Nuevo Video ID:", newID)
ask4token = self.URL_ASK4TOKEN + newID[-3:] + "/" + newID + ".mp4"
self.debug(u"[+] Pidiendo nuevo token")
url2down = Descargar.getHtml(ask4token)
name = streamHTML.split("var title = \'")[1].split(
"\'")[0] + ".mp4"
elif self.url.find(
"videoURL=") != -1: # Forma con el ID en la URL (nueva??)
videoID = self.url.split("videoURL=")[1]
ask4token = self.URL_ASK4TOKEN + videoID[
-3:] + "/" + videoID + ".mp4"
self.debug(u"[+] Pidiendo nuevo token")
url2down = Descargar.getHtml(ask4token)
# Obtner nombre:
xmlURL = "http://estaticos.telecinco.es/xml/Video/Video_" + videoID + ".xml"
streamXML = Descargar.getHtml(xmlURL)
name = streamXML.split("<![CDATA[")[1].split("]")[0] + ".mp4"
elif streamHTML.find("MDS.embedObj(video") != -1:
contentID = streamHTML.split("MDS.embedObj(video, \"")[1].split(
"\"")[0]
try:
clippingID = streamHTML.split("imageClippingId: \'")[1].split(
"\'")[0] # try por que en la API no funcionaba oO
except:
clippingID = "1.jpg"
try:
imageContentID = streamHTML.split("imageContentId: \'")[
1].split("\'")[0] # try por problemas com la API oO
except:
imageContentID = streamHTML.split(
"MDS.embedObj(video, \"")[1].split("\"")[0]
self.debug(u"URL JSON: " + self.URL_JSON + "contentId=" +
contentID + "&clippingId=" + clippingID +
"&imageContentId=" + imageContentID)
streamJSON = Descargar.getHtml(self.URL_JSON + "contentId=" +
contentID + "&clippingId=" +
clippingID + "&imageContentId=" +
imageContentID)
url2down = streamJSON.split("({\"sources\":[{\"src\":\"")[1].split(
"\"")[0].replace("\/", "/")
name = streamHTML.split("<title>")[1].split("<")[0]
name += "." + url2down.split(".")[-1].split("?")[0]
url_img = streamJSON.split("\"poster\":\"")[1].split(
"\"")[0].replace("\/", "/")
elif streamHTML.find("MSV.embedData") != -1:
#rx=re.compile(r"MSV\.embedData\[(.*)\]", re.MULTILINE|re.DOTALL)
rx = re.compile(r'/mdsvideo/popup\.html\?(.*)"')
videos = rx.findall(streamHTML)
if not videos:
raise Error.GeneralPyspainTVsError(
"Telecinco.es. No se encuentra contenido.")
ret = {
"exito": True,
"num_videos": len(videos),
"mensaje": u"URL obtenido correctamente",
"videos": [],
"titulos": [],
"descs": []
}
for js in videos:
vid = {
"url_video": None,
"url_img": None,
"filename": [],
"tipo": "http",
"partes": 1,
"rtmpd_cmd": None,
"menco_cmd": None,
"url_publi": None,
"otros": None,
"mensaje": None
}
self.debug(u"API ENDPOINT: %s" % self.URL_JSON + js +
"&imageContentId=" +
Utiles.recortar(js, 'contentId=', '&'))
stream = Descargar.getHtmlUtf8(
self.URL_JSON + js + "&imageContentId=" +
Utiles.recortar(js, 'contentId=', '&'))
info = json.loads(stream[1:-1])
vid['url_video'] = [info['sources'][0]['src']]
vid['url_img'] = info['poster']
try:
vid['filename'].append(
Utiles.formatearNombre(info['nielsen']['title'] +
'.mp4'))
except:
vid['filename'].append('VideosDeTelecinco.mp4')
ret['videos'].append(vid)
ret['titulos'].append(
unicode(info['nielsen']['title']).encode('utf8').replace(
'"', '').replace("'", ""))
ret['descs'].append(
u'Cat.: %s. Subcat.: %s. %s'.encode('utf8') %
(info['nielsen']['category'].encode('utf8'),
info['nielsen']['subcategory'].encode('utf8'),
info['nielsen']['title'].encode('utf8')))
return ret
else:
raise Error.GeneralPyspainTVsError(
"Telecinco.es. No se encuentra contenido.")
tit_vid = None
if name != None:
name = name.replace("Ver vídeo online", "")
tit_vid = name.split(".")[0]
name = Utiles.formatearNombre(name)
desc = None
try:
desc = Utiles.recortar(streamHTML, "<h3 class=\"subtitle\">",
"<").strip()
except:
desc = tit_vid if tit_vid is not None else None
#TIT FIX:
tit_vid = tit_vid.replace('"', '').replace("'", "")
return {
"exito":
True,
"num_videos":
1,
"mensaje":
u"URL obtenido correctamente",
"videos": [{
"url_video": [url2down],
"url_img": url_img if url_img is not None else None,
"filename": [name] if name is not None else None,
"tipo": "http",
"partes": 1,
"rtmpd_cmd": None,
"menco_cmd": None,
"url_publi": None,
"otros": None,
"mensaje": None
}],
"titulos": [tit_vid] if tit_vid is not None else None,
"descs": [desc] if desc is not None else None
}
