def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' # Por ahora videos que no sean de Play Cuatro: if self._URL_recibida.find("http://play.cuatro.com/") != -1: printt(u"[INFO] Play Cuatro") url, name = self.__playCuatro() else: printt(u"[INFO] Vídeo Común") streamHTML = self.__descHTML(self._URL_recibida) name = streamHTML.split("<title>")[1].split("<")[0] urlComunes = self.URL_CUATRO + streamHTML.split("src_iframe:")[1].replace(" ", "").split("\'")[1].split("\'")[0] streamComunes = self.__descHTML(urlComunes) url = streamComunes.split("document.write(\'<video id=")[1].split("src=\"")[1].split("\"")[0] ext= "." + url.split(".")[-1] name += ext if name: name = formatearNombre(name) return [url, name]
def __metodo_2(self, id, startTime, endTime): ''' Segundo Método implementado: TK2 - Pass de "N": ================== force_http -> 1 id -> /url/url/url.mp4 sec -> encode(serverTime;id;startTime;endTime) ''' printt(u"[INFO] Probando Método 2") AES = aes.AES() tokenizer = "/tokenizer/tk2.php" passwd = "xo85kT+QHz3fRMcHNXp9cA" server_time = self.__descHTML(self.URL_TIME).strip() toEncode = server_time+";"+id+";"+startTime+";"+endTime data = AES.encrypt(toEncode, passwd, 256) post_args = { 'force_http' : '1', 'sec' : data, 'id' : id } url = self.__post(post_args, tokenizer) if url is None: return None else: return url
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' streamHTML = self.__descHTML(self._URL_recibida) name = streamHTML.split("MEDIANAME:unescape(\'")[1].split("\'")[0] ext = streamHTML.split("ORIGVIDEOFORMAT:\'")[1].split("\'")[0] printt(u"[INFO] Vídeo", ext.upper()) ext = "." + ext urlSMIL = streamHTML.split("PATHTOMEDIA:\'")[1].split("\'")[0] streamSMIL = self.__descHTML(urlSMIL) urlBase = streamSMIL.split("base=\"")[1].split("\"")[0] urlSrc = streamSMIL.split("src=\"")[1].split("\"")[0] url = urlBase + urlSrc name += ext if name: name = formatearNombre(name) return [url, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' # Dividir si es de a la carta o de btvnocies: if self._URL_recibida.find("btvnoticies.cat") != -1: url, name = self.__btvnoticies() elif self._URL_recibida.find("btv.cat/alacarta/") != -1: url, name = self.__alacarta() else: printt(u"[!!!] No deberías haber visto este ERROR") if name: name = formatearNombre(name) return [url, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' streamHTML = self.__descHTML(self._URL_recibida) if streamHTML.find("<param name=\"movie\"") != -1: printt(u"[INFO] Vídeo") # Delimitar: streamVideo = streamHTML.split("<param name=\"movie\"")[1].split("/>")[0] url = streamVideo.split("file=")[1].split("&")[0] ext = "." + url.split(".")[-1] name = streamHTML.split("<meta name=\"title\" content=\"")[1].split("\"")[0] + ext else: salir(u"[!!!] No se reconoce el tipo de contenido") if name: name = formatearNombre(name) return [url, name]
def __modoNormal(self): '''return URL y NAME de los vídeos normales de Canal SUR''' printt(u"[INFO] Vídeo Normal") htmlStream = self.__descHTML(self._URL_recibida) url = "http://www.canalsur.es" + htmlStream.split("flashvars=\"file=")[1].split("&")[0] ext = "." + url.split(".")[-1] name = htmlStream.split("<title>")[1].split("<")[0] + ext return [url, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' streamHTML = self.__descHTML(self._URL_recibida) if self._URL_recibida.find("audios/") != -1 or self._URL_recibida.find("audioak/") != -1: printt(u"[INFO] Audio") name = streamHTML.split("<title>")[1].split("<")[0] streamMP3 = streamHTML.split("<a id=\"descargaMp3\"")[1].split(">")[0] url = self.URL_EITB + streamMP3.split("href=\"")[1].split("\"")[0] name += ".mp3" elif self._URL_recibida.find("videos/") != -1 or self._URL_recibida.find("bideoak/") != -1 or self._URL_recibida.find("video/") != -1 : if streamHTML.find("<a id=\"descargaMp4\"") != -1: name = streamHTML.split("<title>")[1].split("<")[0] streamMP4 = streamHTML.split("<a id=\"descargaMp4\"")[1].split(">")[0] url = self.URL_EITB + streamMP4.split("href=\"")[1].split("\"")[0] else: #streamHTML = self.__descHTML(self._URL_recibida) name = self._URL_recibida.split("/")[-1] playerID = streamHTML.split("<param name=\"playerID\" value=\"")[1].split("\"")[0] playerKey = streamHTML.split("<param name=\"playerKey\" value=\"")[1].split("\"")[0] const = "9f8617ac59091bcfd501ae5188e4762ffddb9925" publisherID = "102076681001" videoID = self._URL_recibida.split("/")[-1] rtmpdata = self.get_data(publisherID, playerID, const, videoID, playerKey)['renditions'] URL = str(rtmpdata[0]['defaultURL']) r = URL.split("&")[0] a = "/".join(r.split("/")[-3:]) C1 = "B:0" C2 = "S:" + "&".join(URL.split("&")[1:]) y = URL.split("&")[1] url = r #print "rtmpdump -r " + r + " -a " + a + " -C " + C1 + " -C " + C2 + " -y " + y + " -o " + name + ".mp4" name += ".mp4" else: salir(u"[!!!] No se reconoce el tipo de contenido") if name: name = formatearNombre(name) return [url, name, "-a", a, "-C", C1, "-C", C2, "-y", y]
def __alacarta(self): '''return URL y NAME de los vídeos de A la carta de Canal SUR''' printt(u"[INFO] A la carta") xmlStream = self.__descHTML(self.__descHTML(self._URL_recibida).split("_url_xml_datos=")[1].split("\"")[0]) url = xmlStream.split("<url>")[1].split("<")[0] ext = "." + url.split(".")[-1] name = xmlStream.split("<title><![CDATA[")[1].split("]")[0] + ext return [url, name]
def procesarDescarga(self): """ Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). """ streamHTML = self.__descHTML(self._URL_recibida) # .replace(" ", "") if streamHTML.find("contentArray[") != -1: printt(u"[INFO] Se han detectado varios vídeos en la página:") # Deleimitar los bloques de vídeos: bloques = streamHTML.split("contentArray[")[1:] # Delimitar en un diccionario los videos: videosSucio = {} for i in bloques: videosSucio[int(i.split("]")[0])] = i.split("=")[1].split(");")[0] # Mostrar el menú en pantalla: for i in videosSucio: printt("\t[%4d] %s" % (i, videosSucio[i].split("'")[1])) # Presentar menú para elegir vídeo: printt(u"[-->] Introduce el número del vídeo que quieres descargar (Ctrl+C para cancelar): ") while True: try: ID = int(raw_input()) except ValueError: printt(u"[!!!] Parece que no has introducido un número. Prueba otra vez:") continue except KeyboardInterrupt: salir(u"\nBye!") if ID < 0 or ID > len(videosSucio) - 1: printt(u"[!!!] No existe el vídeo con número [%4d] Prueba otra vez:" % ID) continue else: break # Consguir el vídeo según el ID: url = videosSucio[ID].split("'")[7] ext = "." + url.split(".")[-1] name = videosSucio[ID].split("'")[1] + ext else: salir(u"[!!!] ERROR: No se han econtrado vídeos en la página") if name: name = formatearNombre(name) return [url, name]
def __rtvvRadio(self, htmlStream, sep): ''' Dada una URL de la radio de RTVV devuelve la URL y el NOMBRE de descarga del audio ''' printt(u"[INFO] Modo Audios de Ràdio") url = self.URL_RTVV + htmlStream.split(sep)[1].split("\"")[0] ext = "." + url.split(".")[-1] name = htmlStream.split("class=\"title\"><strong>")[1].split("<")[0] + ext return [url, name]
def __btvnoticies(self): ''' return Nombre y URL de un vídeo de BTV Notícies ''' printt(u"[INFO] BTV Notícies") htmlStream = self.__descHTML(self._URL_recibida) url = htmlStream.split("flashvars.post_guid = \"")[1].split("\"")[0] name = htmlStream.split("<h2>")[1].split("<")[0] name += ".flv" return [url, name]
def __catradio(self): '''Procesa los audios de catradio''' # Primero nos quedamos con el id audioID = self._URL_recibida.split("/")[4] printt(u"[INFO] Audio ID:", audioID) IDsplit = "insertNewItem(\'" + audioID + "\'" # Nos quedamos con su identificacion streamID = self.__descHTML(self._URL_recibida).split(IDsplit)[1].split(">")[0] name = streamID.split(",")[1] + ".mp3" url = "http://" + streamID.split("http://")[1].split("\'")[0] return [url, name]
def __alacarta(self): ''' return Nombre y URL de un vídeos de televisión a la carta de BTV ''' printt(u"[INFO] A la Carta") htmlStream = self.__descHTML(self._URL_recibida) url = htmlStream.split("videoBTV.playlist.add(\"")[1].split("\"")[0] name = htmlStream.split("<div id=\"titol\">")[1].split("</p>")[0].split("<h3>")[1] name = name.replace("</h3><p>", "-") name += ".wmv" return [url, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. ''' # print "[+] Procesando descarga" streamHTML = self.__descHTML(self._URL_recibida) if self._URL_recibida.find("antena3.com/videos/") != -1: # Modo Salón url2down, name = self.__modoSalon(streamHTML) else: # Otro vídeos (No modo salón) printt(u"[INFO] Vídeo normal (no Modo Salón)") if streamHTML.find(".seoURL='") != -1: # Url directamente en HTML url2down, name = self.__modoNormalConURL(streamHTML) elif streamHTML.find("a3_gp_visor_player") != -1: url2down, name = self.__modoF1(streamHTML) else: # No está la url en el hmtl (buscar por varias partes) if streamHTML.find("<div class=\"visor\">") != -1: # Más de 1 parte # Quizas mejor "carrusel"? url2down, name = self.__modoNormalVariasPartes(streamHTML) else: # Solo una parte url2down, name = self.__modoNormalUnaParte(streamHTML) if type(url2down) == list: for i in url2down: if i.find("geobloqueo") != -1: printt(u"[!!!] El vídeo \"" + i + "\" no se puedo descargar (geobloqueado)") url2down.remove(i) # TODO: Borrar también su nombre correspondiente # Comprobar si todas las partes están geobloqueadas (no quedan elementos en la lista): if len(url2down) == 0: salir(u"[!] No se puede descargar ninguna parte (geobloqueadas)") else: if url2down.find("geobloqueo") != -1: salir(u"[!] El vídeo no se puede descargar (geobloqueado)") if type(name) == list: for i in name: b = formatearNombre(i) name[name.index(i)] = b else: name = formatearNombre(name) return [url2down , name]
def __aGalegaInfo(self): """ return url (mms) y nombre de los vídeos de A galega info de crtgv """ # Creo que lo más recomendable es pedir el código javascript # de las WWW de debajo del vídeo printt(u"[INFO] A galega info") printt(u'El vídeo que intentas descargar pertenece a la sección "A galega Info".') printt(u"Para asegurar que se baja el vídeo deseado, haz click con el ratón a las WWW") printt(u"que aparecen debajo del vídeo (a la izquierda).") printt(u"Copia todo el contenido y pégalo aquí") try: javascript = raw_input("Pegua aquí: ") except KeyboardInterrupt, e: salir(u"\nKeyboardInterrupt: Ciao!")
def __getHtmlUrlFromAlacarta(self): ''' Dada una URL de A la Carta de RTVV devuelve su URL normal ''' id = self._URL_recibida.split("/")[-1] if id.find("#") == -1 or self._URL_recibida.endswith("rtvv.es/va/noualacarta/") or \ self._URL_recibida.endswith("rtvv.es/va/noualacarta"): salir(u"[ERROR] Página general de \"A la Carta\". Introducir url específica") id = id.replace("#", "") printt(u"[INFO] ID:", id) frameIDsplit = "<li class=\"scr-item contentId_" + id + "\">" printt(u"[INFO] Separador:", frameIDsplit) frameID = self.__descHTML(self._URL_recibida).split(frameIDsplit)[1].split("</li>")[0] htmlURL = self.URL_RTVV + frameID.split("<a href=\"")[1].split("\"")[0] return htmlURL
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' streamHTML = self.__descHTML(self._URL_recibida) if self._URL_recibida.find("detail.php?id") != -1: # Aun no es el vídeo if streamHTML.find("ShowPreviewMM(\'") != -1: url = streamHTML.split("ShowPreviewMM(\'")[1].split("\'")[0] name = streamHTML.split("); return false;\">")[1].split("<")[0] elif streamHTML.find("onClick=\"ShowPreviewMM(") != -1: printt(u"[INFO] Buscando ID del vídeo") nuevoID = streamHTML.split("onClick=\"ShowPreviewMM(")[1].split(")")[0] printt(u"[INFO] Vídeo ID:", nuevoID) name = streamHTML.split("); return false;\">")[1].split("<")[0] url, name = self.__paginaDvideo(streamHTML, nuevoID, name) elif streamHTML.find("onClick=\"ShowPreviewMM(") != -1: pass else: salir(u"[!!!] No se reconoce el tipo de contenido") elif self._URL_recibida.find("mm.php?id") != -1: url, name = self.__paginaDvideo(streamHTML) elif streamHTML.find("youtube"): salir(u"[!!!] No se reconoce el tipo de contenido.\nPuede que el vídeo sea de YouTube??") else: salir(u"[!!!] No se reconoce el tipo de contenido") url = url.replace("http://", "mms://") ext = "." + url.split(".")[-1] if name.find(ext) == -1: name += ext.lower() if name: name = formatearNombre(name) return [url, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del audio a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. ''' # Primero: nos quedamos con le id dependiendo si el user metio la url con # una barra (/) final o no y si tiene extensión (no es alacarta) audioID = self._URL_recibida.split('/')[-1] if audioID == "": audioID = self._URL_recibida.split('/')[-2] elif audioID.find(".shtml") != -1 or audioID.find(".html") != -1 or \ audioID.find(".html") != -1: audioID = audioID.split('.')[0] printt(u"[INFO] ID del Audio :", audioID) xmlURL = "http://www.rtve.es/swf/data/es/audios/audio/" + audioID[-1] \ + "/" + audioID[-2] + "/" + audioID[-3] \ + "/" + audioID[-4] + "/" + audioID + ".xml" printt(u"[INFO] Url de xml :", xmlURL) #print "[+] Procesando Descarga" sourceXML = self.__descXML(xmlURL) # Ahora la url final del audio puede estar entre las etiquetas <file></file> # o puede que tengamos que dar un rodeo if sourceXML.find("<file>") != -1 and sourceXML.find("</file>"): # Contiene la URL urlAudio = sourceXML.split("<file>")[1].split("</file>")[0] elif sourceXML.find("assetDataId::") != -1: # Dar el rodeo idAsset = sourceXML.split("assetDataId::")[1].split("\"/>")[0] printt(u"[INFO] Nuevo ID Asset :", idAsset) urlXMLasset = "www.rtve.es/scd/CONTENTS/ASSET_DATA_AUDIO/" + idAsset[-1] \ + "/" + idAsset[-2] + "/" + idAsset[-3] \ + "/" + idAsset[-4] + "/ASSET_DATA_AUDIO-" + idAsset + ".xml" printt(u"[INFO] XML URL Asset :", urlXMLasset) sourceAssetXML = self.__descXML(urlXMLasset) urlInSourceAssetXML = sourceAssetXML.split("defaultLocation=\"")[1].split("\"")[0] #print "urllInSourceAssetXML =", urlInSourceAssetXML urlAudio = "http://www.rtve.es/resources/TE_NGVA/mp3/" + urlInSourceAssetXML.split("/mp3/")[1] else: salir(u"[!!!] No se encuentró la URL del Audio") # Nombre con el que se guardará la descarga: extension = '.' + urlAudio.split('.')[-1] name = sourceXML.split("<name>")[1].split("</name")[0] + extension name = formatearNombre(name) return [urlAudio, name]
def __metodo_3(self, id, startTime, endTime): ''' Tercer método implementado: TK3 - Pass de "M": ================== force_http -> 1 hash -> encode(serverTime;id;startTime;endTime) id -> /url/url/url.mp4 startTime -> 0 endTime -> 0 ''' printt(u"[INFO] Probando Método 3") AES = aes.AES() tokenizer = "/tokenizer/tk3.php" passwd = "xo85kT+QHz3fRMcHMXp9cA" server_time = self.__descHTML(self.URL_TIME).strip() toEncode = server_time+";"+id+";"+startTime+";"+endTime data = AES.encrypt(toEncode, passwd, 256) post_args = { #'force_http' : '1', 'hash' : data, 'id' : id, 'startTime' : '0', 'endTime': '0'} data = self.__post(post_args, tokenizer) if data is None: return None else: #print "DATA:", data if data.find("<stream>") != -1: # FIXME: Este comandono funciona R = data.split("<stream>")[1].split("</stream>")[0] A = "\""+ "/".join(data.split("/")[4:]).split("</stream>")[0] +"\"" F = "\""+ "WIN 11,1,102,55" +"\"" W = "\""+ "http://static1.tele-cinco.net/comun/swf/playerMitele.swf" +"\"" P = "\""+ self._URL_recibida +"\"" Y = "\""+ "mp4:" + data.split("</file>")[0].split("mp4:")[1] +"\"" url = [R, "-a", A, "-f", F, "-W", W, "-p", P, "-y", Y] else: try: url = data.split("<url><file>")[1].split("</file></url>")[0].replace("&", "&") except IndexError: url = data.split("<file geoblocked=\"true\">")[1].split("</file></url>")[0].replace("&", "&") return url
def __modoNormalVariasPartes(self, streamHTML): url2down = [] name = [] # Delimitamos la parte del carrusel (funcionará para todos??) streamHTML = streamHTML.split("<a title=\"Video Anterior\"")[1].split("<a title=\"Video Siguiente\"")[0] partes = len(streamHTML.split("<img title="))-1 streamPARTES = streamHTML.split("<img title=")[1:] printt(u"[INFO] Número de partes:", str(partes)) #print streamPARTES for i in streamPARTES: xmlURL = self.URL_DE_ANTENA3 + i.split("rel=\"/")[1].split("\"")[0] streamXML = self.__descXML(xmlURL) url2down.append(self.URL_DE_DESCARGA + streamXML.split("<archivo><![CDATA[")[1].split("]")[0]) ext = streamXML.split("<archivo><![CDATA[")[1].split("]")[0].split('.')[-1] name.append(i.split("\"")[1].split("\"")[0] + '.' + ext) print "[INFO] URLs :", url2down print "[INFO] Nombres :", name return [url2down, name]
def __modoF1(self, streamHTML): ''' <param value="_urlData=http://www.antena3.com/gestorf1/swf/player_hitos/xml/data.xml&_image=http://www.antena3.com/gestorf1/pictures/361/361/malasia-portada_crop1.png&_id_list=1405&_promo1=http://www.smartadserver.com/call/pubx/15272/241149/4654/S/&_promo2=http://www.smartadserver.com/call/pubx/15272/241148/4654/S/" name="flashVars"> ''' streamHTML = self.__get8stream(self._URL_recibida) # Qué vídeo: streamVids = streamHTML.split("<ul class=\"a3_gp_visor_menu\">")[1].split("</ul>")[0].replace("\t", "") streamVids = streamVids.split("<li>")[1:] printt(u"[???] Qué quieres descargar: ") b = 0 for i in streamVids: b += 1 printt(u"\t%d) %s" % (b, i.split(">")[1].split("<")[0].capitalize())) opc = False while opc is False: opc = raw_input("[(%d a %d) >>>] " % (1, b)) if opc.isdigit(): opc = int(opc) if opc < 1 or opc > b: opc = False else: opc = False streamVid = streamVids[opc-1] streamVidUrl = self.URL_DE_ANTENA3 + streamVid.split("href=\"")[1].split("\"")[0] # Vamos a por el vídeo streamHTML = self.__descHTML(streamVidUrl) url2down = [] name = [] id_list = streamHTML.split("_id_list=")[1].split("&")[0] #printt(u"[DEBUG] url2down", str(id_list)) listxml = self.__descXML(self.URL_DE_F1 + id_list + "_playlist.xml") listxml = listxml.split("<video>")[1:] for i in listxml: url2down.append(i.split("<url>")[1].split("<")[0]) ext = "." + url2down[-1].split(".")[-1] name.append(i.split("<title>")[1].split("<")[0] + ext) return [url2down, name]
def __aCarta(self): """ return URL (mms) y NAME """ printt(u"[INFO] Á Carta (tvg)") urlStream = self.__descHTML(self._URL_recibida) urlframeiParte = urlStream.split('<frame src="')[1].split('"')[0] urlframei = self.URL_CRTVG + "reproductor/" + urlframeiParte urlframei = urlframei.replace("&", "&").replace(" ", "%20") frameiStream = self.__descHTML(urlframei) frameVideo = frameiStream.split('<frame src="')[1].split('"')[0] urlframeVideo = self.URL_CRTVG + "reproductor/" + frameVideo urlframeVideo = urlframeVideo.replace("&", "&").replace(" ", "%20") frameVideoStream = self.__descHTML(urlframeVideo) asxFile = frameVideoStream.split('<PARAM NAME="URL" value="')[1].split('"')[0] printt(u"[INFO] ASX File:", asxFile) asxStream = self.__descHTML(asxFile) name = asxStream.split("<TITLE>")[1].split("<")[0] + ".wmv" url = asxStream.split('<ENTRY><REF HREF="')[1].split('"')[0] return [url, name]
def __modoSalonNuevo(self, streamXML): '''Nuevos vídeos con extensión .m4v''' printt(u"[INFO] Nuevos vídeos en formato f4v") if streamXML.find("000.f4v"): url2down1 = self.URL_DE_DESCARGA + streamXML.split("<archivo><![CDATA[")[1].split("]")[0] else: url2down1 = self.URL_DE_DESCARGA + \ streamXML.split("<archivo><![CDATA[")[1].split("001.f4v]]></archivo>")[0] + "000.f4v" try: # Descargar entero urllib2.urlopen(url2down1) url2down = url2down1 name = streamXML.split("<nombre><![CDATA[")[1].split("]]>")[0] + ".f4v" except urllib2.HTTPError: # Descargar por partes: printt(u"[!!!] No se puede descargar el vídeo en un archivo (000.m4v)") printt(u"[INFO] El vídeo se descargará por partes") parts = re.findall("\<archivo\>\<\!\[CDATA\[.*\.f4v\]\]\>\<\/archivo\>", streamXML) if parts: name1 = streamXML.split("<nombre><![CDATA[")[1].split("]]>")[0] url2down = [] name = [] for i in parts: url2down.append(self.URL_DE_DESCARGA + i.split("<archivo><![CDATA[")[1].split("]]></archivo>")[0]) name.append(name1 + "_" + i.split("]")[0].split("/")[-1]) else: salir(u"[!!!] ERROR: No se encuentran las partes del vídeo") return [url2down, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' if self._URL_recibida.find("tv-a-la-carta/") != -1 or self._URL_recibida.find("http://alacarta.canalextremadura.es/tv") != -1 or self._URL_recibida.find("canalextremadura.es/alacarta/tv/") != -1: printt(u"[INFO] TV a la carta") streamHTML = self.__descHTML(self._URL_recibida).replace(" ", "") if streamHTML.find("crea_video_hd(") != -1: urlFLV = streamHTML.split("crea_video_hd(\"")[1].split("\"")[0] streamFLV = self.__descHTML(urlFLV) url = "http://" + streamFLV.split("http://")[1] ext = "." + url.split(".")[-1].split("?")[0] elif streamHTML.find("file:'") != -1: try: url = streamHTML.split("\'file\':\'")[1].split("\'")[0] #Modo nomal nuevo except: #Modo normal antiguo url = streamHTML.split("streamer:\'")[1].split("\'")[0] + streamHTML.split("file:\'")[1].split("\'")[0] ext = "." + url.split(".")[-1] elif streamHTML.find("rel=\"rtmp://") != -1: #RTMP en alacarta url = "rtmp://" + streamHTML.split("rel=\"rtmp://")[1].split("\"")[0].replace("#", "") url = url.split(".mp4")[0] + ".mp4" ext = ".mp4" elif streamHTML.split("if(isiPad)") != -1: #HTTP para iPad url = streamHTML.split("<video")[1].split(".mp4")[0].split("\"")[-1] + ".mp4" ext = ".mp4" else: salir(u"[!!!] No se encuentra el vídeo") name = streamHTML.split("<title>")[1].split("<")[0] + ext elif self._URL_recibida.find("radio-a-la-carta/") != -1 or self._URL_recibida.find("http://alacarta.canalextremadura.es/radio") != -1 or self._URL_recibida.find("canalextremadura.es/alacarta/radio/") != -1: printt(u"[INFO] Radio A la Carta") streamHTML = self.__descHTML(self._URL_recibida).replace(" ", "") try: #Modo nuevo url = streamHTML.split("<divclass=\"descargar\">")[1].split("<ahref=\"")[1].split("\"")[0] except: #Modo antiguo url = streamHTML.split("s1.addVariable(\'file\',\'")[1].split("\'")[0] name = streamHTML.split("<title>")[1].split("<")[0] + ".mp3" else: #Modo normal nuevo con nueva url recibida printt(u"[INFO] Modo Genérico") streamHTML = self.__descHTML(self._URL_recibida).replace(" ", "") url = streamHTML.split("\'file\':\'")[1].split("\'")[0] #Modo nomal nuevo ext = "." + url.split(".")[-1] name = streamHTML.split("<title>")[1].split("<")[0] + ext if name: name = formatearNombre(name) return [url, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' streamHTML = self.__descHTML(self._URL_recibida) if self._URL_recibida.find("audios/") != -1 or self._URL_recibida.find("audioak/") != -1: printt(u"[INFO] Audio") name = streamHTML.split("<title>")[1].split("<")[0] streamMP3 = streamHTML.split("<a id=\"descargaMp3\"")[1].split(">")[0] url = self.URL_EITB + streamMP3.split("href=\"")[1].split("\"")[0] name += ".mp3" elif self._URL_recibida.find("videos/") != -1 or self._URL_recibida.find("bideoak/") != -1: printt(u"[INFO] Vídeo de %s" % (self._URL_recibida.split("/")[4])) name = streamHTML.split("<title>")[1].split("<")[0] streamMP4 = streamHTML.split("<a id=\"descargaMp4\"")[1].split(">")[0] url = self.URL_EITB + streamMP4.split("href=\"")[1].split("\"")[0] name += ".mp4" else: salir(u"[!!!] No se reconoce el tipo de contenido") if name: name = formatearNombre(name) return [url, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' # Diferenciar entre videos a la carta y videos de agalegainfo streamHTML = self.__descHTML(self._URL_recibida).replace(" ", "").replace("\t", "").replace("\n", "") if self._URL_recibida.find("a-carta") != -1: printt(u"[INFO] Modo \"A Carta\"") else: printt(u"[INFO] Vídeo Normal (No \"A Carta\")") rtmp = streamHTML.split("rtmp:{")[1] s = rtmp.split("url:\"")[1].split("\"")[0] r = rtmp.split("netConnectionUrl:\"")[1].split("\"")[0] a = r.split("/")[-1] video = rtmp.split("clip:{")[1] y = video.split("url:\"")[1].split("\"")[0] name = video.split("title:\"")[1].split("\"")[0] + "." + y.split(".")[-1] url = r if name: name = formatearNombre(name) return [url, name, "-y", y, "-s", s, "-a", a]
def descargar(self): ''' Recoge una url la descarga y lo devuelve Pensado para descargar streams HTML y XML ''' if self._URL.find("http://") == -1: self._URL = "http://" + self._URL try: # TVG necesita headers: if self._URL.find("crtvg.es/") != -1: request = urllib2.Request(self._URL, None, self.std_headers) f = urllib2.urlopen(request) stream = f.read() f.close() return stream elif self._URL == PdtVersion.URL_VERSION: # Si lo que se descarga es VERSION (convertir a utf-8) f = urllib2.urlopen(self._URL) Reader = codecs.getreader("utf-8") fh = Reader(f) stream = fh.read() return stream else: f = urllib2.urlopen(self._URL) stream = f.read() f.close() return stream except Exception, e: if self._URL.find("rtve.es") != -1: # No salir (para identificar si es a la carta o no) return -1 elif self._URL == PdtVersion.URL_VERSION: return -1 else: printt(u"[!!!] ERROR al descargar:", e) salir(u"")
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' if self._URL_recibida.find("tv-a-la-carta/") != -1: printt(u"[INFO] TV a la carta") streamHTML = self.__descHTML(self._URL_recibida).replace(" ", "") urlFLV = streamHTML.split("crea_video_hd(\"")[1].split("\"")[0] streamFLV = self.__descHTML(urlFLV) url = "http://" + streamFLV.split("http://")[1] ext = "." + url.split(".")[-1].split("?")[0] name = streamHTML.split("<title>")[1].split("<")[0] + ext elif self._URL_recibida.find("radio-a-la-carta/") != -1: printt(u"[INFO] Radio A la Carta") streamHTML = self.__descHTML(self._URL_recibida).replace(" ", "") url = streamHTML.split("s1.addVariable(\'file\',\'")[1].split("\'")[0] name = streamHTML.split("<title>")[1].split("<")[0] + ".mp3" else: salir(u"[!!!] No se reconoce el tipo de contenido") if name: name = formatearNombre(name) return [url, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. ''' streamHTML = self.__descHTML(self._URL_recibida) if streamHTML.find("http://level3/") != -1: # Método antiguo printt(u"[INFO] Método antiguo (mitele)") videoID = streamHTML.split("\'http://level3/")[1].split(".")[0] videoEXT = streamHTML.split("\'http://level3/")[1].split("\'")[0].split(".")[1] videoEXT = "." + videoEXT url2down = self.URL_DESCARGA_TELECINCO + videoID[-1] + "/" + videoID[-2] + "/" + videoID + videoEXT name = None elif streamHTML.find(self.string2split4id[0]) != -1: # Método nuevo newID = streamHTML.split(self.string2split4id[0])[1].split(self.string2split4id[1])[0].split(".")[0] printt(u"[INFO] Nuevo Video ID:", newID) ask4token = self.URL_ASK4TOKEN + newID[-3:] + "/" + newID + ".mp4" printt(u"[+] Pidiendo nuevo token") url2down = self.__descHTML(ask4token) name = streamHTML.split("var title = \'")[1].split("\'")[0] + ".mp4" elif self._URL_recibida.find("videoURL="): # Forma con el ID en la URL (nueva??) videoID = self._URL_recibida.split("videoURL=")[1] ask4token = self.URL_ASK4TOKEN + videoID[-3:] + "/" + videoID + ".mp4" printt(u"[+] Pidiendo nuevo token") url2down = self.__descHTML(ask4token) # Obtner nombre: xmlURL = "http://estaticos.telecinco.es/xml/Video/Video_" + videoID + ".xml" streamXML = self.__descHTML(xmlURL) name = streamXML.split("<![CDATA[")[1].split("]")[0] + ".mp4" else: salir(u"[!!!] No se encuentra URL de descarga") if name != None: name = formatearNombre(name) return [url2down, name]
def procesarDescarga(self): ''' Procesa lo necesario para obtener la url final del vídeo a descargar y devuelve esta y el nombre como se quiere que se descarge el archivo de la siguiente forma: return [ruta_url, nombre] Si no se quiere especificar un nombre para el archivo resultante en disco, o no se conoce un procedimiento para obtener este automáticamente se utilizará: return [ruta_url, None] Y el método de Descargar que descarga utilizará el nombre por defecto según la url. Tanto "ruta_url" como "nombre" pueden ser listas (por supuesto, el nombre del ruta_url[0] tiene que ser nombre[0] y así sucesivamente). ''' # En principio parece que tenemos 4 tipos de vídeos diferentes: A la carta video, a la carta auido, a 3cat24 # 3cat24.cat: if self._URL_recibida.find("3cat24.cat/video/") != -1: printt(u"[INFO] Vídeos de 3cat24") url, name = self.__3cat24() elif self._URL_recibida.find("3cat24.cat/") != -1: # de 3cat24 pero no directamente el vídeo printt(u"[INFO] 3cat24 (otros vídeos)") streamHTML = self.__descHTML(self._URL_recibida) videoID = streamHTML.split("flashvars.videoid =")[1].split(";")[0].strip() url, name = self.__3cat24(nuevoID=videoID) elif self._URL_recibida.find("tv3.cat/3alacarta") != -1: # Sirve la misma función de 3cat24 (con nuevoID) printt(u"[INFO] Vídeos de 3alacarta") videoID = self._URL_recibida.split("/")[-1] url, name = self.__3cat24(nuevoID=videoID) elif self._URL_recibida.find("") != -1: printt(u"[INFO] Audios de catradio") url, name = self.__catradio() if name: name = formatearNombre(name) return [url, name]