def getContours(imgFilter, imgOriginal):
# Get all contours
contours, hierarchy = cv.findContours(imgFilter, cv.RETR_EXTERNAL,
cv.CHAIN_APPROX_NONE)
img_contour = imgOriginal.copy()
x, y, w, h = 0, 0, 0, 0
for cnt in contours:
area = cv.contourArea(cnt)
if area > 500:
# Suaviza los contornos
contornos_suavizados = []
for c in cnt:
contornos_suavizados.append(cv.convexHull(c))
# Dibuja
cv.drawContours(img_contour, contornos_suavizados, -1,
(0, 255, 255), 3)
# Calcula el perimetro
peri = cv.arcLength(cnt, True)
# Encuentra los vertices
approx = cv.approxPolyDP(cnt, 0.02 * peri, True)
# Agregamos un rectangulo a cada objeto
x, y, w, h = cv.boundingRect(approx)
cv.rectangle(img_contour, (x, y), (x + w, y + h), (0, 255, 0), 2)
# Dibuja el centro
cv.circle(img_contour, (x + w // 2, y + h // 2), 10, (255, 0, 0),
cv.FILLED)
cv.imshow(titulo, img_contour)
if Config.VidProp.guardar:
Utiles.guardar(out, img_contour)
punto = [x + w // 2, y + h // 2]
return Utiles.posicion_relativa(punto, mira)
def atresplayer_mobile(self):
#stream = self.__get(self.url)
stream = Descargar.get(self.url)
episode = re.findall('episode="(.*)">', stream)[0]
header = {"Accept":"application/json"}
j = json.loads(Descargar.getHtmlHeaders("http://servicios.atresplayer.com/episode/get?episodePk="+episode, header=header))
if j['type'] == "REGISTER":
url = Utiles.url_fix(self.__getApiMobileUrl2(episode))
#self.debug(unicode(url))
#jj = json.loads(Descargar.getHtmlHeaders(Utiles.url_fix(url)))
try:
#url2down = jj['resultDes']
url2down = url
except:
raise Error.GeneralPyspainTVsError(unicode(jj['resultDes']))
elif j['type'] == "FREE": # TEMP FIX
url = Utiles.url_fix(self.__getApiMobileUrl2(episode))
try:
url2down = url
except:
raise Error.GeneralPyspainTVsError(unicode(jj['resultDes']))
else:
url = Utiles.url_fix(self.__getApiMobileUrl(episode).replace("https://", "http://"))
self.debug(unicode(url))
#jj = json.loads(self.__get(Utiles.url_fix(url)))
jj = json.loads(Descargar.get(Utiles.url_fix(url)))
try:
url2down = jj['resultObject']['es']
except:
raise Error.GeneralPyspainTVsError(unicode(jj['resultDes']))
if url2down is None:
raise Error.GeneralPyspainTVsError(u"[Atresplayer] No se han podido obtener enlaces para URL proporcionada")
title = u"%s %s".encode('utf-8') % (j['titleSection'].encode('utf-8'), j['titleDetail'].encode('utf-8'))
desc = unicode(j['seoDescription']).encode('utf-8')
name = u"VideoAtresPlayer.mp4"
img = j['urlImage'].replace(".jpg", "06.jpg")
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": [title] if title is not None else None,
"descs": [desc] if desc is not None else None
}
def __modoNormal(self):
self.info(u"[INFO] Vídeo Normal")
html = Descargar.get(self.url).decode('iso-8859-1').encode('utf8')
url = html.split("flashvars=\"file=")[1].split("&")[0]
ext = "." + url.split(".")[-1]
tit = html.split("<title>")[1].split("<")[0]
name = tit + ext
name = Utiles.formatearNombre(name)
try:
desc = html.split("<div class=\"bloqEntradillaEnNoticia\">")[1].split("<p>")[1].split("</p>")[0].strip().decode('string-escape')
except:
desc = u"Vídeo de Canal Sur".encode("utf8")
try: img = self.URL_CANALSUR + Utiles.recortar(html, "image=", "\"")
except: img = None
return {"exito" : True,
"num_videos" : 1,
"mensaje" : u"URL obtenido correctamente",
"videos":[{
"url_video" : [url],
"url_img" : img if 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] if tit is not None else None,
"descs": [desc] if desc is not None else None
}
def getInfoJugadores(self):
lista = []
# Preguntamos el nombre del jugador 1
# j1 = input("\nJUGADOR Nº1, escribe tu nombre: ").upper()
j1 = Utiles.noCadenaVacia(
input("\nJUGADOR Nº1, escribe tu nombre: ")).upper()
j2 = Utiles.noCadenaVacia(
input("\nJUGADOR Nº2, escribe tu nombre: ")).upper()
# Guardamos el nombre del jugador 2
lista.append(j2)
# Guardamos el nombre del jugador 1
lista.append(j1)
return lista
def objetivo_prioritario(punto, objetivos, distancia_max=0):
"""Devuelve el objetivo prioritario segun la distancia a la posicion actual
de la torreta"""
if (len(objetivos) < 1):
return None
puntos_centro = Utiles.centros_rectangulos(objetivos)
objetivo_anterior = punto
distancias = [
Utiles.distancia(x, objetivo_anterior) for x in puntos_centro
]
menor = np.argmin(distancias)
# Si el punto mas cercano esta lo suficientemente cerca no se devuelve nada
if distancia_max and np.min(distancias) > distancia_max:
return np.array([])
return objetivos[menor]
def procesa_objetivos():
"Genera un grafico con las imagenes y las distancias de prediccion"
# Parametros de plot (graficos)
plt.rcParams["axes.grid"] = False
plot_num = 8
fig, ax = plt.subplots(2, plot_num)
axi = np.ravel(ax)
for i in range(plot_num):
# Seleccionamos dos imagen aleatorias
directorio = random.choice(os.listdir(path))
# Imagen A
archivo_a = path + directorio + '/' + random.choice(
os.listdir(path + directorio))
img_a, img_a_proces = prepara_imagen(archivo_a)
# Imagen B
directorio = random.choice(os.listdir(path))
archivo_b = path + directorio + '/' + random.choice(
os.listdir(path + directorio))
img_b, img_b_proces = prepara_imagen(archivo_b)
# Prediccion sobre las imagenes usando la red entrenada
predicciones = modelo.predict(np.array([img_a_proces, img_b_proces]))
# Mide la distancia entre ambos vectores
distancia = Utiles.distancia(predicciones[0], predicciones[1])
# Dibuja los graficos
# A
etiqueta = etiquetas[predicciones[0].argmax()]
muestra_imagen(axi, i, img_a, etiqueta, distancia)
# B
etiqueta = etiquetas[predicciones[1].argmax()]
muestra_imagen(axi, i + plot_num, img_b, etiqueta)
plt.show()
def __ClanTV(self, html, ID):
self.info(u"[INFO] Vídeo de Clan")
logging.debug("entro en clan")
buscar = self.__getSerieName(self.url)
logging.debug(buscar)
if buscar is None:
#html = Descargar.get(self.url)
buscar = "/".join(self.url.split("/")[6:9])
logging.debug(buscar)
if not buscar.startswith("videos") and not buscar.endswith("todos"):
try:
serie = Utiles.recortar(self.url, "/videos/", "/todos/")
logging.debug(serie)
except: #http://www.rtve.es/infantil/videos-juegos/#/videos/suckers/todos/suckers-ventosas/1605449 ó */
Surl = self.url.split("/")
if Surl[-1] == "": buscar = Surl[-3]
if Surl[-1].isdigit(): buscar = Surl[-2]
else:
raise Error.GeneralPyspainTVsError(u"Error al encontrar la serie. Por favor reporta el error")
else:
buscar = "/videos/"+serie+"/todos/"
logging.debug(buscar)
buscar = str(buscar)
self.debug(u"Serie:", buscar)
logging.debug("final: "+ buscar)
#Ir a la página de descripción de vídeos de Clan
try:
dataURL = "http://www.rtve.es/infantil/components/"+html.split(buscar)[0].split("<a rel=\"")[-1].split("\"")[0]+"/videos.xml.inc"
except Exception, e:
logging.debug(e.__str__())
def destruccion(p_actual, p_objetivo):
"Dispara si el objetivo esta en el rango de disparo y devuelve True"
cerca = Utiles.cerca(p_actual, p_objetivo)
if cerca:
# Motor_Mockup.disparo(orden_puntos, objetivos_destruidos)
return True
return False
def inicializarJuego(self):
print(
"En esta opción juegan Dos Jugadores. El JUGADOR Nº1 tendrá que introducir "
+ "un número entre " + str(self._nivelJuego.getMIN()) + " y " +
str(self._nivelJuego.getMAX()) +
", y el JUGADOR Nº2 tendrá que adivinarlo \n" +
"Así que allá vamos :)\n")
print("Turno para el JUGADOR Nº1: ")
# El primer jugador escribe el numero
aux = getpass.getpass(
"Introduce un número entre " + str(self._nivelJuego.getMIN()) +
" y " + str(self._nivelJuego.getMAX()) +
".\nNota: El número que vas a introducir no " +
"se mostrará por pantalla, así tu contrincante no podrá verlo :) ")
# Se comprueba que el numero introducido es correcto. Es decir, si el valor
# introducido es un numero y si, ademas, esta en el intervalo correcto.
# Además se le añade el parámetro False o True para saber si es un número
# oculto o no
# Esta funcion compruebaNumero devuelve el numero correcto
num = Utiles.compruebaNumero(self._nivelJuego.getMIN(),
self._nivelJuego.getMAX(), aux, True)
print("Muy bien! Vamos a ver si el JUGADOR 2 puede adivinarlo :D \n")
print("---*-*-*-*-*-*-*-*-*-*-*-*-*-*-*--- \n")
print("Turno para el JUGADOR Nº2: ")
print("El JUGADOR Nº1 ha pensado en un número entre " +
str(self._nivelJuego.getMIN()) + " y " +
str(self._nivelJuego.getMAX()) + " ¿Podrías adivinarlo en " +
str(self._nivelJuego.getIntentos()) + " intentos?")
return num
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 __ClanTV(self, html, ID):
self.info(u"[INFO] Vídeo de Clan")
logging.debug("entro en clan")
buscar = self.__getSerieName(self.url)
logging.debug(buscar)
if buscar is None:
#html = Descargar.get(self.url)
buscar = "/".join(self.url.split("/")[6:9])
logging.debug(buscar)
if not buscar.startswith("videos") and not buscar.endswith(
"todos"):
try:
serie = Utiles.recortar(self.url, "/videos/", "/todos/")
logging.debug(serie)
except: #http://www.rtve.es/infantil/videos-juegos/#/videos/suckers/todos/suckers-ventosas/1605449 ó */
Surl = self.url.split("/")
if Surl[-1] == "": buscar = Surl[-3]
if Surl[-1].isdigit(): buscar = Surl[-2]
else:
raise Error.GeneralPyspainTVsError(
u"Error al encontrar la serie. Por favor reporta el error"
)
else:
buscar = "/videos/" + serie + "/todos/"
logging.debug(buscar)
buscar = str(buscar)
self.debug(u"Serie:", buscar)
logging.debug("final: " + buscar)
#Ir a la página de descripción de vídeos de Clan
try:
dataURL = "http://www.rtve.es/infantil/components/" + html.split(
buscar)[0].split("<a rel=\"")[-1].split(
"\"")[0] + "/videos.xml.inc"
except Exception, e:
logging.debug(e.__str__())
def __getUrlDescarga(self, xml):
try:
urlDeDescarga = Utiles.recortar(xml, "<urlHttpVideo><![CDATA[",
"]]></urlHttpVideo>")
except:
urlDeDescarga = self.URL_DE_DESCARGA
return urlDeDescarga
def SlotCommand(self, num, side, slot):
''' Вывод информации о пропилах в панели
CUT_G, "", "": 0, "1", 354.000000, 12.000000, 0, 8.000000, cutLA, -350.000000, 45, 0, 0, 0, 0, "", 1, 7
CUT_G, "", "": 0, "1", 54.000000, 12.000000, 0, 8.000000, cutXY, 0, 0, 100, 80, 0, 0, "", 1, 7
num - порядковый номер пропила
slot - пропил'''
bb=slot.panel.bounding_box
Xpanel=bb.max.x-bb.min.x
Ypanel=bb.max.y-bb.min.y
# side = 0
# if slot.is_plane==False:
# side = 5
xstart = bb.min.x
xend = bb.max.x
ystart = slot.start.y
yend = slot.end.y
xstart = Xpanel-xstart
xend = Xpanel-xend
'''
if side == 0:
xstart = Xpanel-xstart
xend = Xpanel-xend
else:
xstart = Xpanel-xstart
xend = Xpanel-xend
# ystart = Ypanel-ystart
# yend = Ypanel-yend
'''
D = 100 # расстояние до центра диска пилы
cutType = 1
if (Utiles.GetSlotDirection(slot)=="X"):
self._SlotByCoords(side, xstart, ystart, xend, yend, slot.depth, D, slot.width, cutType )
return
def opcionSeleccionada(self, n1, n2):
opcion = input("Selecciona una de las opciones anteriores: ")
# Se comprueba que el numero introducido es correcto. Es decir, si el valor
# introducido es un numero y si, ademas, esta en el intervalo correcto.
# Además se le añade el parámetro False o True para saber si es un número
# oculto o no
# Esta funcion compruebaNumero devuelve el numero correcto
return Utiles.compruebaNumero(n1, n2, opcion, False)
def atresplayer_mobile(self):
#stream = self.__get(self.url)
stream = Descargar.get(self.url)
episode = re.findall('episode="(.*)">', stream)[0]
header = {"Accept":"application/json"}
j = json.loads(Descargar.getHtmlHeaders(self.URL_EPISODE_INFO+episode, header=header))
url = Utiles.url_fix(self.__getApiMobileUrl(episode).replace("https://", "http://"))
self.debug(unicode(url))
#jj = json.loads(self.__get(Utiles.url_fix(url)))
jj = json.loads(Descargar.get(Utiles.url_fix(url)))
try:
url2down = jj['resultObject']['es']
except:
raise Error.GeneralPyspainTVsError(unicode(jj['resultDes']))
if url2down is None:
raise Error.GeneralPyspainTVsError(u"[Atresplayer] No se han podido obtener enlaces para URL proporcionada")
title = u"%s %s".encode('utf-8') % (j['titleSection'].encode('utf-8'), j['titleDetail'].encode('utf-8'))
desc = unicode(j['seoDescription']).encode('utf-8')
urlparsed = urlparse.urlparse(self.url)
pathsplit = urlparsed.path.split('/')
del pathsplit[:3]
name = u'_'.join(pathsplit)
name = name.replace('.html','.mp4')
img = j['urlImage'].replace(".jpg", "06.jpg")
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": [title] if title is not None else None,
"descs": [desc] if desc is not None else None
}
def closure(image, ROIs):
nonlocal contador
rects, probabilidades, tipos = ROIs
for rect, probabilidad, tipo in zip(rects, probabilidades, tipos):
cv.imwrite(
f"Salida/Objetivos/Objetivo {contador}.png",
Utiles.ROI_to_img(image, rect))
contador += 1
def search_destroy(image):
"Usa Tracking para seguir al objetivo mientras mueve la torreta y dispara"
global p_actual
global objetivo
global objetivos_destruidos
global modo
centro_objetivo = Utiles.centro_rectangulo(objetivo)
p_actual = Motor_Mockup.desplazamiento(p_actual, centro_objetivo)
# Utiles.dibuja_puntos(image, [centro])
# x1, y1, x2, y2 = aume nta_roi(objetivo)
# cv.imshow("ROI", roi)
# coordenadas_reducidas(image)
# cv.waitKey(0)
# while True:
image, objetivos = Tracker.tracker(image)
objetivo = Tracker.actualiza_objetivo(objetivo, objetivos)
# image = Utiles.atencion_blur(image, objetivo)
Utiles.dibuja_contornos(image, objetivos)
Utiles.dibuja_rectangulo(image, objetivo, Config.UI.cyan2)
image = Utiles.dibuja_mira(image, p_actual)
# Comprueba si se puede disparar
p_objetivo = Utiles.centro_rectangulo(objetivo)
if (destruccion(p_actual, p_objetivo)):
image = cv.putText(image, "Bang!", (p_actual[0] + 5, p_actual[1] - 5),
0, 1, Config.UI.rojo, 2, 16)
# Limpia la lista de destruidos y agrega el ultimo TODO mejorar
objetivos_destruidos.append(objetivo)
if (len(objetivos_destruidos) > 3):
objetivos_destruidos.pop(0)
modo = Config.Modo.deteccion
return image
def Drilling(self, d):
'''Сверловка. Пласти и торцы. Заполняем списки структурами для пластей и торцев'''
if (self.Selobj == 0): # Если это не выбранная панель, то не фиг ее обрабатывать
return
self.drills.append(d)
Side=Utiles.GetDrillPlane(d)
if (Side=="F"):
self.isBlindHoleF=True
return
def writerDrillingCommand(self, drillTuple):
'''Подоготавливает к выводу отверстия
drillTuple - список отверстий в данной панели'''
for d in drillTuple:
SideS=Utiles.GetDrillPlane(d)
SideNum=self.GetBiesseSideNum(SideS)
if (SideNum<0 or SideNum==5): # Если сторона не определена,или это стороны F, отверстие не выводим
continue
self.writer.DrillingCommand(drillTuple.index(d),d)
return
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)
'''
html = self.gethtml()
if html.find("'file'") == -1:
urlXML = self.URL_GET_XML + Utiles.recortar(
html, "var idvideo = '", "'")
else:
urlXML = self.URL_HIST_CARTA + Utiles.unescape(
Utiles.recortar(html, "'file': '", "'"))
import logging
logging.debug(self.PROXY_PYDOWNTV + Utiles.escape(urlXML))
logging.debug(self.PROXY_PYDOWNTV + Utiles.escape(urlXML))
xml = Descargar.get(urlXML)
if xml.find("vohWwiQliW") != -1: # GEOLOCALIZADO
logging.debug("GEO")
xml = Descargar.get(self.PROXY_PYDOWNTV + Utiles.escape(urlXML))
if xml.find("vohWwiQliW") != -1:
logging.debug("GEO2")
try:
xml = Descargar.get(self.PROXY_PYDOWNTV +
Utiles.escape(urlXML))
except Exception, e:
raise Error.GeneralPyspainTVsError(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 __init__(self, para, hostName, Logger):
import Module
import Utiles
self._hostName = hostName
self._taskFreq = para["taskFreq"] if "taskFreq" in para else 0
self._indexFreq = para["indexFreq"] if "indexFreq" in para else 15
self._Message = Utiles.Message(para["dictString"], Logger)
self._Module = Module.Module(self._Message, para["indexUrl"],
para["downloadUrl"], Logger)
self._taskUrl = para["taskUrl"] if "taskUrl" in para else False
self._resultUrl = para["resultUrl"] if "resultUrl" in para else False
self._Logger = Logger
def organiza_objetivos(p_actual, lista_p):
"""Devuelve una lista de objetivos en ordenados segun su distancia mutua
desde un punto"""
orden_objetivos = []
objetivo_anterior = p_actual
for i in range(len(lista_p)):
distancias = [Utiles.distancia(x, objetivo_anterior) for x in lista_p]
menor = np.argmin(distancias)
objetivo_anterior = lista_p[menor]
orden_objetivos.append(lista_p[menor])
lista_p = np.delete(lista_p, menor, axis=0)
return np.array(orden_objetivos)
def __modoNormal(self):
self.info(u"[INFO] Vídeo Normal")
html = Descargar.get(self.url).decode('iso-8859-1').encode('utf8')
url = html.split("flashvars=\"file=")[1].split("&")[0]
ext = "." + url.split(".")[-1]
tit = html.split("<title>")[1].split("<")[0]
name = tit + ext
name = Utiles.formatearNombre(name)
try:
desc = html.split(
"<div class=\"bloqEntradillaEnNoticia\">")[1].split(
"<p>")[1].split("</p>")[0].strip().decode('string-escape')
except:
desc = u"Vídeo de Canal Sur".encode("utf8")
try:
img = self.URL_CANALSUR + Utiles.recortar(html, "image=", "\"")
except:
img = None
return {
"exito":
True,
"num_videos":
1,
"mensaje":
u"URL obtenido correctamente",
"videos": [{
"url_video": [url],
"url_img": img if 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] if tit is not None else None,
"descs": [desc] if desc is not None else None
}
def getInfo(self):
html = Descargar.get(self.url)
m_xml_url = re.search(r"\.xml='(.+?)'", html)
if m_xml_url is None:
return {"exito": False, "mensaje": "No se encontró información del video"}
xml_url = self.URL_DISNEY_CHANNEL + m_xml_url.group(1)
chapter_xml = Descargar.get(xml_url)
doc = xml.etree.ElementTree.fromstring(chapter_xml)
base_http_url = doc.find("./url/urlHttpVideo").text
video_info = doc.find("./multimedias/multimedia")
img = self.URL_DISNEY_CHANNEL + "/" + video_info.find("./archivoMultimediaMaxi/archivo").text
titulo = video_info.find("./nombre").text.encode('utf8')
serie = video_info.find("./seccion").text
desc = video_info.find("./descripcion").text.encode('utf8')
parts_urls = []
filenames = []
parts = list(doc.findall("./multimedias/multimedia"))
parts += list(doc.findall("./multimedias/relacionados/multimedia"))
for (i, part) in enumerate(parts, 1):
self.debug(unicode(part))
part_url = base_http_url + part.find("./archivoMultimedia/archivo").text
ext = part_url.rpartition('.')[2]
try:
filename = "%s-%s %s.%s" % (titulo, i, serie, ext)
except:
filename = "Video-Disney-Chanel_%s.%s" % (i, ext)
filename_clean = Utiles.formatearNombre(filename)
parts_urls.append(part_url)
filenames.append(filename_clean)
return {"exito" : True,
"num_videos" : 1,
"mensaje" : u"URL obtenido correctamente",
"videos":[{
"url_video" : parts_urls,
"url_img" : img,
"filename" : filenames,
"tipo" : "http",
"partes" : len(parts_urls),
"rtmpd_cmd" : None,
"menco_cmd" : None,
"url_publi" : None,
"otros" : None,
"mensaje" : None
}],
"titulos":[titulo],
"descs": [desc],
}
def actualiza_objetivo(objetivo, objetivos):
"Actualiza el objetivo si se mueve"
# No hay nuevos objetivos, nos quedamos con el que se detecto
if (len(objetivos) < 1):
return objetivo
# Elimina las detecciones del tracker con area muy distinta del objetivo
x, y, w, h = objetivo
area_objetivo = w * h
rectangulos = Utiles.genera_rectangulos(objetivos)
rectangulos = Utiles.elimina_rect_irelevantes(rectangulos, area_objetivo)
# Los objetivos no eran suficientemente similares en area
if (len(rectangulos) < 1):
return objetivo
# Cambia el objetivo por el mas cercano detectado por el tracker
distancia_max = max(w, h)
p_objetivo = Utiles.centro_rectangulo(objetivo)
objetivo_alt = Selector.objetivo_prioritario(p_objetivo, rectangulos,
distancia_max)
if (len(objetivo_alt) > 0):
return objetivo_alt
# No habia un objetivo lo suficientemete cercano
return objetivo
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)
'''
html = self.gethtml()
if html.find("'file'") == -1:
urlXML = self.URL_GET_XML+Utiles.recortar(html, "var idvideo = '", "'")
else:
urlXML = self.URL_HIST_CARTA+Utiles.unescape(Utiles.recortar(html, "'file': '", "'"))
import logging
logging.debug(self.PROXY_PYDOWNTV+Utiles.escape(urlXML))
logging.debug(self.PROXY_PYDOWNTV+Utiles.escape(urlXML))
xml = Descargar.get(urlXML)
if xml.find("vohWwiQliW") != -1: # GEOLOCALIZADO
logging.debug("GEO")
xml = Descargar.get(self.PROXY_PYDOWNTV+Utiles.escape(urlXML))
if xml.find("vohWwiQliW") != -1:
logging.debug("GEO2")
try:
xml = Descargar.get(self.PROXY_PYDOWNTV+Utiles.escape(urlXML))
except Exception, e:
raise Error.GeneralPyspainTVsError(e.__str__())
def DrillingCommand(self, num, drill):
'''Вывод информации об отверстии в файл
num - порядковый номер отверстия
drill - отверстие
'''
# x,y,z - координаты отверстия в системе координат панели
x=drill.position.x
y=drill.position.y
z=drill.position.z
# d, h - диаметр и глубина отверстия, соответтсвенно
d=drill.diameter
h=drill.depth
# alpha - угол между Ox и проекцией направляющей на Oxy (угол отверстия в проекции пласти панели)
alpha=drill.alfa
# beta - угол между Oz и направляющей (угол оси отверстия к пласти панели)
beta=drill.beta
thicknessPanel=drill.panel.thickness
## Здесь задаем координаты в зависимости от стороны панели
b=Boa()
side=Utiles.GetDrillPlane(drill)
siden=b.GetBiesseSideNum(side)
bb = drill.panel.bounding_box
Xpanel=bb.max.x-bb.min.x
Ypanel=bb.max.y-bb.min.y
crn=4
thr=0
if (siden==0):
crn=4
if (h>=thicknessPanel):
thr=1
if (siden==5): # Типа, низовой сверзовки нет
crn=1
if (siden==1):
crn=2
x=y
y=z
if (siden==2):
crn=4
y=z
if (siden==3):
crn=3
x=y
y=z
if (siden==4):
crn=1
y=z
z=0
self._Drill(x,y,z,siden,h,d,crn,thr)
return
def normalMultiple(self, xmls):
ret = {
"exito": True,
"num_videos": 0,
"mensaje": u"URLs obtenido correctamente",
"videos": [],
"titulos": [],
"descs": []
}
cont = 0
for xml in xmls:
video = {
"url_video": [],
"url_img": None,
"filename": [],
"tipo": "http",
"partes": 0,
"rtmpd_cmd": None,
"menco_cmd": None,
"url_publi": None,
"otros": None,
"mensaje": None
}
sxml = Descargar.get(xml)
url_desc = self.__getUrlDescarga(sxml)
url_img = re.findall("<urlImg><!\[CDATA\[(.*)\]\]></urlImg>",
sxml)[0]
ret["num_videos"] += 1
ret["titulos"].append(
re.findall("<nombre><!\[CDATA\[(.*)\]\]></nombre>", sxml)[0])
ret["descs"].append(
re.findall("<descripcion><!\[CDATA\[(.*)\]\]></descripcion>",
sxml)[0])
video["url_video"].append(url_desc + re.findall(
"<archivo><!\[CDATA\[(.*\.mp4)\]\]></archivo>", sxml)[0])
video["url_img"] = url_img + re.findall(
"<archivo><!\[CDATA\[(.*\.jpg)\]\]></archivo>", sxml)[0]
print cont, ":", ret["titulos"][cont]
video["filename"].append(
Utiles.formatearNombre(ret["titulos"][cont]))
video["partes"] = 1
ret["videos"].append(video)
cont += 1
return ret
def Slot(self, s):
'''Пропилы. Заполняем списки структурами пропилов'''
if (self.Selobj == 0): # Если это не выбранная панель, то не фиг ее обрабатывать
return
if (s.params["SlotType"][0] == 1):
self.slots.append(s)
slotDir = Utiles.GetSlotDirection(s)
if (s.is_plane==True and slotDir=="Y"): # Если пропил по стороне A вдоль Y
self.isSlotsAY = True
elif (s.is_plane==False and slotDir == "X"): # Если пропил по стороне F вдоль X
self.isSlotsFX=True
elif (s.is_plane==False and slotDir == "Y"): # Если пропил по стороне F вдоль Y
self.isSlotsFY=True
else:
self.millingSlots.append(s)
return
def darPista(self, num):
aleatorio = Utiles.dameNumAleatorio(1, 3)
if (aleatorio == 1):
if (num % 3 == 0):
return "El número es múltiplo de 3\n"
elif (num % 5 == 0):
return "El número es múltiplo de 5\n"
else:
return "El número no es ni múltiplo de 3 ni de 5\n"
elif (aleatorio == 2):
if (num % 2 == 0):
return "El número es par\n"
else:
return "El número es impar\n"
else:
return "El número termina en " + str(num % 10) + "\n"
def normalNuevoMultiple(self, xmls):
ret = {
"exito": True,
"num_videos": 0,
"mensaje": u"URLs obtenido correctamente",
"videos": [],
"titulos": [],
"descs": [],
}
cont = 0
for xml_ in xmls:
video = {
"url_video": [],
"url_img": None,
"filename": [],
"tipo": "http",
"partes": 0,
"rtmpd_cmd": None,
"menco_cmd": None,
"url_publi": None,
"otros": None,
"mensaje": None,
}
sxml = Descargar.get(xml_)
xmltree = xml.etree.ElementTree.fromstring(sxml)
url_desc = xmltree.find("./media/asset/files/videoSource").text.encode("utf8")
url_img = xmltree.find("./media/asset/files/background").text.encode("utf8")
ret["num_videos"] += 1
ret["titulos"].append(xmltree.find("./media/asset/info/art/name").text.encode("utf8"))
ret["descs"].append(xmltree.find("./media/asset/info/art/description").text.encode("utf8"))
video["url_video"].append(url_desc)
video["url_img"] = url_img
# print cont, ":", ret["titulos"][cont]
video["filename"].append(Utiles.formatearNombre(ret["titulos"][cont]) + ".mp4")
video["partes"] = 1
ret["videos"].append(video)
cont += 1
return ret
def __newPlus(self, html):
self.debug(u"Nuevo método PLUS [Febrero 2014]")
charset = re.findall('\<meta http\-equiv\=\"Content\-Type\" content\=\"text\/html\; charset\=(.*)\" \/\>',html)[0]
html = html.decode(charset).encode("utf8")
mp4s = re.findall('source.*src=\"(.*)\".*type=\"video\/mp4\"', html)
try: # Título laterl en rosa
title = re.findall('h2.*class=\"title\">(.*)<\/h2>',html.split("<video")[1])[0].replace("<strong>", "").replace("</strong>","")
except: # Título de "Estás viendo"..
title = re.findall('titulo=(.*?)\"',html)[0]
try: # Descripción en lateral
desc = re.findall('h2.*class=\"title\">.*<\/h2>.*<p>(.*)</p>.*</div>.*<!-- .video_entry -->',html.split("<video")[1],re.S)[0]
except: # Descripción debajo del vídeo
desc = re.findall('div.*class\=\"desc_play_video\".*\<p>(.*?)<\/p>.*<\/div>',html,re.S)[0]
img = ("%s%s") % (self.URL_PLUS, re.findall('video.*poster=\"(.+?)\"',html)[0].replace("&", "&"))
try: name = Utiles.formatearNombre(title)+'.mp4'
except: name = u"VideoCanalPlus.mp4".encode("utf8")
# Otra manera (parece que no siepre disponible para algunos 'xref=' ...):
#xref = re.findall('xref=(.*)',self.url)[0]
#urlInfo = "http://canalplus.es/servicios/player/mm_se_top.html?xref=%s&view=playlist" % (xref)
#info = Descargar.get(urlInfo)
#doc = xml.etree.ElementTree.fromstring(info) ## Parsear XML
return {"exito" : True,
"num_videos" : 1,
"mensaje" : u"URL obtenido correctamente",
"videos":[{
"url_video" : [mp4s[-1]], #De momento nos quedamos la última url, supuestamente la de mayor calidad
"url_img" : img if 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": [title] if title is not None else None,
"descs": [desc] if desc is not None else None
}
def normalMultiple(self, xmls):
ret = {
"exito": True,
"num_videos": 0,
"mensaje": u"URLs obtenido correctamente",
"videos": [],
"titulos": [],
"descs": [],
}
cont = 0
for xml in xmls:
video = {
"url_video": [],
"url_img": None,
"filename": [],
"tipo": "http",
"partes": 0,
"rtmpd_cmd": None,
"menco_cmd": None,
"url_publi": None,
"otros": None,
"mensaje": None,
}
sxml = Descargar.get(xml)
url_desc = self.__getUrlDescarga(sxml)
url_img = re.findall("<urlImg><!\[CDATA\[(.*)\]\]></urlImg>", sxml)[0]
ret["num_videos"] += 1
ret["titulos"].append(re.findall("<nombre><!\[CDATA\[(.*)\]\]></nombre>", sxml)[0])
ret["descs"].append(re.findall("<descripcion><!\[CDATA\[(.*)\]\]></descripcion>", sxml)[0])
video["url_video"].append(url_desc + re.findall("<archivo><!\[CDATA\[(.*\.mp4)\]\]></archivo>", sxml)[0])
video["url_img"] = url_img + re.findall("<archivo><!\[CDATA\[(.*\.jpg)\]\]></archivo>", sxml)[0]
# print cont, ":", ret["titulos"][cont]
video["filename"].append(Utiles.formatearNombre(ret["titulos"][cont]))
video["partes"] = 1
ret["videos"].append(video)
cont += 1
return ret
startTime = '0' if streamXML.find("<link start=\"") == -1 else streamXML.split("<link start=\"")[1].split("\"")[0]
endTime = '0' if streamXML.find("end=\"") == -1 else streamXML.split("end=\"")[1].split("\"")[0]
self.debug(u"startTime: %s\n[DEBUG] endTime: %s" % (startTime, endTime))
# Dejo el que era el método 3
url = self.__getUrl2down(ID, startTime, endTime)
if url is None:
raise Error.GeneralPyspainTVsError("mitele.es: No funciona el procedimiento.")
# Obtener nombre:
if type(url) == str:
name = streamHTML.split("<title>")[1].split("<")[0] + "." + url.split(".")[-1].split("?")[0]
else: # De momento: suponemos que son mp4.
name = streamHTML.split("<title>")[1].split("<")[0] + ".mp4"
if name:
name = Utiles.formatearNombre(name)
try:
tit_vid = name = htmlBackup.split("<div class=\"Destacado-text\">")[1].split("<h2>")[1].split("</h2>")[0]
name = Utiles.formatearNombre(name + ".mp4")
except:
name = name.replace("VERPROGRAMAS", "").replace("Veronline", "")
name = name.replace("VERSERIES", "").replace("Veronline", "")
tit_vid = tit_vid.replace("VER PROGRAMAS", "").replace("Ver online", "")
tit_vid = tit_vid.replace("VER SERIES", "").replace("Ver online", "").replace("|", "").strip()
desc = None
try:
desc = htmlBackup.split("<div class=\"Destacado-text\">")[1].split("<p class=\"text\">")[1].split("</p>")[0]
#desc = Utiles.descriptionFormat(Utiles.recortar(htmlBackup, "\"post_content\":\"", "\"").strip())
except:
if __name__ == "__main__":
# DEBUG Prueba de las funciones (No se usara, Archivo usado como libreria)
titulo = "Detector YoLo"
dims = (0, 0)
# Config.Fullscreen(titulo)
out = None
# Para capturar la salida
if Config.VidProp.guardar:
from Config import VidProp
out = cv.VideoWriter(f"Salida/{titulo}.avi", VidProp.fourcc,
VidProp.fps, VidProp.resolu)
# print(out.get(2)) # TODO
# Abre el video y almacena las dimesiones
cap = cv.VideoCapture(Config.VidProp.source)
dims = Utiles.dimensiones_video(cap)
# Crea la red neural
modelo = genera_DNN()
# Extrae las capas de YoLo
layer_names = modelo.getLayerNames()
layer_names = [
layer_names[i[0] - 1] for i in modelo.getUnconnectedOutLayers()
]
labels = genera_labels()
colores = genera_colores(labels)
fps = FPS().start()
while cap.isOpened():
ret, image = cap.read()
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: 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 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)
'''
html = self.gethtml()
# CREO que ya no hay vídeos desde RTMP, como no encuentro no puedo comprobar
# if html.find("&videoId=") != -1:
# videoID = html.split("&videoId=")[1].split("\'")[0]
# self.info(u"[INFO] Video ID:", videoID)
# streamStreams = Descargar.get(self.URL_STREAMS_START + videoID + self.URL_STREAMS_END)
# streamStreams = streamStreams.replace(" ", "").replace("\n", "")
# videos = streamStreams.split("{")[1:]
# self.info(u"[INFO] Se han detectado varios tipos de calidad:")
# b = 0
# for i in videos:
# self.info(u"\t[%4d] %s" % (b, i.split("\"quality\":\"")[1].split("\"")[0]))
# b += 1
# # Presentar menú para elegir vídeo:
# self.info(u"[-->] Introduce el número del tipo vídeo que quieres descargar (Ctrl+C para cancelar): ")
# while True:
# try:
# ID = int(raw_input())
# except ValueError:
# self.info(u"[!!!] Parece que no has introducido un número. Prueba otra vez:")
# continue
#
# if ID < 0 or ID > len(videos)-1:
# self.info(u"[!!!] No existe el vídeo con número [%4d] Prueba otra vez:" % ID)
# continue
# else:
# break
#
# url = videos[ID].split("\"url\":\"")[1].split("\"")[0]
# ext = "." + url.split("?")[0].split(".")[-1]
# name = (html.split("<title>")[1].split("<")[0]).strip()
# name += ext
if html.find("NicePlayer.js?") != -1 or html.find(
"nicePlayer.js?") != -1:
try:
urlJS = html.split("NicePlayer.js?")[0].split("\"")[-1] + \
"NicePlayer.js?" + html.split("NicePlayer.js?")[1].split("\"")[0]
except IndexError:
try:
urlJS = html.split("nicePlayer.js?")[0].split("\"")[-1] + \
"nicePlayer.js?" + html.split("nicePlayer.js?")[1].split("\"")[0]
except:
raise Error.GeneralPyspainTVsError(
u"No se encustra contenido")
except:
raise Error.GeneralPyspainTVsError(u"No se encustra contenido")
streamJS = Descargar.get(urlJS)
try:
url = streamJS.split("var fileHtml5 = \"")[1].split("\"")[0]
except:
try:
url = self.URL_RTMP + streamJS.split(
"var fileFlash = \"")[1].split("\"")[0]
except:
raise Error.GeneralPyspainTVsError(
u"No se encuentra contenido")
name = html.split("<title>")[1].split("<")[0].strip()
name += Utiles.formatearNombre("." + url.split(".")[-1])
try:
img = streamJS.split("var image = \"")[1].split("\"")[0]
except:
img = None
try:
tit = Utiles.recortar(html, "<title>",
"</title>") #.encode('utf8')
except:
tit = u"Vídeo de Radio Televisión de Castilla y Leon".encode(
'utf8')
try:
desc = Utiles.recortar(
html, "<meta name=\"Description\" content=\"",
"\"").decode('string-escape').strip().encode('utf8')
except:
desc = u"Vídeo de Radio Televisión de Castilla y Leon".encode(
'utf8')
elif html.find("<embed src=\"http://www.youtube.com") != -1:
raise Error.GeneralPyspainTVsError(
u"El vídeo de la página es de YouTube. Encontrarás muchas formas de descargarlo ;)"
)
else:
raise Error.GeneralPyspainTVsError(u"No se encuentra contenido")
return {
"exito":
True,
"num_videos":
1,
"mensaje":
u"URL obtenido correctamente",
"videos": [{
"url_video": [url],
"url_img": img if 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] if tit 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)
'''
# Diferenciar entre vídeos "á carta" y vídeos de "agalegainfo":
streamHTML = Descargar.get(self.url).decode('string-escape')
tit_vid = Utiles.descriptionFormat(streamHTML.split("title: \"")[1].split("\"")[0])
htmlBackup = streamHTML
streamHTML = streamHTML.replace(" ", "").replace("\t", "").replace("\n", "")
if self.url.find("a-carta") != -1:
self.info(u"[INFO] Modo \"Á Carta\"")
else:
self.info(u"[INFO] Vídeo Normal (No \"Á Carta\")")
rtmp = streamHTML.split("rtmp:{")[1]
s = rtmp.split("url:\"")[1].split("\"")[0]
r = rtmp.split("netConnectionUrl:\"")[1].split("\"")[0]
a = r.split("/")[-1]
video = rtmp.split("clip:{")[1]
y = video.split("url:\"")[1].split("\"")[0]
name = video.split("title:\"")[1].split("\"")[0] + "." + y.split(".")[-1]
img = streamHTML.split("backgroundImage:\"url(")[1].split(")")[0]
url = r
if name:
name = Utiles.formatearNombre(name)
rtmpd_cmd = "rtmpdump -v -r "+url+" -y "+y+" -s "+s+" -a "+a+" -o "+name
desc = None
try: #FIXME: Pillar más que solo el primer párrafo
desc = "".join(htmlBackup.split("<p style=\"text-align: justify;\">")[1:]).split("</div>")[0].strip().decode('string-escape')
#desc = Utiles.recortar(htmlBackup, "<p style=\"text-align: justify;\">", "</div>").strip().decode('string-escape')
except:
desc = tit_vid if tit_vid is not None else None
if desc == None: desc = u"Vídeo de Televisión de Galicia".encode("utf8")
return {"exito" : True,
"num_videos" : 1,
"mensaje" : u"URL obtenida correctamente",
"videos":[{
"url_video" : [url],
"url_img" : img if img is not None else None,
"filename" : [name] if name is not None else None,
"tipo" : "rtmp",
"partes" : 1,
"rtmpd_cmd" : [rtmpd_cmd],
"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
}
class TVE(Canal.Canal):
'''
Clase para manejar los vídeos de la RTVE (todos).
'''
URL_RTVE = "http://rtve.es"
def __init__(self, url="", opcs=None):
Canal.Canal.__init__(self, url, opcs, url_validas, __name__)
# Métodos propios del canal, start the party!
# Attributos disponibles:
# - self.url (url recibida)
# - self.opcs (diccionario de opciones) Ver Módulo Canal "_default_opcs" para opciones
# Métodos disponibles de clase Canal:
# - log() para mostrar por pantalla (está disponible si self.opcs["log"] es True)
# - self.debug() mostrar información de debug (está disponible si self.opcs["debug"] es True)
# Comunicación de errores con nivel de aplicación:
# - lanzar la excepción: raise Errors.GeneralPyspainTVsError("mensaje")
def __getSerieName(self, url):
url = url.split("#/")[1]
r = [
n for n in url.split("/")
if not n.isdigit() and n != "videos" and n != "todos"
]
return r[0] if len(r) == 1 else None
def __ClanTV(self, html, ID):
self.info(u"[INFO] Vídeo de Clan")
logging.debug("entro en clan")
buscar = self.__getSerieName(self.url)
logging.debug(buscar)
if buscar is None:
#html = Descargar.get(self.url)
buscar = "/".join(self.url.split("/")[6:9])
logging.debug(buscar)
if not buscar.startswith("videos") and not buscar.endswith(
"todos"):
try:
serie = Utiles.recortar(self.url, "/videos/", "/todos/")
logging.debug(serie)
except: #http://www.rtve.es/infantil/videos-juegos/#/videos/suckers/todos/suckers-ventosas/1605449 ó */
Surl = self.url.split("/")
if Surl[-1] == "": buscar = Surl[-3]
if Surl[-1].isdigit(): buscar = Surl[-2]
else:
raise Error.GeneralPyspainTVsError(
u"Error al encontrar la serie. Por favor reporta el error"
)
else:
buscar = "/videos/" + serie + "/todos/"
logging.debug(buscar)
buscar = str(buscar)
self.debug(u"Serie:", buscar)
logging.debug("final: " + buscar)
#Ir a la página de descripción de vídeos de Clan
try:
dataURL = "http://www.rtve.es/infantil/components/" + html.split(
buscar)[0].split("<a rel=\"")[-1].split(
"\"")[0] + "/videos.xml.inc"
except Exception, e:
logging.debug(e.__str__())
self.debug(u"URL Clan data: " + dataURL)
logging.debug(dataURL)
data = Descargar.get(dataURL).split("<video id=\"" +
str(ID))[1].split("</video>")[0]
logging.debug("tengo data")
url = self.URL_RTVE + Utiles.recortar(data, "url=\"", "\"")
logging.debug(url)
img = Utiles.recortar(data, "url_image=\"", "\"")
logging.debug(img)
tit = Utiles.recortar(data, "<title>", "</title>")
logging.debug(tit)
name = Utiles.recortar(data, "url_name=\"",
"\"") + "." + url.split(".")[-1]
logging.debug(name)
desc = Utiles.recortar(data, "<sinopsis>", "</sinopsis>").strip()
logging.debug(desc)
if desc == "" or desc == " " or desc == ".":
desc = u"Vídeo de Clan TV: ".encode('utf8') + Utiles.recortar(
data, "url_name=\"", "\"")
return {
"exito":
True,
"num_videos":
1,
"mensaje":
u"URL obtenido correctamente",
"videos": [{
"url_video": [url],
"url_img": img,
"filename": [name],
"tipo": "http",
"partes": 1,
"rtmpd_cmd": None,
"menco_cmd": None,
"url_publi": None,
"otros": None,
"mensaje": None
}],
"titulos": [tit],
"descs": [desc] if desc is not None else None
}
def __getUrlDescarga(self, xml):
try:
urlDeDescarga = Utiles.recortar(xml, "<urlHttpVideo><![CDATA[", "]]></urlHttpVideo>")
except:
urlDeDescarga = self.URL_DE_DESCARGA
return urlDeDescarga
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)
'''
com = False
html = Descargar.get(self.url)
html = html.replace("\n", "").replace("\t", "")
try: #ES
uri = html.split("var uri = \"")[1].split("\"")[0]
except: #COM
com = True
uri = html.split(".videoUri = \"")[1].split("\"")[0]
#Spain or .com?
xmlUrl = self.XML_URL + uri if self.url.find(".es") != -1 else self.XML_URL_COM + uri
self.debug(u"URL XML Info: %s" % xmlUrl)
xml = Descargar.get(xmlUrl)
name = None
tit = None
desc = None
try: #ES
name = xml.split("<title>")[1].split("<![CDATA[")[1].split("]]>")[0]
except: #COM
xml = xml.decode('iso-8859-1').encode('utf8')
if xml.find("<item>") != -1:
name = xml.split("<item>")[1].split("<title>")[1].split("<")[0]
tit = name
try: desc = xml.split("<item>")[1].split("<description>")[1].split("<")[0].strip()
except: desc = u"Vídeo de MTV".encode('utf8')
else:
name = xml.split("<title>")[1].split("<")[0]
tit = name
try: desc = xml.split("<description>")[1].split("<")[0].strip()
except: desc = u"Vídeo de MTV".encode('utf8')
name = name.replace("!", "").replace("|","") + ".mp4"
name = Utiles.formatearNombre(name)
import logging
xmlURL = xml.split("<media:content")[1].split("url=\"")[1].split("\"")[0]
self.debug(u"URL XML Archivos: %s" % xmlURL)
xml2 = Descargar.get(xmlURL)
#ulr = streamXML2.split("</rendition>")[-2].split("<src>")[1].split("</src>")[0]
url = "rtmp" + xml2.split("<src>rtmp")[-1].split("</src>")[0]
if url.find("copyright_error.") != -1: # GEO bloqueado!
logging.debug("GEO Bloqueado")
logging.debug(self.PROXY_AABILIO+xml.split("<media:content")[1].split("url=\"")[1].split("\"")[0])
xmlURL = self.PROXY_AABILIO+xml.split("<media:content")[1].split("url=\"")[1].split("\"")[0]
xml2 = Descargar.get(xmlURL)
logging.debug(xml2)
url = "rtmp" + xml2.split("<src>rtmp")[-1].split("</src>")[0]
if com:
rtmpd_cmd = "rtmpdump -r \'"+url+"\' -o \'"+name+"\' -W \'http://media.mtvnservices.com/player/prime/mediaplayerprime.2.3.6.swf\'"
else:
rtmpd_cmd = "rtmpdump -r \'"+url+"\' -o \'"+name+"\'"
try: img = Utiles.recortar(xml, "<image url=\"", "\"")
except: img = None
try: tit = xml.split("<title>")[1].split("<![CDATA[")[1].split("]")[0].strip() if not tit else tit
except: tit = u"Vídeo de MTV".encode('utf8')
try: desc = xml.split("<description>")[1].split("<![CDATA[")[1].split("]")[0].strip() if not desc else desc
except: desc = u"Vídeo de MTV".encode('utf8')
return {"exito" : True,
"num_videos" : 1,
"mensaje" : u"URL obtenido correctamente",
"videos":[{
"url_video" : [url],
"url_img" : img if img is not None else None,
"filename" : [name] if name is not None else None,
"tipo" : "rtmp",
"partes" : 1,
"rtmpd_cmd" : [rtmpd_cmd],
"menco_cmd" : None,
"url_publi" : None,
"otros" : None,
"mensaje" : None
}],
"titulos": [tit] if tit 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 atresplayer_mobile(self):
# stream = self.__get(self.url)
stream = Descargar.get(self.url)
episode = re.findall('episode="(.*)">', stream)[0]
header = {"Accept": "application/json"}
self.debug("http://servicios.atresplayer.com/episode/get?episodePk=" + episode)
j = json.loads(
Descargar.getHtmlHeaders("http://servicios.atresplayer.com/episode/get?episodePk=" + episode, header=header)
)
if j["type"] == "FREE":
url = Utiles.url_fix(self.__getApiMobileUrl2(episode))
header = {"User-Agent": "Dalvik/1.6.0 (Linux; U; Android 4.3; GT-I9300 Build/JSS15J)"}
data = json.loads(Descargar.getHtmlHeaders(url.replace("https://", "http://"), header=header))
self.debug(u"DATA:\n%s" % data)
try:
url2down = data["resultObject"]["es"]
if url2down is None:
raise Error.GeneralPyspainTVsError(u"No se ha podido obtener el enlace del vídeo")
# url2down = url.replace("https://", "http://")
except:
raise Error.GeneralPyspainTVsError(unicode(jj["resultDes"]))
else:
if not self.opcs["a3user"] or not self.opcs["a3pass"]:
raise Error.GeneralPyspainTVsError(
u"No tienes permisos para acceder al contenido. Proporciona tu usuario y contraseña para volver a intentarlo (en la web: botón de opciones arriba a la izquierda)."
)
cj = self.atresplayer_mobile_login(
"http://servicios.atresplayer.com/j_spring_security_check",
{"j_username": self.opcs["a3user"], "j_password": self.opcs["a3pass"]},
)
apiUrl = Utiles.url_fix(self.__getApiMobileUrl2(episode)).replace("https://", "http://")
opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(cj))
opener.addheaders = [
("Accept", "application/json"),
("User-Agent", "Dalvik/1.6.0 (Linux; U; Android 4.3; GT-I9300 Build/JSS15J"),
("Referer", "http://www.atresplayer.com/"),
]
response = opener.open(apiUrl)
content = json.loads(response.read())
self.debug(u"CONTENT:\n%s" % content)
url2down = content["resultObject"]["es"]
if url2down is None:
raise Error.GeneralPyspainTVsError(u"No se ha podido obtener el enlace del vídeo")
if not url2down:
raise Error.GeneralPyspainTVsError(unicode(content["resultDes"]))
# if j['type'] == "REGISTER":
# url = Utiles.url_fix(self.__getApiMobileUrl2(episode))
# #header = {"User-Agent":"Dalvik/1.6.0 (Linux; U; Android 4.3; GT-I9300 Build/JSS15J)"}
# #data = json.loads(Descargar.getHtmlHeaders(url.replace("https://", "http://"), header=header))
# try:
# #url2down = data['resultObject']['es']
# url2down = url.replace("https://", "http://")
# except:
# raise Error.GeneralPyspainTVsError(unicode(jj['resultDes']))
# elif j['type'] == "FREE": # TEMP FIX
# else:
# url = Utiles.url_fix(self.__getApiMobileUrl2(episode).replace("https://", "http://"))
# self.debug(unicode(url))
# #jj = json.loads(self.__get(Utiles.url_fix(url)))
# jj = json.loads(Descargar.get(Utiles.url_fix(url)))
# try:
# url2down = jj['resultObject']['es']
# except:
# raise Error.GeneralPyspainTVsError(unicode(jj['resultDes']))
# if url2down is None:
# raise Error.GeneralPyspainTVsError(u"[Atresplayer] No se han podido obtener enlaces para URL proporcionada")
title = u"%s %s".encode("utf-8") % (j["titleSection"].encode("utf-8"), j["titleDetail"].encode("utf-8"))
desc = unicode(j["seoDescription"]).encode("utf-8")
name = u"VideoAtresPlayer.mp4"
img = j["urlImage"].replace(".jpg", "06.jpg")
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": [title] if title is not None else None,
"descs": [desc] if desc is not None else None,
}
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 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)
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)
'''
#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)
'''
#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 __alacarta(self):
self.info(u"[INFO] A la carta")
xml = Descargar.get(Descargar.get(self.url).split("_url_xml_datos=")[1].split("\"")[0])
if xml.find("0x") != -1: xml = xml.decode('iso-8859-1').encode('utf8')
# Comprobar si varias partes:
# Un "<url> tiene que haber, comprobar si hay más de uno:"
if xml[xml.find("<url>")+1:].find("<url>") != -1:
self.info(u"[INFO] Varios Vídeos")
a = xml.split("<url>")
url = [a[i].split("</url>")[0] for i in range(1,len(a)) if not a[i].split("</url>")[0].find("doubleclick") != -1]
ext = "." + url[0].split(".")[-1]
b = xml.split("<title><![CDATA[")
name = [b[i].split("]]></title>")[0] + ext for i in range(2,len(b))]
if type(name) == list:
for i in name:
b = Utiles.formatearNombre(i)
name[name.index(i)] = b
else: name = Utiles.formatearNombre(name)
try: tit = Utiles.recortar(xml, "<title><![CDATA[", "]]></title>") #El de la primera parte
except: tit = u"Vídeo de Canal Sur A la Carta".encode("utf8")
try: img = xml.split("<picture>")[1].split("</picture>")[0].strip()
except: img = None
try: desc = xml.split("<description>")[1].split("<![CDATA[")[1].split("]]>")[0].strip()
except: desc = u"Vídeo de Canal Sur A la Carta".encode("utf8")
return {"exito" : True,
"num_videos" : 1,
"mensaje" : u"URL obtenido correctamente",
"videos":[{
"url_video" : url,
"url_img" : img if img is not None else None,
"filename" : name,
"tipo" : "http",
"partes" : len(url),
"rtmpd_cmd" : None,
"menco_cmd" : None,
"url_publi" : None,
"otros" : None,
"mensaje" : None
}],
"titulos": [tit] if tit is not None else None,
"descs": [desc] if desc is not None else None
}
else:
# Si solo es una parte (compatiblidad con versiones ateriores):
self.info(u"[INFO] Vídeo único")
url = "http://ondemand" + xml.split("<url>http://ondemand")[1].split("<")[0]
ext = "." + url.split(".")[-1]
tit = xml.split("<title><![CDATA[")[1].split("]")[0]
name = Utiles.formatearNombre(tit + ext)
try: img = xml.split("<picture>")[1].split("</picture>")[0].strip()
except: img = None
try:
desc = xml.split("<description>")[1].split("<![CDATA[")[1].split("]]>")[0].strip()
except: desc = u"Vídeo de Canal Sur A la Carta".encode("utf8")
return {"exito" : True,
"num_videos" : 1,
"mensaje" : u"URL obtenido correctamente",
"videos":[{
"url_video" : [url],
"url_img" : img if 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] if tit 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)
'''
# Comprobar si es de radio primero:
firstHtmlCheck = Descargar.get(self.url)
separador = "this.element.jPlayer(\"setFile\", \""
if firstHtmlCheck.find(separador) != -1 and firstHtmlCheck.find(".mp3") != -1:
raise Error.GeneralPyspainTVsError(u"No soportamos la radio por ahora. Pronto estará disponible.")
url, name = self.__rtvvRadio(firstHtmlCheck, separador)
if name:
name = Utiles.formatearNombre(name)
return [url, name]
# FIN Ràdio
# Ahora Vídeos
html = None
if self.url.find("rtvv.es/va/noualacarta") != -1 or self.url.find("rtvv.es/es/noualacarta") != -1:
self.info(u"[INFO] A la Carta")
htmlURL, cap = self.__getHtmlUrlFromAlacarta()
html = Descargar.get(htmlURL)
xmlURL = self.URL_RTVV + html.split("file: \"")[1].split("\"")[0]
else:
self.info(u"[INFO] Vídeo Normal")
xmlURL = self.URL_RTVV + Descargar.get(self.url).split("file: \"")[1].split("\"")[0]
self.info(u"[INFO] URL de XML:", xmlURL)
xmlStream = Descargar.get(xmlURL)
url = xmlStream.split("<media:content url=\"")[1].split("\"")[0]
ext = "." + url.split(".")[-1]
# Acotar a <item></item> para coger el <title> del <item>
item = xmlStream.split("<item>")[1].split("</item>")[0]
name = item.split("<title><![CDATA[")[1].split("]")[0] + ext
html = self.gethtml() if html is None else html
try: img = Utiles.recortar(xmlStream, "<media:thumbnail url=\"", "\"")
except: img = None
try:
if cap is not None:
tit = html.split("<div class=\"title\">")[1].split("<h2>")[1].split("</h2>")[0] + " ( "+cap+" ) "
else:
tit = html.split("<div class=\"title\">")[1].split("<h2>")[1].split("</h2>")[0]
except: tit = u"Vídeo de Radiotelevisión Valenciana".encode('utf8')
try: name = Utiles.formatearNombre(tit+".mp4")
except: name = "VideoRTVV.mp4"
try: desc = Utiles.recortar(html, "<div class=\"tx\">", "</div>")
except: desc = u"Vídeo de Radiotelevisión Valenciana".encode('utf8')
return {"exito" : True,
"num_videos" : 1,
"mensaje" : u"URL obtenido correctamente",
"videos":[{
"url_video" : [url],
"url_img" : img if 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] if tit 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(".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)
'''
html = Descargar.get(self.url)
try:
name = Utiles.recortar(html, "<title>", "</title>")
html2 = html.replace("%3A", ":").replace("%2F", "/").replace(" ", "").replace("\t", "")
clip = html2.split("clip:")[1].split("url:\'")[1].split("\'")[0].replace("mp4:", "")
server = html2.split("netConnectionUrl:\'")[1].split("\'")[0]
url = server + clip
name += "." + clip.split(".")[-1]
img1 = html.split("logo:")[1].split("url:")[1].split("\'")[1].split("\'")[0]
if img1.find("aragontelevision.es") != -1: img = img1
else: img = self.URL_ARAGONTV_ALACARTA + img1#html.split("logo:")[1].split("url:")[1].split("\'")[1].split("\'")[0]
try:
desc = Utiles.recortar(html, "<span class=\"title\">Resumen del vídeo</span>", "</div>").strip().decode('string-escape')
except:
desc = u"Vídeo de Aragón Televisión".encode("utf8")
else:
try:
if type(desc) is unicode:
if desc == u"": desc = u"Vídeo de Aragón Televisión".encode("utf8")
elif type(desc) is str:
if desc == "": desc = u"Vídeo de Aragón Televisión".encode("utf8")
except:
desc = u"Vídeo de Aragón Televisión".encode("utf8")
try:
tit = Utiles.recortar(html, "<title>", "</title>")
except:
tit = u"Vídeo de Aragón Televisón".encode("utf8")
if name: name = Utiles.formatearNombre(name)
rtmpd_cmd = "rtmpdump -r "+url+" -o "+name
except:
raise Error.GeneralPyspainTVsError(u"Error al recuperar el vídeo de Aragon TV")
return {"exito" : True,
"num_videos" : 1,
"mensaje" : u"URL obtenido correctamente",
"videos":[{
"url_video" : [url],
"url_img" : img if img is not None else None,
"filename" : [name] if name is not None else None,
"tipo" : "rtmp",
"partes" : 1,
"rtmpd_cmd" : [rtmpd_cmd],
"menco_cmd" : None,
"url_publi" : None,
"otros" : None,
"mensaje" : None
}],
"titulos": [tit] if tit 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)
'''
html = Descargar.get(self.url)
if self.url.find("eitb.com/") != -1:
raise Error.GeneralPyspainTVsError(u".com de EITB no está de momento soportado por pydowntv")
#TODO: Incluír este soporte para mp3
if self.url.find("audios/") != -1 or self.url.find("audioak/") != -1:
raise Error.GeneralPyspainTVsError(u"Audios aún no soportados. Lo estarán dentro de poco ;)")
self.info(u"[INFO] Audio")
name = html.split("<title>")[1].split("<")[0]
streamMP3 = html.split("<a id=\"descargaMp3\"")[1].split(">")[0]
url = self.URL_EITB + streamMP3.split("href=\"")[1].split("\"")[0]
name += ".mp3"
elif self.url.find("videos/") != -1 or self.url.find("bideoak/") != -1 or self.url.find("video/") != -1 or self.url.find("bideoa/") != -1:
if html.find("<a id=\"descargaMp4\"") != -1:
name = html.split("<title>")[1].split("<")[0]
streamMP4 = html.split("<a id=\"descargaMp4\"")[1].split(">")[0]
url = self.URL_EITB + streamMP4.split("href=\"")[1].split("\"")[0]
else:
#streamHTML = self.__descHTML(self._URL_recibida)
name = self.url.split("/")[-1]
playerID = html.split("<param name=\"playerID\" value=\"")[1].split("\"")[0]
playerKey = html.split("<param name=\"playerKey\" value=\"")[1].split("\"")[0]
const = "9f8617ac59091bcfd501ae5188e4762ffddb9925"
publisherID = "102076681001"
videoID = self.url.split("/")[-1]
if not videoID.isdigit():
videoID = [n for n in self.url.split("/") if n.isdigit() and len(n)>5][1]
try:
rtmpdata = self.get_data(publisherID, playerID, const, videoID, playerKey)#['renditions']
videos_data = rtmpdata['renditions']
except:
raise Error.GeneralPyspainTVsError(u"Parece que e vídeo no está disponible en la web")
try: img = rtmpdata['videoStillURL']
except: img = None
desc = None
try: desc1 = rtmpdata['longDescription'].encode('utf8') if rtmpdata['longDescription'] is not None else None
except: desc1=None
try: desc2 = rtmpdata['shortDescription'].encode('utf8') if rtmpdata['shortDescription'] is not None else None
except: desc2=None
try: desc3 = rtmpdata['customFields']['longdescription_c'].encode('utf8') if rtmpdata['customFields']['longdescription_c'] is not None else None
except: desc3=None
try: desc4 = rtmpdata['customFields']['shortdescription_c'].encode('utf8') if rtmpdata['customFields']['shortdescription_c'] is not None else None
except: desc4=None
try:
if desc1 is not None and desc1 != "" and desc1 != ".": desc = desc1
elif desc2 is not None and desc2 != "" and desc2 != ".": desc = desc2
elif desc3 is not None and desc3 != "" and desc3 != ".": desc = desc3
elif desc4 is not None and desc4 != "" and desc4 != ".": desc = desc4
except: desc = u"Vídeo de Euskal Irrati Telebista".encode('utf8')
else:
if desc is None or desc == "": desc = u"Vídeo de Euskal Irrati Telebista".encode('utf8')
tit = None
try: tit = rtmpdata['displayName'].encode('utf8')
except: tit = u"Vídeo de Euskal Irrati Telebista".encode('utf8')
else:
if type(tit) is unicode:
if tit == u"": tit = u"Vídeo de Euskal Irrati Telebista".encode('utf8')
elif type(tit) is str:
if tit == "": tit = u"Vídeo de Euskal Irrati Telebista".encode('utf8')
if tit is None: tit = u"Vídeo de Euskal Irrati Telebista".encode('utf8')
try:
name = Utiles.formatearNombre(str(rtmpdata['displayName'].encode('utf8'))+".mp4")
except:
name = "VideoEITB.mp4" #TODO: mejorar el filename
# Devolver 3 vídeos, de las distintas calidades
videos = []
num_videos = 0
for vid in videos_data:
num_videos += 1
#montar comando
url = str(vid['defaultURL'])
#tcurl = url.replace("/&mp4:"+url.split("/&mp4:")[1].split(".mp4")[0]+".mp4", "")
pageurl = self.url
typem = "rtmp"
if url.find("edgefcs.net") != -1: #NUEVO edgefcs de AKAMAI (thanks to http://blog.tvalacarta.info/)
app = "ondemand?"+ url.split(".mp4?")[1]+"&videoId="+videoID+"&lineUpId=&pubId="+publisherID+"&playerId="+playerID
playpath = "mp4:"+url.split("mp4:")[1]+"&videoId="+videoID
swfurl = "http://admin.brightcove.com/viewer/us20121213.1025/federatedVideoUI/BrightcovePlayer.swf?uid=1355746343102"
rtmpd_cmd = "rtmpdump --rtmp '"+url+"' --app='"+app+"' --swfUrl='"+swfurl+"' --playpath='"+playpath+"' --pageUrl='"+pageurl+"' -o '"+name+"'"
msg = u"Nuevos comandos gracias a Jesús de <a href=\"http://blog.tvalacarta.info/\">TV a Carta</a>".encode('utf8')
#Convertir a HTTP, paso intermedio (thanks @denobis)
try: change = re.findall("rtmp://.*\&mp4:", url)[0]
except: change = "#####"
url = url.replace(change, "http://brightcove04.brightcove.com/")
if url.startswith("http://"): typem = "http"
else: #Antiguo: brightcove, hay más?
app = url.split("/&")[0].split(".net/")[1] +"?videoId="+videoID+"&lineUpId=&pubId="+publisherID+"&playerId="+playerID
playpath = "mp4:"+url.split("mp4:")[1].split(".mp4")[0]+".mp4"+"?videoId="+videoID+"&lineUpId=&pubId="+publisherID+"&playerId="+playerID
swfurl = "http://admin.brightcove.com/viewer/us20121218.1107/federatedVideoUI/BrightcovePlayer.swf?uid=1355158765470"
C1 = "B:0"
C2 = "S:" + "&".join(url.split("&")[1:])
rtmpd_cmd = "rtmpdump --rtmp '"+url+"' --app='"+app+"' --swfUrl='"+swfurl+"' --playpath='"+playpath+"' --pageUrl='"+pageurl+"' -C '"+C1+"' -C '"+C2+"' -o '"+name+"'"
msg = None
##END: montar comando
size = str(vid['frameWidth'])+"x"+str(vid['frameHeight'])
temp = {
"url_video" : [url],
"url_img" : img if img is not None else None,
"filename" : [name] if name is not None else None,
"tipo" : typem,
"partes" : 1,
"rtmpd_cmd" : [rtmpd_cmd],
"menco_cmd" : None,
"url_publi" : None,
"otros" : size,
"mensaje" : msg
}
videos.append(temp)
else:
raise Error.GeneralPyspainTVsError(u"No se reconoce el tipo de contenido")
if name:
name = Utiles.formatearNombre(name)
return {"exito" : True,
"num_videos" : num_videos,
"mensaje" : u"URLs obtenidas correctamente",
"videos": videos,
"titulos": [tit]*num_videos if tit is not None else None,
"descs": [desc]*num_videos 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)
'''
html = Descargar.get(self.url)
#Por ahora solo soportados para brightcove:
if not re.findall("ORIGEN[ \=\"\']*([a-zA-Z]*)[ \"\']*;", html)[0] == "bc":
raise Error.GeneralPyspainTVsError(u'Tipo de vídeo aun no soportado para ABC. Por favor, comunica la incidencia.')
self.Publisher_ID = re.findall("publisherID=([0-9]*)", html)[0]
self.Player_ID = re.findall("playerID=([0-9]*)", html)[0]
VideoPlayer = re.findall("RUTA_VIDEO[ \=\"\']*([0-9]*)[ \"\']*;", html)[0]
info = self.__get_info(VideoPlayer)
self.debug(u"info:",info)
#TODO: Soltar todos los vídeos con las distintas calidades, ahora está solo la de mayor
big = 0
for video in info['renditions']:
if video['encodingRate'] >= big:
big = video['encodingRate']
url = video['defaultURL']
ext = "." + url.split(".")[-1]
try: img = info['videoStillURL']
except: img = None
desc = None
try: desc1 = info['longDescription'].encode('utf8') if info['longDescription'] is not None else None
except: pass
try: desc2 = info['shortDescription'].encode('utf8') if info['shortDescription'] is not None else None
except: pass
try:
if desc1 is not None: desc = desc1
else:
if desc2 is not None: desc = desc2
except: desc = u"Vídeo de ABC".encode('utf8')
else:
if desc is None: desc = u"Vídeo de ABC".encode('utf8')
else:
if type(desc) is unicode:
if desc == u"": desc = u"Vídeo de ABC".encode('utf8')
elif type(desc) is str:
if desc == "": desc = u"Vídeo de ABC".encode('utf8')
tit = None
try: tit = info['displayName'].encode('utf8')
except: tit = u"Vídeo de ABC".encode('utf8')
else:
if tit is None: tit = u"Vídeo de ABC".encode('utf8')
if type(tit) is unicode:
if tit == u"": tit = u"Vídeo de ABC".encode('utf8')
elif type(tit) is str:
if tit == "": tit = u"Vídeo de ABC".encode('utf8')
#FIXME: Ver qué pasa aquí!! --> name = Utiles.formatearNombre(tit + ext)
try:
name = Utiles.formatearNombre2(tit+ext)
except:
name = "VideoABC"+ext
# Parece que NO funciona lo siguiente para ABC, solo para Telemadrid
#url = "/".join(img.split("/")[:3])+"/"+"/".join(url.split("/")[3:])
rtmpd_cmd = "rtmpdump -r '"+url.replace("&mp4:","mp4/")+"' -o '"+name+"'"
return {"exito" : True,
"num_videos" : 1,
"mensaje" : u"URL obtenido correctamente",
"videos":[{
"url_video" : [url.replace("&mp4:","mp4/")],
"url_img" : img if img is not None else None,
"filename" : [name] if name is not None else None,
"tipo" : "rtmp",
"partes" : 1,
"rtmpd_cmd" : [rtmpd_cmd],
"menco_cmd" : None,
"url_publi" : None,
"otros" : None,
"mensaje" : None
}],
"titulos": [tit] if tit is not None else None,
"descs": [desc] if desc is not None else None
}
def log(self, *msg):
if self.__OPCS.has_key("log"):
if self.__OPCS["log"]: Utiles.printt(*msg)
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)
'''
# Diferenciar entre vídeos "á carta" y vídeos de "agalegainfo":
streamHTML = Descargar.get(self.url).decode('string-escape')
tit_vid = Utiles.descriptionFormat(
streamHTML.split("title: \"")[1].split("\"")[0])
htmlBackup = streamHTML
streamHTML = streamHTML.replace(" ", "").replace("\t",
"").replace("\n", "")
if self.url.find("a-carta") != -1:
self.info(u"[INFO] Modo \"Á Carta\"")
else:
self.info(u"[INFO] Vídeo Normal (No \"Á Carta\")")
rtmp = streamHTML.split("rtmp:{")[1]
s = rtmp.split("url:\"")[1].split("\"")[0]
r = rtmp.split("netConnectionUrl:\"")[1].split("\"")[0]
a = r.split("/")[-1]
video = rtmp.split("clip:{")[1]
y = video.split("url:\"")[1].split("\"")[0]
name = video.split("title:\"")[1].split("\"")[0] + "." + y.split(
".")[-1]
img = streamHTML.split("backgroundImage:\"url(")[1].split(")")[0]
url = r
if name:
name = Utiles.formatearNombre(name)
rtmpd_cmd = "rtmpdump -v -r " + url + " -y " + y + " -s " + s + " -a " + a + " -o " + name
desc = None
try: #FIXME: Pillar más que solo el primer párrafo
desc = "".join(
htmlBackup.split("<p style=\"text-align: justify;\">")
[1:]).split("</div>")[0].strip().decode('string-escape')
#desc = Utiles.recortar(htmlBackup, "<p style=\"text-align: justify;\">", "</div>").strip().decode('string-escape')
except:
desc = tit_vid if tit_vid is not None else None
if desc == None:
desc = u"Vídeo de Televisión de Galicia".encode("utf8")
return {
"exito":
True,
"num_videos":
1,
"mensaje":
u"URL obtenida correctamente",
"videos": [{
"url_video": [url],
"url_img": img if img is not None else None,
"filename": [name] if name is not None else None,
"tipo": "rtmp",
"partes": 1,
"rtmpd_cmd": [rtmpd_cmd],
"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 debug(self, *msg):
if self.__OPCS.has_key("debug"):
if self.__OPCS["debug"]: Utiles.printt(u"[DEBUG]", *msg)
