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 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 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
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): ''' 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): 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], }
) if html.find("contentArray[") != -1: self.info(u"[INFO] Se han detectado varios vídeos en la página") try: # Deleimitar los bloques de vídeos: videos = [ n.split("',")[1:] for n in html.split("contentArray[")[1:] ] titulos = [v[0].replace("'", "").strip() for v in videos] urls = [v[2].replace("'", "").strip() for v in videos] ext = "." + urls[0].split(".")[-1] try: names = [ Utiles.formatearNombre(v[0].replace("'", "").strip() + ext) for v in videos ] except: names = [u"VideoDeGiraldaTV.mov"] * len(urls) descs = [v[1].replace("'", "").strip() for v in videos] imgs = [v[4].replace("'", "").strip() for v in videos] rVideos = [] for i in range(len(urls)): temp = { "url_video": [urls[i]], "url_img": imgs[i] if imgs[i] is not None else None, "filename": [names[i]] if names is not None else None, "tipo": "http", "partes": 1, "rtmpd_cmd": 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) ''' 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) ''' 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 = Descargar.get(self.url) try: url = self.URL_VTV + html.split("showPlayer(")[1].split( ",")[1].split(",")[0].replace("\"", "").strip() except: try: url = Utiles.recortar( html, "<meta property=\"og:video\" content=\"", "\"").replace("media.", "") except: raise Error.GeneralPyspainTVsError( "No se pudo obtener la url de descarga") try: tit = Utiles.recortar(html, "<meta name=\"title\" content=\"", "\"").decode('iso-8859-1').encode('utf8') except: tit = u"Vídeo de V Televisión".encode('utf8') try: desc = Utiles.recortar(html, "<meta name=\"description\" content=\"", "\"").decode('iso-8859-1').encode('utf8') except: desc = tit try: img = Utiles.recortar(html, "<meta property=\"og:image\" content=\"", "\"") except: img = None try: name = Utiles.formatearNombre(tit) + ".mp4" except: name = "Video_V_Television.mp4" 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 __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) ''' html = Descargar.get(self.url) #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 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') 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": "rtmp", "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 __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 getInfo(self): ''' Devuelve toda la información asociada a la URL recibida, de la siguiente forma: { "exito" : bool, <-- True (si se han obtenido videos) "num_video" : int, <-- Número de vídeos obtenidos "mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False]) "videos" : [{ "url_video" : [], <-- Url de descarga de vídeo "url_img" : "", <-- Url de la miniatura del video "filename" : [], <-- Nombre de las partes para guardar en disco "tipo" : "", <-- http, rtmp[e,..], mms, ... "partes" : int, <-- Número de partes que tiene el vídeo "rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None "menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None "url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo "otros" : [], <-- Lista donde se pueden pasar cosas opcionales "mensaje" : "" <-- Mensajes de la API }], <-- Debe ser una lista de tamaño "num_videos" "titulos" : [u""], <-- Titulos de los videos "descs" : [u""] <-- Descripción de cada vídeo } Los valores que no se rellenen, deberán devolver None. La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente: { "exito": False, "mensaje": "No se pudo descargar el video" } "videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None) "url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None) ''' img = None # print "[+] Procesando descarga" streamHTML = Descargar.getHtml(self.url) if self.url.find(".com/videos/") != -1: # Modo Salón try: img = self.URL_DE_ANTENA3 + Utiles.qe(streamHTML).split( "player_capitulo.poster=\'/")[1].split("\'")[0] except: if streamHTML.find("<div class=\"premium\">") != -1: raise Error.GeneralPyspainTVsError( u"PyDownTV no acepta la descarga de contenidos premium de las cadenas." ) url2down, name = self.__modoSalon(streamHTML) else: # Otro vídeos (No modo salón) self.log(u"[INFO] Vídeo normal (no Modo Salón)") # EN PRUEBAS (solo si hay varios vídeos...)! (23/04/2013) [RETROCOMPATIBLE]: ######### xmls = re.findall("\.xml='(.*)'", streamHTML) if len(xmls) > 1: xmls = ["/".join(self.url.split("/")[:3]) + i for i in xmls] return self.normalMultiple(xmls) ##################################################################################### if streamHTML.find(".seoURL='") != -1: # Url directamente en HTML self.debug(u"Vídeo con SEO URL") img = self.URL_DE_ANTENA3 + streamHTML.split( ".poster=\'/")[1].split("\'")[0] url2down, name = self.__modoNormalConURL(streamHTML) elif streamHTML.find("a3_gp_visor_player") != -1: self.log(u"[INFO] Vídeo de Fórmula 1") return self.__modoF1( streamHTML) # return directamente aquí (varios videos) else: # No está la url en el hmtl (buscar por varias partes) if streamHTML.find( "<div class=\"visor\">" ) != -1: # Más de 1 parte # Quizas mejor "carrusel"? return self.__modoNormalVariasPartes( streamHTML) # return directamente aquí (varios videos) #url2down, name = self.__modoNormalVariasPartes(streamHTML) else: # Solo una parte url2down, name = self.__modoNormalUnaParte(streamHTML) desc = None try: desc = Utiles.recortar( streamHTML, "<meta property=\"og:description\" content=\"", "\"").strip() except: try: desc = Utiles.recortar( streamHTML, "<meta name=\"description\" content=\"", "\" />").strip() except: desc = None #if type(url2down) == list: # for i in url2down: # if i.find("geobloqueo") != -1: # self.log(u"[!!!] El vídeo \"" + i + "\" no se puedo descargar (geobloqueado)") # url2down.remove(i) # # TODO: Borrar también su nombre correspondiente # # # Comprobar si todas las partes están geobloqueadas (no quedan elementos en la lista): # if len(url2down) == 0: # raise Error.GeneralPyspainTVsError("Grupo Antena 3. Todo el contenido Geobloqueado.") #else: # if url2down.find("geobloqueo") != -1: # raise Error.GeneralPyspainTVsError("Grupo Antena 3. Todo el contenido Geobloqueado.") if type(name) == list: try: tit_vid = name[0].split(".")[0] tit_vid = tit_vid.replace("_" + tit_vid.split("_")[1], "") except: try: tit_vid = Utiles.recortar(streamHTML, "<title>", "</title>").replace( "ANTENA 3 TV", "").replace("-", "").strip() except: tit_vid = "Vídeo de Grupo Antena 3" for i in name: b = Utiles.formatearNombre(i) name[name.index(i)] = b else: try: tit_vid = name.split(".")[0].replace("_" + name.split("_")[1], "") tit_vid = tit_vid.replace("_" + tit_vid.split("_")[1], "") except: try: tit_vid = Utiles.recortar(streamHTML, "<title>", "</title>").replace( "ANTENA 3 TV", "").replace("-", "").strip() except: tit_vid = "Vídeo de Grupo Antena 3" name = Utiles.formatearNombre(name) #try: # tit_vid = Utiles.recortar(streamHTML, "<title>", "</title>").replace("ANTENA 3 TV", "").replace("-", "").strip() #except: # tit_vid = "Vídeo de Grupo Antena 3" tit_vid = tit_vid.replace("TV VIDEOS ONLINE", "").strip() return { "exito": True, "num_videos": 1, "mensaje": u"URL obtenido correctamente", "videos": [{ "url_video": [url2down] if type(url2down) != list else url2down, "url_img": img if img is not None else None, "filename": [name] if type(name) != list else name, "tipo": "http", "partes": 1 if type(url2down) != list else len(url2down), "rtmpd_cmd": None, "menco_cmd": None, "url_publi": None, "otros": None, "mensaje": None }], "titulos": [tit_vid] if tit_vid is not None else None, "descs": [desc] if desc is not None else None }
def __modoF1( self, streamHTML ): #TODO: ¡¡¡Acabar esta función para devolver todos los videos y sus partes!!! ''' <param value="_urlData=http://www.antena3.com/gestorf1/swf/player_hitos/xml/data.xml&_image=http://www.antena3.com/gestorf1/pictures/361/361/malasia-portada_crop1.png&_id_list=1405&_promo1=http://www.smartadserver.com/call/pubx/15272/241149/4654/S/&_promo2=http://www.smartadserver.com/call/pubx/15272/241148/4654/S/" name="flashVars"> ''' streamHTML = Descargar.getHtmlUtf8(self.url) # Qué vídeo: streamVids = streamHTML.split( "<ul class=\"a3_gp_visor_menu\">")[1].split("</ul>")[0].replace( "\t", "") streamVids = streamVids.split("<li>")[1:] desc = None try: desc = Utiles.recortar( streamHTML, "<meta property=\"og:description\" content=\"", "\"").strip() except: desc = None #self.debug(streamVids) ret = { "exito": True, "num_videos": 0, "mensaje": u"URLs obtenido correctamente", "videos": [], "titulos": [], "descs": [] } v = -1 for i in streamVids: #todos los vídeos con todas sus partes video = { "url_video": [], "url_img": None, "filename": [], "tipo": "http", "partes": 0, "rtmpd_cmd": None, "menco_cmd": None, "url_publi": None, "otros": None, "mensaje": None } v += 1 streamVid = streamVids[v] streamVidUrl = self.URL_DE_ANTENA3 + streamVid.split( "href=\"")[1].split("\"")[0] self.debug(u"URL Video: " + streamVidUrl) streamHTML = Descargar.getHtml(streamVidUrl) #Partes id_list = streamHTML.split("_id_list=")[1].split("&")[0] listXMLurl = self.URL_DE_F1 + id_list + "_playlist.xml" self.debug(u"URL XML list: " + listXMLurl) listxml = Descargar.getHtml(listXMLurl) video["url_img"] = listxml.split("<picture>")[1].split( "</picture>")[0].strip() listxml = listxml.split("<video>")[1:] #print listxml for b in listxml: video["partes"] += 1 #video["mensaje"] = unicode(i.split(">")[1].split("<")[0].capitalize()) endurl = b.split("<url>")[1].split("<")[0] video["url_video"].append( endurl.replace( endurl.split("mp_")[0], "http://desprogresiva.antena3.com/")) ext = "." + video["url_video"][-1].split(".")[-1] tit = b.split("<title>")[1].split("<")[0] + ext tit = Utiles.formatearNombre(tit) video["filename"].append(tit) ret["titulos"].append( unicode( i.split(">")[1].split("<")[0].capitalize()).encode('utf8')) ret["videos"].append(video) ret["num_videos"] += 1 ret["descs"].append(unicode(desc).encode('utf8')) return ret
def getInfo(self): ''' Devuelve toda la información asociada a la URL recibida, de la siguiente forma: { "exito" : bool, <-- True (si se han obtenido videos) "num_video" : int, <-- Número de vídeos obtenidos "mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False]) "videos" : [{ "url_video" : [], <-- Url de descarga de vídeo "url_img" : "", <-- Url de la miniatura del video "filename" : [], <-- Nombre de las partes para guardar en disco "tipo" : "", <-- http, rtmp[e,..], mms, ... "partes" : int, <-- Número de partes que tiene el vídeo "rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None "menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None "url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo "otros" : [], <-- Lista donde se pueden pasar cosas opcionales "mensaje" : "" <-- Mensajes de la API }], <-- Debe ser una lista de tamaño "num_videos" "titulos" : [u""], <-- Titulos de los videos "descs" : [u""] <-- Descripción de cada vídeo } Los valores que no se rellenen, deberán devolver None. La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente: { "exito": False, "mensaje": "No se pudo descargar el video" } "videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None) "url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None) ''' html = self.gethtml().decode('iso-8859-1').encode('utf8').replace( "ü", "u") #FIXME: Esta chapuza if html.find("showVideo(\'") == -1: raise Error.GeneralPyspainTVsError( u"No se han encontrado vídeos en la página") #Hay Vídeos? try: videos = [n.split("\'")[0] for n in html.split("showVideo(\'")[1:]] try: titulos = [ n.split("\"")[0] for n in html.split("f4v\')\" title=\"")[1:] ] except: titulos = u"Vídeo de Radio Televisión de Castilla-La Mancha".encode( 'utf8') * len(videos) desc = titulos try: names = [Utiles.formatearNombre(n + ".mp4") for n in titulos] except: names = "VideosRTVCM.mp4" * len(videos) url = Utiles.recortar(html.split("clip:")[1], "url: \'", "\'") urls = [url + n for n in videos] try: img_b = Utiles.recortar( html.split("logo:")[1], "url: \'", "\'") except: img_b = None try: img = Utiles.recortar( html.split("<div class=\"centralContent\">")[1], "<img src=\"", "\"") except: img = img_b if img_b is not None else None rVideos = [] for i in range(len(videos)): c = "rtmpdump -r '" + urls[i] + "' -o '" + names[i] + "'" temp = { "url_video": [urls[i]], "url_img": img if img is not None else None, "filename": [names[i]] if names is not None else None, "tipo": "rtmp", "partes": 1, "rtmpd_cmd": [c], "menco_cmd": None, "url_publi": None, "otros": None, "mensaje": None } rVideos.append(temp) except: raise Error.GeneralPyspainTVsError( u"No se han podido conseguir los enlaces") return { "exito": True, "num_videos": len(titulos), "mensaje": u"URL obtenido correctamente", "videos": rVideos, "titulos": titulos if titulos is not None else None, "descs": desc if desc is not None else None }
def getInfo(self): """ Devuelve toda la información asociada a la URL recibida, de la siguiente forma: { "exito" : bool, <-- True (si se han obtenido videos) "num_video" : int, <-- Número de vídeos obtenidos "mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False]) "videos" : [{ "url_video" : [], <-- Url de descarga de vídeo "url_img" : "", <-- Url de la miniatura del video "filename" : [], <-- Nombre de las partes para guardar en disco "tipo" : "", <-- http, rtmp[e,..], mms, ... "partes" : int, <-- Número de partes que tiene el vídeo "rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None "menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None "url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo "otros" : [], <-- Lista donde se pueden pasar cosas opcionales "mensaje" : "" <-- Mensajes de la API }], <-- Debe ser una lista de tamaño "num_videos" "titulos" : [u""], <-- Titulos de los videos "descs" : [u""] <-- Descripción de cada vídeo } Los valores que no se rellenen, deberán devolver None. La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente: { "exito": False, "mensaje": "No se pudo descargar el video" } "videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None) "url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None) """ img = None # print "[+] Procesando descarga" streamHTML = Descargar.getHtml(self.url) if self.url.find("atresplayer.com/") != -1: return self.atresplayer_mobile() elif self.url.find(".com/videos/") != -1: # Modo Salón try: img = self.URL_DE_ANTENA3 + Utiles.qe(streamHTML).split("player_capitulo.poster='/")[1].split("'")[0] except: if streamHTML.find('<div class="premium">') != -1: raise Error.GeneralPyspainTVsError( u"PyDownTV no acepta la descarga de contenidos premium de las cadenas." ) url2down, name = self.__modoSalon(streamHTML) else: # Otro vídeos (No modo salón) self.log(u"[INFO] Vídeo normal (no Modo Salón)") # EN PRUEBAS (nuevo modo normal) (17/05/2014) ####################################### xmls = re.findall(".*(http.*\/videosnuevosxml\/.*\.xml).*", streamHTML) if len(xmls) > 0: return self.normalNuevoMultiple(xmls) ###################################################################################### # EN PRUEBAS (solo si hay varios vídeos...)! (23/04/2013) [RETROCOMPATIBLE]: ######### xmls = re.findall("\.xml='(.*)'", streamHTML) if len(xmls) > 1: xmls = ["/".join(self.url.split("/")[:3]) + i for i in xmls] return self.normalMultiple(xmls) ##################################################################################### if streamHTML.find(".seoURL='") != -1: # Url directamente en HTML self.debug(u"Vídeo con SEO URL") img = self.URL_DE_ANTENA3 + streamHTML.split(".poster='/")[1].split("'")[0] url2down, name = self.__modoNormalConURL(streamHTML) elif streamHTML.find("a3_gp_visor_player") != -1: self.log(u"[INFO] Vídeo de Fórmula 1") return self.__modoF1(streamHTML) # return directamente aquí (varios videos) else: # No está la url en el hmtl (buscar por varias partes) if streamHTML.find('<div class="visor">') != -1: # Más de 1 parte # Quizas mejor "carrusel"? return self.__modoNormalVariasPartes(streamHTML) # return directamente aquí (varios videos) # url2down, name = self.__modoNormalVariasPartes(streamHTML) else: # Solo una parte url2down, name = self.__modoNormalUnaParte(streamHTML) desc = None try: desc = Utiles.recortar(streamHTML, '<meta property="og:description" content="', '"').strip() except: try: desc = Utiles.recortar(streamHTML, '<meta name="description" content="', '" />').strip() except: desc = None # if type(url2down) == list: # for i in url2down: # if i.find("geobloqueo") != -1: # self.log(u"[!!!] El vídeo \"" + i + "\" no se puedo descargar (geobloqueado)") # url2down.remove(i) # # TODO: Borrar también su nombre correspondiente # # # Comprobar si todas las partes están geobloqueadas (no quedan elementos en la lista): # if len(url2down) == 0: # raise Error.GeneralPyspainTVsError("Grupo Antena 3. Todo el contenido Geobloqueado.") # else: # if url2down.find("geobloqueo") != -1: # raise Error.GeneralPyspainTVsError("Grupo Antena 3. Todo el contenido Geobloqueado.") if type(name) == list: try: tit_vid = name[0].split(".")[0] tit_vid = tit_vid.replace("_" + tit_vid.split("_")[1], "") except: try: tit_vid = ( Utiles.recortar(streamHTML, "<title>", "</title>") .replace("ANTENA 3 TV", "") .replace("-", "") .strip() ) except: tit_vid = "Vídeo de Grupo Antena 3" for i in name: b = Utiles.formatearNombre(i) name[name.index(i)] = b else: try: tit_vid = name.split(".")[0].replace("_" + name.split("_")[1], "") tit_vid = tit_vid.replace("_" + tit_vid.split("_")[1], "") except: try: tit_vid = ( Utiles.recortar(streamHTML, "<title>", "</title>") .replace("ANTENA 3 TV", "") .replace("-", "") .strip() ) except: tit_vid = "Vídeo de Grupo Antena 3" name = Utiles.formatearNombre(name) # try: # tit_vid = Utiles.recortar(streamHTML, "<title>", "</title>").replace("ANTENA 3 TV", "").replace("-", "").strip() # except: # tit_vid = "Vídeo de Grupo Antena 3" tit_vid = tit_vid.replace("TV VIDEOS ONLINE", "").strip() return { "exito": True, "num_videos": 1, "mensaje": u"URL obtenido correctamente", "videos": [ { "url_video": [url2down] if type(url2down) != list else url2down, "url_img": img if img is not None else None, "filename": [name] if type(name) != list else name, "tipo": "http", "partes": 1 if type(url2down) != list else len(url2down), "rtmpd_cmd": None, "menco_cmd": None, "url_publi": None, "otros": None, "mensaje": None, } ], "titulos": [tit_vid] if tit_vid is not None else None, "descs": [desc] if desc is not None else None, }
def getInfo(self): ''' Devuelve toda la información asociada a la URL recibida, de la siguiente forma: { "exito" : bool, <-- True (si se han obtenido videos) "num_video" : int, <-- Número de vídeos obtenidos "mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False]) "videos" : [{ "url_video" : [], <-- Url de descarga de vídeo "url_img" : "", <-- Url de la miniatura del video "filename" : [], <-- Nombre de las partes para guardar en disco "tipo" : "", <-- http, rtmp[e,..], mms, ... "partes" : int, <-- Número de partes que tiene el vídeo "rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None "menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None "url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo "otros" : [], <-- Lista donde se pueden pasar cosas opcionales "mensaje" : "" <-- Mensajes de la API }], <-- Debe ser una lista de tamaño "num_videos" "titulos" : [u""], <-- Titulos de los videos "descs" : [u""] <-- Descripción de cada vídeo } Los valores que no se rellenen, deberán devolver None. La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente: { "exito": False, "mensaje": "No se pudo descargar el video" } "videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None) "url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None) ''' url_img = None streamHTML = Descargar.getHtml(self.url) if streamHTML.find("http://level3/") != -1: # Método antiguo self.info(u"[INFO] Método antiguo (mitele)") videoID = streamHTML.split("\'http://level3/")[1].split(".")[0] videoEXT = streamHTML.split("\'http://level3/")[1].split("\'")[0].split(".")[1] videoEXT = "." + videoEXT url2down = self.URL_DESCARGA_TELECINCO + videoID[-1] + "/" + videoID[-2] + "/" + videoID + videoEXT name = None elif streamHTML.find(self.string2split4id[0]) != -1: # Método nuevo newID = streamHTML.split(self.string2split4id[0])[1].split(self.string2split4id[1])[0].split(".")[0] self.info(u"[INFO] Nuevo Video ID:", newID) ask4token = self.URL_ASK4TOKEN + newID[-3:] + "/" + newID + ".mp4" self.debug(u"[+] Pidiendo nuevo token") url2down = Descargar.getHtml(ask4token) name = streamHTML.split("var title = \'")[1].split("\'")[0] + ".mp4" elif self.url.find("videoURL=") != -1: # Forma con el ID en la URL (nueva??) videoID = self.url.split("videoURL=")[1] ask4token = self.URL_ASK4TOKEN + videoID[-3:] + "/" + videoID + ".mp4" self.debug(u"[+] Pidiendo nuevo token") url2down = Descargar.getHtml(ask4token) # Obtner nombre: xmlURL = "http://estaticos.telecinco.es/xml/Video/Video_" + videoID + ".xml" streamXML = Descargar.getHtml(xmlURL) name = streamXML.split("<![CDATA[")[1].split("]")[0] + ".mp4" elif streamHTML.find("MDS.embedObj(video") != -1: contentID = streamHTML.split("MDS.embedObj(video, \"")[1].split("\"")[0] try: clippingID = streamHTML.split("imageClippingId: \'")[1].split("\'")[0] # try por que en la API no funcionaba oO except: clippingID = "3.jpg" try: imageContentID = streamHTML.split("imageContentId: \'")[1].split("\'")[0] # try por problemas com la API oO except: imageContentID = streamHTML.split("MDS.embedObj(video, \"")[1].split("\"")[0] self.debug(u"URL JSON: " + self.URL_JSON + "contentId=" + contentID + "&clippingId=" + clippingID + "&imageContentId=" + imageContentID) streamJSON = Descargar.getHtml(self.URL_JSON + "contentId=" + contentID + "&clippingId=" + clippingID + "&imageContentId=" + imageContentID ) #streamJSON = dict(streamJSON) #url2down = streamJSON["sources"][0]["src"] url2down = streamJSON.split("({\"sources\":[{\"src\":\"")[1].split("\"")[0].replace("\/", "/") name = streamHTML.split("<title>")[1].split("<")[0] name += "." + url2down.split(".")[-1].split("?")[0] url_img = streamJSON.split("\"poster\":\"")[1].split("\"")[0].replace("\/", "/") else: Error.GeneralPyspainTVsError("Telecinco.es. No se encuentra contenido.") tit_vid = None if name != None: name = name.replace("Ver vídeo online","") tit_vid = name.split(".")[0] name = Utiles.formatearNombre(name) desc = None try: desc = Utiles.recortar(streamHTML, "<h3 class=\"subtitle\">", "<").strip() except: desc = tit_vid if tit_vid is not None else None return {"exito" : True, "num_videos" : 1, "mensaje" : u"URL obtenido correctamente", "videos":[{ "url_video" : [url2down], "url_img" : url_img if url_img is not None else None, "filename" : [name] if name is not None else None, "tipo" : "http", "partes" : 1, "rtmpd_cmd" : None, "menco_cmd" : None, "url_publi" : None, "otros" : None, "mensaje" : None }], "titulos": [tit_vid] if tit_vid is not None else None, "descs": [desc] if desc is not None else None }
def getInfo(self): ''' Devuelve toda la información asociada a la URL recibida, de la siguiente forma: { "exito" : bool, <-- True (si se han obtenido videos) "num_video" : int, <-- Número de vídeos obtenidos "mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False]) "videos" : [{ "url_video" : [], <-- Url de descarga de vídeo "url_img" : "", <-- Url de la miniatura del video "filename" : [], <-- Nombre de las partes para guardar en disco "tipo" : "", <-- http, rtmp[e,..], mms, ... "partes" : int, <-- Número de partes que tiene el vídeo "rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None "menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None "url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo "otros" : [], <-- Lista donde se pueden pasar cosas opcionales "mensaje" : "" <-- Mensajes de la API }], <-- Debe ser una lista de tamaño "num_videos" "titulos" : [u""], <-- Titulos de los videos "descs" : [u""] <-- Descripción de cada vídeo } Los valores que no se rellenen, deberán devolver None. La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente: { "exito": False, "mensaje": "No se pudo descargar el video" } "videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None) "url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None) ''' #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) ''' html = Descargar.get(self.url) VideoPlayer = html.split("name=\"@videoPlayer\" value=\"ref:")[1].split("\"")[0] #REFERER!! info = self.__get_info(VideoPlayer) big = 0 for video in info['renditions']: if video['encodingRate'] >= big: big = video['encodingRate'] url = video['defaultURL'] ext = "." + url.split(".")[-1] # Parece que no pilla bien los datos a través de la api de brightcove, # utilizo entonces: /comunes/player/mm_nube_bc.php plusEs = False self.debug(u"URL Info: "+self.URL_PLUS + "/comunes/player/mm_nube_bc.php?xref=" + VideoPlayer) info = Descargar.get(self.URL_PLUS + "/comunes/player/mm_nube_bc.php?xref=" + VideoPlayer).decode('iso-8859-15').encode('utf8') try: img = self.URL_PLUS + info.split("<imagen>")[1].split("<![CDATA[")[1].split("]]>")[0].strip() except: img = None plusEs = True try: tit = info.split("<titulo>")[1].split("<![CDATA[")[1].split("]]>")[0].strip() except: tit = u"Vídeo de Canal Plus".encode('utf8') try: name = Utiles.formatearNombre(tit+ext) except: name = "VideoCanalPlus"+ext try: desc = info.split("<descripcion>")[1].split("<![CDATA[")[1].split("]]>")[0].strip() except: desc = u"Vídeo de Canal Plus".encode('utf8') # Probar título y descripción de la página si es vídeo de plus.es # La url del vídeo ya queda, aunque suele venir en el propio html de la página: # <video id="vid1" src="AQUÍ EL VÍDEO" [...]> html = html.decode('iso-8859-15').encode('utf8') ttit = tdesc = None if self.url.find("plus.es") != -1: if plusEs: try: ttit = html.split("<div class=\"news_type1\">")[1].split("<h3>")[1].split("</h3>")[0] except: ttit = None try: tdesc = html.split("<div class=\"news_type1\">")[1].split("<p>")[1].split("</p>")[0] except: tdesc = None try: img = self.URL_PLUSES+Utiles.recortar(html, "poster=\"", "\"") except: img = None if ttit is not None: tit = ttit if tdesc is not None: desc = tdesc ################################################################# # 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 Canal Plus".encode('utf8') # else: # if desc is None or desc == u"": desc = u"Vídeo de Canal Plus".encode('utf8') # # try: tit = info['displayName'].encode('utf8') # except: tit = u"Vídeo de Canal Plus".encode('utf8') # else: # if tit == u"" or tit is None: tit = u"Vídeo de Canal Plus".encode('utf8') # # #FIXME: Ver qué pasa aquí!! --> name = Utiles.formatearNombre(tit + ext) # name = "VideoCanalPlus"+ext # # url = "/".join(img.split("/")[:3])+"/"+"/".join(url.split("/")[3:]) 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) ''' html = Descargar.get(self.url) VideoPlayer = html.split("name=\"@videoPlayer\" value=\"ref:" )[1].split("\"")[0] #REFERER!! info = self.__get_info(VideoPlayer) big = 0 for video in info['renditions']: if video['encodingRate'] >= big: big = video['encodingRate'] url = video['defaultURL'] ext = "." + url.split(".")[-1] # Parece que no pilla bien los datos a través de la api de brightcove, # utilizo entonces: /comunes/player/mm_nube_bc.php plusEs = False self.debug(u"URL Info: " + self.URL_PLUS + "/comunes/player/mm_nube_bc.php?xref=" + VideoPlayer) info = Descargar.get(self.URL_PLUS + "/comunes/player/mm_nube_bc.php?xref=" + VideoPlayer).decode('iso-8859-15').encode('utf8') try: img = self.URL_PLUS + info.split("<imagen>")[1].split( "<![CDATA[")[1].split("]]>")[0].strip() except: img = None plusEs = True try: tit = info.split("<titulo>")[1].split("<![CDATA[")[1].split( "]]>")[0].strip() except: tit = u"Vídeo de Canal Plus".encode('utf8') try: name = Utiles.formatearNombre(tit + ext) except: name = "VideoCanalPlus" + ext try: desc = info.split("<descripcion>")[1].split("<![CDATA[")[1].split( "]]>")[0].strip() except: desc = u"Vídeo de Canal Plus".encode('utf8') # Probar título y descripción de la página si es vídeo de plus.es # La url del vídeo ya queda, aunque suele venir en el propio html de la página: # <video id="vid1" src="AQUÍ EL VÍDEO" [...]> html = html.decode('iso-8859-15').encode('utf8') ttit = tdesc = None if self.url.find("plus.es") != -1: if plusEs: try: ttit = html.split("<div class=\"news_type1\">")[1].split( "<h3>")[1].split("</h3>")[0] except: ttit = None try: tdesc = html.split("<div class=\"news_type1\">")[1].split( "<p>")[1].split("</p>")[0] except: tdesc = None try: img = self.URL_PLUSES + Utiles.recortar( html, "poster=\"", "\"") except: img = None if ttit is not None: tit = ttit if tdesc is not None: desc = tdesc ################################################################# # 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 Canal Plus".encode('utf8') # else: # if desc is None or desc == u"": desc = u"Vídeo de Canal Plus".encode('utf8') # # try: tit = info['displayName'].encode('utf8') # except: tit = u"Vídeo de Canal Plus".encode('utf8') # else: # if tit == u"" or tit is None: tit = u"Vídeo de Canal Plus".encode('utf8') # # #FIXME: Ver qué pasa aquí!! --> name = Utiles.formatearNombre(tit + ext) # name = "VideoCanalPlus"+ext # # url = "/".join(img.split("/")[:3])+"/"+"/".join(url.split("/")[3:]) 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) ''' html = Descargar.get(self.url) rtmp = False try: url = html.split("<param name=\"movie\"")[1].split("file=")[1].split("&")[0] except: try: url = Utiles.unescape(Utiles.recortar(html, "value=\"src=", "&")) rtmp = True except: #TODO: Añadir vídeos de listas raise Error.GeneralPyspainTVsError("No se pudo obtener la url de descarga") try: tit = html.split("<td class=\"contentheading\"")[1].split(">")[1].split("<")[0].decode('iso-8859-1').encode('utf8') except: try: tit = Utiles.recortar(html, "<meta name=\"title\" content=\"", "\"").decode('iso-8859-1').encode('utf8') except: tit = u"Vídeo de Rias Baixas Televisión".encode('utf8') try: desc = html.split("<table class=\"contentpaneopen\">")[1].split("</strong>")[1].split("</table>")[0].decode('iso-8859-1').encode('utf8') #desc = desc.replace(desc.find("<!-- JW AllVideos"), new) except: desc = tit try: if rtmp: imgs = html.split("MM_preloadImages('")[1] for i in imgs.split("<a href="): if i.find(self.url) != -1: img = self.URL_RB + "/" + i.split("MM_swapImage(")[1].split(",")[2].replace("\'", "").strip() break else: img = None else: img = html.split("<param name=\"movie\"")[1].split("image=")[1].split("&")[0] if Descargar.isReachable(img): pass else: img = None except: img = None try: name = Utiles.formatearNombre(tit) + ".flv" except: name = "Video_RiasBaixas.mp4" if rtmp: rtmpd_cmd = "rtmpdump -r \'"+url+"\' -o \'"+name+"\'" 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" if not rtmp else "rtmp", "partes" : 1, "rtmpd_cmd" : [rtmpd_cmd] if rtmp else 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 }
'./video/info/subcategory').text.encode('utf8') tit_vid = name = "%s (%s) - %s - %s" % ( video_title, video_sub_title, video_category, video_sub_category) 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() try: name = Utiles.formatearNombre(name + ".mp4") except: name = "Video_de_mitele.mp4" 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: desc = tit_vid if tit_vid is not None else None if type(url) is list: # Comando RTMP _type = "rtmp" rtmpd_cmd = "rtmpdump -r " + " ".join(url) + " -o \"" + name + "\"" url = "rtmp" + rtmpd_cmd.split("rtmp")[2].split('"')[0]
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) ''' if self.url.find("tv-a-la-carta/") != -1 or self.url.find("http://alacarta.canalextremadura.es/tv") != -1 \ or self.url.find("canalextremadura.es/alacarta/tv/") != -1: self.info(u"[INFO] TV a la carta") html = html2 = Descargar.get(self.url).decode('utf8').encode('utf8') html = html.replace(" ", "") if html.find("crea_video_hd(") != -1: urlFLV = html.split("crea_video_hd(\"")[1].split("\"")[0] streamFLV = Descargar.get(urlFLV) url = "http://" + streamFLV.split("http://")[1] ext = "." + url.split(".")[-1].split("?")[0] elif html.find("file:'") != -1: try: url = html.split("\'file\':\'")[1].split("\'")[0] #Modo nomal nuevo except: #Modo normal antiguo url = html.split("streamer:\'")[1].split("\'")[0] + html.split("file:\'")[1].split("\'")[0] ext = "." + url.split(".")[-1] elif html.split("if(isiPad)") != -1: #HTTP para iPad url = html.split("<video")[1].split(".mp4")[0].split("\"")[-1] + ".mp4" ext = ".mp4" elif html.find("rel=\"rtmp://") != -1: #RTMP en alacarta url = "rtmp://" + html.split("rel=\"rtmp://")[1].split("\"")[0].replace("#", "") url = url.split(".mp4")[0] + ".mp4" ext = ".mp4" name = html.split("<title>")[1].split("<")[0] + ext if name: name = Utiles.formatearNombre(name) try: img = self.URL_CANAL_EXTREMADURA + Utiles.recortar(html2, "poster=\"", "\"") except: img = None try: tit = Utiles.recortar(html2, "<title>", "</title>").replace("Canal Extremadura", "").replace("|","").strip()#.encode('utf8') except: tit = u"Vídeo de Canal Extremadura".encode('utf8') try: desc = Utiles.recortar(html2, "<div class=\"descripcion\">", "</div>").strip()#.ecnode('utf8') except: desc = u"Vídeo de Canal Extremadura".encode('utf8') else: if type(desc) is str: if desc == "": desc = u"Vídeo de Canal Extremadura".encode('utf8') elif type(desc) is unicode: if desc == u"": desc = u"Vídeo de Canal Extremadura".encode('utf8') rtmpd_cmd = u"rtmpdump -r "+url+" -o "+name 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 } else: raise Error.GeneralPyspainTVsError(u"No se encuentra el contenido audiovisual") name = html.split("<title>")[1].split("<")[0] + ext #TODO: Dar soporte a la radio, por ahora no # elif self.url.find("radio-a-la-carta/") != -1 or self.url.find("http://alacarta.canalextremadura.es/radio") != -1 \ # or self.url.find("canalextremadura.es/alacarta/radio/") != -1: # self.info(u"[INFO] Radio A la Carta") # html = Descargar.get(self.url).replace(" ", "") # try: #Modo nuevo # url = html.split("<divclass=\"descargar\">")[1].split("<ahref=\"")[1].split("\"")[0] # except: #Modo antiguo # url = html.split("s1.addVariable(\'file\',\'")[1].split("\'")[0] # name = html.split("<title>")[1].split("<")[0] + ".mp3" else: #Modo normal nuevo con nueva url recibida try: self.info(u"[INFO] Modo Genérico") html = Descargar.get(self.url).replace(" ", "") url = html.split("\'file\':\'")[1].split("\'")[0] #Modo nomal nuevo ext = "." + url.split(".")[-1] name = html.split("<title>")[1].split("<")[0] + ext except: Error.GeneralPyspainTVsError(u"No se ha podido acceder a ningún contenido") if name: name = Utiles.formatearNombre(name) try: img = self.URL_CANAL_EXTREMADURA + Utiles.recortar(html2, "poster=\"", "\"") except: img = None try: tit = Utiles.recortar(html2, "<title>", "</title>").replace("Canal Extremadura", "").replace("|","").strip()#.encode('utf8') except: tit = u"Vídeo de Canal Extremadura".encode('utf8') try: desc = Utiles.recortar(html2, "<div class=\"descripcion\">", "</div>").strip()#.ecnode('utf8') except: desc = u"Vídeo de Canal Extremadura".encode('utf8') else: if type(desc) is str: if desc == "": desc = u"Vídeo de Canal Extremadura".encode('utf8') elif type(desc) is unicode: if desc == u"": desc = u"Vídeo de Canal Extremadura".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) ''' html = Descargar.get(self.url) rtmp = False try: url = html.split("<param name=\"movie\"")[1].split( "file=")[1].split("&")[0] except: try: url = Utiles.unescape( Utiles.recortar(html, "value=\"src=", "&")) rtmp = True except: #TODO: Añadir vídeos de listas raise Error.GeneralPyspainTVsError( "No se pudo obtener la url de descarga") try: tit = html.split("<td class=\"contentheading\"")[1].split( ">")[1].split("<")[0].decode('iso-8859-1').encode('utf8') except: try: tit = Utiles.recortar(html, "<meta name=\"title\" content=\"", "\"").decode('iso-8859-1').encode('utf8') except: tit = u"Vídeo de Rias Baixas Televisión".encode('utf8') try: desc = html.split("<table class=\"contentpaneopen\">")[1].split( "</strong>")[1].split("</table>")[0].decode( 'iso-8859-1').encode('utf8') #desc = desc.replace(desc.find("<!-- JW AllVideos"), new) except: desc = tit try: if rtmp: imgs = html.split("MM_preloadImages('")[1] for i in imgs.split("<a href="): if i.find(self.url) != -1: img = self.URL_RB + "/" + i.split( "MM_swapImage(")[1].split(",")[2].replace( "\'", "").strip() break else: img = None else: img = html.split("<param name=\"movie\"")[1].split( "image=")[1].split("&")[0] if Descargar.isReachable(img): pass else: img = None except: img = None try: name = Utiles.formatearNombre(tit) + ".flv" except: name = "Video_RiasBaixas.mp4" if rtmp: rtmpd_cmd = "rtmpdump -r \'" + url + "\' -o \'" + name + "\'" 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" if not rtmp else "rtmp", "partes": 1, "rtmpd_cmd": [rtmpd_cmd] if rtmp else 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) ''' html = Descargar.get(self.url) try: url = self.URL_VTV + html.split("showPlayer(")[1].split(",")[1].split(",")[0].replace("\"", "").strip() except: try: url = Utiles.recortar(html, "<meta property=\"og:video\" content=\"", "\"").replace("media.", "") except: raise Error.GeneralPyspainTVsError("No se pudo obtener la url de descarga") try: tit = Utiles.recortar(html, "<meta name=\"title\" content=\"", "\"").decode('iso-8859-1').encode('utf8') except: tit = u"Vídeo de V Televisión".encode('utf8') try: desc = Utiles.recortar(html, "<meta name=\"description\" content=\"", "\"").decode('iso-8859-1').encode('utf8') except: desc = tit try: img = Utiles.recortar(html, "<meta property=\"og:image\" content=\"", "\"") except: img = None try: name = Utiles.formatearNombre(tit) + ".mp4" except: name = "Video_V_Television.mp4" 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) ''' #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 }
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) 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", "") desc = None try: desc = Utiles.descriptionFormat(Utiles.recortar(htmlBackup, '"post_content":"', '"').strip()) except: desc = tit_vid if tit_vid is not None else None return { "exito": True, "num_videos": 1,
def getInfo(self): ''' Devuelve toda la información asociada a la URL recibida, de la siguiente forma: { "exito" : bool, <-- True (si se han obtenido videos) "num_video" : int, <-- Número de vídeos obtenidos "mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False]) "videos" : [{ "url_video" : [], <-- Url de descarga de vídeo "url_img" : "", <-- Url de la miniatura del video "filename" : [], <-- Nombre de las partes para guardar en disco "tipo" : "", <-- http, rtmp[e,..], mms, ... "partes" : int, <-- Número de partes que tiene el vídeo "rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None "menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None "url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo "otros" : [], <-- Lista donde se pueden pasar cosas opcionales "mensaje" : "" <-- Mensajes de la API }], <-- Debe ser una lista de tamaño "num_videos" "titulos" : [u""], <-- Titulos de los videos "descs" : [u""] <-- Descripción de cada vídeo } Los valores que no se rellenen, deberán devolver None. La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente: { "exito": False, "mensaje": "No se pudo descargar el video" } "videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None) "url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None) ''' #TODO: Cuida con las paginas que tiene más de un vídeo. De momento funciona porque es el primer video que aparece! # Primero: nos quedamos con le id dependiendo si el user metio la url con # una barra (/) final o no y si tiene extensión (no es alacarta) videoID = self.url.split('/')[-1] if videoID == "": videoID = self.url.split('/')[-2] elif videoID.find(".shtml") != -1 or videoID.find(".html") != -1 or \ videoID.find(".html") != -1: videoID = videoID.split('.')[0] self.debug(u"ID del vídeo en url = " + videoID) # Añadido para vídeos nuevos (periodo de prueba): sourceHTML = Descargar.getHtml(self.url) videoID_comp = None if sourceHTML.find("flashcontentId:\'videoplayer") != -1: videoID_comp = sourceHTML.split("flashcontentId:\'videoplayer")[1].split("\'")[0] if videoID_comp != videoID: videoID = videoID_comp if sourceHTML.find("<div id=\"video") != -1: videoID_comp = sourceHTML.split("<div id=\"video")[1].split("\"")[0] if videoID_comp != videoID: videoID = videoID_comp ######################################################## self.debug(u"ID del vídeo en HTML = " + videoID_comp if videoID_comp else "No ID en HTML") self.log(u"[INFO] ID del Vídeo :", videoID) # -- Método 1 Octubre 2012: self.debug(u"Probando método de 1 de uno de Octubre de 2012") url = "http://www.rtve.es/ztnr/consumer/xl/video/alta/" + videoID + "_es_292525252525111" self.debug(url) user_agent="Mozilla" opener = urllib2.build_opener(NoRedirectHandler()) urllib2.install_opener(opener) headers = { 'User-Agent' : user_agent } req = urllib2.Request(url, None, headers) u = urllib2.urlopen(req) try: urlVideo = u.info().getheaders("Location")[0] except: raise Error.GeneralPyspainTVsError("No se encuentra Location") u.close() if urlVideo != "": url_video = urlVideo.replace("www.rtve.es", "media5.rtve.es") titulo = sourceHTML.split("<title>")[1].split("</")[0] filename = titulo + ".mp4" filename = Utiles.formatearNombre(filename) #sourceHTML = sourceHTML.split("<div id=\"video")[1].split("flashvars")[0] # Me quedo solo con la parte del vídeo principal url_img = sourceHTML.split("\"thumbnail\" content=\"")[1].split("\"")[0] else: raise Error.GeneralPyspainTVsError("No se pudo encontrar el enlace de descarga") # -- Método 1 Octubre 2012 FIN desc = None try: #obtener descripción del video desc = Utiles.recortar(sourceHTML, "<meta itemprop=\"description\" content=\"", "\"").strip() except: try: desc = Utiles.recortar(sourceHTML, "<meta property=\"og:description\" content=\"", "\"").strip() except: try: desc = Utiles.recortar(sourceHTML, "<meta name=\"description\" content=\"", "\"").strip() except: desc = None return {"exito" : True, "num_videos" : 1, "mensaje" : u"URL obtenido correctamente", "videos":[{ "url_video" : [url_video], "url_img" : url_img, "filename" : [filename], "tipo" : "http", "partes" : 1, "rtmpd_cmd" : None, "menco_cmd" : None, "url_publi" : None, "otros" : None, "mensaje" : None }], "titulos": [titulo], "descs": [desc] if desc is not None else None }
def getInfo(self): ''' Devuelve toda la información asociada a la URL recibida, de la siguiente forma: { "exito" : bool, <-- True (si se han obtenido videos) "num_video" : int, <-- Número de vídeos obtenidos "mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False]) "videos" : [{ "url_video" : [], <-- Url de descarga de vídeo "url_img" : "", <-- Url de la miniatura del video "filename" : [], <-- Nombre de las partes para guardar en disco "tipo" : "", <-- http, rtmp[e,..], mms, ... "partes" : int, <-- Número de partes que tiene el vídeo "rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None "menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None "url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo "otros" : [], <-- Lista donde se pueden pasar cosas opcionales "mensaje" : "" <-- Mensajes de la API }], <-- Debe ser una lista de tamaño "num_videos" "titulos" : [u""], <-- Titulos de los videos "descs" : [u""] <-- Descripción de cada vídeo } Los valores que no se rellenen, deberán devolver None. La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente: { "exito": False, "mensaje": "No se pudo descargar el video" } "videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None) "url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None) ''' 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.getHtmlUtf8Intereconomia(self.url) rtmp = False try: tit = Utiles.recortar(html, "title: '", "'").encode('utf-8') except: try: tit = Utiles.recortar(html, "<title>", "</title>").encode('utf-8') except: tit = u"Vídeo de Intereconomía".encode('utf8') desc = tit try: name = Utiles.formatearNombre(tit + ".mp4") except: name = "VideoIntereconomia.mp4" try: img = self.URL_INTER + Utiles.recortar( html, "backgroundImage: 'url(", ")'") except: img = None try: url = Utiles.url_fix(Utiles.recortar(html, "clip: '", "'")) except: try: url = Utiles.url_fix( html.split("playlist:")[1].split("url: '")[1].split("'") [0]) except: try: url = Utiles.url_fix( html.split("clip:")[1].split("url: \'")[1].split("\'") [0]) rtmp = True except: raise Error.GeneralPyspainTVsError( u"No se ha podido encontrar el vídeo en la página") if rtmp: url = (Utiles.recortar(html, "netConnectionUrl: \'", "\'") + "/" + url).replace("mp4:", "mp4/").replace("mp4%3A", "mp4/") rtmpd_cmd = "rtmpdump -r \'" + url + "\' -o \'" + name + "\'" 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 } 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) ''' html = Descargar.getHtmlUtf8Intereconomia(self.url) rtmp = False try: tit = Utiles.recortar(html, "title: '", "'").encode('utf-8') except: try: tit = Utiles.recortar(html, "<title>", "</title>").encode('utf-8') except:tit = u"Vídeo de Intereconomía".encode('utf8') desc = tit try: name = Utiles.formatearNombre(tit+".mp4") except: name = "VideoIntereconomia.mp4" try: img = self.URL_INTER+Utiles.recortar(html, "backgroundImage: 'url(", ")'") except: img = None try: url = Utiles.url_fix(Utiles.recortar(html, "clip: '", "'")) except: try: url = Utiles.url_fix(html.split("playlist:")[1].split("url: '")[1].split("'")[0]) except: try: url = Utiles.url_fix(html.split("clip:")[1].split("url: \'")[1].split("\'")[0]) rtmp = True except: raise Error.GeneralPyspainTVsError(u"No se ha podido encontrar el vídeo en la página") if rtmp: url = (Utiles.recortar(html, "netConnectionUrl: \'", "\'") + "/" + url).replace("mp4:", "mp4/").replace("mp4%3A", "mp4/") rtmpd_cmd = "rtmpdump -r \'"+url+"\' -o \'"+name+"\'" 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 } 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 __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) """ try: # Tratar de quitar caracteres especiales de las urls que no lo necesitan self.url = self.url.split("video:")[0] + "video:_" + self.url.split("_")[1] self.debug(u"Adaptar URL: %s" % self.url) except: pass streamHTML = htmlBackup = ( Descargar.getHtml(self.url).decode("iso-8859-1").encode("utf8") ) # rtpa codigicada en iso.. streamHTML = streamHTML.replace("\n", "").replace("\t", "") partes = None # método 12/11/2012: # if streamHTML.find("html5") != -1: if re.findall("['\"]type['\"]\ *:\ *['\"]html5['\"]", streamHTML): partes = 1 videoID = re.findall("\:\_(.*)\.", self.url)[0] url = re.findall("['\"]file['\"]\ *?:\ *?['\"](.*?)['\"]", streamHTML)[0] info = json.loads(Descargar.getHtmlUtf8(self.RTPA_API_INFO_ENDPOINT + videoID)) try: name = Utiles.formatearNombre( "%s (%s).mp4" % (info["VOD"][0]["nombre_programa"], info["VOD"][0]["fecha_emision"]) ) except: name = u"ProgramaRTPA.mp4" else: # Cuantas partes son: try: partes = int(streamHTML.split("&partes=")[1].split("&")[0]) except IndexError: # No existe "&partes" partes = 1 if partes == 1: videoID = streamHTML.split('<param value="video1=')[1].split("&")[0] if videoID.find("http://") != -1: url = videoID name = streamHTML.split('data-text="')[1].split('"')[0].strip() + "." + url.split(".")[-1] else: # Probar entre TOKEN nuevo y antiguo por reproductor: repro = streamHTML.split('<param value="player/')[1].split('"')[0] if repro == "reproductorVideoOnDemmand-mp4-rtpa.swf": # Antiguo streamINFO = self.__descHTML(self.TOKEN_ARCHIVO + videoID) url = "http://" + streamINFO.split("http://")[1] else: # Reproductor nuevo: "reproductorVideoOnDemmand.swf" streamINFO = self.__descHTML(self.TOKEN + videoID + "_1") streamINFO = self.__descHTML(streamINFO.split("&url=")[1]) url = "http://" + streamINFO.split("http://")[1] name = streamHTML.split('<div id="sobreElVideo">')[1].split("<h3>")[1].split("</h3>")[0] if name == "": name = streamHTML.split("<title>")[1].split("</title>")[0] + ".mp4" else: name + ".mp4" else: # Recordar que hay videos que ponen varias partes en las que realmente solo existe una: videoID = streamHTML.split('<param value="video1=')[1].split("&")[0] url = [] name = [] for i in range(1, partes + 1): streamINFO = self.__descHTML(self.TOKEN + videoID + "_" + str(i)) streamINFO = self.__descHTML(streamINFO.split("&url=")[1]) tmp_url = "http://" + streamINFO.split("http://")[1] tmp_name = ( streamHTML.split('<div id="sobreElVideo">')[1].split("<h3>")[1].split("</h3>")[0] + "_part" + str(i) ) if tmp_name == "": tmp_name = streamHTML.split("<title>")[1].split("</title>")[0] + "_part" + str(i) + ".mp4" else: tmp_name + ".mp4" if Descargar.isReachable(tmp_url): url.append(tmp_url) name.appen(tmp_name) continue else: break # FIXME: Gran fixme aquí, arreglar todo esto de desc y de tit_vid if info: img = info["VOD"][0]["url_imagen"] desc = u"%s (%s)" % (info["VOD"][0]["nombre_programa"], info["VOD"][0]["fecha_emision"]) try: desc = unicode(desc).encode("utf8") except: desc = u"Vídeo de la web de Radio Televisión del Principado de Asturias".encode("utf8") tit_vid = desc else: try: # imagen del vídeo img = self.URL_RTPA + Utiles.recortar(htmlBackup, "'image': '", "'") except: img = None desc = u"" try: # Descripción del vídeo d = htmlBackup.split('<div class="overview">')[1].split("<div>")[1].split("</div>")[0].strip() except: try: d = htmlBackup.split('<div class="overview">')[1].split("<p>")[1].split("</p>")[0].strip() except: pass try: # desc coding desc = unicode(d).encode("utf8") except: desc = u"Vídeo de la web de Radio Televisión del Principado de Asturias".encode("utf8") if desc == u"": desc = u"Vídeo de la web de Radio Televisión del Principado de Asturias".encode("utf8") tit_vid = u"" try: # Título del vídeo tit = htmlBackup.split('<div id="sobreElVideo">')[1].split("<h3>")[1].split("</h3>")[0].strip() except: try: tit = ( htmlBackup.split('<div id="sobreElVideo">')[1] .split('<h4 class="')[1] .split(">")[1] .split("<")[0] .strip() ) except: pass try: # titulo coding tit = Utiles.tituloFormat(tit) tit_vid = unicode(tit).encode("utf8") except: tit_vid = u"Vídeo de la web de Radio Televisión del Principado de Asturias".encode("utf8") if tit_vid == u"": tit_vid = u"Vídeo de la web de Radio Televisión del Principado de Asturias".encode("utf8") if type(name) == list: for i in name: b = Utiles.formatearNombre(i) name[name.index(i)] = b else: name = Utiles.formatearNombre(name) return { "exito": True, "num_videos": 1, "mensaje": u"URL obtenida correctamente", "videos": [ { "url_video": [url] if type(url) != list else url, "url_img": img if img is not None else None, "filename": [name] if name is not None else None, "tipo": "http", "partes": partes if partes is not None else 1, "rtmpd_cmd": None, "menco_cmd": None, "url_publi": None, "otros": None, "mensaje": None, } ], "titulos": [tit_vid] if tit_vid is not None else None, "descs": [desc] if desc is not None else None, }
def getInfo(self): ''' Devuelve toda la información asociada a la URL recibida, de la siguiente forma: { "exito" : bool, <-- True (si se han obtenido videos) "num_video" : int, <-- Número de vídeos obtenidos "mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False]) "videos" : [{ "url_video" : [], <-- Url de descarga de vídeo "url_img" : "", <-- Url de la miniatura del video "filename" : [], <-- Nombre de las partes para guardar en disco "tipo" : "", <-- http, rtmp[e,..], mms, ... "partes" : int, <-- Número de partes que tiene el vídeo "rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None "menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None "url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo "otros" : [], <-- Lista donde se pueden pasar cosas opcionales "mensaje" : "" <-- Mensajes de la API }], <-- Debe ser una lista de tamaño "num_videos" "titulos" : [u""], <-- Titulos de los videos "descs" : [u""] <-- Descripción de cada vídeo } Los valores que no se rellenen, deberán devolver None. La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente: { "exito": False, "mensaje": "No se pudo descargar el video" } "videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None) "url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None) ''' 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) ''' # 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) ''' # 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 getInfo(self): ''' Devuelve toda la información asociada a la URL recibida, de la siguiente forma: { "exito" : bool, <-- True (si se han obtenido videos) "num_video" : int, <-- Número de vídeos obtenidos "mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False]) "videos" : [{ "url_video" : [], <-- Url de descarga de vídeo "url_img" : "", <-- Url de la miniatura del video "filename" : [], <-- Nombre de las partes para guardar en disco "tipo" : "", <-- http, rtmp[e,..], mms, ... "partes" : int, <-- Número de partes que tiene el vídeo "rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None "menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None "url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo "otros" : [], <-- Lista donde se pueden pasar cosas opcionales "mensaje" : "" <-- Mensajes de la API }], <-- Debe ser una lista de tamaño "num_videos" "titulos" : [u""], <-- Titulos de los videos "descs" : [u""] <-- Descripción de cada vídeo } Los valores que no se rellenen, deberán devolver None. La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente: { "exito": False, "mensaje": "No se pudo descargar el video" } "videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None) "url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None) ''' url_img = None streamHTML = Descargar.getHtml(self.url) if streamHTML.find("http://level3/") != -1: # Método antiguo self.info(u"[INFO] Método antiguo (mitele)") videoID = streamHTML.split("\'http://level3/")[1].split(".")[0] videoEXT = streamHTML.split("\'http://level3/")[1].split("\'")[0].split(".")[1] videoEXT = "." + videoEXT url2down = self.URL_DESCARGA_TELECINCO + videoID[-1] + "/" + videoID[-2] + "/" + videoID + videoEXT name = None elif streamHTML.find(self.string2split4id[0]) != -1: # Método nuevo newID = streamHTML.split(self.string2split4id[0])[1].split(self.string2split4id[1])[0].split(".")[0] self.info(u"[INFO] Nuevo Video ID:", newID) ask4token = self.URL_ASK4TOKEN + newID[-3:] + "/" + newID + ".mp4" self.debug(u"[+] Pidiendo nuevo token") url2down = Descargar.getHtml(ask4token) name = streamHTML.split("var title = \'")[1].split("\'")[0] + ".mp4" elif self.url.find("videoURL=") != -1: # Forma con el ID en la URL (nueva??) videoID = self.url.split("videoURL=")[1] ask4token = self.URL_ASK4TOKEN + videoID[-3:] + "/" + videoID + ".mp4" self.debug(u"[+] Pidiendo nuevo token") url2down = Descargar.getHtml(ask4token) # Obtner nombre: xmlURL = "http://estaticos.telecinco.es/xml/Video/Video_" + videoID + ".xml" streamXML = Descargar.getHtml(xmlURL) name = streamXML.split("<![CDATA[")[1].split("]")[0] + ".mp4" elif streamHTML.find("MDS.embedObj(video") != -1: contentID = streamHTML.split("MDS.embedObj(video, \"")[1].split("\"")[0] clippingID = streamHTML.split("imageClippingId: \'")[1].split("\'")[0] imageContentID = streamHTML.split("imageContentId: \'")[1].split("\'")[0] self.debug(u"URL JSON: " + self.URL_JSON + "contentId=" + contentID + "&clippingId=" + clippingID + "&imageContentId=" + imageContentID) streamJSON = Descargar.getHtml(self.URL_JSON + "contentId=" + contentID + "&clippingId=" + clippingID + "&imageContentId=" + imageContentID ) #streamJSON = dict(streamJSON) #url2down = streamJSON["sources"][0]["src"] url2down = streamJSON.split("({\"sources\":[{\"src\":\"")[1].split("\"")[0].replace("\/", "/") name = streamHTML.split("<title>")[1].split("<")[0] name += "." + url2down.split(".")[-1].split("?")[0] url_img = streamJSON.split("\"poster\":\"")[1].split("\"")[0].replace("\/", "/") else: Error.GeneralPyspainTVsError("Telecinco.es. No se encuentra contenido.") tit_vid = None if name != None: name = name.replace("Ver vídeo online","") tit_vid = name.split(".")[0] name = Utiles.formatearNombre(name) desc = None try: desc = Utiles.recortar(streamHTML, "<h3 class=\"subtitle\">", "<").strip() except: desc = tit_vid if tit_vid is not None else None return {"exito" : True, "num_videos" : 1, "mensaje" : u"URL obtenido correctamente", "videos":[{ "url_video" : [url2down], "url_img" : url_img if url_img is not None else None, "filename" : [name] if name is not None else None, "tipo" : "http", "partes" : 1, "rtmpd_cmd" : None, "menco_cmd" : None, "url_publi" : None, "otros" : None, "mensaje" : None }], "titulos": [tit_vid] if tit_vid is not None else None, "descs": [desc] if desc is not None else None }
def getInfo(self): ''' Devuelve toda la información asociada a la URL recibida, de la siguiente forma: { "exito" : bool, <-- True (si se han obtenido videos) "num_video" : int, <-- Número de vídeos obtenidos "mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False]) "videos" : [{ "url_video" : [], <-- Url de descarga de vídeo "url_img" : "", <-- Url de la miniatura del video "filename" : [], <-- Nombre de las partes para guardar en disco "tipo" : "", <-- http, rtmp[e,..], mms, ... "partes" : int, <-- Número de partes que tiene el vídeo "rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None "menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None "url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo "otros" : [], <-- Lista donde se pueden pasar cosas opcionales "mensaje" : "" <-- Mensajes de la API }], <-- Debe ser una lista de tamaño "num_videos" "titulos" : [u""], <-- Titulos de los videos "descs" : [u""] <-- Descripción de cada vídeo } Los valores que no se rellenen, deberán devolver None. La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente: { "exito": False, "mensaje": "No se pudo descargar el video" } "videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None) "url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None) ''' # 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 }
class Historia(Canal.Canal): ''' Clase para manejar los vídeos de Canal Historia ("A la Carta") ''' URL_HIST_CARTA = "http://historia.adnstream.com" URL_GET_XML = "http://historia.adnstream.com/get_playlist.php?lista=video&c=721&ux=0¶m=" URL_LINFOX_PROXY = "http://linfox.es/p/browse.php?b=0&f=norefer&u=" URL_ANONIM_PROXY = "http://proxyanonimo.es/browse.php?b=12&f=norefer&u=" PROXY_PYDOWNTV = "http://pydowntv.pydowntv.com/p/browse.php?u=" 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 Error.GeneralPyspainTVsError("mensaje") 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__()) logging.debug(xml) try: tit = Utiles.recortar(xml, "<title>", "</title>") except: u"Vídeo de Canal Historia".encode('utf8') try: desc = Utiles.recortar(xml, "<description>", "</description>") except: desc = u"Vídeo de Canal Historia".encode('utf8') try: img = Utiles.recortar(xml, "<media:thumbnail url=\"", "\"") except: img = None try: url = xml.split("<media:content type=\"video")[1].split( "url=\"")[1].split("\"")[0] except: try: url = Utiles.recortar(xml, "<jwplayer:file>", "</jwplayer:file>").strip() except: raise Error.GeneralPyspainTVsError( u"No se ha podido encontrar la URL del vídeo") try: name = Utiles.formatearNombre(tit + Utiles.ext(url)) except: name = "VideoCanalHistoria" + Utiles.ext(url) if url.find("PPV1") != -1: mensaje = u'<span style="color: #ee6557;">EL VÍDEO PERTENECE A LA SECCIÓN PREMIUM, POR LO QUE NO SE PODRÁ DESCARGAR.</span>'.encode( 'utf8') url = "Contenido Premium" else: mensaje = 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": mensaje }], "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) ''' if self.url.find("tv-a-la-carta/") != -1 or self.url.find("http://alacarta.canalextremadura.es/tv") != -1 \ or self.url.find("canalextremadura.es/alacarta/tv/") != -1: self.info(u"[INFO] TV a la carta") html = html2 = Descargar.get( self.url).decode('utf8').encode('utf8') html = html.replace(" ", "") if html.find("crea_video_hd(") != -1: urlFLV = html.split("crea_video_hd(\"")[1].split("\"")[0] streamFLV = Descargar.get(urlFLV) url = "http://" + streamFLV.split("http://")[1] ext = "." + url.split(".")[-1].split("?")[0] elif html.find("file:'") != -1: try: url = html.split("\'file\':\'")[1].split("\'")[ 0] #Modo nomal nuevo except: #Modo normal antiguo url = html.split("streamer:\'")[1].split( "\'")[0] + html.split("file:\'")[1].split("\'")[0] ext = "." + url.split(".")[-1] elif html.split("if(isiPad)") != -1: #HTTP para iPad url = html.split("<video")[1].split(".mp4")[0].split( "\"")[-1] + ".mp4" ext = ".mp4" elif html.find("rel=\"rtmp://") != -1: #RTMP en alacarta url = "rtmp://" + html.split("rel=\"rtmp://")[1].split( "\"")[0].replace("#", "") url = url.split(".mp4")[0] + ".mp4" ext = ".mp4" name = html.split("<title>")[1].split("<")[0] + ext if name: name = Utiles.formatearNombre(name) try: img = self.URL_CANAL_EXTREMADURA + Utiles.recortar( html2, "poster=\"", "\"") except: img = None try: tit = Utiles.recortar(html2, "<title>", "</title>").replace( "Canal Extremadura", "").replace( "|", "").strip() #.encode('utf8') except: tit = u"Vídeo de Canal Extremadura".encode('utf8') try: desc = Utiles.recortar(html2, "<div class=\"descripcion\">", "</div>").strip() #.ecnode('utf8') except: desc = u"Vídeo de Canal Extremadura".encode('utf8') else: if type(desc) is str: if desc == "": desc = u"Vídeo de Canal Extremadura".encode('utf8') elif type(desc) is unicode: if desc == u"": desc = u"Vídeo de Canal Extremadura".encode('utf8') rtmpd_cmd = u"rtmpdump -r " + url + " -o " + name 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 } else: raise Error.GeneralPyspainTVsError( u"No se encuentra el contenido audiovisual") name = html.split("<title>")[1].split("<")[0] + ext #TODO: Dar soporte a la radio, por ahora no # elif self.url.find("radio-a-la-carta/") != -1 or self.url.find("http://alacarta.canalextremadura.es/radio") != -1 \ # or self.url.find("canalextremadura.es/alacarta/radio/") != -1: # self.info(u"[INFO] Radio A la Carta") # html = Descargar.get(self.url).replace(" ", "") # try: #Modo nuevo # url = html.split("<divclass=\"descargar\">")[1].split("<ahref=\"")[1].split("\"")[0] # except: #Modo antiguo # url = html.split("s1.addVariable(\'file\',\'")[1].split("\'")[0] # name = html.split("<title>")[1].split("<")[0] + ".mp3" else: #Modo normal nuevo con nueva url recibida try: self.info(u"[INFO] Modo Genérico") html = Descargar.get(self.url).replace(" ", "") url = html.split("\'file\':\'")[1].split("\'")[ 0] #Modo nomal nuevo ext = "." + url.split(".")[-1] name = html.split("<title>")[1].split("<")[0] + ext except: Error.GeneralPyspainTVsError( u"No se ha podido acceder a ningún contenido") if name: name = Utiles.formatearNombre(name) try: img = self.URL_CANAL_EXTREMADURA + Utiles.recortar( html2, "poster=\"", "\"") except: img = None try: tit = Utiles.recortar(html2, "<title>", "</title>").replace( "Canal Extremadura", "").replace("|", "").strip() #.encode('utf8') except: tit = u"Vídeo de Canal Extremadura".encode('utf8') try: desc = Utiles.recortar(html2, "<div class=\"descripcion\">", "</div>").strip() #.ecnode('utf8') except: desc = u"Vídeo de Canal Extremadura".encode('utf8') else: if type(desc) is str: if desc == "": desc = u"Vídeo de Canal Extremadura".encode('utf8') elif type(desc) is unicode: if desc == u"": desc = u"Vídeo de Canal Extremadura".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) ''' # En principio parece que tenemos 4 tipos de vídeos diferentes: A la carta video, a la carta auido, a 3cat24 if self.url.find("catradio.cat") != -1: raise Error.GeneralPyspainTVsError(u"Los audios aún no están soportados. Lo estarán muy pronto ;)") #self.info(u"[INFO] Audios de catradio") #url, name = self.__catradio() if self.url.find("8tv.cat") != -1: return self.__tv8() ID = self.__searchID(self.url) if ID is None or self.url.find("324.cat") != -1 or self.url.find("3cat24.cat") != -1: #324cat html = Descargar.get(self.url) try: ID = html.split("flashvars.videoid =")[1].split(";")[0].strip() except: raise Error.GeneralPyspainTVsError(u"Error al recuperar el vídeo. ¿Es la URL correcta?") if ID is None: raise Error.GeneralPyspainTVsError(u"No se encuentra vídeo en la página") self.debug(u"ID: ", ID) # # 3cat24.cat: # if self.url.find("3cat24.cat/video/") != -1: # self.info(u"[INFO] Vídeos de 3cat24") # videoID = self.url.split("/")[-1] # url, name = self.__3cat24(nuevoID=videoID) # elif self.url.find("3cat24.cat/") != -1 or self.url.find("324.cat") != -1: # de 3cat24 pero no directamente el vídeo # self.info(u"[INFO] 3cat24 (otros vídeos)") # html = Descargar.get(self.url) # videoID = html.split("flashvars.videoid =")[1].split(";")[0].strip() # url, name = self.__3cat24(nuevoID=videoID) # elif self.url.find("tv3.cat/videos") != -1: # Gracis a Carlesm ;) # self.info(u"[INFO] Vídeos de TV3") # videoID = self.url.split("/")[-2] # if not videoID.isdigit(): videoID = self.url.split("/")[-1] # url, name = self.__3cat24(nuevoID=videoID) # elif self.url.find("tv3.cat/3alacarta") != -1: # Sirve la misma función de 3cat24 (con nuevoID) # self.info(u"[INFO] Vídeos de 3alacarta") # videoID = self.url.split("/")[-1] # if not videoID.isdigit(): videoID = self.url.split("/")[-2] #HTML5 # url, name = self.__3cat24(nuevoID=videoID) # elif self.url.find("3xl.cat/videos") != -1: # self.info(u"[INFO] Vídeos de 3XL") # videoID = self.url.split("/")[-2] # url, name = self.__3cat24(nuevoID=videoID) # elif self.url.find("catradio.cat") != -1: # raise Error.GeneralPyspainTVsError(u"Los audios aún no están soportados. Lo estarán muy pronto ;)") # #self.info(u"[INFO] Audios de catradio") # #url, name = self.__catradio() #Buscar URL vídeo #FIXME: ERROR de Forbiden que da de vez en cuando headers = { 'User-Agent':'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.7; rv:19.0) Gecko/20121211 Firefox/19.0', 'Accept':'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8', 'Accept-Language':'es-ES,es;q=0.8,en-US;q=0.5,en;q=0.3', 'Accept-Encodign':'gzip, deflate' } tok = [ self.URL_TOKEN_START + ID + self.URL_TOKEN_END, self.URL_TOKEN_START + ID + self.URL_TOKEN_END2, self.URL_TOKEN_NUEVO + ID, self.URL_TOKEN_NUEVO2 + ID ] xmlUrl = None for t in tok: try: xmlUrl = Descargar.get(t) except: continue if xmlUrl.find("<error>") != -1 or xmlUrl.find("<code>33</code>") != -1: xmlUrl = None continue else: break if xmlUrl is None: raise Error.GeneralPyspainTVsError(u"No se ha podido obtener los enlaces. Prueba dentro de 5 minutos.") self.debug(u"TOKEN Utilizdo: "+t) url = "rtmp://" + xmlUrl.split("rtmp://")[1].split("<")[0] urlReplace = "http://mp4-medium-dwn-es.media.tv3.cat/" if url.find("mp4-es") != -1 else "http://mp4-medium-dwn.media.tv3.cat/" url = url.replace(url.split("mp4:")[0]+"mp4:", urlReplace).replace(url.split(".mp4")[1],"") #Buscar información con URL_INFO_VIDEO info = Descargar.get(self.URL_INFO_VIDEO + ID, header=headers) try: img = Utiles.recortar(info, "<imgsrc>", "</imgsrc>").strip() except: img = None try: tit = Utiles.recortar(info, "<title>", "</title>").strip().decode('iso-8859-1').encode('utf8') except: tit = u"Vídeo de Televisió de Catalunya".encode('utf8') try: desc = Utiles.recortar(info, "<desc>", "</desc>").strip().decode('iso-8859-1').encode('utf8') except: desc = u"Vídeo de Televisió de Catalunya".encode('utf8') try: name = Utiles.formatearNombre(tit+".mp4") except: name = "VideoTV3.mp4" 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 }
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:
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 }
class Ejemplo(Canal.Canal): ''' Clase para manejar los vídeos del canal XXXXX ''' def __init__(self, url="", opcs=None): Canal.Canal.__init__(self, url, opcs, url_validas, __name__) # Métodos propios del canal: # Atributos disponibles: # ** self.url (url recibida) # ** self.opcs (diccionario de opciones) Ver Módulo Canal "_default_opcs" para opciones # Métodos disponibles de clase Canal: # ** self.log() para mostrar por pantalla (está disponible si self.opcs["log"] es True) # ** self.info() = log() # ** 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") # Funciones de Utiles: # ** Utiles.formatearNombre("cadena") y Utiles.stringFormat("cadena") para quitar caracteres extraños # Funciones de Descargar: # ** Descargar.getHtml(url, withHeader=False, utf8=False, header=std_headers) # Recibe: # - url (http://ejemplo.com/ruta/de/ejemplo) # - withHeader (True or False) # - utf8 (True or False) # - header, de la forma: # { # 'User-Agent': 'Mozilla/5.0 (Windows; U; Windows NT 6.1; ' # 'en-US; rv:1.9.2) Gecko/20100115 Firefox/3.6', # 'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.7', # 'Accept': 'text/xml,application/xml,application/xhtml+xml,' # 'text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5', # 'Accept-Language': 'en-us,en;q=0.5', # } <-- Esto se enviará en caso de omitir el header. # Return: # - Respuesta GET # ** Descargar.isReachable(url) # Recibe: # - url (http://ejemplo.com/ruta/de/ejemplo) # Return: # - True or False # Comprueba si se puede acceder a una web # ** Descargar.doPost(url, path, post_args, doseq=True, headers=None) # Recibe: # - url (http://ejemplo.com) # - path (/ruta/de/ejemplo.php) # - post_args (dicy, ej.: {"usuario":"antonio", "password":"******"}) # - doseq (bool) # - headers, de la forma: # { # 'User-Agent': 'Mozilla/5.0 (Windows; U; Windows NT 6.1; ' # 'en-US; rv:1.9.2) Gecko/20100115 Firefox/3.6', # 'Accept-Charset': 'ISO-8859-1,utf-8;q=0.7,*;q=0.7', # 'Accept': 'text/xml,application/xml,application/xhtml+xml,' # 'text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5', # 'Accept-Language': 'en-us,en;q=0.5', # } <-- Esto se enviará en caso de omitir el header. # Return: # - Respuesta del POST def getInfo(self): ''' Devuelve toda la información asociada a la URL recibida, de la siguiente forma: { "exito" : bool, <-- True (si se han obtenido videos) "num_video" : int, <-- Número de vídeos obtenidos "mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False]) "videos" : [{ "url_video" : [], <-- Url de descarga de vídeo "url_img" : "", <-- Url de la miniatura del video "filename" : [], <-- Nombre de las partes para guardar en disco "tipo" : "", <-- http, rtmp[e,..], mms, ... "partes" : int, <-- Número de partes que tiene el vídeo "rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None "menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None "url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo "otros" : [], <-- Lista donde se pueden pasar cosas opcionales "mensaje" : "" <-- Mensajes de la API }], <-- Debe ser una lista de tamaño "num_videos" "titulos" : [u""], <-- Titulos de los videos "descs" : [u""] <-- Descripción de cada vídeo } Los valores que no se rellenen, deberán devolver None. La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente: { "exito": False, "mensaje": "No se pudo descargar el video" } "videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None) "url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None) ''' #Ejemplo: try: html = Descargar.getHtml(self.url) html.split("blabla")[0] # Buscar vídeo en html except Exception, e: raise Error.GeneralPyspainTVsError("No se encuentra la URL: " + e) url_video = "http://ejmeplo.com/ruta/de/ejemplo.mp4" url_img = "http://ejemplo.com/ruta/de/ejemplo.jpg" tit_vid = "título de ejemplo" titulo = Utiles.formatearNombre(tit_vid + ".mp4") ejemplo = { "exito": True, "num_videos": 1, "mensaje": u"URL obtenida correctamente", "videos": [{ "url_video": [url_video], "url_img": url_img if url_img is not None else None, "filename": [titulo] if titulo 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": None } return ejemplo
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) ''' #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) ''' url_img = None streamHTML = Descargar.getHtml(self.url) if streamHTML.find("http://level3/") != -1: # Método antiguo self.info(u"[INFO] Método antiguo (mitele)") videoID = streamHTML.split("\'http://level3/")[1].split(".")[0] videoEXT = streamHTML.split("\'http://level3/")[1].split( "\'")[0].split(".")[1] videoEXT = "." + videoEXT url2down = self.URL_DESCARGA_TELECINCO + videoID[ -1] + "/" + videoID[-2] + "/" + videoID + videoEXT name = None elif streamHTML.find(self.string2split4id[0]) != -1: # Método nuevo newID = streamHTML.split(self.string2split4id[0])[1].split( self.string2split4id[1])[0].split(".")[0] self.info(u"[INFO] Nuevo Video ID:", newID) ask4token = self.URL_ASK4TOKEN + newID[-3:] + "/" + newID + ".mp4" self.debug(u"[+] Pidiendo nuevo token") url2down = Descargar.getHtml(ask4token) name = streamHTML.split("var title = \'")[1].split( "\'")[0] + ".mp4" elif self.url.find( "videoURL=") != -1: # Forma con el ID en la URL (nueva??) videoID = self.url.split("videoURL=")[1] ask4token = self.URL_ASK4TOKEN + videoID[ -3:] + "/" + videoID + ".mp4" self.debug(u"[+] Pidiendo nuevo token") url2down = Descargar.getHtml(ask4token) # Obtner nombre: xmlURL = "http://estaticos.telecinco.es/xml/Video/Video_" + videoID + ".xml" streamXML = Descargar.getHtml(xmlURL) name = streamXML.split("<![CDATA[")[1].split("]")[0] + ".mp4" elif streamHTML.find("MDS.embedObj(video") != -1: contentID = streamHTML.split("MDS.embedObj(video, \"")[1].split( "\"")[0] try: clippingID = streamHTML.split("imageClippingId: \'")[1].split( "\'")[0] # try por que en la API no funcionaba oO except: clippingID = "1.jpg" try: imageContentID = streamHTML.split("imageContentId: \'")[ 1].split("\'")[0] # try por problemas com la API oO except: imageContentID = streamHTML.split( "MDS.embedObj(video, \"")[1].split("\"")[0] self.debug(u"URL JSON: " + self.URL_JSON + "contentId=" + contentID + "&clippingId=" + clippingID + "&imageContentId=" + imageContentID) streamJSON = Descargar.getHtml(self.URL_JSON + "contentId=" + contentID + "&clippingId=" + clippingID + "&imageContentId=" + imageContentID) url2down = streamJSON.split("({\"sources\":[{\"src\":\"")[1].split( "\"")[0].replace("\/", "/") name = streamHTML.split("<title>")[1].split("<")[0] name += "." + url2down.split(".")[-1].split("?")[0] url_img = streamJSON.split("\"poster\":\"")[1].split( "\"")[0].replace("\/", "/") elif streamHTML.find("MSV.embedData") != -1: #rx=re.compile(r"MSV\.embedData\[(.*)\]", re.MULTILINE|re.DOTALL) rx = re.compile(r'/mdsvideo/popup\.html\?(.*)"') videos = rx.findall(streamHTML) if not videos: raise Error.GeneralPyspainTVsError( "Telecinco.es. No se encuentra contenido.") ret = { "exito": True, "num_videos": len(videos), "mensaje": u"URL obtenido correctamente", "videos": [], "titulos": [], "descs": [] } for js in videos: vid = { "url_video": None, "url_img": None, "filename": [], "tipo": "http", "partes": 1, "rtmpd_cmd": None, "menco_cmd": None, "url_publi": None, "otros": None, "mensaje": None } self.debug(u"API ENDPOINT: %s" % self.URL_JSON + js + "&imageContentId=" + Utiles.recortar(js, 'contentId=', '&')) stream = Descargar.getHtmlUtf8( self.URL_JSON + js + "&imageContentId=" + Utiles.recortar(js, 'contentId=', '&')) info = json.loads(stream[1:-1]) vid['url_video'] = [info['sources'][0]['src']] vid['url_img'] = info['poster'] try: vid['filename'].append( Utiles.formatearNombre(info['nielsen']['title'] + '.mp4')) except: vid['filename'].append('VideosDeTelecinco.mp4') ret['videos'].append(vid) ret['titulos'].append( unicode(info['nielsen']['title']).encode('utf8').replace( '"', '').replace("'", "")) ret['descs'].append( u'Cat.: %s. Subcat.: %s. %s'.encode('utf8') % (info['nielsen']['category'].encode('utf8'), info['nielsen']['subcategory'].encode('utf8'), info['nielsen']['title'].encode('utf8'))) return ret else: raise Error.GeneralPyspainTVsError( "Telecinco.es. No se encuentra contenido.") tit_vid = None if name != None: name = name.replace("Ver vídeo online", "") tit_vid = name.split(".")[0] name = Utiles.formatearNombre(name) desc = None try: desc = Utiles.recortar(streamHTML, "<h3 class=\"subtitle\">", "<").strip() except: desc = tit_vid if tit_vid is not None else None #TIT FIX: tit_vid = tit_vid.replace('"', '').replace("'", "") return { "exito": True, "num_videos": 1, "mensaje": u"URL obtenido correctamente", "videos": [{ "url_video": [url2down], "url_img": url_img if url_img is not None else None, "filename": [name] if name is not None else None, "tipo": "http", "partes": 1, "rtmpd_cmd": None, "menco_cmd": None, "url_publi": None, "otros": None, "mensaje": None }], "titulos": [tit_vid] if tit_vid is not None else None, "descs": [desc] if desc is not None else None }
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) ''' # En principio parece que tenemos 4 tipos de vídeos diferentes: A la carta video, a la carta auido, a 3cat24 if self.url.find("catradio.cat") != -1: raise Error.GeneralPyspainTVsError( u"Los audios aún no están soportados. Lo estarán muy pronto ;)" ) #self.info(u"[INFO] Audios de catradio") #url, name = self.__catradio() if self.url.find("8tv.cat") != -1: return self.__tv8() ID = self.__searchID(self.url) if ID is None or self.url.find("324.cat") != -1 or self.url.find( "3cat24.cat") != -1: #324cat html = Descargar.get(self.url) try: ID = html.split("flashvars.videoid =")[1].split(";")[0].strip() except: raise Error.GeneralPyspainTVsError( u"Error al recuperar el vídeo. ¿Es la URL correcta?") if ID is None: raise Error.GeneralPyspainTVsError( u"No se encuentra vídeo en la página") self.debug(u"ID: ", ID) # # 3cat24.cat: # if self.url.find("3cat24.cat/video/") != -1: # self.info(u"[INFO] Vídeos de 3cat24") # videoID = self.url.split("/")[-1] # url, name = self.__3cat24(nuevoID=videoID) # elif self.url.find("3cat24.cat/") != -1 or self.url.find("324.cat") != -1: # de 3cat24 pero no directamente el vídeo # self.info(u"[INFO] 3cat24 (otros vídeos)") # html = Descargar.get(self.url) # videoID = html.split("flashvars.videoid =")[1].split(";")[0].strip() # url, name = self.__3cat24(nuevoID=videoID) # elif self.url.find("tv3.cat/videos") != -1: # Gracis a Carlesm ;) # self.info(u"[INFO] Vídeos de TV3") # videoID = self.url.split("/")[-2] # if not videoID.isdigit(): videoID = self.url.split("/")[-1] # url, name = self.__3cat24(nuevoID=videoID) # elif self.url.find("tv3.cat/3alacarta") != -1: # Sirve la misma función de 3cat24 (con nuevoID) # self.info(u"[INFO] Vídeos de 3alacarta") # videoID = self.url.split("/")[-1] # if not videoID.isdigit(): videoID = self.url.split("/")[-2] #HTML5 # url, name = self.__3cat24(nuevoID=videoID) # elif self.url.find("3xl.cat/videos") != -1: # self.info(u"[INFO] Vídeos de 3XL") # videoID = self.url.split("/")[-2] # url, name = self.__3cat24(nuevoID=videoID) # elif self.url.find("catradio.cat") != -1: # raise Error.GeneralPyspainTVsError(u"Los audios aún no están soportados. Lo estarán muy pronto ;)") # #self.info(u"[INFO] Audios de catradio") # #url, name = self.__catradio() #Buscar URL vídeo #FIXME: ERROR de Forbiden que da de vez en cuando headers = { 'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.7; rv:19.0) Gecko/20121211 Firefox/19.0', 'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8', 'Accept-Language': 'es-ES,es;q=0.8,en-US;q=0.5,en;q=0.3', 'Accept-Encodign': 'gzip, deflate' } tok = [ self.URL_TOKEN_START + ID + self.URL_TOKEN_END, self.URL_TOKEN_START + ID + self.URL_TOKEN_END2, self.URL_TOKEN_NUEVO + ID, self.URL_TOKEN_NUEVO2 + ID ] xmlUrl = None for t in tok: try: xmlUrl = Descargar.get(t) except: continue if xmlUrl.find("<error>") != -1 or xmlUrl.find( "<code>33</code>") != -1: xmlUrl = None continue else: break if xmlUrl is None: raise Error.GeneralPyspainTVsError( u"No se ha podido obtener los enlaces. Prueba dentro de 5 minutos." ) self.debug(u"TOKEN Utilizdo: " + t) url = "rtmp://" + xmlUrl.split("rtmp://")[1].split("<")[0] url = url.replace( url.split("mp4:")[0] + "mp4:", "http://mp4-high-dwn.media.tv3.cat/").replace( url.split(".mp4")[1], "") #Buscar información con URL_INFO_VIDEO info = Descargar.get(self.URL_INFO_VIDEO + ID, header=headers) try: img = Utiles.recortar(info, "<imgsrc>", "</imgsrc>").strip() except: img = None try: tit = Utiles.recortar( info, "<title>", "</title>").strip().decode('iso-8859-1').encode('utf8') except: tit = u"Vídeo de Televisió de Catalunya".encode('utf8') try: desc = Utiles.recortar( info, "<desc>", "</desc>").strip().decode('iso-8859-1').encode('utf8') except: desc = u"Vídeo de Televisió de Catalunya".encode('utf8') try: name = Utiles.formatearNombre(tit + ".mp4") except: name = "VideoTV3.mp4" 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) ''' url_img = None streamHTML = Descargar.getHtml(self.url).decode('string-escape') if streamHTML.find("CUAVID") != -1: self.debug(u"CUAVID") ContentID = streamHTML.split("imageContentId: \'")[1].split("\'")[0] streamJSON = Descargar.getHtml(self.URL_SOURCES + ContentID) url2down = streamJSON.split("\"src\":\"")[1].split("\"")[0].replace("\/", "/") name = streamJSON.split("\"wrpContent\":\"")[1].split("\"")[0] + ".mp4" elif streamHTML.find("MDS.embedObj(video") != -1: # Este parece ser el único método a 16/10/2012 (pero dejo los demás..) self.debug(u"MDS.embedObj") contentID = streamHTML.split("MDS.embedObj(video, \"")[1].split("\"")[0] clippingID = streamHTML.split("imageClippingId: \'")[1].split("\'")[0] imageContentID = streamHTML.split("imageContentId: \'")[1].split("\'")[0] self.debug("URL Json: "+self.URL_JSON + "contentId=" + contentID + "&clippingId=" + clippingID + "&imageContentId=" + imageContentID) streamJSON = Descargar.getHtml( self.URL_JSON + "contentId=" + contentID + "&clippingId=" + clippingID + "&imageContentId=" + imageContentID ) #streamJSON = dict(streamJSON) #url2down = streamJSON["sources"][0]["src"] url2down = streamJSON.split("({\"sources\":[{\"src\":\"")[1].split("\"")[0].replace("\/", "/") name = streamHTML.split("<title>")[1].split("<")[0] name += "." + url2down.split(".")[-1].split("?")[0] url_img = streamJSON.split("\"poster\":\"")[1].split("\"")[0].replace("\/", "/") elif streamHTML.find("src_iframe:") != -1: self.info(u"[INFO] Vídeo Común") name = streamHTML.split("<title>")[1].split("<")[0] urlComunes = self.URL_CUATRO + streamHTML.split("src_iframe:")[1].replace(" ", "").split("\'")[1].split("\'")[0] streamComunes = Descargar.getHtml(urlComunes) url2down = streamComunes.split("document.write(\'<video id=")[1].split("src=\"")[1].split("\"")[0] ext= "." + url2down.split(".")[-1] name += ext elif streamHTML.find("MSV.embedData") != -1: #rx=re.compile(r"MSV\.embedData\[(.*)\]", re.MULTILINE|re.DOTALL) rx=re.compile(r'/mdsvideo/popup\.html\?(.*)"') videos = rx.findall(streamHTML) if not videos: Error.GeneralPyspainTVsError("Telecinco.es. No se encuentra contenido.") ret = { "exito" : True, "num_videos" : len(videos), "mensaje" : u"URL obtenido correctamente", "videos": [], "titulos": [], "descs": [] } for js in videos: vid = { "url_video" : None, "url_img" : None, "filename" : None, "tipo" : "http", "partes" : 1, "rtmpd_cmd" : None, "menco_cmd" : None, "url_publi" : None, "otros" : None, "mensaje" : None } stream = Descargar.getHtmlUtf8(self.URL_JSON + js + "&imageContentId=" + Utiles.recortar(js, 'contentId=', '&')) info = json.loads(stream[1:-1]) vid['url_video'] = [info['sources'][0]['src']] vid['url_img'] = info['poster'] try: vid['filename'] = Utiles.formatearNombre(info['nielsen']['title']+'.mp4') except: vid['filename'] = 'VideosDeTelecinco.mp4' ret['videos'].append(vid) ret['titulos'].append(unicode(info['nielsen']['title']).encode('utf8').replace("\'","")) ret['descs'].append(u'Cat.: %s. Subcat.: %s. %s'.encode('utf8') % (info['nielsen']['category'].encode('utf8'),info['nielsen']['subcategory'].encode('utf8'),info['nielsen']['title'].encode('utf8'))) return ret else: raise Error.GeneralPyspainTVsError("Cuatro.com: No se encuentra contenido") tit_vid = None if name: name = name.replace("Ver vídeo online","") tit_vid = name.split(".")[0] name = Utiles.formatearNombre(name) desc = None try: desc = Utiles.recortar(streamHTML, "<h3 class=\"subtitle\">", "<").strip() except: desc = tit_vid if tit_vid is not None else None return {"exito" : True, "num_videos" : 1, "mensaje" : u"URL obtenido correctamente", "videos":[{ "url_video" : [url2down], "url_img" : url_img if url_img is not None else None, "filename" : [name] if name is not None else None, "tipo" : "http", "partes" : 1, "rtmpd_cmd" : None, "menco_cmd" : None, "url_publi" : None, "otros" : None, "mensaje" : None }], "titulos": [tit_vid] if tit_vid is not None else None, "descs": [desc] if desc is not None else None }
def getInfo(self): ''' Devuelve toda la información asociada a la URL recibida, de la siguiente forma: { "exito" : bool, <-- True (si se han obtenido videos) "num_video" : int, <-- Número de vídeos obtenidos "mensaje" : u"" , <-- Mensajes de la API (ej.: El vídeo no ha sido encontrado ["exito": False]) "videos" : [{ "url_video" : [], <-- Url de descarga de vídeo "url_img" : "", <-- Url de la miniatura del video "filename" : [], <-- Nombre de las partes para guardar en disco "tipo" : "", <-- http, rtmp[e,..], mms, ... "partes" : int, <-- Número de partes que tiene el vídeo "rtmpd_cmd" : [], <-- Comando rtmpdump (si tipo == rtmp) sino None "menco_cmd" : [], <-- Comando mencoder (Si tipo == rtmp) sino None "url_publi" : "", <-- Url del vídeo de publicidad asociado al vídeo "otros" : [], <-- Lista donde se pueden pasar cosas opcionales "mensaje" : "" <-- Mensajes de la API }], <-- Debe ser una lista de tamaño "num_videos" "titulos" : [u""], <-- Titulos de los videos "descs" : [u""] <-- Descripción de cada vídeo } Los valores que no se rellenen, deberán devolver None. La clave "exito" es obligatoria, sino se puede encontrar el vídeo se puede devolver directamente: { "exito": False, "mensaje": "No se pudo descargar el video" } "videos", "mesajes" y "descs" deben ser listas de cadenas (si no son None) "url_video", "filename", "rtmp_cmd", "menco_cmd" (de "videos") deben ser listas de cadenas (si no son None) ''' 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) ''' 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 }
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 }